github.com/fighterlyt/hugo@v0.47.1/hugolib/pageGroup_test.go (about) 1 // Copyright 2015 The Hugo Authors. All rights reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // http://www.apache.org/licenses/LICENSE-2.0 7 // 8 // Unless required by applicable law or agreed to in writing, software 9 // distributed under the License is distributed on an "AS IS" BASIS, 10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package hugolib 15 16 import ( 17 "errors" 18 "path/filepath" 19 "reflect" 20 "testing" 21 22 "github.com/spf13/cast" 23 ) 24 25 type pageGroupTestObject struct { 26 path string 27 weight int 28 date string 29 param string 30 } 31 32 var pageGroupTestSources = []pageGroupTestObject{ 33 {"/section1/testpage1.md", 3, "2012-04-06", "foo"}, 34 {"/section1/testpage2.md", 3, "2012-01-01", "bar"}, 35 {"/section1/testpage3.md", 2, "2012-04-06", "foo"}, 36 {"/section2/testpage4.md", 1, "2012-03-02", "bar"}, 37 {"/section2/testpage5.md", 1, "2012-04-06", "baz"}, 38 } 39 40 func preparePageGroupTestPages(t *testing.T) Pages { 41 s := newTestSite(t) 42 var pages Pages 43 for _, src := range pageGroupTestSources { 44 p, err := s.NewPage(filepath.FromSlash(src.path)) 45 if err != nil { 46 t.Fatalf("failed to prepare test page %s", src.path) 47 } 48 p.Weight = src.weight 49 p.Date = cast.ToTime(src.date) 50 p.PublishDate = cast.ToTime(src.date) 51 p.ExpiryDate = cast.ToTime(src.date) 52 p.params["custom_param"] = src.param 53 p.params["custom_date"] = cast.ToTime(src.date) 54 pages = append(pages, p) 55 } 56 return pages 57 } 58 59 func TestGroupByWithFieldNameArg(t *testing.T) { 60 t.Parallel() 61 pages := preparePageGroupTestPages(t) 62 expect := PagesGroup{ 63 {Key: 1, Pages: Pages{pages[3], pages[4]}}, 64 {Key: 2, Pages: Pages{pages[2]}}, 65 {Key: 3, Pages: Pages{pages[0], pages[1]}}, 66 } 67 68 groups, err := pages.GroupBy("Weight") 69 if err != nil { 70 t.Fatalf("Unable to make PagesGroup array: %s", err) 71 } 72 if !reflect.DeepEqual(groups, expect) { 73 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 74 } 75 } 76 77 func TestGroupByWithMethodNameArg(t *testing.T) { 78 t.Parallel() 79 pages := preparePageGroupTestPages(t) 80 expect := PagesGroup{ 81 {Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}}, 82 {Key: "section2", Pages: Pages{pages[3], pages[4]}}, 83 } 84 85 groups, err := pages.GroupBy("Type") 86 if err != nil { 87 t.Fatalf("Unable to make PagesGroup array: %s", err) 88 } 89 if !reflect.DeepEqual(groups, expect) { 90 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 91 } 92 } 93 94 func TestGroupByWithSectionArg(t *testing.T) { 95 t.Parallel() 96 pages := preparePageGroupTestPages(t) 97 expect := PagesGroup{ 98 {Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}}, 99 {Key: "section2", Pages: Pages{pages[3], pages[4]}}, 100 } 101 102 groups, err := pages.GroupBy("Section") 103 if err != nil { 104 t.Fatalf("Unable to make PagesGroup array: %s", err) 105 } 106 if !reflect.DeepEqual(groups, expect) { 107 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 108 } 109 } 110 111 func TestGroupByInReverseOrder(t *testing.T) { 112 t.Parallel() 113 pages := preparePageGroupTestPages(t) 114 expect := PagesGroup{ 115 {Key: 3, Pages: Pages{pages[0], pages[1]}}, 116 {Key: 2, Pages: Pages{pages[2]}}, 117 {Key: 1, Pages: Pages{pages[3], pages[4]}}, 118 } 119 120 groups, err := pages.GroupBy("Weight", "desc") 121 if err != nil { 122 t.Fatalf("Unable to make PagesGroup array: %s", err) 123 } 124 if !reflect.DeepEqual(groups, expect) { 125 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 126 } 127 } 128 129 func TestGroupByCalledWithEmptyPages(t *testing.T) { 130 t.Parallel() 131 var pages Pages 132 groups, err := pages.GroupBy("Weight") 133 if err != nil { 134 t.Fatalf("Unable to make PagesGroup array: %s", err) 135 } 136 if groups != nil { 137 t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups) 138 } 139 } 140 141 func TestGroupByCalledWithUnavailableKey(t *testing.T) { 142 t.Parallel() 143 pages := preparePageGroupTestPages(t) 144 _, err := pages.GroupBy("UnavailableKey") 145 if err == nil { 146 t.Errorf("GroupByParam should return an error but didn't") 147 } 148 } 149 150 func (page *Page) DummyPageMethodWithArgForTest(s string) string { 151 return s 152 } 153 154 func (page *Page) DummyPageMethodReturnThreeValueForTest() (string, string, string) { 155 return "foo", "bar", "baz" 156 } 157 158 func (page *Page) DummyPageMethodReturnErrorOnlyForTest() error { 159 return errors.New("some error occurred") 160 } 161 162 func (page *Page) dummyPageMethodReturnTwoValueForTest() (string, string) { 163 return "foo", "bar" 164 } 165 166 func TestGroupByCalledWithInvalidMethod(t *testing.T) { 167 t.Parallel() 168 var err error 169 pages := preparePageGroupTestPages(t) 170 171 _, err = pages.GroupBy("DummyPageMethodWithArgForTest") 172 if err == nil { 173 t.Errorf("GroupByParam should return an error but didn't") 174 } 175 176 _, err = pages.GroupBy("DummyPageMethodReturnThreeValueForTest") 177 if err == nil { 178 t.Errorf("GroupByParam should return an error but didn't") 179 } 180 181 _, err = pages.GroupBy("DummyPageMethodReturnErrorOnlyForTest") 182 if err == nil { 183 t.Errorf("GroupByParam should return an error but didn't") 184 } 185 186 _, err = pages.GroupBy("DummyPageMethodReturnTwoValueForTest") 187 if err == nil { 188 t.Errorf("GroupByParam should return an error but didn't") 189 } 190 } 191 192 func TestReverse(t *testing.T) { 193 t.Parallel() 194 pages := preparePageGroupTestPages(t) 195 196 groups1, err := pages.GroupBy("Weight", "desc") 197 if err != nil { 198 t.Fatalf("Unable to make PagesGroup array: %s", err) 199 } 200 201 groups2, err := pages.GroupBy("Weight") 202 if err != nil { 203 t.Fatalf("Unable to make PagesGroup array: %s", err) 204 } 205 groups2 = groups2.Reverse() 206 207 if !reflect.DeepEqual(groups2, groups1) { 208 t.Errorf("PagesGroup is sorted in unexpected order. It should be %#v, got %#v", groups2, groups1) 209 } 210 } 211 212 func TestGroupByParam(t *testing.T) { 213 t.Parallel() 214 pages := preparePageGroupTestPages(t) 215 expect := PagesGroup{ 216 {Key: "bar", Pages: Pages{pages[1], pages[3]}}, 217 {Key: "baz", Pages: Pages{pages[4]}}, 218 {Key: "foo", Pages: Pages{pages[0], pages[2]}}, 219 } 220 221 groups, err := pages.GroupByParam("custom_param") 222 if err != nil { 223 t.Fatalf("Unable to make PagesGroup array: %s", err) 224 } 225 if !reflect.DeepEqual(groups, expect) { 226 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 227 } 228 } 229 230 func TestGroupByParamInReverseOrder(t *testing.T) { 231 t.Parallel() 232 pages := preparePageGroupTestPages(t) 233 expect := PagesGroup{ 234 {Key: "foo", Pages: Pages{pages[0], pages[2]}}, 235 {Key: "baz", Pages: Pages{pages[4]}}, 236 {Key: "bar", Pages: Pages{pages[1], pages[3]}}, 237 } 238 239 groups, err := pages.GroupByParam("custom_param", "desc") 240 if err != nil { 241 t.Fatalf("Unable to make PagesGroup array: %s", err) 242 } 243 if !reflect.DeepEqual(groups, expect) { 244 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 245 } 246 } 247 248 func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) { 249 testStr := "TestString" 250 f := "/section1/test_capital.md" 251 s := newTestSite(t) 252 p, err := s.NewPage(filepath.FromSlash(f)) 253 if err != nil { 254 t.Fatalf("failed to prepare test page %s", f) 255 } 256 p.params["custom_param"] = testStr 257 pages := Pages{p} 258 259 groups, err := pages.GroupByParam("custom_param") 260 if err != nil { 261 t.Fatalf("Unable to make PagesGroup array: %s", err) 262 } 263 if groups[0].Key != testStr { 264 t.Errorf("PagesGroup key is converted to a lower character string. It should be %#v, got %#v", testStr, groups[0].Key) 265 } 266 } 267 268 func TestGroupByParamCalledWithSomeUnavailableParams(t *testing.T) { 269 t.Parallel() 270 pages := preparePageGroupTestPages(t) 271 delete(pages[1].params, "custom_param") 272 delete(pages[3].params, "custom_param") 273 delete(pages[4].params, "custom_param") 274 275 expect := PagesGroup{ 276 {Key: "foo", Pages: Pages{pages[0], pages[2]}}, 277 } 278 279 groups, err := pages.GroupByParam("custom_param") 280 if err != nil { 281 t.Fatalf("Unable to make PagesGroup array: %s", err) 282 } 283 if !reflect.DeepEqual(groups, expect) { 284 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 285 } 286 } 287 288 func TestGroupByParamCalledWithEmptyPages(t *testing.T) { 289 t.Parallel() 290 var pages Pages 291 groups, err := pages.GroupByParam("custom_param") 292 if err != nil { 293 t.Fatalf("Unable to make PagesGroup array: %s", err) 294 } 295 if groups != nil { 296 t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups) 297 } 298 } 299 300 func TestGroupByParamCalledWithUnavailableParam(t *testing.T) { 301 t.Parallel() 302 pages := preparePageGroupTestPages(t) 303 _, err := pages.GroupByParam("unavailable_param") 304 if err == nil { 305 t.Errorf("GroupByParam should return an error but didn't") 306 } 307 } 308 309 func TestGroupByDate(t *testing.T) { 310 t.Parallel() 311 pages := preparePageGroupTestPages(t) 312 expect := PagesGroup{ 313 {Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}}, 314 {Key: "2012-03", Pages: Pages{pages[3]}}, 315 {Key: "2012-01", Pages: Pages{pages[1]}}, 316 } 317 318 groups, err := pages.GroupByDate("2006-01") 319 if err != nil { 320 t.Fatalf("Unable to make PagesGroup array: %s", err) 321 } 322 if !reflect.DeepEqual(groups, expect) { 323 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 324 } 325 } 326 327 func TestGroupByDateInReverseOrder(t *testing.T) { 328 t.Parallel() 329 pages := preparePageGroupTestPages(t) 330 expect := PagesGroup{ 331 {Key: "2012-01", Pages: Pages{pages[1]}}, 332 {Key: "2012-03", Pages: Pages{pages[3]}}, 333 {Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}}, 334 } 335 336 groups, err := pages.GroupByDate("2006-01", "asc") 337 if err != nil { 338 t.Fatalf("Unable to make PagesGroup array: %s", err) 339 } 340 if !reflect.DeepEqual(groups, expect) { 341 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 342 } 343 } 344 345 func TestGroupByPublishDate(t *testing.T) { 346 t.Parallel() 347 pages := preparePageGroupTestPages(t) 348 expect := PagesGroup{ 349 {Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}}, 350 {Key: "2012-03", Pages: Pages{pages[3]}}, 351 {Key: "2012-01", Pages: Pages{pages[1]}}, 352 } 353 354 groups, err := pages.GroupByPublishDate("2006-01") 355 if err != nil { 356 t.Fatalf("Unable to make PagesGroup array: %s", err) 357 } 358 if !reflect.DeepEqual(groups, expect) { 359 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 360 } 361 } 362 363 func TestGroupByPublishDateInReverseOrder(t *testing.T) { 364 t.Parallel() 365 pages := preparePageGroupTestPages(t) 366 expect := PagesGroup{ 367 {Key: "2012-01", Pages: Pages{pages[1]}}, 368 {Key: "2012-03", Pages: Pages{pages[3]}}, 369 {Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}}, 370 } 371 372 groups, err := pages.GroupByDate("2006-01", "asc") 373 if err != nil { 374 t.Fatalf("Unable to make PagesGroup array: %s", err) 375 } 376 if !reflect.DeepEqual(groups, expect) { 377 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 378 } 379 } 380 381 func TestGroupByPublishDateWithEmptyPages(t *testing.T) { 382 t.Parallel() 383 var pages Pages 384 groups, err := pages.GroupByPublishDate("2006-01") 385 if err != nil { 386 t.Fatalf("Unable to make PagesGroup array: %s", err) 387 } 388 if groups != nil { 389 t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups) 390 } 391 } 392 393 func TestGroupByExpiryDate(t *testing.T) { 394 t.Parallel() 395 pages := preparePageGroupTestPages(t) 396 expect := PagesGroup{ 397 {Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}}, 398 {Key: "2012-03", Pages: Pages{pages[3]}}, 399 {Key: "2012-01", Pages: Pages{pages[1]}}, 400 } 401 402 groups, err := pages.GroupByExpiryDate("2006-01") 403 if err != nil { 404 t.Fatalf("Unable to make PagesGroup array: %s", err) 405 } 406 if !reflect.DeepEqual(groups, expect) { 407 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 408 } 409 } 410 411 func TestGroupByParamDate(t *testing.T) { 412 t.Parallel() 413 pages := preparePageGroupTestPages(t) 414 expect := PagesGroup{ 415 {Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}}, 416 {Key: "2012-03", Pages: Pages{pages[3]}}, 417 {Key: "2012-01", Pages: Pages{pages[1]}}, 418 } 419 420 groups, err := pages.GroupByParamDate("custom_date", "2006-01") 421 if err != nil { 422 t.Fatalf("Unable to make PagesGroup array: %s", err) 423 } 424 if !reflect.DeepEqual(groups, expect) { 425 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 426 } 427 } 428 429 func TestGroupByParamDateInReverseOrder(t *testing.T) { 430 t.Parallel() 431 pages := preparePageGroupTestPages(t) 432 expect := PagesGroup{ 433 {Key: "2012-01", Pages: Pages{pages[1]}}, 434 {Key: "2012-03", Pages: Pages{pages[3]}}, 435 {Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}}, 436 } 437 438 groups, err := pages.GroupByParamDate("custom_date", "2006-01", "asc") 439 if err != nil { 440 t.Fatalf("Unable to make PagesGroup array: %s", err) 441 } 442 if !reflect.DeepEqual(groups, expect) { 443 t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups) 444 } 445 } 446 447 func TestGroupByParamDateWithEmptyPages(t *testing.T) { 448 t.Parallel() 449 var pages Pages 450 groups, err := pages.GroupByParamDate("custom_date", "2006-01") 451 if err != nil { 452 t.Fatalf("Unable to make PagesGroup array: %s", err) 453 } 454 if groups != nil { 455 t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups) 456 } 457 }