eintopf.info@v0.13.16/service/place/place_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 place_test

import (
	"context"
	"fmt"
	"testing"

	"github.com/petergtz/pegomock"

	"eintopf.info/internal/crud"
	"eintopf.info/internal/mock"
	"eintopf.info/service/auth"
	"eintopf.info/service/place"
)

func TestPlaceIndexable(t *testing.T) {
	for i, test := range []struct {
		place     *place.Place
		indexable bool
	}{
		{
			place:     &place.Place{Deactivated: true, Published: true},
			indexable: false,
		}, {
			place:     &place.Place{Deactivated: false, Published: false},
			indexable: true,
		}, {
			place:     &place.Place{Deactivated: false, Published: true},
			indexable: true,
		},
	} {
		t.Run(fmt.Sprintf("%d", i), func(tt *testing.T) {
			if test.place.Indexable() != test.indexable {
				tt.Errorf("%d: Deactivated: %t Published: %t -> Indexable %t", i, test.place.Deactivated, test.place.Published, test.place.Indexable())
			}
		})
	}
}

func TestPlaceListable(t *testing.T) {
	for i, test := range []struct {
		place    *place.Place
		listable bool
	}{
		{
			place:    &place.Place{Deactivated: true, Published: true},
			listable: true,
		}, {
			place:    &place.Place{Deactivated: false, Published: false},
			listable: false,
		}, {
			place:    &place.Place{Deactivated: false, Published: true},
			listable: true,
		},
	} {
		t.Run(fmt.Sprintf("%d", i), func(tt *testing.T) {
			if test.place.Listable() != test.listable {
				tt.Errorf("%d: Deactivated: %t Published: %t -> Listable %t", i, test.place.Deactivated, test.place.Published, test.place.Listable())
			}
		})
	}
}

func TestPlaceIsOwned(t *testing.T) {
	for _, test := range []struct {
		name  string
		place *place.Place
		id    string
		owned bool
	}{
		{
			name:  "Owned",
			place: &place.Place{OwnedBy: []string{"foo", "bar"}},
			id:    "foo",
			owned: true,
		}, {
			name:  "NotOwned",
			place: &place.Place{OwnedBy: []string{"bar"}},
			id:    "foo",
			owned: false,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			if test.place.IsOwned(test.id) != test.owned {
				tt.Errorf("test.place.IsOwned(%s) != test.owned: %t != %t", test.id, test.place.IsOwned(test.id), test.owned)
			}
		})
	}
}

func TestNewPlaceIsOwned(t *testing.T) {
	for _, test := range []struct {
		name  string
		place *place.NewPlace
		id    string
		owned bool
	}{
		{
			name:  "Owned",
			place: &place.NewPlace{OwnedBy: []string{"foo", "bar"}},
			id:    "foo",
			owned: true,
		}, {
			name:  "NotOwned",
			place: &place.NewPlace{OwnedBy: []string{"bar"}},
			id:    "foo",
			owned: false,
		},
	} {
		t.Run(test.name, func(tt *testing.T) {
			if test.place.IsOwned(test.id) != test.owned {
				tt.Errorf("test.place.IsOwned(%s) != test.owned: %t != %t", test.id, test.place.IsOwned(test.id), test.owned)
			}
		})
	}
}

func TestServiceCreateAddsOwnedBy(t *testing.T) {
	pegomock.RegisterMockTestingT(t)

	mockedStore := mock.NewPlaceStore()
	service := place.NewService(mockedStore)

	g := &place.NewPlace{OwnedBy: []string{"foo"}}
	ctx := auth.ContextWithID(context.Background(), "bar")
	service.Create(ctx, g)

	mockedStore.VerifyWasCalledOnce().Create(ctx, &place.NewPlace{
		OwnedBy: []string{"foo", "bar"},
	})
}

func TestServiceCreateWhiteSpace(t *testing.T) {
	store := place.NewMemoryStore()
	service := place.NewService(store)

	ctx := auth.ContextWithID(context.Background(), "bar")
	p, _ := service.Create(ctx, &place.NewPlace{Name: " foo "})
	if p.Name != "foo" {
		t.Fatalf("should remove white space from name: '%s'", p.Name)
	}
}

func TestServiceFindFilterOwnedBySelf(t *testing.T) {
	pegomock.RegisterMockTestingT(t)

	mockedStore := mock.NewPlaceStore()
	service := place.NewService(mockedStore)

	ctx := auth.ContextWithID(context.Background(), "bar")
	service.Find(ctx, &crud.FindParams[place.FindFilters]{
		Filters: &place.FindFilters{OwnedBy: []string{"self"}},
	})

	mockedStore.VerifyWasCalledOnce().Find(ctx, &crud.FindParams[place.FindFilters]{
		Filters: &place.FindFilters{OwnedBy: []string{"bar"}},
	})
}