code.gitea.io/gitea@v1.19.3/modules/paginator/paginator_test.go (about)

     1  // Copyright 2022 The Gitea Authors.
     2  // Copyright 2015 https://github.com/unknwon. Licensed under the Apache License, Version 2.0
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package paginator
     6  
     7  import (
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestPaginator(t *testing.T) {
    14  	t.Run("Basic logics", func(t *testing.T) {
    15  		p := New(0, -1, -1, 0)
    16  		assert.Equal(t, 1, p.PagingNum())
    17  		assert.True(t, p.IsFirst())
    18  		assert.False(t, p.HasPrevious())
    19  		assert.Equal(t, 1, p.Previous())
    20  		assert.False(t, p.HasNext())
    21  		assert.Equal(t, 1, p.Next())
    22  		assert.True(t, p.IsLast())
    23  		assert.Equal(t, 0, p.Total())
    24  
    25  		p = New(1, 10, 2, 0)
    26  		assert.Equal(t, 10, p.PagingNum())
    27  		assert.True(t, p.IsFirst())
    28  		assert.False(t, p.HasPrevious())
    29  		assert.False(t, p.HasNext())
    30  		assert.True(t, p.IsLast())
    31  
    32  		p = New(10, 10, 1, 0)
    33  		assert.Equal(t, 10, p.PagingNum())
    34  		assert.True(t, p.IsFirst())
    35  		assert.False(t, p.HasPrevious())
    36  		assert.False(t, p.HasNext())
    37  		assert.True(t, p.IsLast())
    38  
    39  		p = New(11, 10, 1, 0)
    40  		assert.Equal(t, 10, p.PagingNum())
    41  		assert.True(t, p.IsFirst())
    42  		assert.False(t, p.HasPrevious())
    43  		assert.True(t, p.HasNext())
    44  		assert.Equal(t, 2, p.Next())
    45  		assert.False(t, p.IsLast())
    46  
    47  		p = New(11, 10, 2, 0)
    48  		assert.Equal(t, 10, p.PagingNum())
    49  		assert.False(t, p.IsFirst())
    50  		assert.True(t, p.HasPrevious())
    51  		assert.Equal(t, 1, p.Previous())
    52  		assert.False(t, p.HasNext())
    53  		assert.True(t, p.IsLast())
    54  
    55  		p = New(20, 10, 2, 0)
    56  		assert.Equal(t, 10, p.PagingNum())
    57  		assert.False(t, p.IsFirst())
    58  		assert.True(t, p.HasPrevious())
    59  		assert.False(t, p.HasNext())
    60  		assert.True(t, p.IsLast())
    61  
    62  		p = New(25, 10, 2, 0)
    63  		assert.Equal(t, 10, p.PagingNum())
    64  		assert.False(t, p.IsFirst())
    65  		assert.True(t, p.HasPrevious())
    66  		assert.True(t, p.HasNext())
    67  		assert.False(t, p.IsLast())
    68  	})
    69  
    70  	t.Run("Generate pages", func(t *testing.T) {
    71  		p := New(0, 10, 1, 0)
    72  		pages := p.Pages()
    73  		assert.Equal(t, 0, len(pages))
    74  	})
    75  
    76  	t.Run("Only current page", func(t *testing.T) {
    77  		p := New(0, 10, 1, 1)
    78  		pages := p.Pages()
    79  		assert.Equal(t, 1, len(pages))
    80  		assert.Equal(t, 1, pages[0].Num())
    81  		assert.True(t, pages[0].IsCurrent())
    82  
    83  		p = New(1, 10, 1, 1)
    84  		pages = p.Pages()
    85  		assert.Equal(t, 1, len(pages))
    86  		assert.Equal(t, 1, pages[0].Num())
    87  		assert.True(t, pages[0].IsCurrent())
    88  	})
    89  
    90  	t.Run("Total page number is less or equal", func(t *testing.T) {
    91  		p := New(1, 10, 1, 2)
    92  		pages := p.Pages()
    93  		assert.Equal(t, 1, len(pages))
    94  		assert.Equal(t, 1, pages[0].Num())
    95  		assert.True(t, pages[0].IsCurrent())
    96  
    97  		p = New(11, 10, 1, 2)
    98  		pages = p.Pages()
    99  		assert.Equal(t, 2, len(pages))
   100  		assert.Equal(t, 1, pages[0].Num())
   101  		assert.True(t, pages[0].IsCurrent())
   102  		assert.Equal(t, 2, pages[1].Num())
   103  		assert.False(t, pages[1].IsCurrent())
   104  
   105  		p = New(11, 10, 2, 2)
   106  		pages = p.Pages()
   107  		assert.Equal(t, 2, len(pages))
   108  		assert.Equal(t, 1, pages[0].Num())
   109  		assert.False(t, pages[0].IsCurrent())
   110  		assert.Equal(t, 2, pages[1].Num())
   111  		assert.True(t, pages[1].IsCurrent())
   112  
   113  		p = New(25, 10, 2, 3)
   114  		pages = p.Pages()
   115  		assert.Equal(t, 3, len(pages))
   116  		assert.Equal(t, 1, pages[0].Num())
   117  		assert.False(t, pages[0].IsCurrent())
   118  		assert.Equal(t, 2, pages[1].Num())
   119  		assert.True(t, pages[1].IsCurrent())
   120  		assert.Equal(t, 3, pages[2].Num())
   121  		assert.False(t, pages[2].IsCurrent())
   122  	})
   123  
   124  	t.Run("Has more previous pages ", func(t *testing.T) {
   125  		// ... 2
   126  		p := New(11, 10, 2, 1)
   127  		pages := p.Pages()
   128  		assert.Equal(t, 2, len(pages))
   129  		assert.Equal(t, -1, pages[0].Num())
   130  		assert.False(t, pages[0].IsCurrent())
   131  		assert.Equal(t, 2, pages[1].Num())
   132  		assert.True(t, pages[1].IsCurrent())
   133  
   134  		// ... 2 3
   135  		p = New(21, 10, 2, 2)
   136  		pages = p.Pages()
   137  		assert.Equal(t, 3, len(pages))
   138  		assert.Equal(t, -1, pages[0].Num())
   139  		assert.False(t, pages[0].IsCurrent())
   140  		assert.Equal(t, 2, pages[1].Num())
   141  		assert.True(t, pages[1].IsCurrent())
   142  		assert.Equal(t, 3, pages[2].Num())
   143  		assert.False(t, pages[2].IsCurrent())
   144  
   145  		// ... 2 3 4
   146  		p = New(31, 10, 3, 3)
   147  		pages = p.Pages()
   148  		assert.Equal(t, 4, len(pages))
   149  		assert.Equal(t, -1, pages[0].Num())
   150  		assert.False(t, pages[0].IsCurrent())
   151  		assert.Equal(t, 2, pages[1].Num())
   152  		assert.False(t, pages[1].IsCurrent())
   153  		assert.Equal(t, 3, pages[2].Num())
   154  		assert.True(t, pages[2].IsCurrent())
   155  		assert.Equal(t, 4, pages[3].Num())
   156  		assert.False(t, pages[3].IsCurrent())
   157  
   158  		// ... 3 4 5
   159  		p = New(41, 10, 4, 3)
   160  		pages = p.Pages()
   161  		assert.Equal(t, 4, len(pages))
   162  		assert.Equal(t, -1, pages[0].Num())
   163  		assert.False(t, pages[0].IsCurrent())
   164  		assert.Equal(t, 3, pages[1].Num())
   165  		assert.False(t, pages[1].IsCurrent())
   166  		assert.Equal(t, 4, pages[2].Num())
   167  		assert.True(t, pages[2].IsCurrent())
   168  		assert.Equal(t, 5, pages[3].Num())
   169  		assert.False(t, pages[3].IsCurrent())
   170  
   171  		// ... 4 5 6 7 8 9 10
   172  		p = New(100, 10, 9, 7)
   173  		pages = p.Pages()
   174  		assert.Equal(t, 8, len(pages))
   175  		assert.Equal(t, -1, pages[0].Num())
   176  		assert.False(t, pages[0].IsCurrent())
   177  		assert.Equal(t, 4, pages[1].Num())
   178  		assert.False(t, pages[1].IsCurrent())
   179  		assert.Equal(t, 5, pages[2].Num())
   180  		assert.False(t, pages[2].IsCurrent())
   181  		assert.Equal(t, 6, pages[3].Num())
   182  		assert.False(t, pages[3].IsCurrent())
   183  		assert.Equal(t, 7, pages[4].Num())
   184  		assert.False(t, pages[4].IsCurrent())
   185  		assert.Equal(t, 8, pages[5].Num())
   186  		assert.False(t, pages[5].IsCurrent())
   187  		assert.Equal(t, 9, pages[6].Num())
   188  		assert.True(t, pages[6].IsCurrent())
   189  		assert.Equal(t, 10, pages[7].Num())
   190  		assert.False(t, pages[7].IsCurrent())
   191  	})
   192  
   193  	t.Run("Has more next pages", func(t *testing.T) {
   194  		// 1 ...
   195  		p := New(21, 10, 1, 1)
   196  		pages := p.Pages()
   197  		assert.Equal(t, 2, len(pages))
   198  		assert.Equal(t, 1, pages[0].Num())
   199  		assert.True(t, pages[0].IsCurrent())
   200  		assert.Equal(t, -1, pages[1].Num())
   201  		assert.False(t, pages[1].IsCurrent())
   202  
   203  		// 1 2 ...
   204  		p = New(21, 10, 1, 2)
   205  		pages = p.Pages()
   206  		assert.Equal(t, 3, len(pages))
   207  		assert.Equal(t, 1, pages[0].Num())
   208  		assert.True(t, pages[0].IsCurrent())
   209  		assert.Equal(t, 2, pages[1].Num())
   210  		assert.False(t, pages[1].IsCurrent())
   211  		assert.Equal(t, -1, pages[2].Num())
   212  		assert.False(t, pages[2].IsCurrent())
   213  
   214  		// 1 2 3 ...
   215  		p = New(31, 10, 2, 3)
   216  		pages = p.Pages()
   217  		assert.Equal(t, 4, len(pages))
   218  		assert.Equal(t, 1, pages[0].Num())
   219  		assert.False(t, pages[0].IsCurrent())
   220  		assert.Equal(t, 2, pages[1].Num())
   221  		assert.True(t, pages[1].IsCurrent())
   222  		assert.Equal(t, 3, pages[2].Num())
   223  		assert.False(t, pages[2].IsCurrent())
   224  		assert.Equal(t, -1, pages[3].Num())
   225  		assert.False(t, pages[3].IsCurrent())
   226  
   227  		// 1 2 3 ...
   228  		p = New(41, 10, 2, 3)
   229  		pages = p.Pages()
   230  		assert.Equal(t, 4, len(pages))
   231  		assert.Equal(t, 1, pages[0].Num())
   232  		assert.False(t, pages[0].IsCurrent())
   233  		assert.Equal(t, 2, pages[1].Num())
   234  		assert.True(t, pages[1].IsCurrent())
   235  		assert.Equal(t, 3, pages[2].Num())
   236  		assert.False(t, pages[2].IsCurrent())
   237  		assert.Equal(t, -1, pages[3].Num())
   238  		assert.False(t, pages[3].IsCurrent())
   239  
   240  		// 1 2 3 4 5 6 7 ...
   241  		p = New(100, 10, 1, 7)
   242  		pages = p.Pages()
   243  		assert.Equal(t, 8, len(pages))
   244  		assert.Equal(t, 1, pages[0].Num())
   245  		assert.True(t, pages[0].IsCurrent())
   246  		assert.Equal(t, 2, pages[1].Num())
   247  		assert.False(t, pages[1].IsCurrent())
   248  		assert.Equal(t, 3, pages[2].Num())
   249  		assert.False(t, pages[2].IsCurrent())
   250  		assert.Equal(t, 4, pages[3].Num())
   251  		assert.False(t, pages[3].IsCurrent())
   252  		assert.Equal(t, 5, pages[4].Num())
   253  		assert.False(t, pages[4].IsCurrent())
   254  		assert.Equal(t, 6, pages[5].Num())
   255  		assert.False(t, pages[5].IsCurrent())
   256  		assert.Equal(t, 7, pages[6].Num())
   257  		assert.False(t, pages[6].IsCurrent())
   258  		assert.Equal(t, -1, pages[7].Num())
   259  		assert.False(t, pages[7].IsCurrent())
   260  
   261  		// 1 2 3 4 5 6 7 ...
   262  		p = New(100, 10, 2, 7)
   263  		pages = p.Pages()
   264  		assert.Equal(t, 8, len(pages))
   265  		assert.Equal(t, 1, pages[0].Num())
   266  		assert.False(t, pages[0].IsCurrent())
   267  		assert.Equal(t, 2, pages[1].Num())
   268  		assert.True(t, pages[1].IsCurrent())
   269  		assert.Equal(t, 3, pages[2].Num())
   270  		assert.False(t, pages[2].IsCurrent())
   271  		assert.Equal(t, 4, pages[3].Num())
   272  		assert.False(t, pages[3].IsCurrent())
   273  		assert.Equal(t, 5, pages[4].Num())
   274  		assert.False(t, pages[4].IsCurrent())
   275  		assert.Equal(t, 6, pages[5].Num())
   276  		assert.False(t, pages[5].IsCurrent())
   277  		assert.Equal(t, 7, pages[6].Num())
   278  		assert.False(t, pages[6].IsCurrent())
   279  		assert.Equal(t, -1, pages[7].Num())
   280  		assert.False(t, pages[7].IsCurrent())
   281  	})
   282  
   283  	t.Run("Has both more previous and next pages", func(t *testing.T) {
   284  		// ... 2 3 ...
   285  		p := New(35, 10, 2, 2)
   286  		pages := p.Pages()
   287  		assert.Equal(t, 4, len(pages))
   288  		assert.Equal(t, -1, pages[0].Num())
   289  		assert.False(t, pages[0].IsCurrent())
   290  		assert.Equal(t, 2, pages[1].Num())
   291  		assert.True(t, pages[1].IsCurrent())
   292  		assert.Equal(t, 3, pages[2].Num())
   293  		assert.False(t, pages[2].IsCurrent())
   294  		assert.Equal(t, -1, pages[3].Num())
   295  		assert.False(t, pages[3].IsCurrent())
   296  
   297  		// ... 2 3 4 ...
   298  		p = New(49, 10, 3, 3)
   299  		pages = p.Pages()
   300  		assert.Equal(t, 5, len(pages))
   301  		assert.Equal(t, -1, pages[0].Num())
   302  		assert.False(t, pages[0].IsCurrent())
   303  		assert.Equal(t, 2, pages[1].Num())
   304  		assert.False(t, pages[1].IsCurrent())
   305  		assert.Equal(t, 3, pages[2].Num())
   306  		assert.True(t, pages[2].IsCurrent())
   307  		assert.Equal(t, 4, pages[3].Num())
   308  		assert.False(t, pages[3].IsCurrent())
   309  		assert.Equal(t, -1, pages[4].Num())
   310  		assert.False(t, pages[4].IsCurrent())
   311  	})
   312  }