Improve pagination testing

* Add missing pagination test cases
* Remove some unreachable code paths
* Fix some corner cases

diff --git a/hugolib/pagination.go b/hugolib/pagination.go
index c6db865502dfc1e9632e40d4ae8807013f1e6ce7..67cc021675594f634c1f5f9d2fe9ed666674701c 100644 (file)
--- a/hugolib/pagination.go
+++ b/hugolib/pagination.go
@@ -88,19 +88,11 @@ func (p *pager) Next() *pager {
 
 // First returns the pager for the first page.
 func (p *pager) First() *pager {
-       if p.TotalPages() == 0 {
-               return nil
-       }
-
        return p.pagers[0]
 }
 
 // Last returns the pager for the last page.
 func (p *pager) Last() *pager {
-       if p.TotalPages() == 0 {
-               return nil
-       }
-
        return p.pagers[len(p.pagers)-1]
 }
 
@@ -138,10 +130,6 @@ func splitPages(pages Pages, size int) []Pages {
 // If it's not, one will be created with all pages in Data["Pages"].
 func (n *Node) Paginator() (*pager, error) {
 
-       if n.IsPage() {
-               return nil, errors.New("Paginators isn't supported for content pages.")
-       }
-
        var initError error
 
        n.paginatorInit.Do(func() {
@@ -170,15 +158,18 @@ func (n *Node) Paginator() (*pager, error) {
        return n.paginator, nil
 }
 
+func (p *Page) Paginator() (*pager, error) {
+       return nil, errors.New("Paginators not supported for content pages.")
+}
+func (p *Page) Paginate(seq interface{}) (*pager, error) {
+       return nil, errors.New("Paginators not supported for content pages.")
+}
+
 // Paginate gets this Node's paginator if it's already created.
 // If it's not, one will be created with the qiven sequence.
 // Note that repeated calls will return the same result, even if the sequence is different.
 func (n *Node) Paginate(seq interface{}) (*pager, error) {
 
-       if n.IsPage() {
-               return nil, errors.New("Paginators isn't supported for content pages.")
-       }
-
        var initError error
 
        n.paginatorInit.Do(func() {
@@ -227,16 +218,16 @@ func paginatePages(seq interface{}, section string) (pagers, error) {
        }
 
        urlFactory := newPaginationUrlFactory(section)
-       paginator := newPaginator(pages, paginateSize, urlFactory)
+       paginator, _ := newPaginator(pages, paginateSize, urlFactory)
        pagers := paginator.Pagers()
 
        return pagers, nil
 }
 
-func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) *paginator {
+func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) (*paginator, error) {
 
        if size <= 0 {
-               panic("Paginator size must be positive")
+               return nil, errors.New("Paginator size must be positive")
        }
 
        split := splitPages(pages, size)
@@ -250,7 +241,7 @@ func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) *pagin
 
        p.pagers = pagers
 
-       return p
+       return p, nil
 }
 
 func newPaginationUrlFactory(pathElements ...string) paginationUrlFactory {

diff --git a/hugolib/pagination_test.go b/hugolib/pagination_test.go
index 080866f6f7b5c5903b5b33b42654170cb925ff29..cbf14e16303cda4535865c1e8a247bb9d70b5a69 100644 (file)
--- a/hugolib/pagination_test.go
+++ b/hugolib/pagination_test.go
@@ -24,14 +24,17 @@ func TestSplitPages(t *testing.T) {
 
 }
 
-func TestPaginator(t *testing.T) {
+func TestPager(t *testing.T) {
 
        pages := createTestPages(21)
        urlFactory := func(page int) string {
                return fmt.Sprintf("page/%d/", page)
        }
 
-       paginator := newPaginator(pages, 5, urlFactory)
+       _, err := newPaginator(pages, -1, urlFactory)
+       assert.NotNil(t, err)
+
+       paginator, _ := newPaginator(pages, 5, urlFactory)
        paginatorPages := paginator.Pagers()
 
        assert.Equal(t, 5, len(paginatorPages))
@@ -43,22 +46,40 @@ func TestPaginator(t *testing.T) {
        assert.Equal(t, "page/1/", first.Url())
        assert.Equal(t, first, first.First())
        assert.Equal(t, true, first.HasNext())
+       assert.Equal(t, paginatorPages[1], first.Next())
        assert.Equal(t, false, first.HasPrev())
+       assert.Nil(t, first.Prev())
        assert.Equal(t, 5, first.NumberOfElements())
        assert.Equal(t, 1, first.PageNumber())
 
        third := paginatorPages[2]
        assert.Equal(t, true, third.HasNext())
        assert.Equal(t, true, third.HasPrev())
+       assert.Equal(t, paginatorPages[1], third.Prev())
 
        last := paginatorPages[4]
        assert.Equal(t, "page/5/", last.Url())
        assert.Equal(t, last, last.Last())
        assert.Equal(t, false, last.HasNext())
+       assert.Nil(t, last.Next())
        assert.Equal(t, true, last.HasPrev())
        assert.Equal(t, 1, last.NumberOfElements())
        assert.Equal(t, 5, last.PageNumber())
+}
+
+func TestPagerNoPages(t *testing.T) {
+       pages := createTestPages(0)
+       urlFactory := func(page int) string {
+               return fmt.Sprintf("page/%d/", page)
+       }
 
+       paginator, _ := newPaginator(pages, 5, urlFactory)
+       paginatorPages := paginator.Pagers()
+
+       assert.Equal(t, 0, len(paginatorPages))
+       assert.Equal(t, 0, paginator.TotalNumberOfElements())
+       assert.Equal(t, 5, paginator.PageSize())
+       assert.Equal(t, 0, paginator.TotalPages())
 }
 
 func TestPaginationUrlFactory(t *testing.T) {
@@ -73,6 +94,88 @@ func TestPaginationUrlFactory(t *testing.T) {
 
 }
 
+func TestPaginator(t *testing.T) {
+       viper.Set("paginate", 5)
+       pages := createTestPages(12)
+       s := &Site{}
+       n1 := s.newHomeNode()
+       n2 := s.newHomeNode()
+       n1.Data["Pages"] = pages
+
+       paginator1, err := n1.Paginator()
+
+       assert.Nil(t, err)
+       assert.NotNil(t, paginator1)
+       assert.Equal(t, 3, paginator1.TotalPages())
+       assert.Equal(t, 12, paginator1.TotalNumberOfElements())
+
+       n2.paginator = paginator1.Next()
+       paginator2, err := n2.Paginator()
+       assert.Nil(t, err)
+       assert.Equal(t, paginator2, paginator1.Next())
+
+       n1.Data["Pages"] = createTestPages(1)
+       samePaginator, _ := n1.Paginator()
+       assert.Equal(t, paginator1, samePaginator)
+
+       p, _ := NewPage("test")
+       _, err = p.Paginator()
+       assert.NotNil(t, err)
+}
+
+func TestPaginatorWithNegativePaginate(t *testing.T) {
+       viper.Set("paginate", -1)
+       s := &Site{}
+       _, err := s.newHomeNode().Paginator()
+       assert.NotNil(t, err)
+}
+
+func TestPaginate(t *testing.T) {
+       viper.Set("paginate", 5)
+       pages := createTestPages(6)
+       s := &Site{}
+       n1 := s.newHomeNode()
+       n2 := s.newHomeNode()
+
+       paginator1, err := n1.Paginate(pages)
+
+       assert.Nil(t, err)
+       assert.NotNil(t, paginator1)
+       assert.Equal(t, 2, paginator1.TotalPages())
+       assert.Equal(t, 6, paginator1.TotalNumberOfElements())
+
+       n2.paginator = paginator1.Next()
+       paginator2, err := n2.Paginate(pages)
+       assert.Nil(t, err)
+       assert.Equal(t, paginator2, paginator1.Next())
+
+       samePaginator, err := n1.Paginate(createTestPages(2))
+       assert.Equal(t, paginator1, samePaginator)
+
+       p, _ := NewPage("test")
+       _, err = p.Paginate(pages)
+       assert.NotNil(t, err)
+}
+
+func TestPaginateWithNegativePaginate(t *testing.T) {
+       viper.Set("paginate", -1)
+       s := &Site{}
+       _, err := s.newHomeNode().Paginate(createTestPages(2))
+       assert.NotNil(t, err)
+}
+
+func TestPaginatePages(t *testing.T) {
+       viper.Set("paginate", 11)
+       for i, seq := range []interface{}{createTestPages(11), WeightedPages{}, PageGroup{}, &Pages{}} {
+               v, err := paginatePages(seq, "t")
+               assert.NotNil(t, v, "Val %d", i)
+               assert.Nil(t, err, "Err %d", i)
+       }
+       _, err := paginatePages(Site{}, "t")
+       assert.NotNil(t, err)
+
+}
+
 func createTestPages(num int) Pages {
        pages := make(Pages, num)