mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-21 20:46:30 -05:00
139be09f17
Page.GroupByParam function internally uses Page.GetParam to get a parameter value for a key of a page group but now Page.GetParam returns a lowercase character string every time. It has no need to using lowercase character string as a group key value and it confuse a function user. This fixes it to keep and return an original parameter string as a group key value. Fix #1564
402 lines
11 KiB
Go
402 lines
11 KiB
Go
package hugolib
|
|
|
|
import (
|
|
"errors"
|
|
"path/filepath"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/spf13/cast"
|
|
)
|
|
|
|
type pageGroupTestObject struct {
|
|
path string
|
|
weight int
|
|
date string
|
|
param string
|
|
}
|
|
|
|
var pageGroupTestSources = []pageGroupTestObject{
|
|
{"/section1/testpage1.md", 3, "2012-04-06", "foo"},
|
|
{"/section1/testpage2.md", 3, "2012-01-01", "bar"},
|
|
{"/section1/testpage3.md", 2, "2012-04-06", "foo"},
|
|
{"/section2/testpage4.md", 1, "2012-03-02", "bar"},
|
|
{"/section2/testpage5.md", 1, "2012-04-06", "baz"},
|
|
}
|
|
|
|
func preparePageGroupTestPages(t *testing.T) Pages {
|
|
var pages Pages
|
|
for _, s := range pageGroupTestSources {
|
|
p, err := NewPage(filepath.FromSlash(s.path))
|
|
if err != nil {
|
|
t.Fatalf("failed to prepare test page %s", s.path)
|
|
}
|
|
p.Weight = s.weight
|
|
p.Date = cast.ToTime(s.date)
|
|
p.PublishDate = cast.ToTime(s.date)
|
|
p.Params["custom_param"] = s.param
|
|
p.Params["custom_date"] = cast.ToTime(s.date)
|
|
pages = append(pages, p)
|
|
}
|
|
return pages
|
|
}
|
|
|
|
func TestGroupByWithFieldNameArg(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: 1, Pages: Pages{pages[3], pages[4]}},
|
|
{Key: 2, Pages: Pages{pages[2]}},
|
|
{Key: 3, Pages: Pages{pages[0], pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy("Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByWithMethodNameArg(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}},
|
|
{Key: "section2", Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy("Type")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByWithSectionArg(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}},
|
|
{Key: "section2", Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy("Section")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByInReverseOrder(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: 3, Pages: Pages{pages[0], pages[1]}},
|
|
{Key: 2, Pages: Pages{pages[2]}},
|
|
{Key: 1, Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy("Weight", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByCalledWithEmptyPages(t *testing.T) {
|
|
var pages Pages
|
|
groups, err := pages.GroupBy("Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByCalledWithUnavailableKey(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
_, err := pages.GroupBy("UnavailableKey")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
}
|
|
|
|
func (page *Page) dummyPageMethodWithArgForTest(s string) string {
|
|
return s
|
|
}
|
|
|
|
func (page *Page) dummyPageMethodReturnThreeValueForTest() (string, string, string) {
|
|
return "foo", "bar", "baz"
|
|
}
|
|
|
|
func (page *Page) dummyPageMethodReturnErrorOnlyForTest() error {
|
|
return errors.New("something error occured")
|
|
}
|
|
|
|
func (page *Page) dummyPageMethodReturnTwoValueForTest() (string, string) {
|
|
return "foo", "bar"
|
|
}
|
|
|
|
func TestGroupByCalledWithInvalidMethod(t *testing.T) {
|
|
var err error
|
|
pages := preparePageGroupTestPages(t)
|
|
|
|
_, err = pages.GroupBy("dummyPageMethodWithArgForTest")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
|
|
_, err = pages.GroupBy("dummyPageMethodReturnThreeValueForTest")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
|
|
_, err = pages.GroupBy("dummyPageMethodReturnErrorOnlyForTest")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
|
|
_, err = pages.GroupBy("dummyPageMethodReturnTwoValueForTest")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
}
|
|
|
|
func TestReverse(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
|
|
groups1, err := pages.GroupBy("Weight", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
|
|
groups2, err := pages.GroupBy("Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
groups2 = groups2.Reverse()
|
|
|
|
if !reflect.DeepEqual(groups2, groups1) {
|
|
t.Errorf("PagesGroup is sorted in unexpected order. It should be %#v, got %#v", groups2, groups1)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParam(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "bar", Pages: Pages{pages[1], pages[3]}},
|
|
{Key: "baz", Pages: Pages{pages[4]}},
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamInReverseOrder(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
{Key: "baz", Pages: Pages{pages[4]}},
|
|
{Key: "bar", Pages: Pages{pages[1], pages[3]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
|
|
testStr := "TestString"
|
|
f := "/section1/test_capital.md"
|
|
p, err := NewPage(filepath.FromSlash(f))
|
|
if err != nil {
|
|
t.Fatalf("failed to prepare test page %s", f)
|
|
}
|
|
p.Params["custom_param"] = testStr
|
|
pages := Pages{p}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups[0].Key != testStr {
|
|
t.Errorf("PagesGroup key is converted to a lower character string. It should be %#v, got %#v", testStr, groups[0].Key)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithSomeUnavailableParams(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
delete(pages[1].Params, "custom_param")
|
|
delete(pages[3].Params, "custom_param")
|
|
delete(pages[4].Params, "custom_param")
|
|
|
|
expect := PagesGroup{
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithEmptyPages(t *testing.T) {
|
|
var pages Pages
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithUnavailableParam(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
_, err := pages.GroupByParam("unavailable_param")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
}
|
|
|
|
func TestGroupByDate(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByDateInReverseOrder(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDate(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByPublishDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDateInReverseOrder(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDateWithEmptyPages(t *testing.T) {
|
|
var pages Pages
|
|
groups, err := pages.GroupByPublishDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDate(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDateInReverseOrder(t *testing.T) {
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDateWithEmptyPages(t *testing.T) {
|
|
var pages Pages
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|