kcl-lang.io/kpm@v0.8.7-0.20240520061008-9fc4c5efc8c7/pkg/utils/utils_test.go (about)

     1  package utils
     2  
     3  import (
     4  	"archive/tar"
     5  	"io"
     6  	"os"
     7  	"path"
     8  	"path/filepath"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  const testDataDir = "test_data"
    16  
    17  func getTestDir(subDir string) string {
    18  	pwd, _ := os.Getwd()
    19  	testDir := filepath.Join(pwd, testDataDir)
    20  	testDir = filepath.Join(testDir, subDir)
    21  
    22  	return testDir
    23  }
    24  
    25  func TestParseRepoNameFromGitUrl(t *testing.T) {
    26  	assert.Equal(t, ParseRepoNameFromGitUrl("test"), "test", "ParseRepoNameFromGitUrl failed.")
    27  	assert.Equal(t, ParseRepoNameFromGitUrl("test.git"), "test", "ParseRepoNameFromGitUrl failed.")
    28  	assert.Equal(t, ParseRepoNameFromGitUrl("test.git.git"), "test.git", "ParseRepoNameFromGitUrl failed.")
    29  	assert.Equal(t, ParseRepoNameFromGitUrl("https://test.git"), "test", "ParseRepoNameFromGitUrl failed.")
    30  	assert.Equal(t, ParseRepoNameFromGitUrl("https://test.git.git"), "test.git", "ParseRepoNameFromGitUrl failed.")
    31  	assert.Equal(t, ParseRepoNameFromGitUrl("httfsdafps://test.git.git"), "test.git", "ParseRepoNameFromGitUrl failed.")
    32  }
    33  
    34  type TestPath struct {
    35  	FilePath string
    36  }
    37  
    38  func (tp *TestPath) TestStore() error {
    39  	return StoreToFile(tp.FilePath, "test")
    40  }
    41  
    42  func TestCreateFileIfNotExist(t *testing.T) {
    43  	test_path := getTestDir("test_exist.txt")
    44  	isExist, _ := Exists(test_path)
    45  	assert.Equal(t, isExist, false)
    46  
    47  	tp := TestPath{
    48  		FilePath: test_path,
    49  	}
    50  	err := CreateFileIfNotExist(tp.FilePath, tp.TestStore)
    51  	assert.Equal(t, err, nil)
    52  
    53  	isExist, _ = Exists(test_path)
    54  	assert.Equal(t, isExist, true)
    55  
    56  	_ = os.Remove(test_path)
    57  	isExist, _ = Exists(test_path)
    58  	assert.Equal(t, isExist, false)
    59  }
    60  
    61  func TestHashDir(t *testing.T) {
    62  	test_path := filepath.Join(getTestDir("test_hash"), "test_hash.txt")
    63  	tp := TestPath{
    64  		FilePath: test_path,
    65  	}
    66  
    67  	_ = CreateFileIfNotExist(tp.FilePath, tp.TestStore)
    68  	res, err := HashDir(filepath.Dir(tp.FilePath))
    69  	assert.Equal(t, err, nil)
    70  	assert.Equal(t, res, "n4bQgYhMfWWaL+qgxVrQFaO/TxsrC4Is0V1sFbDwCgg=")
    71  }
    72  
    73  func TestTarDir(t *testing.T) {
    74  	testDir := getTestDir("test_tar")
    75  	tarPath := filepath.Join(testDir, "test.tar")
    76  
    77  	_, err := os.Stat(tarPath)
    78  	if !os.IsNotExist(err) {
    79  		os.Remove(tarPath)
    80  	}
    81  
    82  	testSrcDir := filepath.Join(testDir, "test_src")
    83  
    84  	getTarFileNames := func(filePath string) ([]string, error) {
    85  		file, err := os.Open(filePath)
    86  		if err != nil {
    87  			return nil, err
    88  		}
    89  		defer file.Close()
    90  
    91  		reader := tar.NewReader(file)
    92  		filePaths := []string{}
    93  
    94  		for {
    95  			header, err := reader.Next()
    96  			if err == io.EOF {
    97  				break
    98  			}
    99  			if err != nil {
   100  				return nil, err
   101  			}
   102  
   103  			if header.Typeflag != tar.TypeReg {
   104  				continue
   105  			}
   106  
   107  			fullPath := path.Join(header.Name)
   108  			fullPath = path.Join(filePath, fullPath)
   109  			fullPath = strings.Replace(fullPath, "test.tar", "test_src", 1)
   110  
   111  			filePaths = append(filePaths, fullPath)
   112  		}
   113  
   114  		return filePaths, nil
   115  	}
   116  
   117  	getNewPattern := func(ex string) string {
   118  		return testSrcDir + "/" + ex
   119  	}
   120  
   121  	err = TarDir(testSrcDir, tarPath, []string{}, []string{})
   122  	assert.Equal(t, err, nil)
   123  	_, err = os.Stat(tarPath)
   124  	assert.Equal(t, err, nil)
   125  	os.Remove(tarPath)
   126  
   127  	_ = TarDir(testSrcDir, tarPath, []string{}, []string{"*.mod"})
   128  	fileNames, _ := getTarFileNames(tarPath)
   129  	for _, fileName := range fileNames {
   130  		flag, _ := filepath.Match(getNewPattern("*.mod"), fileName)
   131  		assert.Equal(t, flag, false)
   132  	}
   133  	_, err = os.Stat(tarPath)
   134  	assert.Equal(t, err, nil)
   135  	os.Remove(tarPath)
   136  
   137  	_ = TarDir(testSrcDir, tarPath, []string{"*/*.lock", "*.mod"}, []string{})
   138  	fileNames, _ = getTarFileNames(tarPath)
   139  	for _, fileName := range fileNames {
   140  		flag, _ := filepath.Match(getNewPattern("*/*.lock"), fileName)
   141  		assert.Equal(t, flag, true)
   142  	}
   143  	_, err = os.Stat(tarPath)
   144  	assert.Equal(t, err, nil)
   145  	os.Remove(tarPath)
   146  }
   147  
   148  func TestUnTarDir(t *testing.T) {
   149  	testDir := getTestDir("test_un_tar")
   150  	tarPath := filepath.Join(testDir, "test.tar")
   151  	testSrc := filepath.Join(testDir, "test_src")
   152  
   153  	err := UnTarDir(tarPath, testSrc)
   154  	assert.Equal(t, err, nil)
   155  
   156  	_, err = os.Stat(testSrc)
   157  	assert.Equal(t, err, nil)
   158  	_ = os.RemoveAll(testSrc)
   159  }
   160  
   161  func TestDefaultKpmHome(t *testing.T) {
   162  	homeDir, _ := os.UserHomeDir()
   163  
   164  	filePath := filepath.Join(homeDir, ".kpm")
   165  
   166  	kpmHome, err := CreateSubdirInUserHome(".kpm")
   167  	assert.Equal(t, err, nil)
   168  	assert.Equal(t, kpmHome, filePath)
   169  	assert.Equal(t, DirExists(kpmHome), true)
   170  }
   171  
   172  func TestJoinPath(t *testing.T) {
   173  	assert.Equal(t, JoinPath("base", "elem"), "base/elem")
   174  	assert.Equal(t, JoinPath("base/", "elem"), "base/elem")
   175  	assert.Equal(t, JoinPath("base", "/elem"), "base/elem")
   176  	assert.Equal(t, JoinPath("", "/elem"), "/elem")
   177  	assert.Equal(t, JoinPath("", "elem"), "/elem")
   178  	assert.Equal(t, JoinPath("base/", ""), "base/")
   179  	assert.Equal(t, JoinPath("base", ""), "base/")
   180  }
   181  
   182  func TestIsUrl(t *testing.T) {
   183  	assert.Equal(t, IsURL("invalid url"), false)
   184  	assert.Equal(t, IsURL("https://url/xxx"), true)
   185  	assert.Equal(t, IsURL("https://url"), true)
   186  	assert.Equal(t, IsURL("https://"), false)
   187  }
   188  
   189  func TestIsGitRepoUrl(t *testing.T) {
   190  	assert.Equal(t, IsGitRepoUrl("invalid url"), false)
   191  	assert.Equal(t, IsGitRepoUrl("ftp://github.com/user/project.git"), false)
   192  	assert.Equal(t, IsGitRepoUrl("file:///path/to/repo.git/"), false)
   193  	assert.Equal(t, IsGitRepoUrl("file://~/path/to/repo.git/"), false)
   194  	assert.Equal(t, IsGitRepoUrl("path/to/repo.git/"), false)
   195  	assert.Equal(t, IsGitRepoUrl("~/path/to/repo.git"), false)
   196  	assert.Equal(t, IsGitRepoUrl("rsync://host.xz/path/to/repo.git/"), false)
   197  	assert.Equal(t, IsGitRepoUrl("host.xz:path/to/repo.git"), false)
   198  	assert.Equal(t, IsGitRepoUrl("user@host.xz:path/to/repo.git"), false)
   199  	assert.Equal(t, IsGitRepoUrl("C:\\path\\to\\repo.git"), false)
   200  	assert.Equal(t, IsGitRepoUrl("/path/to/repo.git"), false)
   201  	assert.Equal(t, IsGitRepoUrl("./path/to/repo.git"), false)
   202  	assert.Equal(t, IsGitRepoUrl("oci://host.xz/path/to/repo.git/"), false)
   203  	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project"), true)
   204  	assert.Equal(t, IsGitRepoUrl("git@github.com:user/project.git"), true)
   205  	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project.git"), true)
   206  	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project.git"), true)
   207  	assert.Equal(t, IsGitRepoUrl("git@192.168.101.127:user/project.git"), true)
   208  	assert.Equal(t, IsGitRepoUrl("https://192.168.101.127/user/project.git"), true)
   209  	assert.Equal(t, IsGitRepoUrl("http://192.168.101.127/user/project.git"), true)
   210  	assert.Equal(t, IsGitRepoUrl("ssh://user@host.xz:port/path/to/repo.git/"), true)
   211  	assert.Equal(t, IsGitRepoUrl("ssh://user@host.xz/path/to/repo.git/"), true)
   212  	assert.Equal(t, IsGitRepoUrl("ssh://host.xz:port/path/to/repo.git/"), true)
   213  	assert.Equal(t, IsGitRepoUrl("ssh://host.xz/path/to/repo.git/"), true)
   214  	assert.Equal(t, IsGitRepoUrl("ssh://user@host.xz/path/to/repo.git/"), true)
   215  	assert.Equal(t, IsGitRepoUrl("ssh://user@host.xz/~user/path/to/repo.git/"), true)
   216  	assert.Equal(t, IsGitRepoUrl("ssh://host.xz/~user/path/to/repo.git/"), true)
   217  	assert.Equal(t, IsGitRepoUrl("ssh://user@host.xz/~/path/to/repo.git"), true)
   218  	assert.Equal(t, IsGitRepoUrl("git://host.xz/path/to/repo.git/"), true)
   219  	assert.Equal(t, IsGitRepoUrl("http://host.xz/path/to/repo.git/"), true)
   220  	assert.Equal(t, IsGitRepoUrl("https://host.xz/path/to/repo.git/"), true)
   221  }
   222  
   223  func TestIsRef(t *testing.T) {
   224  	assert.Equal(t, IsRef("invalid ref"), false)
   225  	assert.Equal(t, IsRef("ghcr.io/xxx/xxx"), true)
   226  	assert.Equal(t, IsRef("ghcr.io/xxx"), true)
   227  	assert.Equal(t, IsRef("ghcr.io/xxx:0.0.1"), true)
   228  	assert.Equal(t, IsRef("ghcr.io/"), false)
   229  }
   230  
   231  func TestIsTar(t *testing.T) {
   232  	assert.Equal(t, IsTar("invalid tar"), false)
   233  	assert.Equal(t, IsTar("xxx.tar"), true)
   234  }
   235  
   236  func TestIsKfile(t *testing.T) {
   237  	assert.Equal(t, IsKfile("invalid kfile"), false)
   238  	assert.Equal(t, IsKfile("xxx.k"), true)
   239  }
   240  
   241  func TestAbsTarPath(t *testing.T) {
   242  	pkgPath := getTestDir("test_check_tar_path")
   243  	expectAbsTarPath, _ := filepath.Abs(filepath.Join(pkgPath, "test.tar"))
   244  
   245  	abs, err := AbsTarPath(filepath.Join(pkgPath, "test.tar"))
   246  	assert.Equal(t, err, nil)
   247  	assert.Equal(t, abs, expectAbsTarPath)
   248  
   249  	abs, err = AbsTarPath(filepath.Join(pkgPath, "no_exist.tar"))
   250  	assert.NotEqual(t, err, nil)
   251  	assert.Equal(t, abs, "")
   252  
   253  	abs, err = AbsTarPath(filepath.Join(pkgPath, "invalid_tar"))
   254  	assert.NotEqual(t, err, nil)
   255  	assert.Equal(t, abs, "")
   256  }
   257  
   258  func TestIsSymlinkExist(t *testing.T) {
   259  	testPath := filepath.Join(getTestDir("test_link"), "is_link_exist")
   260  
   261  	link_target_not_exist := filepath.Join(testPath, "link_target_not_exist")
   262  
   263  	linkExist, targetExist, err := IsSymlinkValidAndExists(link_target_not_exist)
   264  	assert.Equal(t, err, nil)
   265  	assert.Equal(t, linkExist, true)
   266  	assert.Equal(t, targetExist, false)
   267  
   268  	linkExist, targetExist, err = IsSymlinkValidAndExists("invalid_link")
   269  	assert.Equal(t, err, nil)
   270  	assert.Equal(t, linkExist, false)
   271  	assert.Equal(t, targetExist, false)
   272  
   273  	filename := filepath.Join(testPath, "test.txt")
   274  	validLink := filepath.Join(testPath, "valid_link")
   275  	err = CreateSymlink(filename, validLink)
   276  	assert.Equal(t, err, nil)
   277  
   278  	linkExist, targetExist, err = IsSymlinkValidAndExists(validLink)
   279  	assert.Equal(t, err, nil)
   280  	assert.Equal(t, linkExist, true)
   281  	assert.Equal(t, targetExist, true)
   282  
   283  	anotherValidLink := filepath.Join(testPath, "another_valid_link")
   284  	err = CreateSymlink(filename, anotherValidLink)
   285  	assert.Equal(t, err, nil)
   286  
   287  	linkExist, targetExist, err = IsSymlinkValidAndExists(anotherValidLink)
   288  	assert.Equal(t, err, nil)
   289  	assert.Equal(t, linkExist, true)
   290  	assert.Equal(t, targetExist, true)
   291  	// Defer the removal of the symlink
   292  	defer func() {
   293  		err := os.Remove(anotherValidLink)
   294  		assert.Equal(t, err, nil)
   295  		err = os.Remove(validLink)
   296  		assert.Equal(t, err, nil)
   297  	}()
   298  }