eintopf.info@v0.13.16/web/event_test.go

// Copyright (C) 2022 The Eintopf authors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package web

import (
	"context"
	"fmt"
	"net/url"
	"regexp"
	"strings"
	"testing"
	"time"

	"github.com/PuerkitoBio/goquery"
	"github.com/google/go-cmp/cmp"
	"github.com/iand/microdata"

	"eintopf.info/service/event"
	"eintopf.info/service/group"
	"eintopf.info/service/place"
	"eintopf.info/service/revent"
)

func TestEventPage(t *testing.T) {
	tests := []routeTest{
		{
			name: "NotFound",
			tz:   time.UTC,
			uri:  "/event/12345",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
				},
			},
			status: 404,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertNodes(t, doc, ".error", []string{"404 Veranstaltung wurde nicht gefunden"})
			},
		},
		{
			name: "NotPublished",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: false,
					Name:      "foo",
				},
			},
			status: 200,
		},
		{
			name: "MetaNoIndexNotPublished",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: false,
					Name:      "foo",
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				assertRobotsIndex(t, doc, "noindex, nofollow")
			},
		},
		{
			name: "MetaIndexPublished",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				assertRobotsIndex(t, doc, "index, follow")
			},
		},
		{
			name:   "MetaDefault",
			tz:     time.UTC,
			uri:    "/event/0",
			themes: []string{"eintopf", "testdata/themes/meta"},
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "Foo",
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				assertRobotsIndex(t, doc, "index, follow")
				assertMeta(t, doc, MetaTags{
					Title:       "Foo | Custom Sitename",
					Description: "Custom Meta Description",
					Image:       "/assets/images/logo.png",
				})
			},
		},
		{
			name: "MetaContent",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:   true,
					Name:        "Foo",
					Description: "Foo bar",
					Image:       "Foobar.png",
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				assertRobotsIndex(t, doc, "index, follow")
				assertMeta(t, doc, MetaTags{
					Title:       "Foo | Eintopf Stuttgart",
					Description: "Foo bar",
					Image:       "/api/v1/media/Foobar.png",
				})
			},
		},
		{
			name: "Schema.orgEventMinimal",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:   true,
					Name:        "Foo",
					Description: "Foo bar",
					Start:       time.Date(2022, 10, 5, 14, 30, 0, 0, time.UTC),
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				var html, err = doc.Html()
				if err != nil {
					tt.Errorf(err.Error())
				}

				baseUrl, _ := url.Parse("http://localhost/")
				p := microdata.NewParser(strings.NewReader(html), baseUrl)
				data, err := p.Parse()
				if err != nil {
					tt.Errorf(err.Error())
				}

				pageMicrodataJSON, err := data.JSON()
				if err != nil {
					t.Errorf(`JSON marshal failed for pageMicrodataJSON`)
				}

				testMicrodataItem := microdata.NewItem()
				testMicrodataItem.AddType("https://schema.org/Event")
				testMicrodataItem.AddString("name", "Foo")
				testMicrodataItem.AddString("description", "Foo bar")
				testMicrodataItem.AddString("startDate", "2022-10-05T14:30:00Z")
				testMicrodata := microdata.NewMicrodata()
				testMicrodata.AddItem(testMicrodataItem)
				testMicrodataJSON, err := testMicrodata.JSON()
				if err != nil {
					t.Errorf(`JSON marshal failed for testMicrodataJSON`)
				}

				if diff := cmp.Diff(string(testMicrodataJSON), string(pageMicrodataJSON)); diff != "" {
					t.Errorf(`schema event content mismatch (-want +got):\n%s`, diff)
				}
			},
		},
		{
			name: "Schema.orgEventMaximum",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:   true,
					Name:        "Foo",
					Description: "Foo bar",
					Start:       time.Date(2022, 10, 5, 14, 30, 0, 0, time.UTC),
					End:         tptr(time.Date(2022, 10, 5, 20, 30, 0, 0, time.UTC)),
					Location:    "bar",
					Organizers:  []string{"dada"},
				},
			},
			status: 200,
			htmlTestFunc: func(tt *testing.T, doc *goquery.Document) {
				var html, err = doc.Html()
				if err != nil {
					tt.Errorf(err.Error())
				}

				baseUrl, _ := url.Parse("http://localhost/")
				p := microdata.NewParser(strings.NewReader(html), baseUrl)
				data, err := p.Parse()
				if err != nil {
					tt.Errorf(err.Error())
				}

				pageMicrodataJSON, err := data.JSON()
				if err != nil {
					t.Errorf(`JSON marshal failed for pageMicrodataJSON`)
				}

				testMicrodataItemLocation := microdata.NewItem()
				testMicrodataItemLocation.AddType("https://schema.org/Place")
				testMicrodataItemLocation.AddString("name", "bar")

				testMicrodataItem := microdata.NewItem()
				testMicrodataItem.AddType("https://schema.org/Event")
				testMicrodataItem.AddString("name", "Foo")
				testMicrodataItem.AddString("description", "Foo bar")
				testMicrodataItem.AddString("startDate", "2022-10-05T14:30:00Z")
				testMicrodataItem.AddString("endDate", "2022-10-05T20:30:00Z")
				testMicrodataItem.AddItem("location", testMicrodataItemLocation)
				testMicrodataItem.AddString("organizer", "dada")

				testMicrodata := microdata.NewMicrodata()
				testMicrodata.AddItem(testMicrodataItem)
				testMicrodataJSON, err := testMicrodata.JSON()
				if err != nil {
					t.Errorf(`JSON marshal failed for testMicrodataJSON`)
				}

				if diff := cmp.Diff(string(testMicrodataJSON), string(pageMicrodataJSON)); diff != "" {
					t.Errorf(`schema event content mismatch (-want +got):\n%s`, diff)
				}
			},
		},
		{
			name: "Canceled",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
				},
			},
			transform: func(eventService event.Storer, groupService group.Service, placeService place.Service) error {
				_, err := eventService.Update(context.Background(), &event.Event{
					ID:        "0",
					Published: true,
					Canceled:  true,
					Name:      "foo",
				})
				return err
			},
			status: 200,
			contentTestFunc: func(t *testing.T, content string) {
				if !strings.Contains(content, "Fällt aus") {
					t.Error("should contain 'Fällt aus'")
				}
			},
		},
		{
			name: "NoEndDate",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Start:     time.Date(2022, 10, 5, 14, 30, 0, 0, time.UTC),
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoDate(t, doc, "05.10.2022 14:30 Uhr")
			},
		},
		{
			name: "WithEndDateSameDay",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Start:     time.Date(2022, 10, 5, 14, 30, 0, 0, time.UTC),
					End:       tptr(time.Date(2022, 10, 5, 16, 30, 0, 0, time.UTC)),
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoDate(t, doc, "05.10.2022 14:30 Uhr - 16:30 Uhr")
			},
		},
		{
			name: "WithEndDateNotSameDay",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Start:     time.Date(2022, 10, 5, 14, 30, 0, 0, time.UTC),
					End:       tptr(time.Date(2022, 10, 7, 16, 30, 0, 0, time.UTC)),
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoDate(t, doc, "05.10.2022 14:30 Uhr - 07.10.2022 16:30 Uhr")
			},
		},
		{
			name: "NoOrganizers",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:  true,
					Name:       "foo",
					Organizers: []string{},
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoOrganizers(t, doc, "")
			},
		},
		{
			name: "OneOrganizer",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:  true,
					Name:       "foo",
					Organizers: []string{"dada"},
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoOrganizers(t, doc, "dada")
			},
		},
		{
			name: "MultipleOrganizer",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:  true,
					Name:       "foo",
					Organizers: []string{"dada", "baba"},
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoOrganizers(t, doc, "dada, baba")
			},
		},
		{
			name: "Involved",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Involved:  []event.Involved{{Name: "foo", Description: "descfoo"}, {Name: "bar", Description: "descbar"}},
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				elementsName := doc.Find(`.info-involved .info-data`)
				elementsDescription := doc.Find(`.description`)
				if elementsName.Length() != 2 {
					t.Errorf(`Expected 2 involved, got %d`, elementsName.Length())
				}
				if diff := cmp.Diff("foobar", elementsName.Text()); diff != "" {
					t.Errorf(`Involved content mismatch (-want +got):\n%s`, diff)
				}
				if elementsDescription.Length() != 2 {
					t.Errorf(`Expected 2 involved descriptions, got %d`, elementsDescription.Length())
				}
				if diff := cmp.Diff("descfoodescbar", elementsDescription.Text()); diff != "" {
					t.Errorf(`Involved description content mismatch (-want +got):\n%s`, diff)
				}
			},
		},
		{
			name: "Location",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Location:  "bar",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoLocation(t, doc, "bar", "")
			},
		},
		{
			name: "LocationAndLocation2",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Location:  "bar",
					Location2: "bar2",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertInfoLocation(t, doc, "bar", "bar2")
			},
		},
		{
			name: "Children",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
				},
				{
					Parent:    "id:0",
					Published: true,
					Name:      "bar",
					Start:     time.Date(2022, 9, 8, 10, 0, 0, 0, time.UTC),
				},
				{
					Parent:    "id:0",
					Published: true,
					Name:      "baz",
					Start:     time.Date(2022, 9, 9, 10, 0, 0, 0, time.UTC),
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertNodes(t, doc, "h2", []string{"Programm 08. Sep / Donnerstag", "Programm 09. Sep / Freitag"})
			},
		},
		{
			name: "WithMap",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Location:  "id:0",
				},
			},
			places: []*place.NewPlace{
				{
					Published: true,
					Name:      "bar",
					Lat:       1,
					Lng:       2,
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertMap(t, doc)
			},
		},
		{
			name: "WithoutMap NoLocation",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertNoMap(t, doc)
			},
		},
		{
			name: "WithoutMap NoPlace",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Location:  "bar",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertNoMap(t, doc)
			},
		},
		{
			name: "WithoutMap NoLatLng",
			tz:   time.UTC,
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published: true,
					Name:      "foo",
					Location:  "id:0",
				},
			},
			places: []*place.NewPlace{
				{
					Published: true,
					Name:      "bar",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertNoMap(t, doc)
			},
		},
		{
			name: "PastEvents",
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:  true,
					Name:       "my event",
					Organizers: []string{"id:0"},
				},
				// Included
				{
					Published:  true,
					Name:       "past",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
				},
				{
					Published:  true,
					Name:       "multiday",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
					End:        tptr(time.Now().Add(-1 * time.Hour * 24 * 4)),
				},
				// Not included
				{
					Published:  true,
					Name:       "another group",
					Organizers: []string{"id:1"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
				},
				{
					Published:  true,
					Name:       "future",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(time.Hour * 24),
				},
				{
					Published:  false,
					Name:       "not published",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
				},
			},
			groups: []*group.NewGroup{
				{
					Published: true,
					Name:      "group1",
				},
				{
					Published: true,
					Name:      "group2",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertPastEvents(t, doc, []string{"past", "multiday"})
			},
		},
		{
			name: "FutureEvents",
			uri:  "/event/0",
			events: []*event.NewEvent{
				{
					Published:  true,
					Name:       "my event",
					Organizers: []string{"id:0"},
				},
				// Included
				{
					Published:  true,
					Name:       "future",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(time.Hour * 24 * 2),
				},
				{
					Published:  true,
					Name:       "multiday",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(time.Hour * 24 * 2),
					End:        tptr(time.Now().Add(time.Hour * 24 * 4)),
				},
				// Not inlcuded
				{
					Published:  true,
					Name:       "another group",
					Organizers: []string{"id:1"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
				},
				{
					Published:  true,
					Name:       "past",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(-1 * time.Hour * 24),
				},
				{
					Published:  false,
					Name:       "not published",
					Organizers: []string{"id:0"},
					Start:      time.Now().Add(time.Hour * 24 * 2),
				},
			},
			groups: []*group.NewGroup{
				{
					Published: true,
					Name:      "group1",
				},
				{
					Published: true,
					Name:      "group2",
				},
			},
			status: 200,
			htmlTestFunc: func(t *testing.T, doc *goquery.Document) {
				assertFutureEvents(t, doc, []string{"future", "multiday"})
			},
		},
	}

	testRoutes(t, tests)
}

func assertInfoDate(t *testing.T, doc *goquery.Document, date string) {
	t.Helper()
	if diff := cmp.Diff(1, len(doc.Find(".info-date").Nodes)); diff != "" {
		t.Errorf(".info-date mismatch (-want +got):\n%s", diff)
	}
	if diff := cmp.Diff(date, removeWhiteSpace(doc.Find(".info-date .info-data").Text())); diff != "" {
		t.Errorf(".info-date .info-data mismatch (-want +got):\n%s", diff)
	}
}

func assertInfoOrganizers(t *testing.T, doc *goquery.Document, organizers string) {
	t.Helper()
	if organizers == "" {
		if diff := cmp.Diff(0, len(doc.Find(".info-organizers").Nodes)); diff != "" {
			t.Errorf(".info-organizers mismatch (-want +got):\n%s", diff)
		}
	} else {
		if diff := cmp.Diff(1, len(doc.Find(".info-organizers").Nodes)); diff != "" {
			t.Errorf(".info-organizers mismatch (-want +got):\n%s", diff)
		}
		if diff := cmp.Diff(organizers, removeWhiteSpace(doc.Find(".info-organizers .info-data").Text())); diff != "" {
			t.Errorf(".info-organizers .info-data mismatch (-want +got):\n%s", diff)
		}
	}
}

func assertInfoLocation(t *testing.T, doc *goquery.Document, location string, location2 string) {
	t.Helper()
	if location == "" {
		if diff := cmp.Diff(1, len(doc.Find(".info-location").Text())); diff != "" {
			t.Errorf(".info-location mismatch (-want +got):\n%s", diff)
		}
		if location2 == "" {
			if diff := cmp.Diff(location, doc.Find(".info-location .info-data").Text()); diff != "" {
				t.Errorf(".info-location .info-data mismatch (-want +got):\n%s", diff)
			}
		} else {
			if diff := cmp.Diff(fmt.Sprintf("%s, %s", location, location2), doc.Find(".info-location .info-data").Text()); diff != "" {
				t.Errorf(".info-location .info-data mismatch (-want +got):\n%s", diff)
			}
		}
	}
}

func removeWhiteSpace(s string) string {
	noLineBreaks := strings.ReplaceAll(s, "\n", "")
	noTabs := strings.ReplaceAll(noLineBreaks, "    ", "")
	space := regexp.MustCompile(`\s+`)
	return strings.TrimSpace(space.ReplaceAllString(noTabs, " "))
}

func tptr(t time.Time) *time.Time {
	return &t
}

func TestFormartInterval(t *testing.T) {
	tests := []struct {
		interval revent.Interval
		want     string
	}{
		{
			interval: revent.Interval{
				Type:     revent.IntervalWeek,
				Interval: 1,
				WeekDay:  time.Monday,
			},
			want: "Jede Woche Montag",
		},
	}
	for _, tc := range tests {
		if formatInterval(tc.interval) != tc.want {
			t.Errorf("want: %s, got: %s", tc.want, formatInterval(tc.interval))
		}
	}
}

func stringContains(slice []string, item string) bool {
	set := make(map[string]struct{}, len(slice))
	for _, s := range slice {
		set[s] = struct{}{}
	}

	_, ok := set[item]
	return ok
}