eintopf.info@v0.13.16/service/group/group_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 group_test

import (
	"context"
	"fmt"
	"testing"

	"github.com/petergtz/pegomock"

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

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

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

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

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

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

	mockedStore := mock.NewGroupStore()
	service := group.NewService(mockedStore)

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

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

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

	ctx := auth.ContextWithID(context.Background(), "bar")
	g, _ := service.Create(ctx, &group.NewGroup{Name: " foo "})

	if g.Name != "foo" {
		t.Fatalf("should remove white space from name: '%s'", g.Name)
	}
}

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

	mockedStore := mock.NewGroupStore()
	service := group.NewService(mockedStore)

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

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