git.sr.ht/~poldi1405/bulkrename@v1.0.0/plan/planning_test.go (about) 1 package plan 2 3 import ( 4 "os" 5 "testing" 6 7 j "git.sr.ht/~poldi1405/bulkrename/plan/jobdescriptor" 8 "github.com/mborders/logmatic" 9 ) 10 11 func TestTempFileRemoved(t *testing.T) { 12 L = logmatic.NewLogger() 13 L.SetLevel(logmatic.LogLevel(42)) 14 L.SetLevel(logmatic.FATAL) 15 var p Plan 16 17 err := p.CreatePlan("probably does not exist. If it does, delete it.") 18 if err == nil { 19 t.Fail() 20 } 21 22 if !os.IsNotExist(err) { 23 t.Fail() 24 } 25 } 26 27 func TestDetectCircles(t *testing.T) { 28 L = logmatic.NewLogger() 29 L.SetLevel(logmatic.LogLevel(42)) 30 L.SetLevel(logmatic.FATAL) 31 var p Plan 32 33 p.InFiles = []string{"1", "2", "3"} 34 p.OutFiles = []string{"2", "3", "1"} 35 p.jobs = []j.JobDescriptor{ 36 { 37 Action: 0, 38 SourcePath: "1", 39 DstPath: "2", 40 }, 41 { 42 Action: 0, 43 SourcePath: "2", 44 DstPath: "3", 45 }, 46 { 47 Action: 0, 48 SourcePath: "3", 49 DstPath: "1", 50 }, 51 } 52 53 results := p.findCollisions() 54 if len(results) != 3 { 55 t.Error("got", len(results), "prerules generated instead of 3") 56 } 57 } 58 59 func TestDetectLinearReplace(t *testing.T) { 60 L = logmatic.NewLogger() 61 L.SetLevel(logmatic.LogLevel(42)) 62 L.SetLevel(logmatic.FATAL) 63 var p Plan 64 65 p.InFiles = []string{"1", "2", "3"} 66 p.OutFiles = []string{"2", "3", "1"} 67 p.jobs = []j.JobDescriptor{ 68 { 69 Action: 0, 70 SourcePath: "1", 71 DstPath: "2", 72 }, 73 { 74 Action: 0, 75 SourcePath: "2", 76 DstPath: "3", 77 }, 78 { 79 Action: 0, 80 SourcePath: "3", 81 DstPath: "4", 82 }, 83 } 84 85 results := p.findCollisions() 86 if len(results) != 2 { 87 t.Error("got", len(results), "prerules generated instead of 3") 88 } 89 } 90 91 func TestDetectNoCircles(t *testing.T) { 92 L = logmatic.NewLogger() 93 L.SetLevel(logmatic.LogLevel(42)) 94 L.SetLevel(logmatic.FATAL) 95 var p Plan 96 97 p.InFiles = []string{"1", "2", "3"} 98 p.OutFiles = []string{"2", "3", "1"} 99 p.jobs = []j.JobDescriptor{ 100 { 101 Action: 0, 102 SourcePath: "1", 103 DstPath: "4", 104 }, 105 { 106 Action: 0, 107 SourcePath: "2", 108 DstPath: "5", 109 }, 110 { 111 Action: 0, 112 SourcePath: "3", 113 DstPath: "6", 114 }, 115 } 116 117 results := p.findCollisions() 118 if len(results) != 0 { 119 t.Error("got", len(results), "prerules generated instead of 0") 120 } 121 } 122 123 func TestFailGetAbsolutePath(t *testing.T) { 124 pwd, err := os.Getwd() 125 if err != nil { 126 t.Skipf(err.Error()) 127 } 128 129 err = os.Mkdir(pwd+"test_failabspath", 0o777) 130 if err != nil { 131 t.Skipf(err.Error()) 132 } 133 defer os.Remove(pwd + "test_failabspath") 134 135 err = os.Chdir(pwd + "test_failabspath") 136 if err != nil { 137 t.Skipf(err.Error()) 138 } 139 defer func() { 140 err := os.Chdir(pwd) 141 if err != nil { 142 t.Log(err) 143 } 144 }() 145 146 f, err := os.Create(pwd + "test.txt") 147 if err != nil { 148 t.Skipf(err.Error()) 149 } 150 defer os.Remove(pwd + "test.txt") 151 defer f.Close() 152 _, err = f.WriteString("Hello World") 153 if err != nil { 154 t.Skipf(err.Error()) 155 } 156 157 err = os.Remove(pwd + "test_failabspath") 158 if err != nil { 159 t.Skipf(err.Error()) 160 } 161 var p Plan 162 err = p.CreatePlan(pwd + "test.txt") 163 if err == nil { 164 t.Fail() 165 } 166 } 167 168 func TestDeleteEmptyLines(t *testing.T) { 169 _, err := os.Create("test.txt") 170 if err != nil { 171 t.Skipf(err.Error()) 172 } 173 defer os.Remove("test.txt") 174 175 var p Plan 176 p.InFiles = []string{"hey there!"} 177 p.DeleteEmpty = true 178 179 err = p.CreatePlan("test.txt") 180 if err != nil { 181 t.Fail() 182 } 183 184 if len(p.jobs) != 1 { 185 t.FailNow() 186 } 187 188 if (p.jobs[0]).Action != -1 { 189 t.Fail() 190 } 191 } 192 193 func TestNoUnnecessaryPrerules(t *testing.T) { 194 L = logmatic.NewLogger() 195 L.SetLevel(logmatic.LogLevel(42)) 196 L.SetLevel(logmatic.FATAL) 197 var p Plan 198 199 p.InFiles = []string{"1"} 200 p.OutFiles = []string{"2"} 201 p.jobs = []j.JobDescriptor{ 202 { 203 Action: 0, 204 SourcePath: "1", 205 DstPath: "2", 206 }, 207 } 208 209 _, err := os.Create("1") 210 if err != nil { 211 t.Skipf(err.Error()) 212 } 213 defer os.Remove("1") 214 215 err = p.PrepareExecution() 216 if err != nil { 217 t.Error(err) 218 } 219 220 if len(p.jobs) != 1 { 221 t.Error("got", len(p.jobs)-1, "prejobs") 222 } 223 } 224 225 func TestFailBecauseActionForbidden(t *testing.T) { 226 L = logmatic.NewLogger() 227 L.SetLevel(logmatic.LogLevel(42)) 228 L.SetLevel(logmatic.FATAL) 229 var p Plan 230 reset := func() { 231 p.InFiles = []string{"1"} 232 p.OutFiles = []string{"3/2/1"} 233 p.jobs = []j.JobDescriptor{ 234 { 235 Action: 0, 236 SourcePath: "1", 237 DstPath: "3/1", 238 }, 239 } 240 } 241 reset() 242 243 _, err := os.Create("1") 244 if err != nil { 245 t.Skipf(err.Error()) 246 } 247 defer os.Remove("1") 248 249 _, err = os.Create("3") 250 if err != nil { 251 t.Skipf(err.Error()) 252 } 253 defer os.Remove("3") 254 255 p.Overwrite = false 256 p.CreateDirs = false 257 err = p.PrepareExecution() 258 if err != errMultipleChoiceNotAllowed { 259 t.Error("did not fail when overwriting and creating directories is forbidden") 260 } 261 262 reset() 263 264 p.Overwrite = false 265 p.CreateDirs = true 266 err = p.PrepareExecution() 267 if err != errMultipleChoiceNotAllowed { 268 t.Error("did not fail when only overwriting is forbidden") 269 if err != nil { 270 t.Log(err) 271 } 272 } 273 274 reset() 275 276 p.Overwrite = true 277 p.CreateDirs = false 278 err = p.PrepareExecution() 279 if err == errDirCreationNotAllowed { 280 t.Error("did not fail when only creating directories is forbidden") 281 } 282 } 283 284 func TestFailBecauseMkdirForbidden(t *testing.T) { 285 L = logmatic.NewLogger() 286 L.SetLevel(logmatic.LogLevel(42)) 287 L.SetLevel(logmatic.FATAL) 288 var p Plan 289 reset := func() { 290 p.InFiles = []string{"1"} 291 p.OutFiles = []string{"2/1"} 292 p.jobs = []j.JobDescriptor{ 293 { 294 Action: 0, 295 SourcePath: "1", 296 DstPath: "2/1", 297 }, 298 } 299 } 300 reset() 301 302 _, err := os.Create("1") 303 if err != nil { 304 t.Skipf(err.Error()) 305 } 306 defer os.Remove("1") 307 308 p.Overwrite = true 309 p.CreateDirs = false 310 err = p.PrepareExecution() 311 if err != errDirCreationNotAllowed { 312 t.Error("did not fail when directories is forbidden") 313 } 314 } 315 316 func TestCreateMkdirPrerule(t *testing.T) { 317 L = logmatic.NewLogger() 318 L.SetLevel(logmatic.LogLevel(42)) 319 L.SetLevel(logmatic.FATAL) 320 var p Plan 321 reset := func() { 322 p.InFiles = []string{"1"} 323 p.OutFiles = []string{"2/1"} 324 p.jobs = []j.JobDescriptor{ 325 { 326 Action: 0, 327 SourcePath: "1", 328 DstPath: "2/1", 329 }, 330 } 331 } 332 reset() 333 334 _, err := os.Create("1") 335 if err != nil { 336 t.Skipf(err.Error()) 337 } 338 defer os.Remove("1") 339 340 p.Overwrite = true 341 p.CreateDirs = true 342 err = p.PrepareExecution() 343 if err != nil { 344 t.Error(err) 345 } 346 347 if len(p.jobs) != 2 || p.jobs[0].Action != 2 { 348 t.Fail() 349 } 350 } 351 352 func TestReplaceFileWithDirectoryPrerules(t *testing.T) { 353 L = logmatic.NewLogger() 354 L.SetLevel(logmatic.LogLevel(42)) 355 L.SetLevel(logmatic.FATAL) 356 var p Plan 357 reset := func() { 358 p.InFiles = []string{"1"} 359 p.OutFiles = []string{"3/1"} 360 p.jobs = []j.JobDescriptor{ 361 { 362 Action: 0, 363 SourcePath: "1", 364 DstPath: "3/1", 365 }, 366 } 367 } 368 reset() 369 370 _, err := os.Create("1") 371 if err != nil { 372 t.Skipf(err.Error()) 373 } 374 defer os.Remove("1") 375 376 _, err = os.Create("3") 377 if err != nil { 378 t.Skipf(err.Error()) 379 } 380 defer os.Remove("3") 381 382 p.Overwrite = true 383 p.CreateDirs = true 384 err = p.PrepareExecution() 385 if err != nil { 386 t.Error(err) 387 } 388 389 if len(p.jobs) != 3 || p.jobs[0].Action != -1 || p.jobs[1].Action != 2 { 390 t.Fail() 391 } 392 } 393 394 func TestIgnoreRingDetectionRules(t *testing.T) { 395 L = logmatic.NewLogger() 396 L.SetLevel(logmatic.LogLevel(42)) 397 L.SetLevel(logmatic.FATAL) 398 var p Plan 399 reset := func() { 400 p.InFiles = []string{"1"} 401 p.OutFiles = []string{"3/1"} 402 p.jobs = []j.JobDescriptor{ 403 { 404 Action: 3, 405 SourcePath: "1", 406 DstPath: "3/1", 407 }, 408 } 409 } 410 reset() 411 412 _, err := os.Create("1") 413 if err != nil { 414 t.Skipf(err.Error()) 415 } 416 defer os.Remove("1") 417 418 _, err = os.Create("3") 419 if err != nil { 420 t.Skipf(err.Error()) 421 } 422 defer os.Remove("3") 423 424 p.Overwrite = true 425 p.CreateDirs = true 426 err = p.PrepareExecution() 427 if err != nil { 428 t.Error(err) 429 } 430 431 if len(p.jobs) != 1 { 432 t.Fail() 433 } 434 } 435 436 func TestPlanningSourceFileNotExist(t *testing.T) { 437 L = logmatic.NewLogger() 438 L.SetLevel(logmatic.LogLevel(42)) 439 L.SetLevel(logmatic.FATAL) 440 var p Plan 441 reset := func() { 442 p.InFiles = []string{"1"} 443 p.OutFiles = []string{"3/1"} 444 p.jobs = []j.JobDescriptor{ 445 { 446 Action: 0, 447 SourcePath: "1", 448 DstPath: "3/1", 449 }, 450 } 451 } 452 reset() 453 454 p.Overwrite = true 455 p.CreateDirs = true 456 err := p.PrepareExecution() 457 if !os.IsNotExist(err) { 458 t.Fail() 459 } 460 }