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  }