github.com/phrase/openapi@v0.0.0-20240514140800-49e8a106740e/clients/go/config_test.go (about) 1 package phrase 2 3 import ( 4 "fmt" 5 "os" 6 "testing" 7 ) 8 9 func TestValidateIsType(t *testing.T) { 10 var t1 string = "foobar" 11 var t2 int = 1 12 var t3 bool = true 13 expErrT1 := fmt.Sprintf(cfgValueErrStr, "a", t1) 14 expErrT2 := fmt.Sprintf(cfgValueErrStr, "a", t2) 15 expErrT3 := fmt.Sprintf(cfgValueErrStr, "a", t3) 16 17 switch res, err := ValidateIsString("a", t1); { 18 case err != nil: 19 t.Errorf("didn't expect an error, got %q", err) 20 case res != t1: 21 t.Errorf("expected value to be %q, got %q", t1, res) 22 } 23 24 switch _, err := ValidateIsString("a", t2); { 25 case err == nil: 26 t.Errorf("expect an error, got none") 27 case err.Error() != expErrT2: 28 t.Errorf("expected error to be %q, got %q", expErrT2, err) 29 } 30 31 switch _, err := ValidateIsString("a", t3); { 32 case err == nil: 33 t.Errorf("expect an error, got none") 34 case err.Error() != expErrT3: 35 t.Errorf("expected error to be %q, got %q", expErrT3, err) 36 } 37 38 switch _, err := ValidateIsInt("a", t1); { 39 case err == nil: 40 t.Errorf("expect an error, got none") 41 case err.Error() != expErrT1: 42 t.Errorf("expected error to be %q, got %q", expErrT1, err) 43 } 44 45 switch res, err := ValidateIsInt("a", t2); { 46 case err != nil: 47 t.Errorf("didn't expect an error, got %q", err) 48 case res != t2: 49 t.Errorf("expected value to be %q, got %q", t2, res) 50 } 51 52 switch _, err := ValidateIsInt("a", t3); { 53 case err == nil: 54 t.Errorf("expect an error, got none") 55 case err.Error() != expErrT3: 56 t.Errorf("expected error to be %q, got %q", expErrT3, err) 57 } 58 59 switch _, err := ValidateIsBool("a", t1); { 60 case err == nil: 61 t.Errorf("expect an error, got none") 62 case err.Error() != expErrT1: 63 t.Errorf("expected error to be %q, got %q", expErrT1, err) 64 } 65 66 switch _, err := ValidateIsBool("a", t2); { 67 case err == nil: 68 t.Errorf("expect an error, got none") 69 case err.Error() != expErrT2: 70 t.Errorf("expected error to be %q, got %q", expErrT2, err) 71 } 72 73 switch res, err := ValidateIsBool("a", t3); { 74 case err != nil: 75 t.Errorf("didn't expect an error, got %q", err) 76 case res != t3: 77 t.Errorf("expected value to be %t, got %t", t3, res) 78 } 79 } 80 81 func TestValidateIsRawMapHappyPath(t *testing.T) { 82 m := map[interface{}]interface{}{ 83 "foo": "bar", 84 "fuu": 1, 85 "few": true, 86 } 87 88 res, err := ValidateIsRawMap("a", m) 89 if err != nil { 90 t.Errorf("didn't expect an error, got %q", err) 91 } 92 93 if len(m) != len(res) { 94 t.Errorf("expected %d elements, got %d", len(m), len(res)) 95 } 96 97 for k, v := range res { 98 if value, found := m[k]; !found { 99 t.Errorf("expected key %q to be in source set, it wasn't", k) 100 } else if value != v { 101 t.Errorf("expected value of %q to be %q, got %q", k, value, v) 102 } 103 } 104 } 105 106 func TestValidateIsRawMapWithErrors(t *testing.T) { 107 m := map[interface{}]interface{}{ 108 4: "should be error", 109 } 110 111 expErr := fmt.Sprintf(cfgKeyErrStr, "a.4", 4) 112 _, err := ValidateIsRawMap("a", m) 113 if err == nil { 114 t.Errorf("expect an error, got none") 115 } else if err.Error() != expErr { 116 t.Errorf("expected error %q, got %q", expErr, err) 117 } 118 } 119 120 func TestParseYAMLToMap(t *testing.T) { 121 var a string 122 var b int 123 var c bool 124 var d []byte 125 e := map[string]interface{}{} 126 127 err := ParseYAMLToMap(func(raw interface{}) error { 128 m, ok := raw.(map[string]interface{}) 129 if !ok { 130 return fmt.Errorf("invalid type received") 131 } 132 m["a"] = "foo" 133 m["b"] = 1 134 m["c"] = true 135 m["d"] = &struct { 136 A string 137 B int 138 }{A: "bar", B: 2} 139 m["e"] = map[interface{}]interface{}{"c": "baz", "d": 4} 140 return nil 141 }, map[string]interface{}{ 142 "a": &a, 143 "b": &b, 144 "c": &c, 145 "d": &d, 146 "e": &e, 147 }) 148 if err != nil { 149 t.Fatalf("didn't expect an error, got %q", err) 150 } 151 152 if a != "foo" { 153 t.Errorf("expected %q, got %q", "foo", a) 154 } 155 156 if b != 1 { 157 t.Errorf("expected %d, got %d", 1, b) 158 } 159 160 if c != true { 161 t.Errorf("expected %t, got %t", true, c) 162 } 163 164 if string(d) != "a: bar\nb: 2\n" { 165 t.Errorf("expected %s, got %s", "a: bar\nb: 2\n", string(d)) 166 } 167 168 if val, found := e["c"]; !found { 169 t.Errorf("expected e to contain key %q, it didn't", "c") 170 } else if val != "baz" { 171 t.Errorf("expected e['c'] to have value %q, got %q", "baz", val) 172 } 173 174 if val, found := e["d"]; !found { 175 t.Errorf("expected e to contain key %q, it didn't", "d") 176 } else if val != 4 { 177 t.Errorf("expected e['d'] to have value %d, got %d", 4, val) 178 } 179 } 180 181 func TestConfigPath_ConfigFromEnv(t *testing.T) { 182 // The phrase.yml file without the leading '.' so not hidden. Any file can be used from the environment! 183 pwd, err := os.Getwd() 184 if err != nil { 185 t.Fatalf("Cannot Getwd, got: %s", err) 186 } 187 188 p := pwd + "/testdata/phraseapp.yml" 189 190 os.Setenv("PHRASEAPP_CONFIG", p) 191 defer os.Unsetenv("PHRASEAPP_CONFIG") 192 193 path, err := configPath() 194 if err != nil { 195 t.Fatalf("didn't expect an error, got: %s", err) 196 } else if path != p { 197 t.Errorf("expected path to be %q, got %q", p, path) 198 } 199 } 200 201 func TestConfigPath_ConfigFromEnvButNotExisting(t *testing.T) { 202 os.Setenv("PHRASEAPP_CONFIG", "phraseapp_does_not_exist.yml") 203 defer os.Unsetenv("PHRASEAPP_CONFIG") 204 205 _, err := configPath() 206 if err == nil { 207 t.Fatalf("expect an error, got none") 208 } 209 210 expErr := `file "phraseapp_does_not_exist.yml" (from PHRASEAPP_CONFIG environment variable) doesn't exist` 211 if err.Error() != expErr { 212 t.Errorf("expected error to be %q, got %q", expErr, err) 213 } 214 } 215 216 func TestConfigPath_ConfigInCWD(t *testing.T) { 217 pwd, err := os.Getwd() 218 if err != nil { 219 t.Fatalf("Cannot Getwd, got: %s", err) 220 } 221 222 cwd := pwd + "/testdata" 223 224 oldDir, _ := os.Getwd() 225 err = os.Chdir(cwd) 226 if err != nil { 227 t.Fatalf("didn't expect an error changing the working directory, got: %s", err) 228 } 229 defer os.Chdir(oldDir) 230 231 path, err := configPath() 232 if err != nil { 233 t.Fatalf("didn't expect an error, got: %s", err) 234 } 235 expPath := cwd + "/.phraseapp.yml" 236 if path != expPath { 237 t.Errorf("expected path to be %q, got %q", expPath, path) 238 } 239 } 240 241 func TestConfigPath_ConfigPreference(t *testing.T) { 242 pwd, err := os.Getwd() 243 if err != nil { 244 t.Fatalf("Cannot Getwd, got: %s", err) 245 } 246 247 cwd := pwd + "/testdata/config_files" 248 249 oldDir, _ := os.Getwd() 250 err = os.Chdir(cwd) 251 if err != nil { 252 t.Fatalf("didn't expect an error changing the working directory, got: %s", err) 253 } 254 defer os.Chdir(oldDir) 255 256 path, err := configPath() 257 if err != nil { 258 t.Fatalf("didn't expect an error, got: %s", err) 259 } 260 expPath := cwd + "/.phrase.yml" 261 if path != expPath { 262 t.Errorf("expected path to be %q, got %q", expPath, path) 263 } 264 } 265 266 func TestConfigPath_ConfigInHomeDir(t *testing.T) { 267 pwd, err := os.Getwd() 268 if err != nil { 269 t.Fatalf("Cannot Getwd, got: %s", err) 270 } 271 272 cwd := pwd + "/testdata/empty" 273 274 oldDir, _ := os.Getwd() 275 err = os.Chdir(cwd) 276 if err != nil { 277 t.Fatalf("didn't expect an error changing the working directory, got: %s", err) 278 } 279 defer os.Chdir(oldDir) 280 281 newHome := pwd + "/testdata" 282 oldHome := os.Getenv("HOME") 283 os.Setenv("HOME", newHome) 284 defer os.Setenv("HOME", oldHome) 285 286 path, err := configPath() 287 if err != nil { 288 t.Fatalf("didn't expect an error, got: %s", err) 289 } 290 expPath := newHome + "/.phraseapp.yml" 291 if path != expPath { 292 t.Errorf("expected path to be %q, got %q", expPath, path) 293 } 294 } 295 296 func TestConfigPath_NoConfigAvailable(t *testing.T) { 297 // For this to work the configuration of the user running the test 298 // must be obfuscated (changing the CWD and HOME env variable), so 299 // user's files do not inflict the test environment. 300 pwd, err := os.Getwd() 301 if err != nil { 302 t.Fatalf("Cannot Getwd, got: %s", err) 303 } 304 305 cwd := pwd + "/testdata/empty" 306 307 oldDir, _ := os.Getwd() 308 err = os.Chdir(cwd) 309 if err != nil { 310 t.Fatalf("didn't expect an error changing the working directory, got: %s", err) 311 } 312 defer os.Chdir(oldDir) 313 314 oldHome := os.Getenv("HOME") 315 316 pwd, err = os.Getwd() 317 if err != nil { 318 t.Fatalf("Cannot Getwd, got: %s", err) 319 } 320 321 os.Setenv("HOME", pwd+"/testdata/empty2") 322 defer os.Setenv("HOME", oldHome) 323 324 path, err := configPath() 325 if err != nil { 326 t.Fatalf("didn't expect an error, got: %s", err) 327 } 328 expPath := "" 329 if path != expPath { 330 t.Errorf("expected path to be %q, got %q", expPath, path) 331 } 332 } 333 334 func TestParseConfig(t *testing.T) { 335 pwd, err := os.Getwd() 336 if err != nil { 337 t.Fatalf("Cannot Getwd, got: %s", err) 338 } 339 340 os.Setenv("PHRASEAPP_CONFIG", pwd+"/testdata/config_files/.phrase.yml") 341 defer os.Unsetenv("PHRASEAPP_CONFIG") 342 config, err := ReadConfig("") 343 if err != nil { 344 t.Error(err) 345 } 346 347 if config.Token != "123" { 348 t.Errorf("Got %s, expected %s", config.Token, "123") 349 } 350 } 351 352 func TestParseConfig_fromPath(t *testing.T) { 353 pwd, err := os.Getwd() 354 if err != nil { 355 t.Fatalf("Cannot Getwd, got: %s", err) 356 } 357 358 path := pwd + "/testdata/random.yml" 359 config, err := ReadConfig(path) 360 if err != nil { 361 t.Error(err) 362 } 363 364 if config.Token != "123" { 365 t.Errorf("Got %s, expected %s", config.Token, "123") 366 } 367 } 368 369 func TestParseConfig_LegacyPhraseApp(t *testing.T) { 370 pwd, err := os.Getwd() 371 if err != nil { 372 t.Fatalf("Cannot Getwd, got: %s", err) 373 } 374 375 os.Setenv("PHRASEAPP_CONFIG", pwd+"/testdata/config_files/.phraseapp.yml") 376 defer os.Unsetenv("PHRASEAPP_CONFIG") 377 config, err := ReadConfig("") 378 if err != nil { 379 t.Error(err) 380 } 381 382 if config.Token != "123" { 383 t.Errorf("Got %s, expected %s", config.Token, "123") 384 } 385 }