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