github.com/getgauge/gauge@v1.6.9/util/fileUtils_test.go (about)

     1  /*----------------------------------------------------------------
     2   *  Copyright (c) ThoughtWorks, Inc.
     3   *  Licensed under the Apache License, Version 2.0
     4   *  See LICENSE in the project root for license information.
     5   *----------------------------------------------------------------*/
     6  
     7  package util
     8  
     9  import (
    10  	"fmt"
    11  	"os"
    12  	"path/filepath"
    13  	"testing"
    14  
    15  	"github.com/getgauge/gauge/config"
    16  	"github.com/getgauge/gauge/env"
    17  	. "gopkg.in/check.v1"
    18  )
    19  
    20  func Test(t *testing.T) { TestingT(t) }
    21  
    22  type MySuite struct{}
    23  
    24  var _ = Suite(&MySuite{})
    25  var dir string
    26  
    27  func (s *MySuite) SetUpTest(c *C) {
    28  	var err error
    29  	dir, err = os.MkdirTemp("", "gaugeTest")
    30  	c.Assert(err, Equals, nil)
    31  }
    32  
    33  func (s *MySuite) TearDownTest(c *C) {
    34  	err := os.RemoveAll(dir)
    35  	c.Assert(err, Equals, nil)
    36  	c.Assert(os.Unsetenv(env.SpecsDir), Equals, nil)
    37  	c.Assert(os.Unsetenv(env.ConceptsDir), Equals, nil)
    38  }
    39  
    40  func (s *MySuite) TestFindAllSpecFiles(c *C) {
    41  	data := []byte(`Specification Heading
    42  =====================
    43  Scenario 1
    44  ----------
    45  * say hello
    46  `)
    47  	spec1, err := createFileIn(dir, "gaugeSpec1.spec", data)
    48  	c.Assert(err, Equals, nil)
    49  
    50  	dataRead, err := os.ReadFile(spec1)
    51  	c.Assert(err, Equals, nil)
    52  	c.Assert(string(dataRead), Equals, string(data))
    53  	c.Assert(len(FindSpecFilesIn(dir)), Equals, 1)
    54  
    55  	_, err = createFileIn(dir, "gaugeSpec2.spec", data)
    56  	c.Assert(err, Equals, nil)
    57  
    58  	c.Assert(len(FindSpecFilesIn(dir)), Equals, 2)
    59  }
    60  
    61  func (s *MySuite) TestFindAllConceptFiles(c *C) {
    62  	data := []byte(`#Concept Heading`)
    63  	_, err := createFileIn(dir, "concept1.cpt", data)
    64  	c.Assert(err, Equals, nil)
    65  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 1)
    66  
    67  	_, err = createFileIn(dir, "concept2.cpt", data)
    68  	c.Assert(err, Equals, nil)
    69  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 2)
    70  }
    71  
    72  func (s *MySuite) TestIsValidSpecExensionDefault(c *C) {
    73  	c.Assert(IsValidSpecExtension("/home/user/foo/myspec.spec"), Equals, true)
    74  	c.Assert(IsValidSpecExtension("/home/user/foo/myspec.sPeC"), Equals, true)
    75  	c.Assert(IsValidSpecExtension("/home/user/foo/myspec.SPEC"), Equals, true)
    76  	c.Assert(IsValidSpecExtension("/home/user/foo/myspec.md"), Equals, true)
    77  	c.Assert(IsValidSpecExtension("/home/user/foo/myspec.MD"), Equals, true)
    78  	c.Assert(IsValidSpecExtension("/home/user/foo/myconcept.cpt"), Equals, false)
    79  }
    80  
    81  func TestIsValidSpecExensionWhenSet(t *testing.T) {
    82  	var tests = map[string]bool{
    83  		"/home/user/foo/myspec.spec":   true,
    84  		"/home/user/foo/myspec.sPeC":   true,
    85  		"/home/user/foo/myspec.SPEC":   true,
    86  		"/home/user/foo/myspec.md":     false,
    87  		"/home/user/foo/myspec.MD":     false,
    88  		"/home/user/foo/myspec.foo":    true,
    89  		"/home/user/foo/myspec.Foo":    true,
    90  		"/home/user/foo/myconcept.cpt": false,
    91  	}
    92  	for k, v := range tests {
    93  		t.Run(filepath.Ext(k), func(t *testing.T) {
    94  			old := env.GaugeSpecFileExtensions
    95  			env.GaugeSpecFileExtensions = func() []string { return []string{".spec", ".foo"} }
    96  			if IsValidSpecExtension(k) != v {
    97  				t.Errorf("Expected IsValidSpecExtension(%s) to be %t", k, v)
    98  			}
    99  			env.GaugeSpecFileExtensions = old
   100  		})
   101  	}
   102  }
   103  
   104  func (s *MySuite) TestIsValidConceptExension(c *C) {
   105  	c.Assert(IsValidConceptExtension("/home/user/foo/myconcept.cpt"), Equals, true)
   106  	c.Assert(IsValidConceptExtension("/home/user/foo/myconcept.CPT"), Equals, true)
   107  	c.Assert(IsValidConceptExtension("/home/user/foo/myconcept.cPt"), Equals, true)
   108  	c.Assert(IsValidConceptExtension("/home/user/foo/myspec.spC"), Equals, false)
   109  }
   110  
   111  func (s *MySuite) TestFindAllConceptFilesShouldFilterDirectoriesThatAreSkipped(c *C) {
   112  	config.ProjectRoot = dir
   113  	data := []byte(`#Concept Heading`)
   114  	git, _ := createDirIn(dir, ".git")
   115  	bin, _ := createDirIn(dir, "gauge_bin")
   116  	reports, _ := createDirIn(dir, "reports")
   117  	env, _ := createDirIn(dir, "env")
   118  
   119  	_, err := createFileIn(git, "concept1.cpt", data)
   120  	c.Assert(err, IsNil)
   121  	_, err = createFileIn(bin, "concept2.cpt", data)
   122  	c.Assert(err, IsNil)
   123  	_, err = createFileIn(reports, "concept3.cpt", data)
   124  	c.Assert(err, IsNil)
   125  	_, err = createFileIn(env, "concept4.cpt", data)
   126  	c.Assert(err, IsNil)
   127  
   128  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 0)
   129  
   130  	_, err = createFileIn(dir, "concept2.cpt", data)
   131  	c.Assert(err, Equals, nil)
   132  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 1)
   133  }
   134  
   135  func (s *MySuite) TestFindAllConceptFilesInNestedDir(c *C) {
   136  	data := []byte(`#Concept Heading
   137  * Say "hello" to gauge
   138  `)
   139  	_, err := createFileIn(dir, "concept1.cpt", data)
   140  	c.Assert(err, Equals, nil)
   141  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 1)
   142  
   143  	dir1, err := os.MkdirTemp(dir, "gaugeTest1")
   144  	c.Assert(err, Equals, nil)
   145  
   146  	_, err = createFileIn(dir1, "concept2.cpt", data)
   147  	c.Assert(err, Equals, nil)
   148  	c.Assert(len(FindConceptFilesIn(dir)), Equals, 2)
   149  }
   150  
   151  func (s *MySuite) TestGetConceptFiles(c *C) {
   152  	config.ProjectRoot = "_testdata"
   153  	specsDir, _ := filepath.Abs(filepath.Join("_testdata", "specs"))
   154  
   155  	config.ProjectRoot = specsDir
   156  	c.Assert(len(GetConceptFiles()), Equals, 2)
   157  
   158  	config.ProjectRoot = filepath.Join(specsDir, "concept1.cpt")
   159  	c.Assert(len(GetConceptFiles()), Equals, 1)
   160  
   161  	config.ProjectRoot = filepath.Join(specsDir, "subdir")
   162  	c.Assert(len(GetConceptFiles()), Equals, 1)
   163  
   164  	config.ProjectRoot = filepath.Join(specsDir, "subdir", "concept2.cpt")
   165  	c.Assert(len(GetConceptFiles()), Equals, 1)
   166  }
   167  
   168  func (s *MySuite) TestGetConceptFilesWhenSpecDirIsOutsideProjectRoot(c *C) {
   169  	config.ProjectRoot = "_testdata"
   170  	os.Setenv(env.SpecsDir, "../_testSpecDir")
   171  	c.Assert(len(GetConceptFiles()), Equals, 3)
   172  }
   173  
   174  func (s *MySuite) TestGetConceptFilesWhenSpecDirIsWithInProject(c *C) {
   175  	config.ProjectRoot = "_testdata"
   176  	os.Setenv(env.SpecsDir, "_testdata/specs")
   177  	c.Assert(len(GetConceptFiles()), Equals, 2)
   178  }
   179  
   180  func (s *MySuite) TestGetConceptFilesWhenConceptsDirSet(c *C) {
   181  	config.ProjectRoot = "_testdata"
   182  	c.Assert(len(GetConceptFiles()), Equals, 2)
   183  
   184  	os.Setenv(env.ConceptsDir, filepath.Join("specs", "concept1.cpt"))
   185  	c.Assert(len(GetConceptFiles()), Equals, 1)
   186  
   187  	os.Setenv(env.ConceptsDir, filepath.Join("specs", "subdir"))
   188  	c.Assert(len(GetConceptFiles()), Equals, 1)
   189  
   190  	conceptPath, _ := filepath.Abs(filepath.Join("_testdata", "specs", "subdir", "concept2.cpt"))
   191  	os.Setenv(env.ConceptsDir, conceptPath)
   192  	c.Assert(len(GetConceptFiles()), Equals, 1)
   193  }
   194  
   195  func (s *MySuite) TestGetConceptFilesWhenConceptDirIsOutsideProjectRoot(c *C) {
   196  	config.ProjectRoot = "_testdata"
   197  	os.Setenv(env.ConceptsDir, "../_testSpecDir,../_testdata/specs")
   198  	c.Assert(len(GetConceptFiles()), Equals, 3)
   199  }
   200  
   201  func (s *MySuite) TestFindAllNestedDirs(c *C) {
   202  	nested1 := filepath.Join(dir, "nested")
   203  	nested2 := filepath.Join(dir, "nested2")
   204  	nested3 := filepath.Join(dir, "nested2", "deep")
   205  	nested4 := filepath.Join(dir, "nested2", "deep", "deeper")
   206  	err := os.Mkdir(nested1, 0755)
   207  	c.Assert(err, IsNil)
   208  	err = os.Mkdir(nested2, 0755)
   209  	c.Assert(err, IsNil)
   210  	err = os.Mkdir(nested3, 0755)
   211  	c.Assert(err, IsNil)
   212  	err = os.Mkdir(nested4, 0755)
   213  	c.Assert(err, IsNil)
   214  
   215  	nestedDirs := FindAllNestedDirs(dir)
   216  	c.Assert(len(nestedDirs), Equals, 4)
   217  	c.Assert(stringInSlice(nested1, nestedDirs), Equals, true)
   218  	c.Assert(stringInSlice(nested2, nestedDirs), Equals, true)
   219  	c.Assert(stringInSlice(nested3, nestedDirs), Equals, true)
   220  	c.Assert(stringInSlice(nested4, nestedDirs), Equals, true)
   221  }
   222  
   223  func (s *MySuite) TestFindAllNestedDirsWhenDirDoesNotExist(c *C) {
   224  	nestedDirs := FindAllNestedDirs("unknown-dir")
   225  	c.Assert(len(nestedDirs), Equals, 0)
   226  }
   227  
   228  func (s *MySuite) TestIsDir(c *C) {
   229  	c.Assert(IsDir(dir), Equals, true)
   230  	c.Assert(IsDir(filepath.Join(dir, "foo.txt")), Equals, false)
   231  	c.Assert(IsDir("unknown path"), Equals, false)
   232  	c.Assert(IsDir("foo/goo.txt"), Equals, false)
   233  }
   234  
   235  func stringInSlice(a string, list []string) bool {
   236  	for _, b := range list {
   237  		if b == a {
   238  			return true
   239  		}
   240  	}
   241  	return false
   242  }
   243  
   244  func (s *MySuite) TestGetPathToFile(c *C) {
   245  	var path string
   246  	config.ProjectRoot = "PROJECT_ROOT"
   247  	absPath, _ := filepath.Abs("resources")
   248  	path = GetPathToFile(absPath)
   249  	c.Assert(path, Equals, absPath)
   250  
   251  	path = GetPathToFile("resources")
   252  	c.Assert(path, Equals, filepath.Join(config.ProjectRoot, "resources"))
   253  }
   254  
   255  func (s *MySuite) TestGetPathToFileInGaugeDataDir(c *C) {
   256  	var path string
   257  	config.ProjectRoot = "PROJECT_ROOT"
   258  	oldGaugeDataDirFn := env.GaugeDataDir
   259  	defer func(fn func() string) { env.GaugeDataDir = fn }(oldGaugeDataDirFn)
   260  	env.GaugeDataDir = func() string { return "foo" }
   261  
   262  	absPath, _ := filepath.Abs("foo.csv")
   263  	path = GetPathToFile(absPath)
   264  	c.Assert(path, Equals, absPath)
   265  }
   266  
   267  func (s *MySuite) TestGetPathToAbsFileWithGaugeDataDir(c *C) {
   268  	var path string
   269  	config.ProjectRoot = "PROJECT_ROOT"
   270  	oldGaugeDataDirFn := env.GaugeDataDir
   271  	defer func(fn func() string) { env.GaugeDataDir = fn }(oldGaugeDataDirFn)
   272  	env.GaugeDataDir = func() string { return "foo" }
   273  
   274  	path = GetPathToFile("foo.csv")
   275  	c.Assert(path, Equals, filepath.Join(config.ProjectRoot, "foo", "foo.csv"))
   276  }
   277  
   278  func (s *MySuite) TestGetSpecFilesWhenSpecsDirDoesNotExists(c *C) {
   279  	var expectedErrorMessage string
   280  	exitWithMessage = func(message string) {
   281  		expectedErrorMessage = message
   282  	}
   283  	GetSpecFiles([]string{"dir1"})
   284  	c.Assert(expectedErrorMessage, Equals, "Specs directory dir1 does not exist.")
   285  }
   286  
   287  func (s *MySuite) TestGetConceptFilesWhenConceptsDirDoesNotExists(c *C) {
   288  	var expectedErrorMessage string
   289  	exitWithMessage = func(message string) {
   290  		expectedErrorMessage = message
   291  	}
   292  	config.ProjectRoot = "_testdata"
   293  
   294  	os.Setenv(env.SpecsDir, "specs2")
   295  	GetConceptFiles()
   296  	directory, _ := filepath.Abs(filepath.Join(config.ProjectRoot, "specs2"))
   297  	c.Assert(expectedErrorMessage, Equals, fmt.Sprintf("No such file or diretory: %s", directory))
   298  
   299  	os.Setenv(env.SpecsDir, "_testSpecsDir,non-exisitng")
   300  	GetConceptFiles()
   301  	directory, _ = filepath.Abs(filepath.Join(config.ProjectRoot, "non-exisitng"))
   302  	c.Assert(expectedErrorMessage, Equals, fmt.Sprintf("No such file or diretory: %s", directory))
   303  }
   304  
   305  func (s *MySuite) TestGetSpecFilesWhenSpecsDirIsEmpty(c *C) {
   306  	var expectedErrorMessage string
   307  	exitWithMessage = func(message string) {
   308  		expectedErrorMessage = message
   309  	}
   310  	GetSpecFiles([]string{dir})
   311  	c.Assert(expectedErrorMessage, Equals, fmt.Sprintf("No specifications found in %s.", dir))
   312  }
   313  
   314  func (s *MySuite) TestGetSpecFiles(c *C) {
   315  	expectedSpecFiles := []string{"spec-file-1.spec", "spec-file2.spec"}
   316  	old := FindSpecFilesIn
   317  	FindSpecFilesIn = func(dir string) []string {
   318  		return []string{"spec-file-1.spec", "spec-file2.spec"}
   319  	}
   320  	actualSpecFiles := GetSpecFiles([]string{dir})
   321  	c.Assert(actualSpecFiles, DeepEquals, expectedSpecFiles)
   322  	FindSpecFilesIn = old
   323  }
   324  
   325  func createFileIn(dir string, fileName string, data []byte) (string, error) {
   326  	err := os.MkdirAll(dir, 0755)
   327  	if err != nil {
   328  		return "", err
   329  	}
   330  	err = os.WriteFile(filepath.Join(dir, fileName), data, 0644)
   331  	return filepath.Join(dir, fileName), err
   332  }
   333  
   334  func createDirIn(dir string, dirName string) (string, error) {
   335  	tempDir, err := os.MkdirTemp(dir, dirName)
   336  	if err != nil {
   337  		return "", err
   338  	}
   339  
   340  	fullDirName := filepath.Join(dir, dirName)
   341  	err = os.Rename(tempDir, fullDirName)
   342  	return fullDirName, err
   343  }