github.com/lyeb/hugo@v0.47.1/hugolib/config_test.go (about)

     1  // Copyright 2016-present 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  	"testing"
    18  
    19  	"github.com/spf13/afero"
    20  	"github.com/spf13/viper"
    21  	"github.com/stretchr/testify/require"
    22  )
    23  
    24  func TestLoadConfig(t *testing.T) {
    25  	t.Parallel()
    26  
    27  	assert := require.New(t)
    28  
    29  	// Add a random config variable for testing.
    30  	// side = page in Norwegian.
    31  	configContent := `
    32  	PaginatePath = "side"
    33  	`
    34  
    35  	mm := afero.NewMemMapFs()
    36  
    37  	writeToFs(t, mm, "hugo.toml", configContent)
    38  
    39  	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Filename: "hugo.toml"})
    40  	require.NoError(t, err)
    41  
    42  	assert.Equal("side", cfg.GetString("paginatePath"))
    43  	// default
    44  	assert.Equal("layouts", cfg.GetString("layoutDir"))
    45  	// no themes
    46  	assert.False(cfg.IsSet("allThemes"))
    47  }
    48  
    49  func TestLoadMultiConfig(t *testing.T) {
    50  	t.Parallel()
    51  
    52  	assert := require.New(t)
    53  
    54  	// Add a random config variable for testing.
    55  	// side = page in Norwegian.
    56  	configContentBase := `
    57  	DontChange = "same"
    58  	PaginatePath = "side"
    59  	`
    60  	configContentSub := `
    61  	PaginatePath = "top"
    62  	`
    63  	mm := afero.NewMemMapFs()
    64  
    65  	writeToFs(t, mm, "base.toml", configContentBase)
    66  
    67  	writeToFs(t, mm, "override.toml", configContentSub)
    68  
    69  	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Filename: "base.toml,override.toml"})
    70  	require.NoError(t, err)
    71  
    72  	assert.Equal("top", cfg.GetString("paginatePath"))
    73  	assert.Equal("same", cfg.GetString("DontChange"))
    74  }
    75  
    76  func TestLoadConfigFromTheme(t *testing.T) {
    77  	t.Parallel()
    78  
    79  	assert := require.New(t)
    80  
    81  	mainConfigBasic := `
    82  theme = "test-theme"
    83  baseURL = "https://example.com/"
    84  
    85  `
    86  	mainConfig := `
    87  theme = "test-theme"
    88  baseURL = "https://example.com/"
    89  
    90  [frontmatter]
    91  date = ["date","publishDate"]
    92  
    93  [params]
    94  p1 = "p1 main"
    95  p2 = "p2 main"
    96  top = "top"
    97  
    98  [mediaTypes]
    99  [mediaTypes."text/m1"]
   100  suffix = "m1main"
   101  
   102  [outputFormats.o1]
   103  mediaType = "text/m1"
   104  baseName = "o1main"
   105  
   106  [languages]
   107  [languages.en]
   108  languageName = "English"
   109  [languages.en.params]
   110  pl1 = "p1-en-main"
   111  [languages.nb]
   112  languageName = "Norsk"
   113  [languages.nb.params]
   114  pl1 = "p1-nb-main"
   115  
   116  [[menu.main]]
   117  name = "menu-main-main"
   118  
   119  [[menu.top]]
   120  name = "menu-top-main"
   121  
   122  `
   123  
   124  	themeConfig := `
   125  baseURL = "http://bep.is/"
   126  
   127  # Can not be set in theme.
   128  [frontmatter]
   129  expiryDate = ["date"]
   130  
   131  [params]
   132  p1 = "p1 theme"
   133  p2 = "p2 theme"
   134  p3 = "p3 theme"
   135  
   136  [mediaTypes]
   137  [mediaTypes."text/m1"]
   138  suffix = "m1theme"
   139  [mediaTypes."text/m2"]
   140  suffix = "m2theme"
   141  
   142  [outputFormats.o1]
   143  mediaType = "text/m1"
   144  baseName = "o1theme"
   145  [outputFormats.o2]
   146  mediaType = "text/m2"
   147  baseName = "o2theme"
   148  
   149  [languages]
   150  [languages.en]
   151  languageName = "English2"
   152  [languages.en.params]
   153  pl1 = "p1-en-theme"
   154  pl2 = "p2-en-theme"
   155  [[languages.en.menu.main]]
   156  name   = "menu-lang-en-main"
   157  [[languages.en.menu.theme]]
   158  name   = "menu-lang-en-theme"
   159  [languages.nb]
   160  languageName = "Norsk2"
   161  [languages.nb.params]
   162  pl1 = "p1-nb-theme"
   163  pl2 = "p2-nb-theme"
   164  top = "top-nb-theme"
   165  [[languages.nb.menu.main]]
   166  name   = "menu-lang-nb-main"
   167  [[languages.nb.menu.theme]]
   168  name   = "menu-lang-nb-theme"
   169  [[languages.nb.menu.top]]
   170  name   = "menu-lang-nb-top"
   171  
   172  [[menu.main]]
   173  name = "menu-main-theme"
   174  
   175  [[menu.thememenu]]
   176  name = "menu-theme"
   177  
   178  `
   179  
   180  	b := newTestSitesBuilder(t)
   181  	b.WithConfigFile("toml", mainConfig).WithThemeConfigFile("toml", themeConfig)
   182  	b.CreateSites().Build(BuildCfg{})
   183  
   184  	got := b.Cfg.(*viper.Viper).AllSettings()
   185  
   186  	b.AssertObject(`
   187  map[string]interface {}{
   188    "p1": "p1 main",
   189    "p2": "p2 main",
   190    "p3": "p3 theme",
   191    "test-theme": map[string]interface {}{
   192      "p1": "p1 theme",
   193      "p2": "p2 theme",
   194      "p3": "p3 theme",
   195    },
   196    "top": "top",
   197  }`, got["params"])
   198  
   199  	b.AssertObject(`
   200  map[string]interface {}{
   201    "date": []interface {}{
   202      "date",
   203      "publishDate",
   204    },
   205  }`, got["frontmatter"])
   206  
   207  	b.AssertObject(`
   208  map[string]interface {}{
   209    "text/m1": map[string]interface {}{
   210      "suffix": "m1main",
   211    },
   212    "text/m2": map[string]interface {}{
   213      "suffix": "m2theme",
   214    },
   215  }`, got["mediatypes"])
   216  
   217  	b.AssertObject(`
   218  map[string]interface {}{
   219    "o1": map[string]interface {}{
   220      "basename": "o1main",
   221      "mediatype": Type{
   222        MainType: "text",
   223        SubType: "m1",
   224        OldSuffix: "m1main",
   225        Delimiter: ".",
   226        Suffixes: []string{
   227          "m1main",
   228        },
   229      },
   230    },
   231    "o2": map[string]interface {}{
   232      "basename": "o2theme",
   233      "mediatype": Type{
   234        MainType: "text",
   235        SubType: "m2",
   236        OldSuffix: "m2theme",
   237        Delimiter: ".",
   238        Suffixes: []string{
   239          "m2theme",
   240        },
   241      },
   242    },
   243  }`, got["outputformats"])
   244  
   245  	b.AssertObject(`map[string]interface {}{
   246    "en": map[string]interface {}{
   247      "languagename": "English",
   248      "menu": map[string]interface {}{
   249        "theme": []interface {}{
   250          map[string]interface {}{
   251            "name": "menu-lang-en-theme",
   252          },
   253        },
   254      },
   255      "params": map[string]interface {}{
   256        "pl1": "p1-en-main",
   257        "pl2": "p2-en-theme",
   258        "test-theme": map[string]interface {}{
   259          "pl1": "p1-en-theme",
   260          "pl2": "p2-en-theme",
   261        },
   262      },
   263    },
   264    "nb": map[string]interface {}{
   265      "languagename": "Norsk",
   266      "menu": map[string]interface {}{
   267        "theme": []interface {}{
   268          map[string]interface {}{
   269            "name": "menu-lang-nb-theme",
   270          },
   271        },
   272      },
   273      "params": map[string]interface {}{
   274        "pl1": "p1-nb-main",
   275        "pl2": "p2-nb-theme",
   276        "test-theme": map[string]interface {}{
   277          "pl1": "p1-nb-theme",
   278          "pl2": "p2-nb-theme",
   279          "top": "top-nb-theme",
   280        },
   281      },
   282    },
   283  }
   284  `, got["languages"])
   285  
   286  	b.AssertObject(`
   287  map[string]interface {}{
   288    "main": []interface {}{
   289      map[string]interface {}{
   290        "name": "menu-main-main",
   291      },
   292    },
   293    "thememenu": []interface {}{
   294      map[string]interface {}{
   295        "name": "menu-theme",
   296      },
   297    },
   298    "top": []interface {}{
   299      map[string]interface {}{
   300        "name": "menu-top-main",
   301      },
   302    },
   303  }
   304  `, got["menu"])
   305  
   306  	assert.Equal("https://example.com/", got["baseurl"])
   307  
   308  	if true {
   309  		return
   310  	}
   311  	// Test variants with only values from theme
   312  	b = newTestSitesBuilder(t)
   313  	b.WithConfigFile("toml", mainConfigBasic).WithThemeConfigFile("toml", themeConfig)
   314  	b.CreateSites().Build(BuildCfg{})
   315  
   316  	got = b.Cfg.(*viper.Viper).AllSettings()
   317  
   318  	b.AssertObject(`map[string]interface {}{
   319    "p1": "p1 theme",
   320    "p2": "p2 theme",
   321    "p3": "p3 theme",
   322    "test-theme": map[string]interface {}{
   323      "p1": "p1 theme",
   324      "p2": "p2 theme",
   325      "p3": "p3 theme",
   326    },
   327  }`, got["params"])
   328  
   329  	assert.Nil(got["languages"])
   330  	b.AssertObject(`
   331  map[string]interface {}{
   332    "text/m1": map[string]interface {}{
   333      "suffix": "m1theme",
   334    },
   335    "text/m2": map[string]interface {}{
   336      "suffix": "m2theme",
   337    },
   338  }`, got["mediatypes"])
   339  
   340  	b.AssertObject(`
   341  map[string]interface {}{
   342    "o1": map[string]interface {}{
   343      "basename": "o1theme",
   344      "mediatype": Type{
   345        MainType: "text",
   346        SubType: "m1",
   347        Suffix: "m1theme",
   348        Delimiter: ".",
   349      },
   350    },
   351    "o2": map[string]interface {}{
   352      "basename": "o2theme",
   353      "mediatype": Type{
   354        MainType: "text",
   355        SubType: "m2",
   356        Suffix: "m2theme",
   357        Delimiter: ".",
   358      },
   359    },
   360  }`, got["outputformats"])
   361  	b.AssertObject(`
   362  map[string]interface {}{
   363    "main": []interface {}{
   364      map[string]interface {}{
   365        "name": "menu-main-theme",
   366      },
   367    },
   368    "thememenu": []interface {}{
   369      map[string]interface {}{
   370        "name": "menu-theme",
   371      },
   372    },
   373  }`, got["menu"])
   374  
   375  }
   376  
   377  func TestPrivacyConfig(t *testing.T) {
   378  	t.Parallel()
   379  
   380  	assert := require.New(t)
   381  
   382  	tomlConfig := `
   383  
   384  someOtherValue = "foo"
   385  
   386  [privacy]
   387  [privacy.youtube]
   388  privacyEnhanced = true
   389  `
   390  
   391  	b := newTestSitesBuilder(t)
   392  	b.WithConfigFile("toml", tomlConfig)
   393  	b.Build(BuildCfg{SkipRender: true})
   394  
   395  	assert.True(b.H.Sites[0].Info.Config().Privacy.YouTube.PrivacyEnhanced)
   396  
   397  }