github.com/jfrog/jfrog-cli-core/v2@v2.51.0/artifactory/commands/transferinstall/datatransferinstall_test.go (about)

     1  package transferinstall
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/jfrog/gofrog/version"
     6  	commonTests "github.com/jfrog/jfrog-cli-core/v2/common/tests"
     7  	"github.com/jfrog/jfrog-cli-core/v2/utils/tests"
     8  	"github.com/jfrog/jfrog-client-go/utils/io/fileutils"
     9  	testsutils "github.com/jfrog/jfrog-client-go/utils/tests"
    10  	"github.com/stretchr/testify/assert"
    11  	"net/http"
    12  	"net/url"
    13  	"os"
    14  	"path"
    15  	"path/filepath"
    16  	"reflect"
    17  	"runtime"
    18  	"strings"
    19  	"testing"
    20  )
    21  
    22  func TestPluginFileItemNameAndDirs(t *testing.T) {
    23  	cases := []struct {
    24  		expectedDirs FileItem
    25  		expectedName string
    26  		file         FileItem
    27  	}{
    28  		{FileItem{"dir", "dir2"}, "name.txt", FileItem{"dir", "dir2", "name.txt"}},
    29  		{FileItem{}, "name.txt", FileItem{"name.txt"}},
    30  		{FileItem{}, "", FileItem{}},
    31  		{FileItem{}, "", FileItem{""}},
    32  		{FileItem{}, "", FileItem{"", "", ""}},
    33  		{FileItem{"dir"}, "", FileItem{"", "dir", ""}},
    34  		{FileItem{"dir"}, "name", FileItem{"dir", "", "name"}},
    35  	}
    36  
    37  	for _, testCase := range cases {
    38  		testFileItemNameDirs(t, testCase.expectedDirs, testCase.expectedName, testCase.file)
    39  	}
    40  }
    41  
    42  func testFileItemNameDirs(t *testing.T, expectedDirs FileItem, expectedName string, file FileItem) {
    43  	assert.Equal(t, expectedName, file.Name())
    44  	assert.Equal(t, &expectedDirs, file.Dirs())
    45  	fileName, fileDirs := file.SplitNameAndDirs()
    46  	assert.Equal(t, expectedName, fileName)
    47  	assert.Equal(t, &expectedDirs, fileDirs)
    48  	assert.Len(t, *fileDirs, len(expectedDirs))
    49  	for i, DirName := range *fileDirs {
    50  		assert.Equal(t, expectedDirs[i], DirName)
    51  	}
    52  }
    53  
    54  func TestPluginFileItemToUrlAndToPath(t *testing.T) {
    55  	cases := []struct {
    56  		expectedUrl  string
    57  		expectedPath string
    58  		file         FileItem
    59  	}{
    60  		{"dir/dir2/name.txt", filepath.Join("dir", "dir2", "name.txt"), FileItem{"dir", "dir2", "name.txt"}},
    61  		{"name.txt", "name.txt", FileItem{"name.txt"}},
    62  		{"", "", FileItem{}},
    63  		{"", "", FileItem{""}},
    64  		{"", "", FileItem{"", ""}},
    65  		{"dir", filepath.Join("dir", ""), FileItem{"", "dir", ""}},
    66  		{"dir/name", filepath.Join("dir", "name"), FileItem{"dir", "", "name"}},
    67  	}
    68  
    69  	for _, testCase := range cases {
    70  		testFileItemToUrlAndToPath(t, testCase.expectedUrl, testCase.expectedPath, testCase.file)
    71  	}
    72  }
    73  
    74  func testFileItemToUrlAndToPath(t *testing.T, expectedUrl string, expectedPath string, file FileItem) {
    75  	fUrl, err := file.toURL("")
    76  	assert.NoError(t, err)
    77  	assert.Equal(t, expectedUrl, fUrl)
    78  	assert.Equal(t, expectedPath, file.toPath(""))
    79  	prefix := "prefix"
    80  	assert.Equal(t, filepath.Join(prefix, expectedPath), file.toPath(prefix))
    81  	expectedPrefixUrl := prefix
    82  	if expectedUrl != "" {
    83  		expectedPrefixUrl += "/"
    84  	}
    85  	fUrl, err = file.toURL(prefix)
    86  	assert.NoError(t, err)
    87  	assert.Equal(t, expectedPrefixUrl+expectedUrl, fUrl)
    88  }
    89  
    90  func populateDirWith(rootDir string, dirs ...FileItem) (err error) {
    91  	for _, dir := range dirs {
    92  		if err = fileutils.CreateDirIfNotExist(dir.toPath(rootDir)); err != nil {
    93  			return
    94  		}
    95  	}
    96  	return
    97  }
    98  
    99  func TestSearchDestinationPath(t *testing.T) {
   100  	testDir := FileItem{artifactory, "test_plugin_install_dir", "test"}
   101  	confuse := FileItem{artifactory, "test_plugin_install_dir", "test2"}
   102  	manager := &PluginInstallManager{}
   103  	temp, clean := tests.CreateTempDirWithCallbackAndAssert(t)
   104  	defer clean()
   105  	assert.NoError(t, populateDirWith(temp, confuse))
   106  	// No destinations
   107  	exists, target, err := manager.findDestination(temp)
   108  	assert.NoError(t, err)
   109  	assert.False(t, exists, fmt.Sprintf("The match is %s", target))
   110  	// Destination not exists
   111  	manager.addDestination(testDir[1:])
   112  	exists, target, err = manager.findDestination(temp)
   113  	assert.NoError(t, err)
   114  	assert.False(t, exists, fmt.Sprintf("The match is %s", target))
   115  	// Destination exists
   116  	assert.NoError(t, populateDirWith(temp, testDir))
   117  	exists, dst, err := manager.findDestination(temp)
   118  	assert.NoError(t, err)
   119  	assert.True(t, exists)
   120  	assert.Equal(t, testDir.toPath(temp), dst.toPath())
   121  }
   122  
   123  func TestGetPluginDirDestination(t *testing.T) {
   124  	// Init mock and test env
   125  	testEnvDir := "testEnv"
   126  	testCustomDir := "testCustom"
   127  	targetDir := "plugins_test_target"
   128  	testHomePath, clean := tests.CreateTempDirWithCallbackAndAssert(t)
   129  	defer clean()
   130  	if oldVal, exists := os.LookupEnv(jfrogHomeEnvVar); exists {
   131  		testsutils.UnSetEnvAndAssert(t, jfrogHomeEnvVar)
   132  		defer testsutils.SetEnvAndAssert(t, jfrogHomeEnvVar, oldVal)
   133  	}
   134  	assert.NoError(t, populateDirWith(testHomePath, FileItem{testEnvDir, artifactory + "-confuse", targetDir}, FileItem{testCustomDir, "confuse-" + artifactory, targetDir}))
   135  	manager := NewArtifactoryPluginInstallManager(nil)
   136  	manager.addDestination(FileItem{targetDir})
   137  	cmd := &InstallDataTransferPluginCommand{transferManger: manager}
   138  	defaultExists, err := fileutils.IsDirExists(defaultSearchPath, false)
   139  	assert.NoError(t, err)
   140  
   141  	// Make sure contains artifactory structures as destinations
   142  	assert.Contains(t, manager.destinations, originalDirPath)
   143  	assert.Contains(t, manager.destinations, v7DirPath)
   144  
   145  	// Default
   146  	dst, err := cmd.getPluginDirDestination()
   147  	if defaultExists {
   148  		assert.NoError(t, err)
   149  		assert.True(t, dst.toPath() == originalDirPath.toPath(defaultSearchPath) || (dst.toPath() == v7DirPath.toPath(defaultSearchPath)))
   150  	} else {
   151  		assert.Errorf(t, err, notValidDestinationErr.Error())
   152  	}
   153  
   154  	// Env var override
   155  	testsutils.SetEnvAndAssert(t, jfrogHomeEnvVar, filepath.Join(testHomePath, testEnvDir))
   156  	dst, err = cmd.getPluginDirDestination()
   157  	assert.NoError(t, err)
   158  	assert.Equal(t, filepath.Join(testHomePath, testEnvDir, artifactory+"-confuse", targetDir), dst.toPath())
   159  
   160  	// Flag override
   161  	cmd.SetJFrogHomePath(filepath.Join(testHomePath, testCustomDir))
   162  	dst, err = cmd.getPluginDirDestination()
   163  	assert.NoError(t, err)
   164  	assert.Equal(t, filepath.Join(testHomePath, testCustomDir, "confuse-"+artifactory, targetDir), dst.toPath())
   165  	cmd.SetJFrogHomePath("not_existing_dir")
   166  	_, err = cmd.getPluginDirDestination()
   167  	assert.Errorf(t, err, notValidDestinationErr.Error())
   168  }
   169  
   170  func TestGetTransferSourceAndAction(t *testing.T) {
   171  	// baseUrl := "baseurl"
   172  	v1 := "1.0.0"
   173  	cmd := &InstallDataTransferPluginCommand{}
   174  
   175  	// Latest
   176  	src, action, err := cmd.getTransferSourceAndAction()
   177  	assert.NoError(t, err)
   178  	vUrl, err := url.Parse(dataTransferUrl)
   179  	assert.NoError(t, err)
   180  	vUrl.Path = path.Join(vUrl.Path, latest)
   181  	assert.Equal(t, vUrl.String(), src)
   182  	assert.Contains(t, runtime.FuncForPC(reflect.ValueOf(action).Pointer()).Name(), "transferinstall.DownloadFiles")
   183  
   184  	// Specific version
   185  	cmd.SetInstallVersion(version.NewVersion(v1))
   186  	src, action, err = cmd.getTransferSourceAndAction()
   187  	assert.NoError(t, err)
   188  	vUrl, err = url.Parse(dataTransferUrl)
   189  	assert.NoError(t, err)
   190  	vUrl.Path = path.Join(vUrl.Path, v1)
   191  	assert.Equal(t, vUrl.String(), src)
   192  	assert.True(t, strings.Contains(runtime.FuncForPC(reflect.ValueOf(action).Pointer()).Name(), "transferinstall.DownloadFiles"))
   193  
   194  	// Local file system
   195  	cmd.SetLocalPluginFiles(dataTransferUrl)
   196  	src, action, err = cmd.getTransferSourceAndAction()
   197  	assert.NoError(t, err)
   198  	assert.Equal(t, dataTransferUrl, src)
   199  	assert.True(t, strings.Contains(runtime.FuncForPC(reflect.ValueOf(action).Pointer()).Name(), "transferinstall.CopyFiles"))
   200  }
   201  
   202  func TestInstallCopy(t *testing.T) {
   203  	fileBundle := PluginFiles{
   204  		FileItem{"file"},
   205  		FileItem{"dir", "file1"},
   206  		FileItem{"dir1", "dir2", "file2"},
   207  	}
   208  	srcPath, cleanUpSrc := tests.CreateTempDirWithCallbackAndAssert(t)
   209  	defer cleanUpSrc()
   210  	tempDst, cleanTempDst := tests.CreateTempDirWithCallbackAndAssert(t)
   211  	defer cleanTempDst()
   212  	dstPath, cleanUpDst := tests.CreateTempDirWithCallbackAndAssert(t)
   213  	defer cleanUpDst()
   214  
   215  	// Empty
   216  	assert.NoError(t, CopyFiles(srcPath, tempDst, PluginFiles{}))
   217  	// No src files in dir
   218  	assert.Error(t, CopyFiles(srcPath, tempDst, fileBundle))
   219  	// Generate empty files in dir (and another to confuse)
   220  	for _, file := range fileBundle {
   221  		assert.NoError(t, os.WriteFile(filepath.Join(srcPath, file.Name()), nil, 0644))
   222  		assert.NoError(t, os.WriteFile(filepath.Join(srcPath, "not_"+file.Name()), nil, 0644))
   223  	}
   224  	// First time in plugin dir (i.e. need to create folders)
   225  	assert.NoError(t, CopyFiles(srcPath, dstPath, fileBundle))
   226  	for _, file := range fileBundle {
   227  		assert.FileExists(t, file.toPath(dstPath))
   228  	}
   229  	// Dir already has plugin (i.e. need to override items, no error)
   230  	assert.NoError(t, CopyFiles(srcPath, dstPath, fileBundle))
   231  }
   232  
   233  func TestDownloadTransferInstall(t *testing.T) {
   234  	testDstPath, clean := tests.CreateTempDirWithCallbackAndAssert(t)
   235  	defer clean()
   236  	// Download latest and make sure exists at the end
   237  	assert.NoError(t, DownloadFiles(dataTransferUrl+"/"+latest, testDstPath, transferPluginFiles))
   238  	for _, file := range transferPluginFiles {
   239  		assert.FileExists(t, file.toPath(testDstPath))
   240  	}
   241  }
   242  
   243  func TestReloadPlugins(t *testing.T) {
   244  	testServer, details, _ := commonTests.CreateRtRestsMockServer(t, func(w http.ResponseWriter, r *http.Request) {
   245  		if r.RequestURI == "/"+pluginReloadRestApi {
   246  			w.WriteHeader(http.StatusOK)
   247  			assert.Equal(t, http.MethodPost, r.Method)
   248  		} else {
   249  			w.WriteHeader(http.StatusBadRequest)
   250  		}
   251  	})
   252  	defer testServer.Close()
   253  	installCmd := NewInstallDataTransferCommand(details)
   254  	assert.NoError(t, installCmd.sendReloadRequest())
   255  }