| 1 | package config |
| 2 | |
| 3 | import ( |
| 4 | "os" |
| 5 | "path/filepath" |
| 6 | "testing" |
| 7 | "time" |
| 8 | ) |
| 9 | |
| 10 | func TestDefaults(t *testing.T) { |
| 11 | c, err := Load(filepath.Join(t.TempDir(), "geen.yml")) |
| 12 | if err != nil { |
| 13 | t.Fatal(err) |
| 14 | } |
| 15 | if c.ArchiveInterval.Duration != 24*time.Hour || c.RetentionDays != 30 || c.RateLimitKiB != 1024 || c.Listen != "0.0.0.0:8080" { |
| 16 | t.Fatalf("%+v", c) |
| 17 | } |
| 18 | } |
| 19 | |
| 20 | func TestLoad(t *testing.T) { |
| 21 | p := filepath.Join(t.TempDir(), "c.yml") |
| 22 | _ = os.WriteFile(p, []byte("archive_interval: 7d\nretention_days: -1\nrate_limit_kib: -1\npublic_url: http://b:1\n"), 0o600) |
| 23 | c, err := Load(p) |
| 24 | if err != nil { |
| 25 | t.Fatal(err) |
| 26 | } |
| 27 | if c.ArchiveInterval.Duration != 7*24*time.Hour || c.RetentionDays != 0 || c.RateLimitKiB != 0 { |
| 28 | t.Fatalf("%+v", c) |
| 29 | } |
| 30 | _ = os.WriteFile(p, []byte("public_url: ftp://x\n"), 0o600) |
| 31 | if _, err := Load(p); err == nil { |
| 32 | t.Fatal("ftp geaccepteerd") |
| 33 | } |
| 34 | _ = os.WriteFile(p, []byte("archive_interval: soms\n"), 0o600) |
| 35 | if _, err := Load(p); err == nil { |
| 36 | t.Fatal("ongeldige duur geaccepteerd") |
| 37 | } |
| 38 | if _, err := os.Stat(p); err != nil { |
| 39 | t.Fatal(err) |
| 40 | } |
| 41 | if Example() == "" { |
| 42 | t.Fatal("geen voorbeeld") |
| 43 | } |
| 44 | } |
| 45 | |
| 46 | func TestFieldsRoundTrip(t *testing.T) { |
| 47 | var c Config |
| 48 | c.Defaults() |
| 49 | for _, f := range Fields { |
| 50 | v := c.Get(f.Key) |
| 51 | if f.Key != "public_url" && v == "" { |
| 52 | t.Errorf("%s: leeg", f.Key) |
| 53 | } |
| 54 | if f.Readonly { |
| 55 | if err := c.Set(f.Key, v); err == nil { |
| 56 | t.Errorf("%s: readonly werd gewijzigd", f.Key) |
| 57 | } |
| 58 | continue |
| 59 | } |
| 60 | if err := c.Set(f.Key, v); err != nil && f.Key != "public_url" { |
| 61 | t.Errorf("%s=%q: %v", f.Key, v, err) |
| 62 | } |
| 63 | if got := c.Get(f.Key); got != v { |
| 64 | t.Errorf("%s: %q != %q", f.Key, got, v) |
| 65 | } |
| 66 | } |
| 67 | if c.Listen != "0.0.0.0:8080" { |
| 68 | t.Fatalf("standaardpoort %s", c.Listen) |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | func TestApplyIsAtomic(t *testing.T) { |
| 73 | var c Config |
| 74 | c.Defaults() |
| 75 | if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "nee"}); err == nil { |
| 76 | t.Fatal("fout verwacht") |
| 77 | } |
| 78 | if c.RetentionDays != 30 { |
| 79 | t.Fatal("half toegepast") |
| 80 | } |
| 81 | if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "7d", "public_url": "http://b:8080/"}); err != nil { |
| 82 | t.Fatal(err) |
| 83 | } |
| 84 | if c.RetentionDays != 7 || c.ArchiveInterval.Duration != 7*24*time.Hour || c.PublicURL != "http://b:8080" { |
| 85 | t.Fatalf("%+v", c) |
| 86 | } |
| 87 | if err := c.Apply(map[string]string{"data_dir": "/tmp"}); err == nil { |
| 88 | t.Fatal("data_dir mag niet") |
| 89 | } |
| 90 | } |
| 91 | |
| 92 | func TestSettingsFile(t *testing.T) { |
| 93 | d := t.TempDir() |
| 94 | if err := SaveSettings(d, map[string]string{"retention_days": "3"}); err != nil { |
| 95 | t.Fatal(err) |
| 96 | } |
| 97 | m, err := LoadSettings(d) |
| 98 | if err != nil || m["retention_days"] != "3" { |
| 99 | t.Fatal(m, err) |
| 100 | } |
| 101 | } |
| 102 | |
| 103 | func TestParsePublicURL(t *testing.T) { |
| 104 | ok := []string{ |
| 105 | "", |
| 106 | "http://backup.lan:8080", |
| 107 | "https://backup.example.com", |
| 108 | "http://192.168.1.50:8080", |
| 109 | "http://127.0.0.1", |
| 110 | "http://[2001:db8::1]:8080", |
| 111 | "https://[::1]:443", |
| 112 | } |
| 113 | for _, s := range ok { |
| 114 | got, err := ParsePublicURL(s) |
| 115 | if err != nil { |
| 116 | t.Errorf("%q: %v", s, err) |
| 117 | } |
| 118 | if s != "" && got == "" { |
| 119 | t.Errorf("%q: leeg terug", s) |
| 120 | } |
| 121 | } |
| 122 | // Trailing slash gaat eraf. |
| 123 | got, err := ParsePublicURL("http://192.168.1.50:8080/") |
| 124 | if err != nil || got != "http://192.168.1.50:8080" { |
| 125 | t.Fatalf("slash: %q %v", got, err) |
| 126 | } |
| 127 | bad := []string{"ftp://x", "http://", "niet-een-url", "192.168.1.50:8080", "http://user:pass@host"} |
| 128 | for _, s := range bad { |
| 129 | if _, err := ParsePublicURL(s); err == nil { |
| 130 | t.Errorf("%q geaccepteerd", s) |
| 131 | } |
| 132 | } |
| 133 | var c Config |
| 134 | c.Defaults() |
| 135 | if err := c.Set("public_url", "http://192.168.1.50:8080"); err != nil { |
| 136 | t.Fatal(err) |
| 137 | } |
| 138 | if err := c.Set("public_url", "http://[2001:db8::1]:8080"); err != nil { |
| 139 | t.Fatal(err) |
| 140 | } |
| 141 | if err := c.Set("public_url", "ftp://x"); err == nil { |
| 142 | t.Fatal("ftp via Set") |
| 143 | } |
| 144 | } |
| 145 | |
| 146 | func TestLoadRuntimeAndImportOnce(t *testing.T) { |
| 147 | root := t.TempDir() |
| 148 | data := filepath.Join(root, "data") |
| 149 | cfgPath := filepath.Join(root, "config.yml") |
| 150 | if err := os.WriteFile(cfgPath, []byte("listen: 127.0.0.1:9090\npublic_url: http://192.168.1.50:8080\ndata_dir: "+data+"\nretention_days: 7\n"), 0o600); err != nil { |
| 151 | t.Fatal(err) |
| 152 | } |
| 153 | c, err := LoadRuntime(Startup{ConfigPath: cfgPath}, nil) |
| 154 | if err != nil { |
| 155 | t.Fatal(err) |
| 156 | } |
| 157 | if c.DataDir != data || c.Listen != "127.0.0.1:9090" || c.PublicURL != "http://192.168.1.50:8080" || c.RetentionDays != 7 { |
| 158 | t.Fatalf("eerste import %+v", c) |
| 159 | } |
| 160 | if _, err := os.Stat(filepath.Join(data, SettingsFile)); err != nil { |
| 161 | t.Fatal("settings.yml ontbreekt") |
| 162 | } |
| 163 | if _, err := os.Stat(filepath.Join(data, LegacyImportMarker)); err != nil { |
| 164 | t.Fatal("marker ontbreekt") |
| 165 | } |
| 166 | // settings.yml wint; een latere wijziging in config.yml telt niet meer. |
| 167 | if err := os.WriteFile(cfgPath, []byte("listen: 0.0.0.0:1\npublic_url: http://other:1\ndata_dir: "+data+"\nretention_days: 99\n"), 0o600); err != nil { |
| 168 | t.Fatal(err) |
| 169 | } |
| 170 | if err := SaveSettings(data, map[string]string{"retention_days": "14", "listen": "127.0.0.1:9090", "public_url": "http://192.168.1.50:8080"}); err != nil { |
| 171 | t.Fatal(err) |
| 172 | } |
| 173 | c2, err := LoadRuntime(Startup{ConfigPath: cfgPath, DataDir: data}, nil) |
| 174 | if err != nil { |
| 175 | t.Fatal(err) |
| 176 | } |
| 177 | if c2.RetentionDays != 14 || c2.Listen != "127.0.0.1:9090" || c2.PublicURL != "http://192.168.1.50:8080" { |
| 178 | t.Fatalf("tweede start moet settings behouden %+v", c2) |
| 179 | } |
| 180 | // Zonder config.yml, alleen --data-dir. |
| 181 | empty := filepath.Join(root, "leeg") |
| 182 | c3, err := LoadRuntime(Startup{DataDir: empty, ConfigPath: filepath.Join(root, "bestaat-niet.yml")}, nil) |
| 183 | if err != nil { |
| 184 | t.Fatal(err) |
| 185 | } |
| 186 | if c3.DataDir != empty || c3.Listen != "0.0.0.0:8080" { |
| 187 | t.Fatalf("zonder config: %+v", c3) |
| 188 | } |
| 189 | // --data-dir wint van data_dir in het bestand. |
| 190 | other := filepath.Join(root, "other") |
| 191 | c4, err := LoadRuntime(Startup{ConfigPath: cfgPath, DataDir: other}, nil) |
| 192 | if err != nil { |
| 193 | t.Fatal(err) |
| 194 | } |
| 195 | if c4.DataDir != other { |
| 196 | t.Fatalf("flag moet winnen: %s", c4.DataDir) |
| 197 | } |
| 198 | } |
| 199 | |
| 200 | func TestDataDirFlagWinsOverEnv(t *testing.T) { |
| 201 | root := t.TempDir() |
| 202 | flagDir := filepath.Join(root, "flag") |
| 203 | envDir := filepath.Join(root, "env") |
| 204 | d, _, err := (Startup{DataDir: flagDir, DataDirEnv: envDir}).Resolve() |
| 205 | if err != nil || d != flagDir { |
| 206 | t.Fatalf("flag %s err %v", d, err) |
| 207 | } |
| 208 | d, _, err = (Startup{DataDirEnv: envDir, ConfigPath: filepath.Join(root, "nee.yml")}).Resolve() |
| 209 | if err != nil || d != envDir { |
| 210 | t.Fatalf("env %s err %v", d, err) |
| 211 | } |
| 212 | } |