diff options
Diffstat (limited to 'resources/page/pages_sort_test.go')
-rw-r--r-- | resources/page/pages_sort_test.go | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/resources/page/pages_sort_test.go b/resources/page/pages_sort_test.go new file mode 100644 index 000000000..c781de2f3 --- /dev/null +++ b/resources/page/pages_sort_test.go @@ -0,0 +1,279 @@ +// Copyright 2019 The Hugo Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package page + +import ( + "fmt" + "testing" + "time" + + "github.com/gohugoio/hugo/resources/resource" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestDefaultSort(t *testing.T) { + t.Parallel() + d1 := time.Now() + d2 := d1.Add(-1 * time.Hour) + d3 := d1.Add(-2 * time.Hour) + d4 := d1.Add(-3 * time.Hour) + + p := createSortTestPages(4) + + // first by weight + setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "c", "d"}, [4]int{4, 3, 2, 1}, p) + SortByDefault(p) + + assert.Equal(t, 1, p[0].Weight()) + + // Consider zero weight, issue #2673 + setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "d", "c"}, [4]int{0, 0, 0, 1}, p) + SortByDefault(p) + + assert.Equal(t, 1, p[0].Weight()) + + // next by date + setSortVals([4]time.Time{d3, d4, d1, d2}, [4]string{"a", "b", "c", "d"}, [4]int{1, 1, 1, 1}, p) + SortByDefault(p) + assert.Equal(t, d1, p[0].Date()) + + // finally by link title + setSortVals([4]time.Time{d3, d3, d3, d3}, [4]string{"b", "c", "a", "d"}, [4]int{1, 1, 1, 1}, p) + SortByDefault(p) + assert.Equal(t, "al", p[0].LinkTitle()) + assert.Equal(t, "bl", p[1].LinkTitle()) + assert.Equal(t, "cl", p[2].LinkTitle()) +} + +// https://github.com/gohugoio/hugo/issues/4953 +func TestSortByLinkTitle(t *testing.T) { + t.Parallel() + assert := require.New(t) + pages := createSortTestPages(6) + + for i, p := range pages { + pp := p.(*testPage) + if i < 5 { + pp.title = fmt.Sprintf("title%d", i) + } + + if i > 2 { + pp.linkTitle = fmt.Sprintf("linkTitle%d", i) + } + + } + + pages.shuffle() + + bylt := pages.ByLinkTitle() + + for i, p := range bylt { + msg := fmt.Sprintf("test: %d", i) + if i < 3 { + assert.Equal(fmt.Sprintf("linkTitle%d", i+3), p.LinkTitle(), msg) + } else { + assert.Equal(fmt.Sprintf("title%d", i-3), p.LinkTitle(), msg) + } + } +} + +func TestSortByN(t *testing.T) { + t.Parallel() + d1 := time.Now() + d2 := d1.Add(-2 * time.Hour) + d3 := d1.Add(-10 * time.Hour) + d4 := d1.Add(-20 * time.Hour) + + p := createSortTestPages(4) + + for i, this := range []struct { + sortFunc func(p Pages) Pages + assertFunc func(p Pages) bool + }{ + {(Pages).ByWeight, func(p Pages) bool { return p[0].Weight() == 1 }}, + {(Pages).ByTitle, func(p Pages) bool { return p[0].Title() == "ab" }}, + {(Pages).ByLinkTitle, func(p Pages) bool { return p[0].LinkTitle() == "abl" }}, + {(Pages).ByDate, func(p Pages) bool { return p[0].Date() == d4 }}, + {(Pages).ByPublishDate, func(p Pages) bool { return p[0].PublishDate() == d4 }}, + {(Pages).ByExpiryDate, func(p Pages) bool { return p[0].ExpiryDate() == d4 }}, + {(Pages).ByLastmod, func(p Pages) bool { return p[1].Lastmod() == d3 }}, + {(Pages).ByLength, func(p Pages) bool { return p[0].(resource.LengthProvider).Len() == len(p[0].(*testPage).content) }}, + } { + setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "ab", "cde", "fg"}, [4]int{0, 3, 2, 1}, p) + + sorted := this.sortFunc(p) + if !this.assertFunc(sorted) { + t.Errorf("[%d] sort error", i) + } + } + +} + +func TestLimit(t *testing.T) { + t.Parallel() + p := createSortTestPages(10) + firstFive := p.Limit(5) + assert.Equal(t, 5, len(firstFive)) + for i := 0; i < 5; i++ { + assert.Equal(t, p[i], firstFive[i]) + } + assert.Equal(t, p, p.Limit(10)) + assert.Equal(t, p, p.Limit(11)) +} + +func TestPageSortReverse(t *testing.T) { + t.Parallel() + p1 := createSortTestPages(10) + assert.Equal(t, 0, p1[0].(*testPage).fuzzyWordCount) + assert.Equal(t, 9, p1[9].(*testPage).fuzzyWordCount) + p2 := p1.Reverse() + assert.Equal(t, 9, p2[0].(*testPage).fuzzyWordCount) + assert.Equal(t, 0, p2[9].(*testPage).fuzzyWordCount) + // cached + assert.True(t, pagesEqual(p2, p1.Reverse())) +} + +func TestPageSortByParam(t *testing.T) { + t.Parallel() + var k interface{} = "arbitrarily.nested" + + unsorted := createSortTestPages(10) + delete(unsorted[9].Params(), "arbitrarily") + + firstSetValue, _ := unsorted[0].Param(k) + secondSetValue, _ := unsorted[1].Param(k) + lastSetValue, _ := unsorted[8].Param(k) + unsetValue, _ := unsorted[9].Param(k) + + assert.Equal(t, "xyz100", firstSetValue) + assert.Equal(t, "xyz99", secondSetValue) + assert.Equal(t, "xyz92", lastSetValue) + assert.Equal(t, nil, unsetValue) + + sorted := unsorted.ByParam("arbitrarily.nested") + firstSetSortedValue, _ := sorted[0].Param(k) + secondSetSortedValue, _ := sorted[1].Param(k) + lastSetSortedValue, _ := sorted[8].Param(k) + unsetSortedValue, _ := sorted[9].Param(k) + + assert.Equal(t, firstSetValue, firstSetSortedValue) + assert.Equal(t, secondSetValue, lastSetSortedValue) + assert.Equal(t, lastSetValue, secondSetSortedValue) + assert.Equal(t, unsetValue, unsetSortedValue) +} + +func TestPageSortByParamNumeric(t *testing.T) { + t.Parallel() + var k interface{} = "arbitrarily.nested" + + n := 10 + unsorted := createSortTestPages(n) + for i := 0; i < n; i++ { + v := 100 - i + if i%2 == 0 { + v = 100.0 - i + } + + unsorted[i].(*testPage).params = map[string]interface{}{ + "arbitrarily": map[string]interface{}{ + "nested": v, + }, + } + } + delete(unsorted[9].Params(), "arbitrarily") + + firstSetValue, _ := unsorted[0].Param(k) + secondSetValue, _ := unsorted[1].Param(k) + lastSetValue, _ := unsorted[8].Param(k) + unsetValue, _ := unsorted[9].Param(k) + + assert.Equal(t, 100, firstSetValue) + assert.Equal(t, 99, secondSetValue) + assert.Equal(t, 92, lastSetValue) + assert.Equal(t, nil, unsetValue) + + sorted := unsorted.ByParam("arbitrarily.nested") + firstSetSortedValue, _ := sorted[0].Param(k) + secondSetSortedValue, _ := sorted[1].Param(k) + lastSetSortedValue, _ := sorted[8].Param(k) + unsetSortedValue, _ := sorted[9].Param(k) + + assert.Equal(t, 92, firstSetSortedValue) + assert.Equal(t, 93, secondSetSortedValue) + assert.Equal(t, 100, lastSetSortedValue) + assert.Equal(t, unsetValue, unsetSortedValue) +} + +func BenchmarkSortByWeightAndReverse(b *testing.B) { + p := createSortTestPages(300) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + p = p.ByWeight().Reverse() + } +} + +func setSortVals(dates [4]time.Time, titles [4]string, weights [4]int, pages Pages) { + for i := range dates { + this := pages[i].(*testPage) + other := pages[len(dates)-1-i].(*testPage) + + this.date = dates[i] + this.lastMod = dates[i] + this.weight = weights[i] + this.title = titles[i] + // make sure we compare apples and ... apples ... + other.linkTitle = this.Title() + "l" + other.pubDate = dates[i] + other.expiryDate = dates[i] + other.content = titles[i] + "_content" + } + lastLastMod := pages[2].Lastmod() + pages[2].(*testPage).lastMod = pages[1].Lastmod() + pages[1].(*testPage).lastMod = lastLastMod + + for _, p := range pages { + p.(*testPage).content = "" + } + +} + +func createSortTestPages(num int) Pages { + pages := make(Pages, num) + + for i := 0; i < num; i++ { + p := newTestPage() + p.path = fmt.Sprintf("/x/y/p%d.md", i) + p.params = map[string]interface{}{ + "arbitrarily": map[string]interface{}{ + "nested": ("xyz" + fmt.Sprintf("%v", 100-i)), + }, + } + + w := 5 + + if i%2 == 0 { + w = 10 + } + p.fuzzyWordCount = i + p.weight = w + p.description = "initial" + + pages[i] = p + } + + return pages +} |