github.com/haalcala/mattermost-server-change-repo@v0.0.0-20210713015153-16753fbeee5f/config/utils_test.go (about) 1 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. 2 // See LICENSE.txt for license information. 3 4 package config 5 6 import ( 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 11 "github.com/mattermost/mattermost-server/v5/model" 12 "github.com/mattermost/mattermost-server/v5/utils" 13 ) 14 15 func TestDesanitize(t *testing.T) { 16 actual := &model.Config{} 17 actual.SetDefaults() 18 19 // These setting should be ignored 20 actual.LdapSettings.Enable = bToP(false) 21 actual.FileSettings.DriverName = sToP("s3") 22 23 // These settings should be desanitized into target. 24 actual.LdapSettings.BindPassword = sToP("bind_password") 25 actual.FileSettings.PublicLinkSalt = sToP("public_link_salt") 26 actual.FileSettings.AmazonS3SecretAccessKey = sToP("amazon_s3_secret_access_key") 27 actual.EmailSettings.SMTPPassword = sToP("smtp_password") 28 actual.GitLabSettings.Secret = sToP("secret") 29 actual.OpenIdSettings.Secret = sToP("secret") 30 actual.SqlSettings.DataSource = sToP("data_source") 31 actual.SqlSettings.AtRestEncryptKey = sToP("at_rest_encrypt_key") 32 actual.ElasticsearchSettings.Password = sToP("password") 33 actual.SqlSettings.DataSourceReplicas = append(actual.SqlSettings.DataSourceReplicas, "replica0") 34 actual.SqlSettings.DataSourceReplicas = append(actual.SqlSettings.DataSourceReplicas, "replica1") 35 actual.SqlSettings.DataSourceSearchReplicas = append(actual.SqlSettings.DataSourceSearchReplicas, "search_replica0") 36 actual.SqlSettings.DataSourceSearchReplicas = append(actual.SqlSettings.DataSourceSearchReplicas, "search_replica1") 37 38 target := &model.Config{} 39 target.SetDefaults() 40 41 // These setting should be ignored 42 target.LdapSettings.Enable = bToP(true) 43 target.FileSettings.DriverName = sToP("file") 44 45 // These settings should be updated from actual 46 target.LdapSettings.BindPassword = sToP(model.FAKE_SETTING) 47 target.FileSettings.PublicLinkSalt = sToP(model.FAKE_SETTING) 48 target.FileSettings.AmazonS3SecretAccessKey = sToP(model.FAKE_SETTING) 49 target.EmailSettings.SMTPPassword = sToP(model.FAKE_SETTING) 50 target.GitLabSettings.Secret = sToP(model.FAKE_SETTING) 51 target.OpenIdSettings.Secret = sToP(model.FAKE_SETTING) 52 target.SqlSettings.DataSource = sToP(model.FAKE_SETTING) 53 target.SqlSettings.AtRestEncryptKey = sToP(model.FAKE_SETTING) 54 target.ElasticsearchSettings.Password = sToP(model.FAKE_SETTING) 55 target.SqlSettings.DataSourceReplicas = []string{model.FAKE_SETTING, model.FAKE_SETTING} 56 target.SqlSettings.DataSourceSearchReplicas = []string{model.FAKE_SETTING, model.FAKE_SETTING} 57 58 actualClone := actual.Clone() 59 desanitize(actual, target) 60 assert.Equal(t, actualClone, actual, "actual should not have been changed") 61 62 // Verify the settings that should have been left untouched in target 63 assert.True(t, *target.LdapSettings.Enable, "LdapSettings.Enable should not have changed") 64 assert.Equal(t, "file", *target.FileSettings.DriverName, "FileSettings.DriverName should not have been changed") 65 66 // Verify the settings that should have been desanitized into target 67 assert.Equal(t, *actual.LdapSettings.BindPassword, *target.LdapSettings.BindPassword) 68 assert.Equal(t, *actual.FileSettings.PublicLinkSalt, *target.FileSettings.PublicLinkSalt) 69 assert.Equal(t, *actual.FileSettings.AmazonS3SecretAccessKey, *target.FileSettings.AmazonS3SecretAccessKey) 70 assert.Equal(t, *actual.EmailSettings.SMTPPassword, *target.EmailSettings.SMTPPassword) 71 assert.Equal(t, *actual.GitLabSettings.Secret, *target.GitLabSettings.Secret) 72 assert.Equal(t, *actual.OpenIdSettings.Secret, *target.OpenIdSettings.Secret) 73 assert.Equal(t, *actual.SqlSettings.DataSource, *target.SqlSettings.DataSource) 74 assert.Equal(t, *actual.SqlSettings.AtRestEncryptKey, *target.SqlSettings.AtRestEncryptKey) 75 assert.Equal(t, *actual.ElasticsearchSettings.Password, *target.ElasticsearchSettings.Password) 76 assert.Equal(t, actual.SqlSettings.DataSourceReplicas, target.SqlSettings.DataSourceReplicas) 77 assert.Equal(t, actual.SqlSettings.DataSourceSearchReplicas, target.SqlSettings.DataSourceSearchReplicas) 78 assert.Equal(t, actual.ServiceSettings.SplitKey, target.ServiceSettings.SplitKey) 79 } 80 81 func TestFixInvalidLocales(t *testing.T) { 82 utils.TranslationsPreInit() 83 84 cfg := &model.Config{} 85 cfg.SetDefaults() 86 87 *cfg.LocalizationSettings.DefaultServerLocale = "en" 88 *cfg.LocalizationSettings.DefaultClientLocale = "en" 89 *cfg.LocalizationSettings.AvailableLocales = "" 90 91 changed := FixInvalidLocales(cfg) 92 assert.False(t, changed) 93 94 *cfg.LocalizationSettings.DefaultServerLocale = "junk" 95 changed = FixInvalidLocales(cfg) 96 assert.True(t, changed) 97 assert.Equal(t, "en", *cfg.LocalizationSettings.DefaultServerLocale) 98 99 *cfg.LocalizationSettings.DefaultServerLocale = "" 100 changed = FixInvalidLocales(cfg) 101 assert.True(t, changed) 102 assert.Equal(t, "en", *cfg.LocalizationSettings.DefaultServerLocale) 103 104 *cfg.LocalizationSettings.AvailableLocales = "en" 105 *cfg.LocalizationSettings.DefaultServerLocale = "de" 106 changed = FixInvalidLocales(cfg) 107 assert.False(t, changed) 108 assert.NotContains(t, *cfg.LocalizationSettings.AvailableLocales, *cfg.LocalizationSettings.DefaultServerLocale, "DefaultServerLocale should not be added to AvailableLocales") 109 110 *cfg.LocalizationSettings.AvailableLocales = "" 111 *cfg.LocalizationSettings.DefaultClientLocale = "junk" 112 changed = FixInvalidLocales(cfg) 113 assert.True(t, changed) 114 assert.Equal(t, "en", *cfg.LocalizationSettings.DefaultClientLocale) 115 116 *cfg.LocalizationSettings.DefaultClientLocale = "" 117 changed = FixInvalidLocales(cfg) 118 assert.True(t, changed) 119 assert.Equal(t, "en", *cfg.LocalizationSettings.DefaultClientLocale) 120 121 *cfg.LocalizationSettings.AvailableLocales = "en" 122 *cfg.LocalizationSettings.DefaultClientLocale = "de" 123 changed = FixInvalidLocales(cfg) 124 assert.True(t, changed) 125 assert.Contains(t, *cfg.LocalizationSettings.AvailableLocales, *cfg.LocalizationSettings.DefaultServerLocale, "DefaultClientLocale should have been added to AvailableLocales") 126 127 // validate AvailableLocales 128 *cfg.LocalizationSettings.DefaultServerLocale = "en" 129 *cfg.LocalizationSettings.DefaultClientLocale = "en" 130 *cfg.LocalizationSettings.AvailableLocales = "junk" 131 changed = FixInvalidLocales(cfg) 132 assert.True(t, changed) 133 assert.Equal(t, "", *cfg.LocalizationSettings.AvailableLocales) 134 135 *cfg.LocalizationSettings.AvailableLocales = "en,de,junk" 136 changed = FixInvalidLocales(cfg) 137 assert.True(t, changed) 138 assert.Equal(t, "", *cfg.LocalizationSettings.AvailableLocales) 139 140 *cfg.LocalizationSettings.DefaultServerLocale = "fr" 141 *cfg.LocalizationSettings.DefaultClientLocale = "de" 142 *cfg.LocalizationSettings.AvailableLocales = "en" 143 changed = FixInvalidLocales(cfg) 144 assert.True(t, changed) 145 assert.NotContains(t, *cfg.LocalizationSettings.AvailableLocales, *cfg.LocalizationSettings.DefaultServerLocale, "DefaultServerLocale should not be added to AvailableLocales") 146 assert.Contains(t, *cfg.LocalizationSettings.AvailableLocales, *cfg.LocalizationSettings.DefaultClientLocale, "DefaultClientLocale should have been added to AvailableLocales") 147 } 148 149 func TestIsDatabaseDSN(t *testing.T) { 150 testCases := []struct { 151 Name string 152 DSN string 153 Expected bool 154 }{ 155 { 156 Name: "Mysql DSN", 157 DSN: "mysql://localhost", 158 Expected: true, 159 }, 160 { 161 Name: "Postgresql DSN", 162 DSN: "postgres://localhost", 163 Expected: true, 164 }, 165 { 166 Name: "Empty DSN", 167 DSN: "", 168 Expected: false, 169 }, 170 { 171 Name: "Default file DSN", 172 DSN: "config.json", 173 Expected: false, 174 }, 175 { 176 Name: "Relative path DSN", 177 DSN: "configuration/config.json", 178 Expected: false, 179 }, 180 { 181 Name: "Absolute path DSN", 182 DSN: "/opt/mattermost/configuration/config.json", 183 Expected: false, 184 }, 185 } 186 187 for _, tc := range testCases { 188 t.Run(tc.Name, func(t *testing.T) { 189 assert.Equal(t, tc.Expected, IsDatabaseDSN(tc.DSN)) 190 }) 191 } 192 } 193 194 func TestStripPassword(t *testing.T) { 195 for name, test := range map[string]struct { 196 DSN string 197 Schema string 198 ExpectedOut string 199 }{ 200 "mysql": { 201 DSN: "mysql://mmuser:password@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 202 Schema: "mysql", 203 ExpectedOut: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 204 }, 205 "mysql idempotent": { 206 DSN: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 207 Schema: "mysql", 208 ExpectedOut: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 209 }, 210 "mysql: password with : and @": { 211 DSN: "mysql://mmuser:p:assw@ord@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 212 Schema: "mysql", 213 ExpectedOut: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 214 }, 215 "mysql: password with @ and :": { 216 DSN: "mysql://mmuser:pa@sswo:rd@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 217 Schema: "mysql", 218 ExpectedOut: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", 219 }, 220 "postgres": { 221 DSN: "postgres://mmuser:password@localhost:5432/mattermost?sslmode=disable&connect_timeout=10", 222 Schema: "postgres", 223 ExpectedOut: "postgres://mmuser:@localhost:5432/mattermost?sslmode=disable&connect_timeout=10", 224 }, 225 "pipe": { 226 DSN: "mysql://user@unix(/path/to/socket)/dbname", 227 Schema: "mysql", 228 ExpectedOut: "mysql://user@unix(/path/to/socket)/dbname", 229 }, 230 "malformed without :": { 231 DSN: "postgres://mmuserpassword@localhost:5432/mattermost?sslmode=disable&connect_timeout=10", 232 Schema: "postgres", 233 ExpectedOut: "postgres://mmuserpassword@localhost:5432/mattermost?sslmode=disable&connect_timeout=10", 234 }, 235 "malformed without @": { 236 DSN: "postgres://mmuser:passwordlocalhost:5432/mattermost?sslmode=disable&connect_timeout=10", 237 Schema: "postgres", 238 ExpectedOut: "(omitted due to error parsing the DSN)", 239 }, 240 } { 241 t.Run(name, func(t *testing.T) { 242 out := stripPassword(test.DSN, test.Schema) 243 244 assert.Equal(t, test.ExpectedOut, out) 245 }) 246 } 247 } 248 249 func sToP(s string) *string { 250 return &s 251 } 252 253 func bToP(b bool) *bool { 254 return &b 255 } 256 257 func TestIsJsonMap(t *testing.T) { 258 tests := []struct { 259 name string 260 data string 261 want bool 262 }{ 263 {name: "good json", data: `{"local_tcp": { 264 "Type": "tcp","Format": "json","Levels": [ 265 {"ID": 5,"Name": "debug","Stacktrace": false} 266 ], 267 "Options": {"ip": "localhost","port": 18065}, 268 "MaxQueueSize": 1000}} 269 `, want: true, 270 }, 271 {name: "empty json", data: "{}", want: true}, 272 {name: "string json", data: `"test"`, want: false}, 273 {name: "array json", data: `["test1", "test2"]`, want: false}, 274 {name: "bad json", data: `{huh?}`, want: false}, 275 {name: "filename", data: "/tmp/logger.conf", want: false}, 276 {name: "mysql dsn", data: "mysql://mmuser:@tcp(localhost:3306)/mattermost?charset=utf8mb4,utf8&readTimeout=30s", want: false}, 277 {name: "postgres dsn", data: "postgres://mmuser:passwordlocalhost:5432/mattermost?sslmode=disable&connect_timeout=10", want: false}, 278 } 279 for _, tt := range tests { 280 t.Run(tt.name, func(t *testing.T) { 281 if got := IsJsonMap(tt.data); got != tt.want { 282 t.Errorf("IsJsonMap() = %v, want %v", got, tt.want) 283 } 284 }) 285 } 286 }