pagorminator/pagination_test.go at main · manuelarte/pagorminator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package pagorminator

import (
	"errors"
	"testing"
)

func TestUnPaged(t *testing.T) {
	t.Parallel()

	tests := map[string]struct {
		page     int
		size     int
		expected bool
	}{
		"page 0 size 0": {
			page:     0,
			size:     0,
			expected: true,
		},
		"page zero size not zero": {
			page:     0,
			size:     1,
			expected: false,
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			page, err := NewPageRequest(test.page, test.size)
			if err != nil {
				t.Errorf("Unexpected error: %s", err)
			}

			if page.IsUnPaged() != test.expected {
				t.Errorf("IsUnPaged() expected %v, got %v", test.expected, page.IsUnPaged())
			}
		})
	}
}

func TestCalculateTotalPages(t *testing.T) {
	t.Parallel()

	tests := map[string]struct {
		totalElements int64
		size          int
		expected      int
	}{
		"totalElements lower than size": {
			totalElements: 2,
			size:          4,
			expected:      1,
		},
		"totalElements greater and not divisible by size": {
			totalElements: 3,
			size:          2,
			expected:      2,
		},
		"totalElements greater and divisible by size": {
			totalElements: 4,
			size:          2,
			expected:      2,
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			actual := calculateTotalPages(test.totalElements, test.size)
			if actual != test.expected {
				t.Errorf("totalPages expected %v, got %v", test.expected, actual)
			}
		})
	}
}

func TestSetTotalElements(t *testing.T) {
	t.Parallel()

	tests := map[string]struct {
		totalElements int64
		expectedErr   error
	}{
		"positive totalElements": {
			totalElements: 2,
		},
		"0 totalElements": {
			totalElements: 0,
		},
		"negative totalElements": {
			totalElements: -1,
			expectedErr:   TotalElementsNotValidError{totalElements: -1},
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			p := &Pagination{}

			actualErr := p.SetTotalElements(test.totalElements)
			if !errors.Is(actualErr, test.expectedErr) {
				t.Errorf("expected: %v, got: %v", test.expectedErr, actualErr)
				t.Fail()
			}
		})
	}
}