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 }