package hugolib import ( "bytes" "context" "fmt" "image/jpeg" "io" "io/fs" "math/rand" "os" "path/filepath" "regexp" "strings" "testing" "text/template" "time" "github.com/gohugoio/hugo/config/allconfig" "github.com/gohugoio/hugo/config/security" "github.com/gohugoio/hugo/htesting" "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/parser/metadecoders" "github.com/google/go-cmp/cmp" "github.com/gohugoio/hugo/parser" "github.com/fsnotify/fsnotify" "github.com/gohugoio/hugo/common/hexec" "github.com/gohugoio/hugo/common/loggers" "github.com/gohugoio/hugo/common/maps" "github.com/gohugoio/hugo/config" "github.com/gohugoio/hugo/deps" "github.com/gohugoio/hugo/resources/page" "github.com/sanity-io/litter" "github.com/spf13/afero" "github.com/spf13/cast" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/resources/resource" qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/hugofs" ) var ( deepEqualsPages = qt.CmpEquals(cmp.Comparer(func(p1, p2 *pageState) bool { return p1 == p2 })) deepEqualsOutputFormats = qt.CmpEquals(cmp.Comparer(func(o1, o2 output.Format) bool { return o1.Name == o2.Name && o1.MediaType.Type == o2.MediaType.Type })) ) type sitesBuilder struct { Cfg config.Provider Configs *allconfig.Configs environ []string Fs *hugofs.Fs T testing.TB depsCfg deps.DepsCfg *qt.C logger loggers.Logger rnd *rand.Rand dumper litter.Options // Used to test partial rebuilds. changedFiles []string removedFiles []string // Aka the Hugo server mode. running bool H *HugoSites theme string // Default toml configFormat string configFileSet bool configSet bool // Default is empty. // TODO(bep) revisit this and consider always setting it to something. // Consider this in relation to using the BaseFs.PublishFs to all publishing. workingDir string addNothing bool // Base data/content contentFilePairs []filenameContent templateFilePairs []filenameContent i18nFilePairs []filenameContent dataFilePairs []filenameContent // Additional data/content. // As in "use the base, but add these on top". contentFilePairsAdded []filenameContent templateFilePairsAdded []filenameContent i18nFilePairsAdded []filenameContent dataFilePairsAdded []filenameContent } type filenameContent struct { filename string content string } func newTestSitesBuilder(t testing.TB) *sitesBuilder { v := config.New() v.Set("publishDir", "public") v.Set("disableLiveReload", true) fs := hugofs.NewFromOld(afero.NewMemMapFs(), v) litterOptions := litter.Options{ HidePrivateFields: true, StripPackageNames: true, Separator: " ", } return &sitesBuilder{ T: t, C: qt.New(t), Fs: fs, configFormat: "toml", dumper: litterOptions, rnd: rand.New(rand.NewSource(time.Now().Unix())), } } func newTestSitesBuilderFromDepsCfg(t testing.TB, d deps.DepsCfg) *sitesBuilder { c := qt.New(t) litterOptions := litter.Options{ HidePrivateFields: true, StripPackageNames: true, Separator: " ", } b := &sitesBuilder{T: t, C: c, depsCfg: d, Fs: d.Fs, dumper: litterOptions, rnd: rand.New(rand.NewSource(time.Now().Unix()))} workingDir := d.Configs.LoadingInfo.BaseConfig.WorkingDir b.WithWorkingDir(workingDir) return b } func (s *sitesBuilder) Running() *sitesBuilder { s.running = true return s } func (s *sitesBuilder) WithNothingAdded() *sitesBuilder { s.addNothing = true return s } func (s *sitesBuilder) WithLogger(logger loggers.Logger) *sitesBuilder { s.logger = logger return s } func (s *sitesBuilder) WithWorkingDir(dir string) *sitesBuilder { s.workingDir = filepath.FromSlash(dir) return s } func (s *sitesBuilder) WithEnviron(env ...string) *sitesBuilder { for i := 0; i < len(env); i += 2 { s.environ = append(s.environ, fmt.Sprintf("%s=%s", env[i], env[i+1])) } return s } func (s *sitesBuilder) WithConfigTemplate(data any, format, configTemplate string) *sitesBuilder { s.T.Helper() if format == "" { format = "toml" } templ, err := template.New("test").Parse(configTemplate) if err != nil { s.Fatalf("Template parse failed: %s", err) } var b bytes.Buffer templ.Execute(&b, data) return s.WithConfigFile(format, b.String()) } func (s *sitesBuilder) WithViper(v config.Provider) *sitesBuilder { s.T.Helper() if s.configFileSet { s.T.Fatal("WithViper: use Viper or config.toml, not both") } defer func() { s.configSet = true }() // Write to a config file to make sure the tests follow the same code path. var buff bytes.Buffer m := v.Get("").(maps.Params) s.Assert(parser.InterfaceToConfig(m, metadecoders.TOML, &buff), qt.IsNil) return s.WithConfigFile("toml", buff.String()) } func (s *sitesBuilder) WithConfigFile(format, conf string) *sitesBuilder { s.T.Helper() if s.configSet { s.T.Fatal("WithConfigFile: use config.Config or config.toml, not both") } s.configFileSet = true filename := s.absFilename("config." + format) writeSource(s.T, s.Fs, filename, conf) s.configFormat = format return s } func (s *sitesBuilder) WithThemeConfigFile(format, conf string) *sitesBuilder { s.T.Helper() if s.theme == "" { s.theme = "test-theme" } filename := filepath.Join("themes", s.theme, "config."+format) writeSource(s.T, s.Fs, s.absFilename(filename), conf) return s } func (s *sitesBuilder) WithSourceFile(filenameContent ...string) *sitesBuilder { s.T.Helper() for i := 0; i < len(filenameContent); i += 2 { writeSource(s.T, s.Fs, s.absFilename(filenameContent[i]), filenameContent[i+1]) } return s } func (s *sitesBuilder) absFilename(filename string) string { filename = filepath.FromSlash(filename) if filepath.IsAbs(filename) { return filename } if s.workingDir != "" && !strings.HasPrefix(filename, s.workingDir) { filename = filepath.Join(s.workingDir, filename) } return filename } const commonConfigSections = ` [services] [services.disqus] shortname = "disqus_shortname" [services.googleAnalytics] id = "UA-ga_id" [privacy] [privacy.disqus] disable = false [privacy.googleAnalytics] respectDoNotTrack = true [privacy.instagram] simple = true [privacy.twitter] enableDNT = true [privacy.vimeo] disable = false [privacy.youtube] disable = false privacyEnhanced = true ` func (s *sitesBuilder) WithSimpleConfigFile() *sitesBuilder { s.T.Helper() return s.WithSimpleConfigFileAndBaseURL("http://example.com/") } func (s *sitesBuilder) WithSimpleConfigFileAndBaseURL(baseURL string) *sitesBuilder { s.T.Helper() return s.WithSimpleConfigFileAndSettings(map[string]any{"baseURL": baseURL}) } func (s *sitesBuilder) WithSimpleConfigFileAndSettings(settings any) *sitesBuilder { s.T.Helper() var buf bytes.Buffer parser.InterfaceToConfig(settings, metadecoders.TOML, &buf) config := buf.String() + commonConfigSections return s.WithConfigFile("toml", config) } func (s *sitesBuilder) WithDefaultMultiSiteConfig() *sitesBuilder { defaultMultiSiteConfig := ` baseURL = "http://example.com/blog" paginate = 1 disablePathToLower = true defaultContentLanguage = "en" defaultContentLanguageInSubdir = true [permalinks] other = "/somewhere/else/:filename" [Taxonomies] tag = "tags" [Languages] [Languages.en] weight = 10 title = "In English" languageName = "English" [[Languages.en.menu.main]] url = "/" name = "Home" weight = 0 [Languages.fr] weight = 20 title = "Le Français" languageName = "Français" [Languages.fr.Taxonomies] plaque = "plaques" [Languages.nn] weight = 30 title = "På nynorsk" languageName = "Nynorsk" paginatePath = "side" [Languages.nn.Taxonomies] lag = "lag" [[Languages.nn.menu.main]] url = "/" name = "Heim" weight = 1 [Languages.nb] weight = 40 title = "På bokmål" languageName = "Bokmål" paginatePath = "side" [Languages.nb.Taxonomies] lag = "lag" ` + commonConfigSections return s.WithConfigFile("toml", defaultMultiSiteConfig) } func (s *sitesBuilder) WithSunset(in string) { // Write a real image into one of the bundle above. src, err := os.Open(filepath.FromSlash("testdata/sunset.jpg")) s.Assert(err, qt.IsNil) out, err := s.Fs.Source.Create(filepath.FromSlash(filepath.Join(s.workingDir, in))) s.Assert(err, qt.IsNil) _, err = io.Copy(out, src) s.Assert(err, qt.IsNil) out.Close() src.Close() } func (s *sitesBuilder) createFilenameContent(pairs []string) []filenameContent { var slice []filenameContent s.appendFilenameContent(&slice, pairs...) return slice } func (s *sitesBuilder) appendFilenameContent(slice *[]filenameContent, pairs ...string) { if len(pairs)%2 != 0 { panic("file content mismatch") } for i := 0; i < len(pairs); i += 2 { c := filenameContent{ filename: pairs[i], content: pairs[i+1], } *slice = append(*slice, c) } } func (s *sitesBuilder) WithContent(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.contentFilePairs, filenameContent...) return s } func (s *sitesBuilder) WithContentAdded(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.contentFilePairsAdded, filenameContent...) return s } func (s *sitesBuilder) WithTemplates(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.templateFilePairs, filenameContent...) return s } func (s *sitesBuilder) WithTemplatesAdded(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.templateFilePairsAdded, filenameContent...) return s } func (s *sitesBuilder) WithData(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.dataFilePairs, filenameContent...) return s } func (s *sitesBuilder) WithDataAdded(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.dataFilePairsAdded, filenameContent...) return s } func (s *sitesBuilder) WithI18n(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.i18nFilePairs, filenameContent...) return s } func (s *sitesBuilder) WithI18nAdded(filenameContent ...string) *sitesBuilder { s.appendFilenameContent(&s.i18nFilePairsAdded, filenameContent...) return s } func (s *sitesBuilder) EditFiles(filenameContent ...string) *sitesBuilder { for i := 0; i < len(filenameContent); i += 2 { filename, content := filepath.FromSlash(filenameContent[i]), filenameContent[i+1] absFilename := s.absFilename(filename) s.changedFiles = append(s.changedFiles, absFilename) writeSource(s.T, s.Fs, absFilename, content) } return s } func (s *sitesBuilder) RemoveFiles(filenames ...string) *sitesBuilder { for _, filename := range filenames { absFilename := s.absFilename(filename) s.removedFiles = append(s.removedFiles, absFilename) s.Assert(s.Fs.Source.Remove(absFilename), qt.IsNil) } return s } func (s *sitesBuilder) writeFilePairs(folder string, files []filenameContent) *sitesBuilder { // We have had some "filesystem ordering" bugs that we have not discovered in // our tests running with the in memory filesystem. // That file system is backed by a map so not sure how this helps, but some // randomness in tests doesn't hurt. // TODO(bep) this turns out to be more confusing than helpful. // s.rnd.Shuffle(len(files), func(i, j int) { files[i], files[j] = files[j], files[i] }) for _, fc := range files { target := folder // TODO(bep) clean up this magic. if strings.HasPrefix(fc.filename, folder) { target = "" } if s.workingDir != "" { target = filepath.Join(s.workingDir, target) } writeSource(s.T, s.Fs, filepath.Join(target, fc.filename), fc.content) } return s } func (s *sitesBuilder) CreateSites() *sitesBuilder { if err := s.CreateSitesE(); err != nil { s.Fatalf("Failed to create sites: %s", err) } s.Assert(s.Fs.PublishDir, qt.IsNotNil) s.Assert(s.Fs.WorkingDirReadOnly, qt.IsNotNil) return s } func (s *sitesBuilder) LoadConfig() error { if !s.configFileSet { s.WithSimpleConfigFile() } flags := config.New() flags.Set("internal", map[string]any{ "running": s.running, "watch": s.running, }) if s.workingDir != "" { flags.Set("workingDir", s.workingDir) } res, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{ Fs: s.Fs.Source, Logger: s.logger, Flags: flags, Environ: s.environ, Filename: "config." + s.configFormat, }) if err != nil { return err } s.Cfg = res.LoadingInfo.Cfg s.Configs = res return nil } func (s *sitesBuilder) CreateSitesE() error { if !s.addNothing { if _, ok := s.Fs.Source.(*afero.OsFs); ok { for _, dir := range []string{ "content/sect", "layouts/_default", "layouts/_default/_markup", "layouts/partials", "layouts/shortcodes", "data", "i18n", } { if err := os.MkdirAll(filepath.Join(s.workingDir, dir), 0o777); err != nil { return fmt.Errorf("failed to create %q: %w", dir, err) } } } s.addDefaults() s.writeFilePairs("content", s.contentFilePairsAdded) s.writeFilePairs("layouts", s.templateFilePairsAdded) s.writeFilePairs("data", s.dataFilePairsAdded) s.writeFilePairs("i18n", s.i18nFilePairsAdded) s.writeFilePairs("i18n", s.i18nFilePairs) s.writeFilePairs("data", s.dataFilePairs) s.writeFilePairs("content", s.contentFilePairs) s.writeFilePairs("layouts", s.templateFilePairs) } if err := s.LoadConfig(); err != nil { return fmt.Errorf("failed to load config: %w", err) } s.Fs.PublishDir = hugofs.NewCreateCountingFs(s.Fs.PublishDir) depsCfg := s.depsCfg depsCfg.Fs = s.Fs if depsCfg.Configs.IsZero() { depsCfg.Configs = s.Configs } depsCfg.TestLogger = s.logger sites, err := NewHugoSites(depsCfg) if err != nil { return fmt.Errorf("failed to create sites: %w", err) } s.H = sites return nil } func (s *sitesBuilder) BuildE(cfg BuildCfg) error { if s.H == nil { s.CreateSites() } return s.H.Build(cfg) } func (s *sitesBuilder) Build(cfg BuildCfg) *sitesBuilder { s.T.Helper() return s.build(cfg, false) } func (s *sitesBuilder) BuildFail(cfg BuildCfg) *sitesBuilder { s.T.Helper() return s.build(cfg, true) } func (s *sitesBuilder) changeEvents() []fsnotify.Event { var events []fsnotify.Event for _, v := range s.changedFiles { events = append(events, fsnotify.Event{ Name: v, Op: fsnotify.Write, }) } for _, v := range s.removedFiles { events = append(events, fsnotify.Event{ Name: v, Op: fsnotify.Remove, }) } return events } func (s *sitesBuilder) build(cfg BuildCfg, shouldFail bool) *sitesBuilder { s.Helper() defer func() { s.changedFiles = nil }() if s.H == nil { s.CreateSites() } err := s.H.Build(cfg, s.changeEvents()...) if err == nil { logErrorCount := s.H.NumLogErrors() if logErrorCount > 0 { err = fmt.Errorf("logged %d errors", logErrorCount) } } if err != nil && !shouldFail { s.Fatalf("Build failed: %s", err) } else if err == nil && shouldFail { s.Fatalf("Expected error") } return s } func (s *sitesBuilder) addDefaults() { var ( contentTemplate = `--- title: doc1 weight: 1 tags: - tag1 date: "2018-02-28" --- # doc1 *some "content"* {{< shortcode >}} {{< lingo >}} ` defaultContent = []string{ "content/sect/doc1.en.md", contentTemplate, "content/sect/doc1.fr.md", contentTemplate, "content/sect/doc1.nb.md", contentTemplate, "content/sect/doc1.nn.md", contentTemplate, } listTemplateCommon = "{{ $p := .Paginator }}{{ $p.PageNumber }}|{{ .Title }}|{{ i18n \"hello\" }}|{{ .Permalink }}|Pager: {{ template \"_internal/pagination.html\" . }}|Kind: {{ .Kind }}|Content: {{ .Content }}|Len Pages: {{ len .Pages }}|Len RegularPages: {{ len .RegularPages }}| HasParent: {{ if .Parent }}YES{{ else }}NO{{ end }}" defaultTemplates = []string{ "_default/single.html", "Single: {{ .Title }}|{{ i18n \"hello\" }}|{{.Language.Lang}}|RelPermalink: {{ .RelPermalink }}|Permalink: {{ .Permalink }}|{{ .Content }}|Resources: {{ range .Resources }}{{ .MediaType }}: {{ .RelPermalink}} -- {{ end }}|Summary: {{ .Summary }}|Truncated: {{ .Truncated }}|Parent: {{ .Parent.Title }}", "_default/list.html", "List Page " + listTemplateCommon, "index.html", "{{ $p := .Paginator }}Default Home Page {{ $p.PageNumber }}: {{ .Title }}|{{ .IsHome }}|{{ i18n \"hello\" }}|{{ .Permalink }}|{{ .Site.Data.hugo.slogan }}|String Resource: {{ ( \"Hugo Pipes\" | resources.FromString \"text/pipes.txt\").RelPermalink }}|String Resource Permalink: {{ ( \"Hugo Pipes\" | resources.FromString \"text/pipes.txt\").Permalink }}", "index.fr.html", "{{ $p := .Paginator }}French Home Page {{ $p.PageNumber }}: {{ .Title }}|{{ .IsHome }}|{{ i18n \"hello\" }}|{{ .Permalink }}|{{ .Site.Data.hugo.slogan }}|String Resource: {{ ( \"Hugo Pipes\" | resources.FromString \"text/pipes.txt\").RelPermalink }}|String Resource Permalink: {{ ( \"Hugo Pipes\" | resources.FromString \"text/pipes.txt\").Permalink }}", "_default/terms.html", "Taxonomy Term Page " + listTemplateCommon, "_default/taxonomy.html", "Taxonomy List Page " + listTemplateCommon, // Shortcodes "shortcodes/shortcode.html", "Shortcode: {{ i18n \"hello\" }}", // A shortcode in multiple languages "shortcodes/lingo.html", "LingoDefault", "shortcodes/lingo.fr.html", "LingoFrench", // Special templates "404.html", "404|{{ .Lang }}|{{ .Title }}", "robots.txt", "robots|{{ .Lang }}|{{ .Title }}", } defaultI18n = []string{ "en.yaml", ` hello: other: "Hello" `, "fr.yaml", ` hello: other: "Bonjour" `, } defaultData = []string{ "hugo.toml", "slogan = \"Hugo Rocks!\"", } ) if len(s.contentFilePairs) == 0 { s.writeFilePairs("content", s.createFilenameContent(defaultContent)) } if len(s.templateFilePairs) == 0 { s.writeFilePairs("layouts", s.createFilenameContent(defaultTemplates)) } if len(s.dataFilePairs) == 0 { s.writeFilePairs("data", s.createFilenameContent(defaultData)) } if len(s.i18nFilePairs) == 0 { s.writeFilePairs("i18n", s.createFilenameContent(defaultI18n)) } } func (s *sitesBuilder) Fatalf(format string, args ...any) { s.T.Helper() s.T.Fatalf(format, args...) } func (s *sitesBuilder) AssertFileContentFn(filename string, f func(s string) bool) { s.T.Helper() content := s.FileContent(filename) if !f(content) { s.Fatalf("Assert failed for %q in content\n%s", filename, content) } } // Helper to migrate tests to new format. func (s *sitesBuilder) DumpTxtar() string { var sb strings.Builder skipRe := regexp.MustCompile(`^(public|resources|package-lock.json|go.sum)`) afero.Walk(s.Fs.Source, s.workingDir, func(path string, info fs.FileInfo, err error) error { if err != nil { return err } rel := strings.TrimPrefix(path, s.workingDir+"/") if skipRe.MatchString(rel) { if info.IsDir() { return filepath.SkipDir } return nil } if info == nil || info.IsDir() { return nil } sb.WriteString(fmt.Sprintf("-- %s --\n", rel)) b, err := afero.ReadFile(s.Fs.Source, path) s.Assert(err, qt.IsNil) sb.WriteString(strings.TrimSpace(string(b))) sb.WriteString("\n") return nil }) return sb.String() } func (s *sitesBuilder) AssertHome(matches ...string) { s.AssertFileContent("public/index.html", matches...) } func (s *sitesBuilder) AssertFileContent(filename string, matches ...string) { s.T.Helper() content := s.FileContent(filename) for _, m := range matches { lines := strings.Split(m, "\n") for _, match := range lines { match = strings.TrimSpace(match) if match == "" { continue } if !strings.Contains(content, match) { s.Assert(content, qt.Contains, match, qt.Commentf(match+" not in: \n"+content)) } } } } func (s *sitesBuilder) AssertFileDoesNotExist(filename string) { if s.CheckExists(filename) { s.Fatalf("File %q exists but must not exist.", filename) } } func (s *sitesBuilder) AssertImage(width, height int, filename string) { f, err := s.Fs.WorkingDirReadOnly.Open(filename) s.Assert(err, qt.IsNil) defer f.Close() cfg, err := jpeg.DecodeConfig(f) s.Assert(err, qt.IsNil) s.Assert(cfg.Width, qt.Equals, width) s.Assert(cfg.Height, qt.Equals, height) } func (s *sitesBuilder) AssertNoDuplicateWrites() { s.Helper() hugofs.WalkFilesystems(s.Fs.PublishDir, func(fs afero.Fs) bool { if dfs, ok := fs.(hugofs.DuplicatesReporter); ok { s.Assert(dfs.ReportDuplicates(), qt.Equals, "") } return false }) } func (s *sitesBuilder) FileContent(filename string) string { s.Helper() filename = filepath.FromSlash(filename) return readWorkingDir(s.T, s.Fs, filename) } func (s *sitesBuilder) AssertObject(expected string, object any) { s.T.Helper() got := s.dumper.Sdump(object) expected = strings.TrimSpace(expected) if expected != got { fmt.Println(got) diff := htesting.DiffStrings(expected, got) s.Fatalf("diff:\n%s\nexpected\n%s\ngot\n%s", diff, expected, got) } } func (s *sitesBuilder) AssertFileContentRe(filename string, matches ...string) { content := readWorkingDir(s.T, s.Fs, filename) for _, match := range matches { r := regexp.MustCompile("(?s)" + match) if !r.MatchString(content) { s.Fatalf("No match for %q in content for %s\n%q", match, filename, content) } } } func (s *sitesBuilder) CheckExists(filename string) bool { return workingDirExists(s.Fs, filepath.Clean(filename)) } func (s *sitesBuilder) GetPage(ref string) page.Page { p, err := s.H.Sites[0].getPage(nil, ref) s.Assert(err, qt.IsNil) return p } func (s *sitesBuilder) GetPageRel(p page.Page, ref string) page.Page { p, err := s.H.Sites[0].getPage(p, ref) s.Assert(err, qt.IsNil) return p } func (s *sitesBuilder) NpmInstall() hexec.Runner { sc := security.DefaultConfig var err error sc.Exec.Allow, err = security.NewWhitelist("npm") s.Assert(err, qt.IsNil) ex := hexec.New(sc, s.workingDir) command, err := ex.New("npm", "install") s.Assert(err, qt.IsNil) return command } func newTestHelperFromProvider(cfg config.Provider, fs *hugofs.Fs, t testing.TB) (testHelper, *allconfig.Configs) { res, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{ Flags: cfg, Fs: fs.Source, }) if err != nil { t.Fatal(err) } return newTestHelper(res.Base, fs, t), res } func newTestHelper(cfg *allconfig.Config, fs *hugofs.Fs, t testing.TB) testHelper { return testHelper{ Cfg: cfg, Fs: fs, C: qt.New(t), } } type testHelper struct { Cfg *allconfig.Config Fs *hugofs.Fs *qt.C } func (th testHelper) assertFileContent(filename string, matches ...string) { th.Helper() filename = th.replaceDefaultContentLanguageValue(filename) content := readWorkingDir(th, th.Fs, filename) for _, match := range matches { match = th.replaceDefaultContentLanguageValue(match) th.Assert(strings.Contains(content, match), qt.Equals, true, qt.Commentf(match+" not in: \n"+content)) } } func (th testHelper) assertFileNotExist(filename string) { exists, err := helpers.Exists(filename, th.Fs.PublishDir) th.Assert(err, qt.IsNil) th.Assert(exists, qt.Equals, false) } func (th testHelper) replaceDefaultContentLanguageValue(value string) string { defaultInSubDir := th.Cfg.DefaultContentLanguageInSubdir replace := th.Cfg.DefaultContentLanguage + "/" if !defaultInSubDir { value = strings.Replace(value, replace, "", 1) } return value } func loadTestConfigFromProvider(cfg config.Provider) (*allconfig.Configs, error) { workingDir := cfg.GetString("workingDir") fs := afero.NewMemMapFs() if workingDir != "" { fs.MkdirAll(workingDir, 0o755) } res, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{Flags: cfg, Fs: fs}) return res, err } func newTestCfg(withConfig ...func(cfg config.Provider) error) (config.Provider, *hugofs.Fs) { mm := afero.NewMemMapFs() cfg := config.New() cfg.Set("defaultContentLanguageInSubdir", false) cfg.Set("publishDir", "public") fs := hugofs.NewFromOld(hugofs.NewBaseFileDecorator(mm), cfg) return cfg, fs } func newTestSitesFromConfig(t testing.TB, afs afero.Fs, tomlConfig string, layoutPathContentPairs ...string) (testHelper, *HugoSites) { if len(layoutPathContentPairs)%2 != 0 { t.Fatalf("Layouts must be provided in pairs") } c := qt.New(t) writeToFs(t, afs, filepath.Join("content", ".gitkeep"), "") writeToFs(t, afs, "config.toml", tomlConfig) cfg, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{Fs: afs}) c.Assert(err, qt.IsNil) fs := hugofs.NewFrom(afs, cfg.LoadingInfo.BaseConfig) th := newTestHelper(cfg.Base, fs, t) for i := 0; i < len(layoutPathContentPairs); i += 2 { writeSource(t, fs, layoutPathContentPairs[i], layoutPathContentPairs[i+1]) } h, err := NewHugoSites(deps.DepsCfg{Fs: fs, Configs: cfg}) c.Assert(err, qt.IsNil) return th, h } // TODO(bep) replace these with the builder func buildSingleSite(t testing.TB, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site { t.Helper() return buildSingleSiteExpected(t, false, false, depsCfg, buildCfg) } func buildSingleSiteExpected(t testing.TB, expectSiteInitError, expectBuildError bool, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site { t.Helper() b := newTestSitesBuilderFromDepsCfg(t, depsCfg).WithNothingAdded() err := b.CreateSitesE() if expectSiteInitError { b.Assert(err, qt.Not(qt.IsNil)) return nil } else { b.Assert(err, qt.IsNil) } h := b.H b.Assert(len(h.Sites), qt.Equals, 1) if expectBuildError { b.Assert(h.Build(buildCfg), qt.Not(qt.IsNil)) return nil } b.Assert(h.Build(buildCfg), qt.IsNil) return h.Sites[0] } func writeSourcesToSource(t *testing.T, base string, fs *hugofs.Fs, sources ...[2]string) { for _, src := range sources { writeSource(t, fs, filepath.Join(base, src[0]), src[1]) } } func getPage(in page.Page, ref string) page.Page { p, err := in.GetPage(ref) if err != nil { panic(err) } return p } func content(c resource.ContentProvider) string { cc, err := c.Content(context.Background()) if err != nil { panic(err) } ccs, err := cast.ToStringE(cc) if err != nil { panic(err) } return ccs }