pllist/internal/service/item_test.go

package service

import (
	"math"
	"strings"
	"testing"

	"git.entityseven.com/rilaxik/pllist/internal/domain"
)

func TestValidateItemTitle(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		want    string
		wantErr bool
	}{
		{name: "trims", input: "  Milk  ", want: "Milk"},
		{name: "empty", input: "", wantErr: true},
		{name: "spaces only", input: "   ", wantErr: true},
		{name: "max length", input: strings.Repeat("a", 200), want: strings.Repeat("a", 200)},
		{name: "too long", input: strings.Repeat("a", 201), wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := validateItemTitle(tt.input)
			if (err != nil) != tt.wantErr {
				t.Fatalf("validateItemTitle() error = %v, wantErr %v", err, tt.wantErr)
			}
			if got != tt.want {
				t.Fatalf("validateItemTitle() = %q, want %q", got, tt.want)
			}
		})
	}
}

func TestValidateItemNote(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		want    string
		wantErr bool
	}{
		{name: "trims", input: "  2% milk  ", want: "2% milk"},
		{name: "empty", input: "", want: ""},
		{name: "max length", input: strings.Repeat("a", 1000), want: strings.Repeat("a", 1000)},
		{name: "too long", input: strings.Repeat("a", 1001), wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := validateItemNote(tt.input)
			if (err != nil) != tt.wantErr {
				t.Fatalf("validateItemNote() error = %v, wantErr %v", err, tt.wantErr)
			}
			if got != tt.want {
				t.Fatalf("validateItemNote() = %q, want %q", got, tt.want)
			}
		})
	}
}

func TestValidUrgency(t *testing.T) {
	for _, urgency := range []domain.Urgency{
		domain.UrgencyLow, domain.UrgencyNormal, domain.UrgencyHigh,
	} {
		if !validUrgency(urgency) {
			t.Fatalf("validUrgency(%q) = false", urgency)
		}
	}
	if validUrgency("urgent") {
		t.Fatal("validUrgency() accepted an unknown value")
	}
}

func TestItemPage(t *testing.T) {
	tests := []struct {
		name      string
		page      ItemPage
		wantPages int
		wantPrev  bool
		wantNext  bool
	}{
		{
			name:      "empty",
			page:      ItemPage{Page: 1, Total: 0},
			wantPages: 1,
		},
		{
			name:      "one full page",
			page:      ItemPage{Page: 1, Total: ItemPageSize},
			wantPages: 1,
		},
		{
			name:      "two pages on first",
			page:      ItemPage{Page: 1, Total: ItemPageSize + 1},
			wantPages: 2,
			wantNext:  true,
		},
		{
			name:      "two pages on last",
			page:      ItemPage{Page: 2, Total: ItemPageSize + 1},
			wantPages: 2,
			wantPrev:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.page.PageCount(); got != tt.wantPages {
				t.Fatalf("PageCount() = %d, want %d", got, tt.wantPages)
			}
			if got := tt.page.HasPrev(); got != tt.wantPrev {
				t.Fatalf("HasPrev() = %v, want %v", got, tt.wantPrev)
			}
			if got := tt.page.HasNext(); got != tt.wantNext {
				t.Fatalf("HasNext() = %v, want %v", got, tt.wantNext)
			}
		})
	}
}

func TestNormalizeItemQuantity(t *testing.T) {
	tests := []struct {
		name    string
		input   float64
		want    float64
		wantErr bool
	}{
		{name: "whole number", input: 2, want: 2},
		{name: "fraction", input: 1.5, want: 1.5},
		{name: "three decimals", input: 1.234, want: 1.234},
		{name: "too many decimals", input: 1.2345, wantErr: true},
		{name: "zero", input: 0, wantErr: true},
		{name: "negative", input: -1, wantErr: true},
		{name: "nan", input: math.NaN(), wantErr: true},
		{name: "infinity", input: math.Inf(1), wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := normalizeItemQuantity(tt.input)
			if (err != nil) != tt.wantErr {
				t.Fatalf("normalizeItemQuantity() error = %v, wantErr %v", err, tt.wantErr)
			}
			if !tt.wantErr && got != tt.want {
				t.Fatalf("normalizeItemQuantity() = %v, want %v", got, tt.want)
			}
		})
	}
}