231 lines
6.6 KiB
Go
231 lines
6.6 KiB
Go
package pdfrender
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
// TestContinuationPages_WhenSkillsExceedCapacity tests that overflow items
|
|
// are distributed to continuation pages when template capacity is exceeded
|
|
func TestContinuationPages_WhenSkillsExceedCapacity(t *testing.T) {
|
|
// Arrange - Create more skills than fit on a single page
|
|
// Assuming page1_stats has capacity of 64 (2 columns x 32 each)
|
|
templateSet := DefaultA4QuerTemplateSet()
|
|
paginator := NewPaginator(templateSet)
|
|
|
|
// Create 100 skills to force overflow
|
|
skills := make([]SkillViewModel, 100)
|
|
for i := 0; i < 100; i++ {
|
|
skills[i] = SkillViewModel{
|
|
Name: "Skill " + string(rune('A'+i%26)),
|
|
Value: 10 + i%20,
|
|
}
|
|
}
|
|
|
|
// Act - Paginate skills for page1_stats
|
|
pages, err := paginator.PaginateSkills(skills, "page1_stats.html", "")
|
|
|
|
// Assert
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
// Should have more than 1 page (100 skills / 64 capacity = 2 pages)
|
|
if len(pages) < 2 {
|
|
t.Errorf("Expected at least 2 pages for 100 skills, got %d", len(pages))
|
|
}
|
|
|
|
// First page should be "page1_stats.html"
|
|
if pages[0].TemplateName != "page1_stats.html" {
|
|
t.Errorf("Expected first page template 'page1_stats.html', got '%s'", pages[0].TemplateName)
|
|
}
|
|
|
|
// Second page should be continuation page with name pattern "page1.2_stats.html"
|
|
expectedContinuation := "page1.2_stats.html"
|
|
if pages[1].TemplateName != expectedContinuation {
|
|
t.Errorf("Expected continuation page template '%s', got '%s'",
|
|
expectedContinuation, pages[1].TemplateName)
|
|
}
|
|
|
|
// Verify page numbers are sequential
|
|
for i, page := range pages {
|
|
expectedPageNum := i + 1
|
|
if page.PageNumber != expectedPageNum {
|
|
t.Errorf("Page %d: expected page number %d, got %d",
|
|
i, expectedPageNum, page.PageNumber)
|
|
}
|
|
}
|
|
|
|
// Verify all 100 skills are distributed
|
|
totalSkills := 0
|
|
for _, page := range pages {
|
|
for _, data := range page.Data {
|
|
if skillSlice, ok := data.([]SkillViewModel); ok {
|
|
totalSkills += len(skillSlice)
|
|
}
|
|
}
|
|
}
|
|
|
|
if totalSkills != 100 {
|
|
t.Errorf("Expected 100 total skills across all pages, got %d", totalSkills)
|
|
}
|
|
}
|
|
|
|
// TestContinuationPages_WhenWeaponsExceedCapacity tests overflow handling for weapons
|
|
func TestContinuationPages_WhenWeaponsExceedCapacity(t *testing.T) {
|
|
// Arrange
|
|
templateSet := DefaultA4QuerTemplateSet()
|
|
paginator := NewPaginator(templateSet)
|
|
|
|
// Get capacity for page2_play weapons (should be 12)
|
|
var weaponsCapacity int
|
|
for _, tmpl := range templateSet.Templates {
|
|
if tmpl.Metadata.Name == "page2_play.html" {
|
|
for _, block := range tmpl.Metadata.Blocks {
|
|
if block.ListType == "weapons" {
|
|
weaponsCapacity = block.MaxItems
|
|
t.Logf("Found weapons block: %s with capacity %d", block.Name, block.MaxItems)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
t.Logf("Total weapons capacity per page: %d", weaponsCapacity)
|
|
|
|
// Create more weapons than capacity (enough for exactly 2 pages)
|
|
// If capacity is 3, create 4 weapons to get 2 pages (3 + 1)
|
|
numWeapons := weaponsCapacity + 1
|
|
weapons := make([]WeaponViewModel, numWeapons)
|
|
for i := 0; i < len(weapons); i++ {
|
|
weapons[i] = WeaponViewModel{
|
|
Name: "Weapon " + string(rune('A'+i%26)),
|
|
Value: 10 + i,
|
|
}
|
|
}
|
|
|
|
t.Logf("Created %d weapons (capacity %d)", numWeapons, weaponsCapacity)
|
|
|
|
// Act
|
|
pages, err := paginator.PaginateWeapons(weapons, "page2_play.html")
|
|
|
|
// Assert
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
// Should have 2 pages (base + continuation)
|
|
if len(pages) != 2 {
|
|
t.Errorf("Expected 2 pages (main + continuation), got %d", len(pages))
|
|
}
|
|
|
|
// First page should be original template
|
|
if pages[0].TemplateName != "page2_play.html" {
|
|
t.Errorf("Expected first page 'page2_play.html', got '%s'", pages[0].TemplateName)
|
|
}
|
|
|
|
// Second page should be continuation
|
|
if pages[1].TemplateName != "page2.2_play.html" {
|
|
t.Errorf("Expected continuation 'page2.2_play.html', got '%s'", pages[1].TemplateName)
|
|
}
|
|
}
|
|
|
|
// TestContinuationPages_MultipleOverflows tests handling of multiple continuation pages
|
|
func TestContinuationPages_MultipleOverflows(t *testing.T) {
|
|
// Arrange
|
|
templateSet := DefaultA4QuerTemplateSet()
|
|
paginator := NewPaginator(templateSet)
|
|
|
|
// Get actual capacity from template
|
|
var skillsCapacity int
|
|
for _, tmpl := range templateSet.Templates {
|
|
if tmpl.Metadata.Name == "page1_stats.html" {
|
|
for _, block := range tmpl.Metadata.Blocks {
|
|
if block.ListType == "skills" {
|
|
skillsCapacity += block.MaxItems
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
t.Logf("Skills capacity per page: %d", skillsCapacity)
|
|
|
|
// Create 200 skills to force multiple continuations
|
|
skills := make([]SkillViewModel, 200)
|
|
for i := 0; i < 200; i++ {
|
|
skills[i] = SkillViewModel{
|
|
Name: "Skill " + string(rune('A'+i%26)),
|
|
Value: 10 + i%20,
|
|
}
|
|
}
|
|
|
|
// Calculate expected pages
|
|
expectedPages := (200 + skillsCapacity - 1) / skillsCapacity
|
|
|
|
// Act
|
|
pages, err := paginator.PaginateSkills(skills, "page1_stats.html", "")
|
|
|
|
// Assert
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
// Should have calculated number of pages
|
|
if len(pages) != expectedPages {
|
|
t.Errorf("Expected %d pages for 200 skills (capacity %d), got %d", expectedPages, skillsCapacity, len(pages))
|
|
}
|
|
|
|
t.Logf("Created %d pages for 200 skills", len(pages))
|
|
|
|
// Verify template names follow pattern: page1_stats.html, then all use page1.2_stats.html
|
|
for i, page := range pages {
|
|
var expectedTemplate string
|
|
if i == 0 {
|
|
expectedTemplate = "page1_stats.html"
|
|
} else {
|
|
// All continuation pages use the same .2 template
|
|
expectedTemplate = "page1.2_stats.html"
|
|
}
|
|
|
|
if page.TemplateName != expectedTemplate {
|
|
t.Errorf("Page %d: expected template '%s', got '%s'",
|
|
i+1, expectedTemplate, page.TemplateName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestContinuationPages_NoOverflow tests that no continuation pages are created
|
|
// when items fit within the original page capacity
|
|
func TestContinuationPages_NoOverflow(t *testing.T) {
|
|
// Arrange
|
|
templateSet := DefaultA4QuerTemplateSet()
|
|
paginator := NewPaginator(templateSet)
|
|
|
|
// Create only 10 skills (well below capacity)
|
|
skills := make([]SkillViewModel, 10)
|
|
for i := 0; i < 10; i++ {
|
|
skills[i] = SkillViewModel{
|
|
Name: "Skill " + string(rune('A'+i)),
|
|
Value: 10 + i,
|
|
}
|
|
}
|
|
|
|
// Act
|
|
pages, err := paginator.PaginateSkills(skills, "page1_stats.html", "")
|
|
|
|
// Assert
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
// Should have exactly 1 page (no overflow)
|
|
if len(pages) != 1 {
|
|
t.Errorf("Expected 1 page for 10 skills, got %d", len(pages))
|
|
}
|
|
|
|
// Should use original template, not continuation
|
|
if pages[0].TemplateName != "page1_stats.html" {
|
|
t.Errorf("Expected original template 'page1_stats.html', got '%s'", pages[0].TemplateName)
|
|
}
|
|
}
|