eintopf.info@v0.13.16/service/place/indexer_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"
// 	"time"

// 	"github.com/petergtz/pegomock"
// 	"eintopf.info/internal/mock"
// 	"eintopf.info/service/place"
// )

// func TestIndexerCreate(t *testing.T) {
// 	for _, test := range []struct {
// 		name       string
// 		place      *place.NewPlace
// 		err        bool
// 		callsIndex bool
// 	}{
// 		{
// 			name:       "Error->Abort",
// 			err:        true,
// 			callsIndex: false,
// 		}, {
// 			name:       "NotPublished->Nothing",
// 			place:      &place.NewPlace{Published: false},
// 			err:        false,
// 			callsIndex: false,
// 		}, {
// 			name:       "Published->Index",
// 			place:      &place.NewPlace{Published: true},
// 			err:        false,
// 			callsIndex: true,
// 		},
// 	} {
// 		t.Run(test.name, func(tt *testing.T) {
// 			pegomock.RegisterMockTestingT(tt)
// 			ctx := context.Background()

// 			mockedService := mock.NewPlaceService()
// 			mockedSearch := mock.NewSearchService()
// 			indexer := place.NewIndexer(mockedService, mockedSearch)

// 			g := &place.Place{}
// 			if test.place != nil {
// 				g.Published = test.place.Published
// 			}
// 			if test.err {
// 				pegomock.When(mockedService.Create(ctx, nil)).
// 					ThenReturn(nil, fmt.Errorf("error"))
// 			} else {
// 				pegomock.When(mockedService.Create(ctx, test.place)).
// 					ThenReturn(g, nil)
// 			}

// 			indexer.Create(context.Background(), test.place)

// 			// Allow the goroutine to be called.
// 			time.Sleep(time.Millisecond)

// 			if test.callsIndex {
// 				mockedSearch.VerifyWasCalledOnce().Index(g)
// 			} else {
// 				mockedSearch.VerifyWasCalled(pegomock.Never()).Index(g)
// 			}
// 		})
// 	}
// }

// func TestIndexerUpdate(t *testing.T) {
// 	for _, test := range []struct {
// 		name        string
// 		place       *place.Place
// 		err         bool
// 		callsIndex  bool
// 		callsDelete bool
// 	}{
// 		{
// 			name:        "Error->Abort",
// 			place:       &place.Place{},
// 			err:         true,
// 			callsIndex:  false,
// 			callsDelete: false,
// 		}, {
// 			name:        "NotPublished->Delete",
// 			place:       &place.Place{ID: "foo", Published: false},
// 			err:         false,
// 			callsIndex:  false,
// 			callsDelete: true,
// 		}, {
// 			name:        "Published->Index",
// 			place:       &place.Place{Published: true},
// 			err:         false,
// 			callsIndex:  true,
// 			callsDelete: false,
// 		},
// 	} {
// 		t.Run(test.name, func(tt *testing.T) {
// 			pegomock.RegisterMockTestingT(tt)
// 			ctx := context.Background()

// 			mockedService := mock.NewPlaceService()
// 			mockedSearch := mock.NewSearchService()
// 			indexer := place.NewIndexer(mockedService, mockedSearch)

// 			if test.err {
// 				pegomock.When(mockedService.Update(ctx, nil)).
// 					ThenReturn(nil, fmt.Errorf("error"))
// 			} else {
// 				pegomock.When(mockedService.Update(ctx, test.place)).
// 					ThenReturn(test.place, nil)
// 			}

// 			indexer.Update(context.Background(), test.place)

// 			// Allow the goroutine to be called.
// 			time.Sleep(time.Millisecond)

// 			if test.callsIndex {
// 				mockedSearch.VerifyWasCalledOnce().Index(test.place)
// 			} else {
// 				mockedSearch.VerifyWasCalled(pegomock.Never()).Index(test.place)
// 			}
// 			if test.callsDelete {
// 				mockedSearch.VerifyWasCalledOnce().Delete("place", test.place.ID)
// 			} else {
// 				mockedSearch.VerifyWasCalled(pegomock.Never()).Delete("place", test.place.ID)
// 			}
// 		})
// 	}
// }

// func TestIndexerDelete(t *testing.T) {
// 	for _, test := range []struct {
// 		name        string
// 		id          string
// 		err         bool
// 		callsDelete bool
// 	}{
// 		{
// 			name:        "Error->Abort",
// 			err:         true,
// 			callsDelete: false,
// 		}, {
// 			name:        "NoError->Delete",
// 			id:          "foo",
// 			err:         false,
// 			callsDelete: true,
// 		},
// 	} {
// 		t.Run(test.name, func(tt *testing.T) {
// 			pegomock.RegisterMockTestingT(tt)
// 			ctx := context.Background()

// 			mockedService := mock.NewPlaceService()
// 			mockedSearch := mock.NewSearchService()
// 			indexer := place.NewIndexer(mockedService, mockedSearch)

// 			if test.err {
// 				pegomock.When(mockedService.Delete(ctx, test.id)).
// 					ThenReturn(fmt.Errorf("error"))
// 			} else {
// 				pegomock.When(mockedService.Delete(ctx, test.id)).
// 					ThenReturn(nil)
// 			}

// 			indexer.Delete(context.Background(), test.id)

// 			// Allow the goroutine to be called.
// 			time.Sleep(time.Millisecond)

// 			if test.callsDelete {
// 				mockedSearch.VerifyWasCalledOnce().Delete("place", test.id)
// 			} else {
// 				mockedSearch.VerifyWasCalled(pegomock.Never()).Delete("place", test.id)
// 			}
// 		})
// 	}
// }