mpldr.codes/br@v1.0.1-0.20220117103752-dc4f0c6d76b1/plan/planning_test.go (about)

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