mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-07 20:30:36 -05:00
286821e360
Before this change, data files from Hugo modules were always mounted at the root of the `data` directory. The File and FileMetaInfo structs for modules are different from 'native' data directories. This changes how the keyParts for data files are generated so that data from modules or native directories are treated the same.
1209 lines
30 KiB
Go
1209 lines
30 KiB
Go
// 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 hugolib
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/bep/logg"
|
|
"github.com/gohugoio/hugo/config"
|
|
"github.com/gohugoio/hugo/modules/npm"
|
|
|
|
"github.com/spf13/afero"
|
|
|
|
"github.com/gohugoio/hugo/hugofs/files"
|
|
|
|
"github.com/gohugoio/hugo/common/hugo"
|
|
"github.com/gohugoio/hugo/common/loggers"
|
|
|
|
"github.com/gohugoio/hugo/htesting"
|
|
"github.com/gohugoio/hugo/hugofs"
|
|
|
|
qt "github.com/frankban/quicktest"
|
|
"github.com/gohugoio/testmodBuilder/mods"
|
|
)
|
|
|
|
func TestHugoModulesVariants(t *testing.T) {
|
|
if !htesting.IsCI() {
|
|
t.Skip("skip (relative) long running modules test when running locally")
|
|
}
|
|
|
|
tomlConfig := `
|
|
baseURL="https://example.org"
|
|
workingDir = %q
|
|
|
|
[module]
|
|
[[module.imports]]
|
|
path="github.com/gohugoio/hugoTestModule2"
|
|
%s
|
|
`
|
|
|
|
createConfig := func(workingDir, moduleOpts string) string {
|
|
return fmt.Sprintf(tomlConfig, workingDir, moduleOpts)
|
|
}
|
|
|
|
newTestBuilder := func(t testing.TB, moduleOpts string) *sitesBuilder {
|
|
b := newTestSitesBuilder(t)
|
|
tempDir := t.TempDir()
|
|
workingDir := filepath.Join(tempDir, "myhugosite")
|
|
b.Assert(os.MkdirAll(workingDir, 0777), qt.IsNil)
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workingDir)
|
|
cfg.Set("publishDir", "public")
|
|
b.Fs = hugofs.NewDefaultOld(cfg)
|
|
b.WithWorkingDir(workingDir).WithConfigFile("toml", createConfig(workingDir, moduleOpts))
|
|
b.WithTemplates(
|
|
"index.html", `
|
|
Param from module: {{ site.Params.Hugo }}|
|
|
{{ $js := resources.Get "jslibs/alpinejs/alpine.js" }}
|
|
JS imported in module: {{ with $js }}{{ .RelPermalink }}{{ end }}|
|
|
`,
|
|
"_default/single.html", `{{ .Content }}`)
|
|
b.WithContent("p1.md", `---
|
|
title: "Page"
|
|
---
|
|
|
|
[A link](https://bep.is)
|
|
|
|
`)
|
|
b.WithSourceFile("go.mod", `
|
|
module github.com/gohugoio/tests/testHugoModules
|
|
|
|
|
|
`)
|
|
|
|
b.WithSourceFile("go.sum", `
|
|
github.com/gohugoio/hugoTestModule2 v0.0.0-20200131160637-9657d7697877 h1:WLM2bQCKIWo04T6NsIWsX/Vtirhf0TnpY66xyqGlgVY=
|
|
github.com/gohugoio/hugoTestModule2 v0.0.0-20200131160637-9657d7697877/go.mod h1:CBFZS3khIAXKxReMwq0le8sEl/D8hcXmixlOHVv+Gd0=
|
|
`)
|
|
|
|
return b
|
|
}
|
|
|
|
t.Run("Target in subfolder", func(t *testing.T) {
|
|
b := newTestBuilder(t, "ignoreImports=true")
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/p1/index.html", `<p>Page|https://bep.is|Title: |Text: A link|END</p>`)
|
|
})
|
|
|
|
t.Run("Ignore config", func(t *testing.T) {
|
|
b := newTestBuilder(t, "ignoreConfig=true")
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", `
|
|
Param from module: |
|
|
JS imported in module: |
|
|
`)
|
|
})
|
|
|
|
t.Run("Ignore imports", func(t *testing.T) {
|
|
b := newTestBuilder(t, "ignoreImports=true")
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", `
|
|
Param from module: Rocks|
|
|
JS imported in module: |
|
|
`)
|
|
})
|
|
|
|
t.Run("Create package.json", func(t *testing.T) {
|
|
b := newTestBuilder(t, "")
|
|
|
|
b.WithSourceFile("package.json", `{
|
|
"name": "mypack",
|
|
"version": "1.2.3",
|
|
"scripts": {
|
|
"client": "wait-on http://localhost:1313 && open http://localhost:1313",
|
|
"start": "run-p client server",
|
|
"test": "echo 'hoge' > hoge"
|
|
},
|
|
"dependencies": {
|
|
"nonon": "error"
|
|
}
|
|
}`)
|
|
|
|
b.WithSourceFile("package.hugo.json", `{
|
|
"name": "mypack",
|
|
"version": "1.2.3",
|
|
"scripts": {
|
|
"client": "wait-on http://localhost:1313 && open http://localhost:1313",
|
|
"start": "run-p client server",
|
|
"test": "echo 'hoge' > hoge"
|
|
},
|
|
"dependencies": {
|
|
"foo": "1.2.3"
|
|
},
|
|
"devDependencies": {
|
|
"postcss-cli": "7.8.0",
|
|
"tailwindcss": "1.8.0"
|
|
|
|
}
|
|
}`)
|
|
|
|
b.Build(BuildCfg{})
|
|
b.Assert(npm.Pack(b.H.BaseFs.SourceFs, b.H.BaseFs.Assets.Dirs), qt.IsNil)
|
|
|
|
b.AssertFileContentFn("package.json", func(s string) bool {
|
|
return s == `{
|
|
"comments": {
|
|
"dependencies": {
|
|
"foo": "project",
|
|
"react-dom": "github.com/gohugoio/hugoTestModule2"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/core": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/preset-env": "github.com/gohugoio/hugoTestModule2",
|
|
"postcss-cli": "project",
|
|
"tailwindcss": "project"
|
|
}
|
|
},
|
|
"dependencies": {
|
|
"foo": "1.2.3",
|
|
"react-dom": "^16.13.1"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "7.8.4",
|
|
"@babel/core": "7.9.0",
|
|
"@babel/preset-env": "7.9.5",
|
|
"postcss-cli": "7.8.0",
|
|
"tailwindcss": "1.8.0"
|
|
},
|
|
"name": "mypack",
|
|
"scripts": {
|
|
"client": "wait-on http://localhost:1313 && open http://localhost:1313",
|
|
"start": "run-p client server",
|
|
"test": "echo 'hoge' > hoge"
|
|
},
|
|
"version": "1.2.3"
|
|
}
|
|
`
|
|
})
|
|
})
|
|
|
|
t.Run("Create package.json, no default", func(t *testing.T) {
|
|
b := newTestBuilder(t, "")
|
|
|
|
const origPackageJSON = `{
|
|
"name": "mypack",
|
|
"version": "1.2.3",
|
|
"scripts": {
|
|
"client": "wait-on http://localhost:1313 && open http://localhost:1313",
|
|
"start": "run-p client server",
|
|
"test": "echo 'hoge' > hoge"
|
|
},
|
|
"dependencies": {
|
|
"moo": "1.2.3"
|
|
}
|
|
}`
|
|
|
|
b.WithSourceFile("package.json", origPackageJSON)
|
|
|
|
b.Build(BuildCfg{})
|
|
b.Assert(npm.Pack(b.H.BaseFs.SourceFs, b.H.BaseFs.Assets.Dirs), qt.IsNil)
|
|
|
|
b.AssertFileContentFn("package.json", func(s string) bool {
|
|
return s == `{
|
|
"comments": {
|
|
"dependencies": {
|
|
"moo": "project",
|
|
"react-dom": "github.com/gohugoio/hugoTestModule2"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/core": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/preset-env": "github.com/gohugoio/hugoTestModule2",
|
|
"postcss-cli": "github.com/gohugoio/hugoTestModule2",
|
|
"tailwindcss": "github.com/gohugoio/hugoTestModule2"
|
|
}
|
|
},
|
|
"dependencies": {
|
|
"moo": "1.2.3",
|
|
"react-dom": "^16.13.1"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "7.8.4",
|
|
"@babel/core": "7.9.0",
|
|
"@babel/preset-env": "7.9.5",
|
|
"postcss-cli": "7.1.0",
|
|
"tailwindcss": "1.2.0"
|
|
},
|
|
"name": "mypack",
|
|
"scripts": {
|
|
"client": "wait-on http://localhost:1313 && open http://localhost:1313",
|
|
"start": "run-p client server",
|
|
"test": "echo 'hoge' > hoge"
|
|
},
|
|
"version": "1.2.3"
|
|
}
|
|
`
|
|
})
|
|
|
|
// https://github.com/gohugoio/hugo/issues/7690
|
|
b.AssertFileContent("package.hugo.json", origPackageJSON)
|
|
})
|
|
|
|
t.Run("Create package.json, no default, no package.json", func(t *testing.T) {
|
|
b := newTestBuilder(t, "")
|
|
|
|
b.Build(BuildCfg{})
|
|
b.Assert(npm.Pack(b.H.BaseFs.SourceFs, b.H.BaseFs.Assets.Dirs), qt.IsNil)
|
|
|
|
b.AssertFileContentFn("package.json", func(s string) bool {
|
|
return s == `{
|
|
"comments": {
|
|
"dependencies": {
|
|
"react-dom": "github.com/gohugoio/hugoTestModule2"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/core": "github.com/gohugoio/hugoTestModule2",
|
|
"@babel/preset-env": "github.com/gohugoio/hugoTestModule2",
|
|
"postcss-cli": "github.com/gohugoio/hugoTestModule2",
|
|
"tailwindcss": "github.com/gohugoio/hugoTestModule2"
|
|
}
|
|
},
|
|
"dependencies": {
|
|
"react-dom": "^16.13.1"
|
|
},
|
|
"devDependencies": {
|
|
"@babel/cli": "7.8.4",
|
|
"@babel/core": "7.9.0",
|
|
"@babel/preset-env": "7.9.5",
|
|
"postcss-cli": "7.1.0",
|
|
"tailwindcss": "1.2.0"
|
|
},
|
|
"name": "myhugosite",
|
|
"version": "0.1.0"
|
|
}
|
|
`
|
|
})
|
|
})
|
|
}
|
|
|
|
// TODO(bep) this fails when testmodBuilder is also building ...
|
|
func TestHugoModulesMatrix(t *testing.T) {
|
|
if !htesting.IsCI() {
|
|
t.Skip("skip (relative) long running modules test when running locally")
|
|
}
|
|
t.Parallel()
|
|
|
|
if !htesting.IsCI() || hugo.GoMinorVersion() < 12 {
|
|
// https://github.com/golang/go/issues/26794
|
|
// There were some concurrent issues with Go modules in < Go 12.
|
|
t.Skip("skip this on local host and for Go <= 1.11 due to a bug in Go's stdlib")
|
|
}
|
|
|
|
if testing.Short() {
|
|
t.Skip()
|
|
}
|
|
|
|
rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
gooss := []string{"linux", "darwin", "windows"}
|
|
goos := gooss[rnd.Intn(len(gooss))]
|
|
ignoreVendor := rnd.Intn(2) == 0
|
|
testmods := mods.CreateModules(goos).Collect()
|
|
rnd.Shuffle(len(testmods), func(i, j int) { testmods[i], testmods[j] = testmods[j], testmods[i] })
|
|
|
|
for _, m := range testmods[:2] {
|
|
c := qt.New(t)
|
|
|
|
workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-modules-test")
|
|
c.Assert(err, qt.IsNil)
|
|
defer clean()
|
|
|
|
v := config.New()
|
|
v.Set("workingDir", workingDir)
|
|
v.Set("publishDir", "public")
|
|
|
|
configTemplate := `
|
|
baseURL = "https://example.com"
|
|
title = "My Modular Site"
|
|
workingDir = %q
|
|
theme = %q
|
|
ignoreVendorPaths = %q
|
|
|
|
`
|
|
|
|
ignoreVendorPaths := ""
|
|
if ignoreVendor {
|
|
ignoreVendorPaths = "github.com/**"
|
|
}
|
|
config := fmt.Sprintf(configTemplate, workingDir, m.Path(), ignoreVendorPaths)
|
|
|
|
b := newTestSitesBuilder(t)
|
|
|
|
// Need to use OS fs for this.
|
|
b.Fs = hugofs.NewDefaultOld(v)
|
|
|
|
b.WithWorkingDir(workingDir).WithConfigFile("toml", config)
|
|
b.WithContent("page.md", `
|
|
---
|
|
title: "Foo"
|
|
---
|
|
`)
|
|
b.WithTemplates("home.html", `
|
|
|
|
{{ $mod := .Site.Data.modinfo.module }}
|
|
Mod Name: {{ $mod.name }}
|
|
Mod Version: {{ $mod.version }}
|
|
----
|
|
{{ range $k, $v := .Site.Data.modinfo }}
|
|
- {{ $k }}: {{ range $kk, $vv := $v }}{{ $kk }}: {{ $vv }}|{{ end -}}
|
|
{{ end }}
|
|
|
|
|
|
`)
|
|
b.WithSourceFile("go.mod", `
|
|
module github.com/gohugoio/tests/testHugoModules
|
|
|
|
|
|
`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
// Verify that go.mod is autopopulated with all the modules in config.toml.
|
|
b.AssertFileContent("go.mod", m.Path())
|
|
|
|
b.AssertFileContent("public/index.html",
|
|
"Mod Name: "+m.Name(),
|
|
"Mod Version: v1.4.0")
|
|
|
|
b.AssertFileContent("public/index.html", createChildModMatchers(m, ignoreVendor, m.Vendor)...)
|
|
|
|
}
|
|
}
|
|
|
|
func createChildModMatchers(m *mods.Md, ignoreVendor, vendored bool) []string {
|
|
// Child dependencies are one behind.
|
|
expectMinorVersion := 3
|
|
|
|
if !ignoreVendor && vendored {
|
|
// Vendored modules are stuck at v1.1.0.
|
|
expectMinorVersion = 1
|
|
}
|
|
|
|
expectVersion := fmt.Sprintf("v1.%d.0", expectMinorVersion)
|
|
|
|
var matchers []string
|
|
|
|
for _, mm := range m.Children {
|
|
matchers = append(
|
|
matchers,
|
|
fmt.Sprintf("%s: name: %s|version: %s", mm.Name(), mm.Name(), expectVersion))
|
|
matchers = append(matchers, createChildModMatchers(mm, ignoreVendor, vendored || mm.Vendor)...)
|
|
}
|
|
return matchers
|
|
}
|
|
|
|
func TestModulesWithContent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
b := newTestSitesBuilder(t).WithWorkingDir("/site").WithConfigFile("toml", `
|
|
baseURL="https://example.org"
|
|
|
|
workingDir="/site"
|
|
|
|
defaultContentLanguage = "en"
|
|
|
|
[module]
|
|
[[module.imports]]
|
|
path="a"
|
|
[[module.imports.mounts]]
|
|
source="myacontent"
|
|
target="content/blog"
|
|
lang="en"
|
|
[[module.imports]]
|
|
path="b"
|
|
[[module.imports.mounts]]
|
|
source="mybcontent"
|
|
target="content/blog"
|
|
lang="nn"
|
|
[[module.imports]]
|
|
path="c"
|
|
[[module.imports]]
|
|
path="d"
|
|
|
|
[languages]
|
|
|
|
[languages.en]
|
|
title = "Title in English"
|
|
languageName = "English"
|
|
weight = 1
|
|
[languages.nn]
|
|
languageName = "Nynorsk"
|
|
weight = 2
|
|
title = "Tittel på nynorsk"
|
|
[languages.nb]
|
|
languageName = "Bokmål"
|
|
weight = 3
|
|
title = "Tittel på bokmål"
|
|
[languages.fr]
|
|
languageName = "French"
|
|
weight = 4
|
|
title = "French Title"
|
|
|
|
|
|
`)
|
|
|
|
b.WithTemplatesAdded("index.html", `
|
|
{{ range .Site.RegularPages }}
|
|
|{{ .Title }}|{{ .RelPermalink }}|{{ .Plain }}
|
|
{{ end }}
|
|
{{ $data := .Site.Data }}
|
|
Data Common: {{ $data.common.value }}
|
|
Data C: {{ $data.c.value }}
|
|
Data D: {{ $data.d.value }}
|
|
All Data: {{ $data }}
|
|
|
|
i18n hello1: {{ i18n "hello1" . }}
|
|
i18n theme: {{ i18n "theme" . }}
|
|
i18n theme2: {{ i18n "theme2" . }}
|
|
`)
|
|
|
|
content := func(id string) string {
|
|
return fmt.Sprintf(`---
|
|
title: Title %s
|
|
---
|
|
Content %s
|
|
|
|
`, id, id)
|
|
}
|
|
|
|
i18nContent := func(id, value string) string {
|
|
return fmt.Sprintf(`
|
|
[%s]
|
|
other = %q
|
|
`, id, value)
|
|
}
|
|
|
|
// Content files
|
|
b.WithSourceFile("themes/a/myacontent/page.md", content("theme-a-en"))
|
|
b.WithSourceFile("themes/b/mybcontent/page.md", content("theme-b-nn"))
|
|
b.WithSourceFile("themes/c/content/blog/c.md", content("theme-c-nn"))
|
|
|
|
// Data files
|
|
b.WithSourceFile("data/common.toml", `value="Project"`)
|
|
b.WithSourceFile("themes/c/data/common.toml", `value="Theme C"`)
|
|
b.WithSourceFile("themes/c/data/c.toml", `value="Hugo Rocks!"`)
|
|
b.WithSourceFile("themes/d/data/c.toml", `value="Hugo Rodcks!"`)
|
|
b.WithSourceFile("themes/d/data/d.toml", `value="Hugo Rodks!"`)
|
|
|
|
// i18n files
|
|
b.WithSourceFile("i18n/en.toml", i18nContent("hello1", "Project"))
|
|
b.WithSourceFile("themes/c/i18n/en.toml", `
|
|
[hello1]
|
|
other="Theme C Hello"
|
|
[theme]
|
|
other="Theme C"
|
|
`)
|
|
b.WithSourceFile("themes/d/i18n/en.toml", i18nContent("theme", "Theme D"))
|
|
b.WithSourceFile("themes/d/i18n/en.toml", i18nContent("theme2", "Theme2 D"))
|
|
|
|
// Static files
|
|
b.WithSourceFile("themes/c/static/hello.txt", `Hugo Rocks!"`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", "|Title theme-a-en|/blog/page/|Content theme-a-en")
|
|
b.AssertFileContent("public/nn/index.html", "|Title theme-b-nn|/nn/blog/page/|Content theme-b-nn")
|
|
|
|
// Data
|
|
b.AssertFileContent("public/index.html",
|
|
"Data Common: Project",
|
|
"Data C: Hugo Rocks!",
|
|
"Data D: Hugo Rodks!",
|
|
)
|
|
|
|
// i18n
|
|
b.AssertFileContent("public/index.html",
|
|
"i18n hello1: Project",
|
|
"i18n theme: Theme C",
|
|
"i18n theme2: Theme2 D",
|
|
)
|
|
}
|
|
|
|
func TestModulesIgnoreConfig(t *testing.T) {
|
|
b := newTestSitesBuilder(t).WithWorkingDir("/site").WithConfigFile("toml", `
|
|
baseURL="https://example.org"
|
|
|
|
workingDir="/site"
|
|
|
|
[module]
|
|
[[module.imports]]
|
|
path="a"
|
|
ignoreConfig=true
|
|
|
|
`)
|
|
|
|
b.WithSourceFile("themes/a/config.toml", `
|
|
[params]
|
|
a = "Should Be Ignored!"
|
|
`)
|
|
|
|
b.WithTemplatesAdded("index.html", `Params: {{ .Site.Params }}`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContentFn("public/index.html", func(s string) bool {
|
|
return !strings.Contains(s, "Ignored")
|
|
})
|
|
}
|
|
|
|
func TestModulesDisabled(t *testing.T) {
|
|
b := newTestSitesBuilder(t).WithWorkingDir("/site").WithConfigFile("toml", `
|
|
baseURL="https://example.org"
|
|
|
|
workingDir="/site"
|
|
|
|
[module]
|
|
[[module.imports]]
|
|
path="a"
|
|
[[module.imports]]
|
|
path="b"
|
|
disable=true
|
|
|
|
|
|
`)
|
|
|
|
b.WithSourceFile("themes/a/config.toml", `
|
|
[params]
|
|
a = "A param"
|
|
`)
|
|
|
|
b.WithSourceFile("themes/b/config.toml", `
|
|
[params]
|
|
b = "B param"
|
|
`)
|
|
|
|
b.WithTemplatesAdded("index.html", `Params: {{ .Site.Params }}`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContentFn("public/index.html", func(s string) bool {
|
|
return strings.Contains(s, "A param") && !strings.Contains(s, "B param")
|
|
})
|
|
}
|
|
|
|
func TestModulesIncompatible(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
b := newTestSitesBuilder(t).WithWorkingDir("/site").WithConfigFile("toml", `
|
|
baseURL="https://example.org"
|
|
|
|
workingDir="/site"
|
|
|
|
[module]
|
|
[[module.imports]]
|
|
path="ok"
|
|
[[module.imports]]
|
|
path="incompat1"
|
|
[[module.imports]]
|
|
path="incompat2"
|
|
[[module.imports]]
|
|
path="incompat3"
|
|
|
|
`)
|
|
|
|
b.WithSourceFile("themes/ok/data/ok.toml", `title = "OK"`)
|
|
|
|
b.WithSourceFile("themes/incompat1/config.toml", `
|
|
|
|
[module]
|
|
[module.hugoVersion]
|
|
min = "0.33.2"
|
|
max = "0.45.0"
|
|
|
|
`)
|
|
|
|
// Old setup.
|
|
b.WithSourceFile("themes/incompat2/theme.toml", `
|
|
min_version = "5.0.0"
|
|
|
|
`)
|
|
|
|
// Issue 6162
|
|
b.WithSourceFile("themes/incompat3/theme.toml", `
|
|
min_version = 0.55.0
|
|
|
|
`)
|
|
|
|
logger := loggers.NewDefault()
|
|
b.WithLogger(logger)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
c := qt.New(t)
|
|
|
|
c.Assert(logger.LoggCount(logg.LevelWarn), qt.Equals, 3)
|
|
}
|
|
|
|
func TestModulesSymlinks(t *testing.T) {
|
|
skipSymlink(t)
|
|
|
|
wd, _ := os.Getwd()
|
|
defer func() {
|
|
os.Chdir(wd)
|
|
}()
|
|
|
|
c := qt.New(t)
|
|
workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-mod-sym")
|
|
c.Assert(err, qt.IsNil)
|
|
|
|
// We need to use the OS fs for this.
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workingDir)
|
|
cfg.Set("publishDir", "public")
|
|
fs := hugofs.NewFromOld(hugofs.Os, cfg)
|
|
|
|
defer clean()
|
|
|
|
const homeTemplate = `
|
|
Data: {{ .Site.Data }}
|
|
`
|
|
|
|
createDirsAndFiles := func(baseDir string) {
|
|
for _, dir := range files.ComponentFolders {
|
|
realDir := filepath.Join(baseDir, dir, "real")
|
|
c.Assert(os.MkdirAll(realDir, 0777), qt.IsNil)
|
|
c.Assert(afero.WriteFile(fs.Source, filepath.Join(realDir, "data.toml"), []byte("[hello]\nother = \"hello\""), 0777), qt.IsNil)
|
|
}
|
|
|
|
c.Assert(afero.WriteFile(fs.Source, filepath.Join(baseDir, "layouts", "index.html"), []byte(homeTemplate), 0777), qt.IsNil)
|
|
}
|
|
|
|
// Create project dirs and files.
|
|
createDirsAndFiles(workingDir)
|
|
// Create one module inside the default themes folder.
|
|
themeDir := filepath.Join(workingDir, "themes", "mymod")
|
|
createDirsAndFiles(themeDir)
|
|
|
|
createSymlinks := func(baseDir, id string) {
|
|
for _, dir := range files.ComponentFolders {
|
|
// Issue #9119: private use language tags cannot exceed 8 characters.
|
|
if dir != "i18n" {
|
|
c.Assert(os.Chdir(filepath.Join(baseDir, dir)), qt.IsNil)
|
|
c.Assert(os.Symlink("real", fmt.Sprintf("realsym%s", id)), qt.IsNil)
|
|
c.Assert(os.Chdir(filepath.Join(baseDir, dir, "real")), qt.IsNil)
|
|
c.Assert(os.Symlink("data.toml", fmt.Sprintf(filepath.FromSlash("datasym%s.toml"), id)), qt.IsNil)
|
|
}
|
|
}
|
|
}
|
|
|
|
createSymlinks(workingDir, "project")
|
|
createSymlinks(themeDir, "mod")
|
|
|
|
config := `
|
|
baseURL = "https://example.com"
|
|
theme="mymod"
|
|
defaultContentLanguage="nn"
|
|
defaultContentLanguageInSubDir=true
|
|
|
|
[languages]
|
|
[languages.nn]
|
|
weight = 1
|
|
[languages.en]
|
|
weight = 2
|
|
|
|
|
|
`
|
|
|
|
b := newTestSitesBuilder(t).WithNothingAdded().WithWorkingDir(workingDir)
|
|
b.WithLogger(loggers.NewDefault())
|
|
b.Fs = fs
|
|
|
|
b.WithConfigFile("toml", config)
|
|
c.Assert(os.Chdir(workingDir), qt.IsNil)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContentFn(filepath.Join("public", "en", "index.html"), func(s string) bool {
|
|
// Symbolic links only followed in project. There should be WARNING logs.
|
|
return !strings.Contains(s, "symmod") && strings.Contains(s, "symproject")
|
|
})
|
|
|
|
bfs := b.H.BaseFs
|
|
|
|
for i, componentFs := range []afero.Fs{
|
|
bfs.Static[""].Fs,
|
|
bfs.Archetypes.Fs,
|
|
bfs.Content.Fs,
|
|
bfs.Data.Fs,
|
|
bfs.Assets.Fs,
|
|
bfs.I18n.Fs,
|
|
} {
|
|
|
|
if i != 0 {
|
|
continue
|
|
}
|
|
|
|
for j, id := range []string{"mod", "project"} {
|
|
|
|
statCheck := func(fs afero.Fs, filename string, isDir bool) {
|
|
shouldFail := j == 0
|
|
if !shouldFail && i == 0 {
|
|
// Static dirs only supports symlinks for files
|
|
shouldFail = isDir
|
|
}
|
|
|
|
_, err := fs.Stat(filepath.FromSlash(filename))
|
|
if err != nil {
|
|
if i > 0 && strings.HasSuffix(filename, "toml") && strings.Contains(err.Error(), "files not supported") {
|
|
// OK
|
|
return
|
|
}
|
|
}
|
|
|
|
if shouldFail {
|
|
c.Assert(err, qt.Not(qt.IsNil))
|
|
c.Assert(err, qt.Equals, hugofs.ErrPermissionSymlink)
|
|
} else {
|
|
c.Assert(err, qt.IsNil)
|
|
}
|
|
}
|
|
|
|
c.Logf("Checking %d:%d %q", i, j, id)
|
|
|
|
statCheck(componentFs, fmt.Sprintf("realsym%s", id), true)
|
|
statCheck(componentFs, fmt.Sprintf("real/datasym%s.toml", id), false)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMountsProject(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
config := `
|
|
|
|
baseURL="https://example.org"
|
|
|
|
[module]
|
|
[[module.mounts]]
|
|
source="mycontent"
|
|
target="content"
|
|
|
|
`
|
|
b := newTestSitesBuilder(t).
|
|
WithConfigFile("toml", config).
|
|
WithSourceFile(filepath.Join("mycontent", "mypage.md"), `
|
|
---
|
|
title: "My Page"
|
|
---
|
|
|
|
`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
// helpers.PrintFs(b.H.Fs.Source, "public", os.Stdout)
|
|
|
|
b.AssertFileContent("public/mypage/index.html", "Permalink: https://example.org/mypage/")
|
|
}
|
|
|
|
// https://github.com/gohugoio/hugo/issues/6684
|
|
func TestMountsContentFile(t *testing.T) {
|
|
t.Parallel()
|
|
c := qt.New(t)
|
|
workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-modules-content-file")
|
|
c.Assert(err, qt.IsNil)
|
|
defer clean()
|
|
|
|
configTemplate := `
|
|
baseURL = "https://example.com"
|
|
title = "My Modular Site"
|
|
workingDir = %q
|
|
|
|
[module]
|
|
[[module.mounts]]
|
|
source = "README.md"
|
|
target = "content/_index.md"
|
|
[[module.mounts]]
|
|
source = "mycontent"
|
|
target = "content/blog"
|
|
|
|
`
|
|
|
|
tomlConfig := fmt.Sprintf(configTemplate, workingDir)
|
|
|
|
b := newTestSitesBuilder(t).Running()
|
|
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workingDir)
|
|
cfg.Set("publishDir", "public")
|
|
|
|
b.Fs = hugofs.NewDefaultOld(cfg)
|
|
|
|
b.WithWorkingDir(workingDir).WithConfigFile("toml", tomlConfig)
|
|
b.WithTemplatesAdded("index.html", `
|
|
{{ .Title }}
|
|
{{ .Content }}
|
|
|
|
{{ $readme := .Site.GetPage "/README.md" }}
|
|
{{ with $readme }}README: {{ .Title }}|Filename: {{ path.Join .File.Filename }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }}
|
|
|
|
|
|
{{ $mypage := .Site.GetPage "/blog/mypage.md" }}
|
|
{{ with $mypage }}MYPAGE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }}
|
|
{{ $mybundle := .Site.GetPage "/blog/mybundle" }}
|
|
{{ with $mybundle }}MYBUNDLE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }}
|
|
|
|
|
|
`, "_default/_markup/render-link.html", `
|
|
{{ $link := .Destination }}
|
|
{{ $isRemote := strings.HasPrefix $link "http" }}
|
|
{{- if not $isRemote -}}
|
|
{{ $url := urls.Parse .Destination }}
|
|
{{ $fragment := "" }}
|
|
{{- with $url.Fragment }}{{ $fragment = printf "#%s" . }}{{ end -}}
|
|
{{- with .Page.GetPage $url.Path }}{{ $link = printf "%s%s" .Permalink $fragment }}{{ end }}{{ end -}}
|
|
<a href="{{ $link | safeURL }}"{{ with .Title}} title="{{ . }}"{{ end }}{{ if $isRemote }} target="_blank"{{ end }}>{{ .Text | safeHTML }}</a>
|
|
`)
|
|
|
|
os.Mkdir(filepath.Join(workingDir, "mycontent"), 0777)
|
|
os.Mkdir(filepath.Join(workingDir, "mycontent", "mybundle"), 0777)
|
|
|
|
b.WithSourceFile("README.md", `---
|
|
title: "Readme Title"
|
|
---
|
|
|
|
Readme Content.
|
|
`,
|
|
filepath.Join("mycontent", "mypage.md"), `
|
|
---
|
|
title: "My Page"
|
|
---
|
|
|
|
|
|
* [Relative Link From Page](mybundle)
|
|
* [Relative Link From Page, filename](mybundle/index.md)
|
|
* [Link using original path](/mycontent/mybundle/index.md)
|
|
|
|
|
|
`, filepath.Join("mycontent", "mybundle", "index.md"), `
|
|
---
|
|
title: "My Bundle"
|
|
---
|
|
|
|
* [Dot Relative Link From Bundle](../mypage.md)
|
|
* [Link using original path](/mycontent/mypage.md)
|
|
* [Link to Home](/)
|
|
* [Link to Home, README.md](/README.md)
|
|
* [Link to Home, _index.md](/_index.md)
|
|
|
|
`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", `
|
|
README: Readme Title
|
|
/README.md|Path: _index.md|FilePath: README.md
|
|
Readme Content.
|
|
MYPAGE: My Page|Path: blog/mypage.md|FilePath: mycontent/mypage.md|
|
|
MYBUNDLE: My Bundle|Path: blog/mybundle/index.md|FilePath: mycontent/mybundle/index.md|
|
|
`)
|
|
b.AssertFileContent("public/blog/mypage/index.html", `
|
|
<a href="https://example.com/blog/mybundle/">Relative Link From Page</a>
|
|
<a href="https://example.com/blog/mybundle/">Relative Link From Page, filename</a>
|
|
<a href="https://example.com/blog/mybundle/">Link using original path</a>
|
|
|
|
`)
|
|
b.AssertFileContent("public/blog/mybundle/index.html", `
|
|
<a href="https://example.com/blog/mypage/">Dot Relative Link From Bundle</a>
|
|
<a href="https://example.com/blog/mypage/">Link using original path</a>
|
|
<a href="https://example.com/">Link to Home</a>
|
|
<a href="https://example.com/">Link to Home, README.md</a>
|
|
<a href="https://example.com/">Link to Home, _index.md</a>
|
|
`)
|
|
|
|
b.EditFiles("README.md", `---
|
|
title: "Readme Edit"
|
|
---
|
|
`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", `
|
|
Readme Edit
|
|
`)
|
|
}
|
|
|
|
func TestMountsPaths(t *testing.T) {
|
|
c := qt.New(t)
|
|
|
|
type test struct {
|
|
b *sitesBuilder
|
|
clean func()
|
|
workingDir string
|
|
}
|
|
|
|
prepare := func(c *qt.C, mounts string) test {
|
|
workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-mounts-paths")
|
|
c.Assert(err, qt.IsNil)
|
|
|
|
configTemplate := `
|
|
baseURL = "https://example.com"
|
|
title = "My Modular Site"
|
|
workingDir = %q
|
|
|
|
%s
|
|
|
|
`
|
|
tomlConfig := fmt.Sprintf(configTemplate, workingDir, mounts)
|
|
tomlConfig = strings.Replace(tomlConfig, "WORKING_DIR", workingDir, -1)
|
|
|
|
b := newTestSitesBuilder(c).Running()
|
|
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workingDir)
|
|
cfg.Set("publishDir", "public")
|
|
b.Fs = hugofs.NewDefaultOld(cfg)
|
|
|
|
os.MkdirAll(filepath.Join(workingDir, "content", "blog"), 0777)
|
|
|
|
b.WithWorkingDir(workingDir).WithConfigFile("toml", tomlConfig)
|
|
|
|
return test{
|
|
b: b,
|
|
clean: clean,
|
|
workingDir: workingDir,
|
|
}
|
|
}
|
|
|
|
c.Run("Default", func(c *qt.C) {
|
|
mounts := ``
|
|
|
|
test := prepare(c, mounts)
|
|
b := test.b
|
|
defer test.clean()
|
|
|
|
b.WithContent("blog/p1.md", `---
|
|
title: P1
|
|
---`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
p := b.GetPage("blog/p1.md")
|
|
f := p.File().FileInfo().Meta()
|
|
b.Assert(filepath.ToSlash(f.Path), qt.Equals, "blog/p1.md")
|
|
b.Assert(filepath.ToSlash(f.PathFile()), qt.Equals, "content/blog/p1.md")
|
|
|
|
b.Assert(b.H.BaseFs.Layouts.Path(filepath.Join(test.workingDir, "layouts", "_default", "single.html")), qt.Equals, filepath.FromSlash("_default/single.html"))
|
|
})
|
|
|
|
c.Run("Mounts", func(c *qt.C) {
|
|
absDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-mounts-paths-abs")
|
|
c.Assert(err, qt.IsNil)
|
|
defer clean()
|
|
|
|
mounts := `[module]
|
|
[[module.mounts]]
|
|
source = "README.md"
|
|
target = "content/_index.md"
|
|
[[module.mounts]]
|
|
source = "mycontent"
|
|
target = "content/blog"
|
|
[[module.mounts]]
|
|
source = "subdir/mypartials"
|
|
target = "layouts/partials"
|
|
[[module.mounts]]
|
|
source = %q
|
|
target = "layouts/shortcodes"
|
|
`
|
|
mounts = fmt.Sprintf(mounts, filepath.Join(absDir, "/abs/myshortcodes"))
|
|
|
|
test := prepare(c, mounts)
|
|
b := test.b
|
|
defer test.clean()
|
|
|
|
subContentDir := filepath.Join(test.workingDir, "mycontent", "sub")
|
|
os.MkdirAll(subContentDir, 0777)
|
|
myPartialsDir := filepath.Join(test.workingDir, "subdir", "mypartials")
|
|
os.MkdirAll(myPartialsDir, 0777)
|
|
|
|
absShortcodesDir := filepath.Join(absDir, "abs", "myshortcodes")
|
|
os.MkdirAll(absShortcodesDir, 0777)
|
|
|
|
b.WithSourceFile("README.md", "---\ntitle: Readme\n---")
|
|
b.WithSourceFile("mycontent/sub/p1.md", "---\ntitle: P1\n---")
|
|
|
|
b.WithSourceFile(filepath.Join(absShortcodesDir, "myshort.html"), "MYSHORT")
|
|
b.WithSourceFile(filepath.Join(myPartialsDir, "mypartial.html"), "MYPARTIAL")
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
p1_1 := b.GetPage("/blog/sub/p1.md")
|
|
p1_2 := b.GetPage("/mycontent/sub/p1.md")
|
|
b.Assert(p1_1, qt.Not(qt.IsNil))
|
|
b.Assert(p1_2, qt.Equals, p1_1)
|
|
|
|
f := p1_1.File().FileInfo().Meta()
|
|
b.Assert(filepath.ToSlash(f.Path), qt.Equals, "blog/sub/p1.md")
|
|
b.Assert(filepath.ToSlash(f.PathFile()), qt.Equals, "mycontent/sub/p1.md")
|
|
b.Assert(b.H.BaseFs.Layouts.Path(filepath.Join(myPartialsDir, "mypartial.html")), qt.Equals, filepath.FromSlash("partials/mypartial.html"))
|
|
b.Assert(b.H.BaseFs.Layouts.Path(filepath.Join(absShortcodesDir, "myshort.html")), qt.Equals, filepath.FromSlash("shortcodes/myshort.html"))
|
|
b.Assert(b.H.BaseFs.Content.Path(filepath.Join(subContentDir, "p1.md")), qt.Equals, filepath.FromSlash("blog/sub/p1.md"))
|
|
b.Assert(b.H.BaseFs.Content.Path(filepath.Join(test.workingDir, "README.md")), qt.Equals, filepath.FromSlash("_index.md"))
|
|
})
|
|
}
|
|
|
|
// https://github.com/gohugoio/hugo/issues/6299
|
|
func TestSiteWithGoModButNoModules(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
c := qt.New(t)
|
|
// We need to use the OS fs for this.
|
|
workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-no-mod")
|
|
c.Assert(err, qt.IsNil)
|
|
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workDir)
|
|
cfg.Set("publishDir", "public")
|
|
fs := hugofs.NewFromOld(hugofs.Os, cfg)
|
|
|
|
defer clean()
|
|
|
|
b := newTestSitesBuilder(t)
|
|
b.Fs = fs
|
|
|
|
b.WithWorkingDir(workDir).WithViper(cfg)
|
|
|
|
b.WithSourceFile("go.mod", "")
|
|
b.Build(BuildCfg{})
|
|
}
|
|
|
|
// https://github.com/gohugoio/hugo/issues/6622
|
|
func TestModuleAbsMount(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
c := qt.New(t)
|
|
// We need to use the OS fs for this.
|
|
workDir, clean1, err := htesting.CreateTempDir(hugofs.Os, "hugo-project")
|
|
c.Assert(err, qt.IsNil)
|
|
absContentDir, clean2, err := htesting.CreateTempDir(hugofs.Os, "hugo-content")
|
|
c.Assert(err, qt.IsNil)
|
|
|
|
cfg := config.New()
|
|
cfg.Set("workingDir", workDir)
|
|
cfg.Set("publishDir", "public")
|
|
fs := hugofs.NewFromOld(hugofs.Os, cfg)
|
|
|
|
config := fmt.Sprintf(`
|
|
workingDir=%q
|
|
|
|
[module]
|
|
[[module.mounts]]
|
|
source = %q
|
|
target = "content"
|
|
|
|
`, workDir, absContentDir)
|
|
|
|
defer clean1()
|
|
defer clean2()
|
|
|
|
b := newTestSitesBuilder(t)
|
|
b.Fs = fs
|
|
|
|
contentFilename := filepath.Join(absContentDir, "p1.md")
|
|
afero.WriteFile(hugofs.Os, contentFilename, []byte(`
|
|
---
|
|
title: Abs
|
|
---
|
|
|
|
Content.
|
|
`), 0777)
|
|
|
|
b.WithWorkingDir(workDir).WithConfigFile("toml", config)
|
|
b.WithContent("dummy.md", "")
|
|
|
|
b.WithTemplatesAdded("index.html", `
|
|
{{ $p1 := site.GetPage "p1" }}
|
|
P1: {{ $p1.Title }}|{{ $p1.RelPermalink }}|Filename: {{ $p1.File.Filename }}
|
|
`)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/index.html", "P1: Abs|/p1/", "Filename: "+contentFilename)
|
|
}
|
|
|
|
// Issue 9426
|
|
func TestMountSameSource(t *testing.T) {
|
|
config := `baseURL = 'https://example.org/'
|
|
languageCode = 'en-us'
|
|
title = 'Hugo GitHub Issue #9426'
|
|
|
|
disableKinds = ['RSS','sitemap','taxonomy','term']
|
|
|
|
[[module.mounts]]
|
|
source = "content"
|
|
target = "content"
|
|
|
|
[[module.mounts]]
|
|
source = "extra-content"
|
|
target = "content/resources-a"
|
|
|
|
[[module.mounts]]
|
|
source = "extra-content"
|
|
target = "content/resources-b"
|
|
`
|
|
b := newTestSitesBuilder(t).WithConfigFile("toml", config)
|
|
|
|
b.WithContent("p1.md", "")
|
|
|
|
b.WithSourceFile(
|
|
"extra-content/_index.md", "",
|
|
"extra-content/subdir/_index.md", "",
|
|
"extra-content/subdir/about.md", "",
|
|
)
|
|
|
|
b.Build(BuildCfg{})
|
|
|
|
b.AssertFileContent("public/resources-a/subdir/about/index.html", "Single")
|
|
b.AssertFileContent("public/resources-b/subdir/about/index.html", "Single")
|
|
}
|
|
|
|
func TestMountData(t *testing.T) {
|
|
files := `
|
|
-- hugo.toml --
|
|
baseURL = 'https://example.org/'
|
|
disableKinds = ["taxonomy", "term", "RSS", "sitemap", "robotsTXT", "page", "section"]
|
|
|
|
[[module.mounts]]
|
|
source = "data"
|
|
target = "data"
|
|
|
|
[[module.mounts]]
|
|
source = "extra-data"
|
|
target = "data/extra"
|
|
-- extra-data/test.yaml --
|
|
message: Hugo Rocks
|
|
-- layouts/index.html --
|
|
{{ site.Data.extra.test.message }}
|
|
`
|
|
|
|
b := NewIntegrationTestBuilder(
|
|
IntegrationTestConfig{
|
|
T: t,
|
|
TxtarString: files,
|
|
},
|
|
).Build()
|
|
|
|
b.AssertFileContent("public/index.html", "Hugo Rocks")
|
|
}
|