|
| 1 | +package frontend |
| 2 | + |
| 3 | +import ( |
| 4 | + "strconv" |
| 5 | + "strings" |
| 6 | + "testing" |
| 7 | + |
| 8 | + "github.com/stretchr/testify/assert" |
| 9 | +) |
| 10 | + |
| 11 | +// renderPages produces a compact string like "1 2 [3] 4 5 … 20" so test |
| 12 | +// expectations read like the buttons a user sees. Active pages are |
| 13 | +// bracketed; ellipsis slots render as an ellipsis character. |
| 14 | +func renderPages(pages []PageLink) string { |
| 15 | + parts := make([]string, 0, len(pages)) |
| 16 | + for _, p := range pages { |
| 17 | + switch { |
| 18 | + case p.Ellipsis: |
| 19 | + parts = append(parts, "…") |
| 20 | + case p.Active: |
| 21 | + parts = append(parts, "["+strconv.Itoa(p.Number)+"]") |
| 22 | + default: |
| 23 | + parts = append(parts, strconv.Itoa(p.Number)) |
| 24 | + } |
| 25 | + } |
| 26 | + return strings.Join(parts, " ") |
| 27 | +} |
| 28 | + |
| 29 | +func TestBuildPageList(t *testing.T) { |
| 30 | + // Expected outputs cross-referenced against BootstrapVue's |
| 31 | + // <b-pagination-nav first-number last-number> with default limit=5. |
| 32 | + cases := []struct { |
| 33 | + name string |
| 34 | + currentPage int |
| 35 | + totalPages int |
| 36 | + want string |
| 37 | + }{ |
| 38 | + {"empty", 1, 0, ""}, |
| 39 | + {"single", 1, 1, "[1]"}, |
| 40 | + {"two pages", 1, 2, "[1] 2"}, |
| 41 | + {"five pages current 1", 1, 5, "[1] 2 3 4 5"}, |
| 42 | + {"five pages current 3", 3, 5, "1 2 [3] 4 5"}, |
| 43 | + {"six pages current 1", 1, 6, "[1] 2 3 4 5 6"}, |
| 44 | + {"six pages current 2", 2, 6, "1 [2] 3 4 5 6"}, |
| 45 | + {"six pages current 3", 3, 6, "1 2 [3] 4 5 6"}, |
| 46 | + {"six pages current 4", 4, 6, "1 2 3 [4] 5 6"}, |
| 47 | + {"six pages current 5", 5, 6, "1 2 3 4 [5] 6"}, |
| 48 | + {"six pages current 6", 6, 6, "1 2 3 4 5 [6]"}, |
| 49 | + {"ten pages current 1 ellipsis right", 1, 10, "[1] 2 3 4 5 … 10"}, |
| 50 | + {"ten pages current 3 ellipsis right", 3, 10, "1 2 [3] 4 5 … 10"}, |
| 51 | + {"ten pages current 4 collapses left", 4, 10, "1 2 3 [4] 5 … 10"}, |
| 52 | + {"ten pages current 5 both sides", 5, 10, "1 … 4 [5] 6 … 10"}, |
| 53 | + {"ten pages current 6 both sides", 6, 10, "1 … 5 [6] 7 … 10"}, |
| 54 | + {"ten pages current 7 collapses right", 7, 10, "1 … 6 [7] 8 9 10"}, |
| 55 | + {"ten pages current 8 near end", 8, 10, "1 … 6 7 [8] 9 10"}, |
| 56 | + {"ten pages current 10 near end", 10, 10, "1 … 6 7 8 9 [10]"}, |
| 57 | + {"twenty pages current 1", 1, 20, "[1] 2 3 4 5 … 20"}, |
| 58 | + {"twenty pages current 10 middle", 10, 20, "1 … 9 [10] 11 … 20"}, |
| 59 | + {"twenty pages current 17 collapses right", 17, 20, "1 … 16 [17] 18 19 20"}, |
| 60 | + {"twenty pages current 20", 20, 20, "1 … 16 17 18 19 [20]"}, |
| 61 | + } |
| 62 | + |
| 63 | + for _, tc := range cases { |
| 64 | + t.Run(tc.name, func(t *testing.T) { |
| 65 | + got := renderPages(buildPageList(tc.currentPage, tc.totalPages)) |
| 66 | + assert.Equal(t, tc.want, got) |
| 67 | + }) |
| 68 | + } |
| 69 | +} |
| 70 | + |
| 71 | +func TestComputePagination(t *testing.T) { |
| 72 | + t.Run("zero total returns empty", func(t *testing.T) { |
| 73 | + p := computePagination(0, 0) |
| 74 | + assert.Equal(t, 0, p.TotalPages) |
| 75 | + assert.Empty(t, p.Pages) |
| 76 | + assert.False(t, p.HasPrev) |
| 77 | + assert.False(t, p.HasNext) |
| 78 | + }) |
| 79 | + |
| 80 | + t.Run("offset drives current page", func(t *testing.T) { |
| 81 | + p := computePagination(40, 200) // page 5 of 20 |
| 82 | + assert.Equal(t, 5, p.CurrentPage) |
| 83 | + assert.Equal(t, 20, p.TotalPages) |
| 84 | + assert.Equal(t, "1 … 4 [5] 6 … 20", renderPages(p.Pages)) |
| 85 | + assert.True(t, p.HasPrev) |
| 86 | + assert.True(t, p.HasNext) |
| 87 | + assert.Equal(t, 30, p.PrevOffset) |
| 88 | + assert.Equal(t, 50, p.NextOffset) |
| 89 | + }) |
| 90 | + |
| 91 | + t.Run("first page offsets", func(t *testing.T) { |
| 92 | + p := computePagination(0, 200) |
| 93 | + assert.False(t, p.HasPrev) |
| 94 | + assert.True(t, p.HasNext) |
| 95 | + assert.Equal(t, 10, p.NextOffset) |
| 96 | + }) |
| 97 | + |
| 98 | + t.Run("last page offsets", func(t *testing.T) { |
| 99 | + p := computePagination(190, 200) |
| 100 | + assert.True(t, p.HasPrev) |
| 101 | + assert.False(t, p.HasNext) |
| 102 | + assert.Equal(t, 180, p.PrevOffset) |
| 103 | + }) |
| 104 | + |
| 105 | + t.Run("page link offsets use buildsPerPage", func(t *testing.T) { |
| 106 | + p := computePagination(0, 100) |
| 107 | + for _, link := range p.Pages { |
| 108 | + if link.Ellipsis { |
| 109 | + continue |
| 110 | + } |
| 111 | + assert.Equal(t, (link.Number-1)*buildsPerPage, link.Offset) |
| 112 | + } |
| 113 | + }) |
| 114 | +} |
0 commit comments