320 lines
9.7 KiB
Go
320 lines
9.7 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"wucher/internal/domain/helicopter"
|
|
)
|
|
|
|
type helicopterRepoMock struct {
|
|
createCalled bool
|
|
updateCalled bool
|
|
deleteCalled bool
|
|
getByIDCalled bool
|
|
listCalled bool
|
|
nextReportNumberCalled bool
|
|
isInUseCalled bool
|
|
inUseByIDsCalled bool
|
|
existsByIdentifier bool
|
|
existsCalled bool
|
|
|
|
lastCreate *helicopter.Helicopter
|
|
lastUpdate *helicopter.Helicopter
|
|
lastDeleteID []byte
|
|
lastGetByID []byte
|
|
lastListFilter string
|
|
lastListStatuses []string
|
|
lastListSort string
|
|
lastListLimit int
|
|
lastListOffset int
|
|
lastNextReportID []byte
|
|
lastIsInUseID []byte
|
|
lastInUseIDs [][]byte
|
|
|
|
getByIDResult *helicopter.Helicopter
|
|
listResult []helicopter.Helicopter
|
|
listTotal int64
|
|
nextReportNumberResult string
|
|
nextReportCounter int
|
|
isInUseResult bool
|
|
inUseByIDsResult map[string]bool
|
|
existsByIdentifierID string
|
|
existsByIdentifierSkip []byte
|
|
|
|
createErr error
|
|
updateErr error
|
|
deleteErr error
|
|
getByIDErr error
|
|
listErr error
|
|
nextReportNumberErr error
|
|
isInUseErr error
|
|
inUseByIDsErr error
|
|
existsErr error
|
|
}
|
|
|
|
func (m *helicopterRepoMock) Create(_ context.Context, row *helicopter.Helicopter) error {
|
|
m.createCalled = true
|
|
m.lastCreate = row
|
|
return m.createErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) Update(_ context.Context, row *helicopter.Helicopter) error {
|
|
m.updateCalled = true
|
|
m.lastUpdate = row
|
|
return m.updateErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) Delete(_ context.Context, id []byte) error {
|
|
m.deleteCalled = true
|
|
m.lastDeleteID = id
|
|
return m.deleteErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) GetByID(_ context.Context, id []byte) (*helicopter.Helicopter, error) {
|
|
m.getByIDCalled = true
|
|
m.lastGetByID = id
|
|
return m.getByIDResult, m.getByIDErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) List(_ context.Context, filter string, statuses []string, sort string, limit, offset int, _ [][]byte) ([]helicopter.Helicopter, int64, error) {
|
|
m.listCalled = true
|
|
m.lastListFilter = filter
|
|
m.lastListStatuses = statuses
|
|
m.lastListSort = sort
|
|
m.lastListLimit = limit
|
|
m.lastListOffset = offset
|
|
return m.listResult, m.listTotal, m.listErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) NextReportNumber(_ context.Context, id []byte) (string, int, error) {
|
|
m.nextReportNumberCalled = true
|
|
m.lastNextReportID = id
|
|
return m.nextReportNumberResult, m.nextReportCounter, m.nextReportNumberErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) IsInUse(_ context.Context, id []byte) (bool, error) {
|
|
m.isInUseCalled = true
|
|
m.lastIsInUseID = append([]byte(nil), id...)
|
|
return m.isInUseResult, m.isInUseErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) InUseByAircraftIDs(_ context.Context, ids [][]byte) (map[string]bool, error) {
|
|
m.inUseByIDsCalled = true
|
|
m.lastInUseIDs = m.lastInUseIDs[:0]
|
|
for i := range ids {
|
|
m.lastInUseIDs = append(m.lastInUseIDs, append([]byte(nil), ids[i]...))
|
|
}
|
|
if m.inUseByIDsResult == nil {
|
|
return map[string]bool{}, m.inUseByIDsErr
|
|
}
|
|
return m.inUseByIDsResult, m.inUseByIDsErr
|
|
}
|
|
|
|
func (m *helicopterRepoMock) ActiveFlightIDByAircraftIDs(_ context.Context, _ [][]byte) (map[string][]byte, error) {
|
|
return map[string][]byte{}, nil
|
|
}
|
|
|
|
func (m *helicopterRepoMock) ExistsByIdentifier(_ context.Context, identifier string, excludeID []byte) (bool, error) {
|
|
m.existsCalled = true
|
|
m.existsByIdentifierID = identifier
|
|
m.existsByIdentifierSkip = append([]byte(nil), excludeID...)
|
|
return m.existsByIdentifier, m.existsErr
|
|
}
|
|
|
|
func TestNewHelicopterService(t *testing.T) {
|
|
repo := &helicopterRepoMock{}
|
|
svc := NewHelicopterService(repo)
|
|
if svc == nil || svc.repo == nil {
|
|
t.Fatalf("expected service and repo initialized")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceCreate(t *testing.T) {
|
|
repo := &helicopterRepoMock{}
|
|
svc := NewHelicopterService(repo)
|
|
row := &helicopter.Helicopter{Designation: "H145", Identifier: "PK-ABC", Type: "Twin"}
|
|
|
|
if err := svc.Create(context.Background(), row); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !repo.createCalled || repo.lastCreate != row {
|
|
t.Fatalf("expected Create forwarded to repo")
|
|
}
|
|
|
|
repo.createErr = errors.New("create failed")
|
|
if err := svc.Create(context.Background(), row); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceUpdate(t *testing.T) {
|
|
repo := &helicopterRepoMock{}
|
|
svc := NewHelicopterService(repo)
|
|
row := &helicopter.Helicopter{Designation: "H145", Identifier: "PK-ABC", Type: "Twin"}
|
|
|
|
if err := svc.Update(context.Background(), row); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !repo.updateCalled || repo.lastUpdate != row {
|
|
t.Fatalf("expected Update forwarded to repo")
|
|
}
|
|
|
|
repo.updateErr = errors.New("update failed")
|
|
if err := svc.Update(context.Background(), row); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceDelete(t *testing.T) {
|
|
repo := &helicopterRepoMock{}
|
|
svc := NewHelicopterService(repo)
|
|
id := []byte("id")
|
|
|
|
if err := svc.Delete(context.Background(), id); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !repo.deleteCalled {
|
|
t.Fatalf("expected Delete forwarded to repo")
|
|
}
|
|
if string(repo.lastDeleteID) != string(id) {
|
|
t.Fatalf("expected delete id forwarded")
|
|
}
|
|
|
|
repo.deleteErr = errors.New("delete failed")
|
|
if err := svc.Delete(context.Background(), id); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceGetByID(t *testing.T) {
|
|
expected := &helicopter.Helicopter{Designation: "H145", Identifier: "PK-ABC", Type: "Twin"}
|
|
repo := &helicopterRepoMock{getByIDResult: expected}
|
|
svc := NewHelicopterService(repo)
|
|
id := []byte("id")
|
|
|
|
got, err := svc.GetByID(context.Background(), id)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got != expected {
|
|
t.Fatalf("unexpected result")
|
|
}
|
|
if !repo.getByIDCalled || string(repo.lastGetByID) != string(id) {
|
|
t.Fatalf("expected GetByID forwarded")
|
|
}
|
|
|
|
repo.getByIDErr = errors.New("get failed")
|
|
if _, err := svc.GetByID(context.Background(), id); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceList(t *testing.T) {
|
|
repo := &helicopterRepoMock{
|
|
listResult: []helicopter.Helicopter{{Designation: "H145", Identifier: "PK-ABC", Type: "Twin"}},
|
|
listTotal: 1,
|
|
}
|
|
svc := NewHelicopterService(repo)
|
|
|
|
rows, total, err := svc.List(context.Background(), "find", []string{"available", "booked"}, "-designation", 10, 20, nil)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(rows) != 1 || total != 1 {
|
|
t.Fatalf("unexpected list result")
|
|
}
|
|
if !repo.listCalled {
|
|
t.Fatalf("expected List forwarded to repo")
|
|
}
|
|
if repo.lastListFilter != "find" || repo.lastListSort != "designation DESC" || repo.lastListLimit != 10 || repo.lastListOffset != 20 {
|
|
t.Fatalf("unexpected list args forwarded")
|
|
}
|
|
if len(repo.lastListStatuses) != 2 || repo.lastListStatuses[0] != "available" || repo.lastListStatuses[1] != "booked" {
|
|
t.Fatalf("unexpected status filter forwarded: %v", repo.lastListStatuses)
|
|
}
|
|
|
|
repo.listErr = errors.New("list failed")
|
|
if _, _, err := svc.List(context.Background(), "", nil, "unknown", 1, 0, nil); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
if repo.lastListSort != "" {
|
|
t.Fatalf("expected unknown sort normalized to empty")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceExistsByIdentifier(t *testing.T) {
|
|
repo := &helicopterRepoMock{existsByIdentifier: true}
|
|
svc := NewHelicopterService(repo)
|
|
excludeID := []byte("id")
|
|
|
|
exists, err := svc.ExistsByIdentifier(context.Background(), "SN-0001", excludeID)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !exists {
|
|
t.Fatalf("expected duplicate exists result")
|
|
}
|
|
if !repo.existsCalled || repo.existsByIdentifierID != "SN-0001" || string(repo.existsByIdentifierSkip) != string(excludeID) {
|
|
t.Fatalf("expected ExistsByIdentifier forwarded")
|
|
}
|
|
|
|
repo.existsErr = errors.New("exists failed")
|
|
if _, err := svc.ExistsByIdentifier(context.Background(), "SN-0001", nil); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestHelicopterServiceNextReportNumber(t *testing.T) {
|
|
repo := &helicopterRepoMock{
|
|
nextReportNumberResult: "RPT-0001",
|
|
nextReportCounter: 1,
|
|
}
|
|
svc := NewHelicopterService(repo)
|
|
id := []byte("id")
|
|
|
|
number, counter, err := svc.NextReportNumber(context.Background(), id)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if number != "RPT-0001" || counter != 1 {
|
|
t.Fatalf("unexpected next report result")
|
|
}
|
|
if !repo.nextReportNumberCalled || string(repo.lastNextReportID) != string(id) {
|
|
t.Fatalf("expected NextReportNumber forwarded")
|
|
}
|
|
|
|
repo.nextReportNumberErr = errors.New("next failed")
|
|
if _, _, err := svc.NextReportNumber(context.Background(), id); err == nil {
|
|
t.Fatalf("expected error from repo")
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHelicopterSort(t *testing.T) {
|
|
cases := map[string]string{
|
|
"designation": "designation ASC",
|
|
"-designation": "designation DESC",
|
|
"sortkey": "is_active DESC, CASE WHEN is_active = 1 AND sortkey IS NOT NULL AND sortkey >= 0 THEN 0 ELSE 1 END ASC, CASE WHEN is_active = 1 AND sortkey IS NOT NULL AND sortkey >= 0 THEN sortkey END ASC, designation ASC",
|
|
"-sortkey": "is_active DESC, CASE WHEN is_active = 1 AND sortkey IS NOT NULL AND sortkey >= 0 THEN 0 ELSE 1 END ASC, CASE WHEN is_active = 1 AND sortkey IS NOT NULL AND sortkey >= 0 THEN sortkey END DESC, designation ASC",
|
|
"identifier": "",
|
|
"-identifier": "",
|
|
"type": "",
|
|
"-type": "",
|
|
"counter": "",
|
|
"-counter": "",
|
|
"created_at": "",
|
|
"-created_at": "",
|
|
"updated_at": "",
|
|
"-updated_at": "",
|
|
"unknown": "",
|
|
"": "",
|
|
}
|
|
|
|
for in, want := range cases {
|
|
if got := normalizeHelicopterSort(in); got != want {
|
|
t.Fatalf("normalizeHelicopterSort(%q) = %q, want %q", in, got, want)
|
|
}
|
|
}
|
|
}
|