987 lines
23 KiB
Go
987 lines
23 KiB
Go
package main
|
|
|
|
import (
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"os/user"
|
|
"path/filepath"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/appleboy/easyssh-proxy"
|
|
"github.com/stretchr/testify/assert"
|
|
"golang.org/x/crypto/ssh"
|
|
)
|
|
|
|
func TestMissingAllConfig(t *testing.T) {
|
|
var plugin Plugin
|
|
|
|
err := plugin.Exec()
|
|
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestMissingSSHConfig(t *testing.T) {
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"example.com"},
|
|
Username: "ubuntu",
|
|
},
|
|
}
|
|
|
|
err := plugin.Exec()
|
|
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestMissingSourceConfig(t *testing.T) {
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"example.com"},
|
|
Username: "ubuntu",
|
|
Port: 443,
|
|
Password: "1234",
|
|
},
|
|
}
|
|
|
|
err := plugin.Exec()
|
|
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestTrimElement(t *testing.T) {
|
|
var input, result []string
|
|
|
|
input = []string{"1", " ", "3"}
|
|
result = []string{"1", "3"}
|
|
|
|
assert.Equal(t, result, trimValues(input))
|
|
|
|
input = []string{"1", "2"}
|
|
result = []string{"1", "2"}
|
|
|
|
assert.Equal(t, result, trimValues(input))
|
|
}
|
|
|
|
func TestSCPFileFromPublicKey(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{filepath.Join(u.HomeDir, "/test")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test/tests/a.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test/tests/b.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
// Test -rm flag
|
|
plugin.Config.Source = []string{"tests/a.txt"}
|
|
plugin.Config.Remove = true
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test/tests/b.txt")); os.IsExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSCPFileFromPublicKeyWithPassphrase(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/test",
|
|
Passphrase: "1234",
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{filepath.Join(u.HomeDir, "/test2")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test2/tests/a.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test2/tests/b.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestWrongFingerprint(t *testing.T) {
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "./tests/.ssh/id_rsa",
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{filepath.Join(u.HomeDir, "/test2")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
Fingerprint: "wrong",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
log.Println(err)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func getHostPublicKeyFile(keypath string) (ssh.PublicKey, error) {
|
|
var pubkey ssh.PublicKey
|
|
var err error
|
|
buf, err := os.ReadFile(keypath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
pubkey, _, _, _, err = ssh.ParseAuthorizedKey(buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return pubkey, nil
|
|
}
|
|
|
|
func TestSCPFileFromPublicKeyWithFingerprint(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
hostKey, err := getHostPublicKeyFile("/etc/ssh/ssh_host_rsa_key.pub")
|
|
assert.NoError(t, err)
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "./tests/.ssh/id_rsa",
|
|
Fingerprint: ssh.FingerprintSHA256(hostKey),
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{filepath.Join(u.HomeDir, "/test2")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test2/tests/a.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "/test2/tests/b.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSCPWildcardFileList(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
Target: []string{filepath.Join(u.HomeDir, "abc")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "abc/tests/global/c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "abc/tests/global/d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSCPFromProxySetting(t *testing.T) {
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
Target: []string{filepath.Join(u.HomeDir, "def")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
Proxy: easyssh.DefaultConfig{
|
|
Server: "localhost",
|
|
User: "drone-scp",
|
|
Port: "22",
|
|
KeyPath: "./tests/.ssh/id_rsa",
|
|
},
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "def/tests/global/c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "def/tests/global/d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestStripComponentsFlag(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
StripComponents: 2,
|
|
Target: []string{filepath.Join(u.HomeDir, "123")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123/c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123/d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUseInsecureCipherFlag(t *testing.T) {
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
StripComponents: 2,
|
|
Target: []string{filepath.Join(u.HomeDir, "123")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
UseInsecureCipher: true,
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123/c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123/d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestIgnoreList(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*", "!tests/global/c.txt", "!tests/global/e.txt"},
|
|
StripComponents: 2,
|
|
Target: []string{filepath.Join(u.HomeDir, "ignore")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
Debug: true,
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "ignore/c.txt")); !os.IsNotExist(err) {
|
|
t.Fatal("c.txt file exist")
|
|
}
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "ignore/e.txt")); !os.IsNotExist(err) {
|
|
t.Fatal("c.txt file exist")
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "ignore/d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
// func TestSCPFileFromSSHAgent(t *testing.T) {
|
|
// if os.Getenv("SSH_AUTH_SOCK") == "" {
|
|
// exec.Command("eval", "`ssh-agent -s`").Run()
|
|
// exec.Command("ssh-add", "tests/.ssh/id_rsa").Run()
|
|
// }
|
|
|
|
// u, err := user.Lookup("drone-scp")
|
|
// if err != nil {
|
|
// t.Fatalf("Lookup: %v", err)
|
|
// }
|
|
|
|
// plugin := Plugin{
|
|
// Config: Config{
|
|
// Host: []string{"localhost"},
|
|
// Username: "drone-scp",
|
|
// Port: "22",
|
|
// Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
// Target: []string{u.HomeDir + "/test"},
|
|
// },
|
|
// }
|
|
|
|
// err = plugin.Exec()
|
|
// assert.Nil(t, err)
|
|
// }
|
|
|
|
// func TestSCPFileFromPassword(t *testing.T) {
|
|
// u, err := user.Lookup("drone-scp")
|
|
// if err != nil {
|
|
// t.Fatalf("Lookup: %v", err)
|
|
// }
|
|
|
|
// plugin := Plugin{
|
|
// Config: Config{
|
|
// Host: []string{"localhost"},
|
|
// Username: "drone-scp",
|
|
// Port: "22",
|
|
// Password: "1234",
|
|
// Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
// Target: []string{u.HomeDir + "/test"},
|
|
// },
|
|
// }
|
|
|
|
// err = plugin.Exec()
|
|
// assert.Nil(t, err)
|
|
// }
|
|
|
|
func TestIncorrectPassword(t *testing.T) {
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
Password: "123456",
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{"/home"},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err := plugin.Exec()
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestNoPermissionCreateFolder(t *testing.T) {
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/a.txt", "tests/b.txt"},
|
|
Target: []string{"/etc/test"},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.NotNil(t, err)
|
|
|
|
// check tmp file exist
|
|
if _, err = os.Stat(filepath.Join(u.HomeDir, plugin.DestFile)); os.IsExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGlobList(t *testing.T) {
|
|
// wrong patern
|
|
paterns := []string{"[]a]", "tests/?.txt"}
|
|
expects := []string{"tests/a.txt", "tests/b.txt"}
|
|
assert.Equal(t, expects, globList(paterns).Source)
|
|
|
|
paterns = []string{"tests/*.txt", "tests/.ssh/*", "abc*"}
|
|
expects = []string{"tests/a.txt", "tests/b.txt", "tests/.ssh/id_rsa", "tests/.ssh/id_rsa.pub", "tests/.ssh/test", "tests/.ssh/test.pub"}
|
|
assert.Equal(t, expects, globList(paterns).Source)
|
|
|
|
paterns = []string{"tests/?.txt"}
|
|
expects = []string{"tests/a.txt", "tests/b.txt"}
|
|
assert.Equal(t, expects, globList(paterns).Source)
|
|
|
|
// remove item which file not found.
|
|
paterns = []string{"tests/aa.txt", "tests/b.txt"}
|
|
expects = []string{"tests/b.txt"}
|
|
assert.Equal(t, expects, globList(paterns).Source)
|
|
|
|
paterns = []string{"./tests/b.txt"}
|
|
expects = []string{"./tests/b.txt"}
|
|
assert.Equal(t, expects, globList(paterns).Source)
|
|
|
|
paterns = []string{"./tests/*.txt", "!./tests/b.txt"}
|
|
expectSources := []string{"tests/a.txt", "tests/b.txt"}
|
|
expectIgnores := []string{"./tests/b.txt"}
|
|
result := globList(paterns)
|
|
assert.Equal(t, expectSources, result.Source)
|
|
assert.Equal(t, expectIgnores, result.Ignore)
|
|
}
|
|
|
|
func TestRemoveDestFile(t *testing.T) {
|
|
ssh := &easyssh.MakeConfig{
|
|
Server: "localhost",
|
|
User: "drone-scp",
|
|
Port: "22",
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
// io timeout
|
|
Timeout: 1,
|
|
}
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
CommandTimeout: 60 * time.Second,
|
|
},
|
|
DestFile: "/etc/resolv.conf",
|
|
}
|
|
|
|
_, _, _, err := ssh.Run("ver", plugin.Config.CommandTimeout)
|
|
systemType := "unix"
|
|
if err == nil {
|
|
systemType = "windows"
|
|
}
|
|
|
|
// ssh io timeout
|
|
err = plugin.removeDestFile(systemType, ssh)
|
|
assert.Error(t, err)
|
|
|
|
ssh.Timeout = 0
|
|
|
|
// permission denied
|
|
err = plugin.removeDestFile(systemType, ssh)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestPlugin_buildUnTarArgs(t *testing.T) {
|
|
type fields struct {
|
|
Config Config
|
|
DestFile string
|
|
}
|
|
type args struct {
|
|
target string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
want []string
|
|
}{
|
|
{
|
|
name: "default command",
|
|
fields: fields{
|
|
Config: Config{
|
|
Overwrite: false,
|
|
UnlinkFirst: false,
|
|
TarExec: "tar",
|
|
},
|
|
DestFile: "foo.tar.gz",
|
|
},
|
|
args: args{
|
|
target: "foo",
|
|
},
|
|
want: []string{"tar", "-zxf", "foo.tar.gz", "-C", "foo"},
|
|
},
|
|
{
|
|
name: "strip components",
|
|
fields: fields{
|
|
Config: Config{
|
|
Overwrite: false,
|
|
UnlinkFirst: false,
|
|
TarExec: "tar",
|
|
StripComponents: 2,
|
|
},
|
|
DestFile: "foo.tar.gz",
|
|
},
|
|
args: args{
|
|
target: "foo",
|
|
},
|
|
want: []string{"tar", "-zxf", "foo.tar.gz", "--strip-components", "2", "-C", "foo"},
|
|
},
|
|
{
|
|
name: "overwrite",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
StripComponents: 2,
|
|
Overwrite: true,
|
|
UnlinkFirst: false,
|
|
},
|
|
DestFile: "foo.tar.gz",
|
|
},
|
|
args: args{
|
|
target: "foo",
|
|
},
|
|
want: []string{"tar", "-zxf", "foo.tar.gz", "--strip-components", "2", "--overwrite", "-C", "foo"},
|
|
},
|
|
{
|
|
name: "unlink first",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
StripComponents: 2,
|
|
Overwrite: true,
|
|
UnlinkFirst: true,
|
|
},
|
|
DestFile: "foo.tar.gz",
|
|
},
|
|
args: args{
|
|
target: "foo",
|
|
},
|
|
want: []string{"tar", "-zxf", "foo.tar.gz", "--strip-components", "2", "--overwrite", "--unlink-first", "-C", "foo"},
|
|
},
|
|
{
|
|
name: "output folder path with space",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
StripComponents: 2,
|
|
Overwrite: true,
|
|
UnlinkFirst: true,
|
|
},
|
|
DestFile: "foo.tar.gz",
|
|
},
|
|
args: args{
|
|
target: "foo\\ bar",
|
|
},
|
|
want: []string{"tar", "-zxf", "foo.tar.gz", "--strip-components", "2", "--overwrite", "--unlink-first", "-C", "foo\\ bar"},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
p := &Plugin{
|
|
Config: tt.fields.Config,
|
|
DestFile: tt.fields.DestFile,
|
|
}
|
|
if got := p.buildUnTarArgs(tt.args.target); !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("Plugin.buildArgs() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPlugin_buildTarArgs(t *testing.T) {
|
|
type fields struct {
|
|
Config Config
|
|
}
|
|
type args struct {
|
|
src string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
want []string
|
|
}{
|
|
{
|
|
name: "default command",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
},
|
|
},
|
|
args: args{
|
|
src: "foo.tar.gz",
|
|
},
|
|
want: []string{"-zcf", "foo.tar.gz"},
|
|
},
|
|
{
|
|
name: "ignore list",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
Source: []string{
|
|
"tests/*.txt",
|
|
"!tests/a.txt",
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
src: "foo.tar.gz",
|
|
},
|
|
want: []string{"--exclude", "tests/a.txt", "-zcf", "foo.tar.gz", "tests/a.txt", "tests/b.txt"},
|
|
},
|
|
{
|
|
name: "dereference flag",
|
|
fields: fields{
|
|
Config: Config{
|
|
TarExec: "tar",
|
|
TarDereference: true,
|
|
Source: []string{
|
|
"tests/*.txt",
|
|
"!tests/a.txt",
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
src: "foo.tar.gz",
|
|
},
|
|
want: []string{"--exclude", "tests/a.txt", "--dereference", "-zcf", "foo.tar.gz", "tests/a.txt", "tests/b.txt"},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
p := &Plugin{
|
|
Config: tt.fields.Config,
|
|
}
|
|
if got := p.buildTarArgs(tt.args.src); !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("Plugin.buildTarArgs() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTargetFolderWithSpaces(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
StripComponents: 2,
|
|
Target: []string{filepath.Join(u.HomeDir, "123 456 789")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123 456 789", "c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "123 456 789", "d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHostPortString(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost:22", "localhost:22"},
|
|
Username: "drone-scp",
|
|
Protocol: easyssh.PROTOCOL_TCP4,
|
|
Port: 8080,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/global/*"},
|
|
StripComponents: 2,
|
|
Target: []string{filepath.Join(u.HomeDir, "1234")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "1234", "c.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "1234", "d.txt")); os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|
|
|
|
// Unit test for hostPort
|
|
func TestHostPort(t *testing.T) {
|
|
p := Plugin{
|
|
Config: Config{
|
|
Port: 8080,
|
|
Protocol: easyssh.PROTOCOL_TCP4,
|
|
},
|
|
}
|
|
|
|
// Test case 1: host string with port
|
|
host1 := "example.com:1234"
|
|
expectedHost1 := "example.com"
|
|
expectedPort1 := "1234"
|
|
actualHost1, actualPort1 := p.hostPort(host1)
|
|
if actualHost1 != expectedHost1 || actualPort1 != expectedPort1 {
|
|
t.Errorf("hostPort(%s) = (%s, %s); expected (%s, %s)", host1, actualHost1, actualPort1, expectedHost1, expectedPort1)
|
|
}
|
|
|
|
// Test case 2: host string without port
|
|
host2 := "example.com"
|
|
expectedHost2 := "example.com"
|
|
expectedPort2 := "8080" // default port
|
|
actualHost2, actualPort2 := p.hostPort(host2)
|
|
if actualHost2 != expectedHost2 || actualPort2 != expectedPort2 {
|
|
t.Errorf("hostPort(%s) = (%s, %s); expected (%s, %s)", host2, actualHost2, actualPort2, expectedHost2, expectedPort2)
|
|
}
|
|
}
|
|
|
|
func TestPlugin_hostPort(t *testing.T) {
|
|
type fields struct {
|
|
Config Config
|
|
Writer io.Writer
|
|
}
|
|
type args struct {
|
|
h string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
wantHost string
|
|
wantPort string
|
|
}{
|
|
{
|
|
name: "default host and port",
|
|
fields: fields{
|
|
Config: Config{
|
|
Port: 22,
|
|
},
|
|
},
|
|
args: args{
|
|
h: "localhost",
|
|
},
|
|
wantHost: "localhost",
|
|
wantPort: "22",
|
|
},
|
|
{
|
|
name: "different port",
|
|
fields: fields{
|
|
Config: Config{
|
|
Port: 22,
|
|
Protocol: easyssh.PROTOCOL_TCP4,
|
|
},
|
|
},
|
|
args: args{
|
|
h: "localhost:443",
|
|
},
|
|
wantHost: "localhost",
|
|
wantPort: "443",
|
|
},
|
|
{
|
|
name: "ipv6",
|
|
fields: fields{
|
|
Config: Config{
|
|
Port: 22,
|
|
Protocol: easyssh.PROTOCOL_TCP6,
|
|
},
|
|
},
|
|
args: args{
|
|
h: "::1",
|
|
},
|
|
wantHost: "::1",
|
|
wantPort: "22",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
p := Plugin{
|
|
Config: tt.fields.Config,
|
|
}
|
|
gotHost, gotPort := p.hostPort(tt.args.h)
|
|
if gotHost != tt.wantHost {
|
|
t.Errorf("Plugin.hostPort() gotHost = %v, want %v", gotHost, tt.wantHost)
|
|
}
|
|
if gotPort != tt.wantPort {
|
|
t.Errorf("Plugin.hostPort() gotPort = %v, want %v", gotPort, tt.wantPort)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIgnoreFolder(t *testing.T) {
|
|
if os.Getenv("SSH_AUTH_SOCK") != "" {
|
|
if err := exec.Command("eval", "`ssh-agent -k`").Run(); err != nil {
|
|
t.Fatalf("exec: %v", err)
|
|
}
|
|
}
|
|
|
|
u, err := user.Lookup("drone-scp")
|
|
if err != nil {
|
|
t.Fatalf("Lookup: %v", err)
|
|
}
|
|
|
|
plugin := Plugin{
|
|
Config: Config{
|
|
Host: []string{"localhost"},
|
|
Username: "drone-scp",
|
|
Protocol: easyssh.PROTOCOL_TCP4,
|
|
Port: 22,
|
|
KeyPath: "tests/.ssh/id_rsa",
|
|
Source: []string{"tests/*", "!tests/global"},
|
|
Target: []string{filepath.Join(u.HomeDir, "test_ignore")},
|
|
CommandTimeout: 60 * time.Second,
|
|
TarExec: "tar",
|
|
},
|
|
}
|
|
|
|
err = plugin.Exec()
|
|
assert.Nil(t, err)
|
|
|
|
// check file exist
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "test_ignore", "global", "c.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(u.HomeDir, "test_ignore", "global", "d.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("SCP-error: %v", err)
|
|
}
|
|
}
|