func Test_GlobalFlagPRRun(t *testing.T) {
configPth := "global_flag_test_bitrise.yml"
secretsPth := "global_flag_test_secrets.yml"
t.Log("Should run in pr mode")
{
cmd := cmdex.NewCommand(binPath(), "--pr", "run", "primary", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("Should run in pr mode")
{
cmd := cmdex.NewCommand(binPath(), "--pr=true", "run", "primary", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("Should run in non pr mode")
{
cmd := cmdex.NewCommand(binPath(), "--pr=false", "run", "primary", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
func Test_RunExitCode(t *testing.T) {
configPth := "exit_code_test_bitrise.yml"
t.Log("exit_code_test_fail")
{
cmd := cmdex.NewCommand(binPath(), "run", "exit_code_test_fail", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
t.Log("exit_code_test_ok")
{
cmd := cmdex.NewCommand(binPath(), "run", "exit_code_test_ok", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("exit_code_test_sippable_fail")
{
cmd := cmdex.NewCommand(binPath(), "run", "exit_code_test_sippable_fail", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("exit_code_test_sippable_ok")
{
cmd := cmdex.NewCommand(binPath(), "run", "exit_code_test_sippable_ok", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
func Test_GlobalFlagPRTrigger(t *testing.T) {
configPth := "global_flag_test_bitrise.yml"
secretsPth := "global_flag_test_secrets.yml"
prModeEnv := os.Getenv(configs.PRModeEnvKey)
prIDEnv := os.Getenv(configs.PullRequestIDEnvKey)
// cleanup Envs after these tests
defer func() {
require.NoError(t, os.Setenv(configs.PRModeEnvKey, prModeEnv))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, prIDEnv))
}()
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
t.Log("global flag sets pr mode")
{
cmd := cmdex.NewCommand(binPath(), "--pr", "trigger", "deprecated_pr", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
t.Log("global flag sets pr mode")
{
cmd := cmdex.NewCommand(binPath(), "--pr=true", "trigger", "deprecated_pr", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
}
func Test_StepTemplate(t *testing.T) {
configPth := "bitrise.yml"
t.Log("step template test")
{
cmd := cmdex.NewCommand(binPath(), "run", "test", "--config", configPth)
cmd.SetDir("step_template")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("bash toolkit step template test")
{
cmd := cmdex.NewCommand(binPath(), "run", "test", "--config", configPth)
cmd.SetDir("bash_toolkit_step_template")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("go toolkit step template test")
{
cmd := cmdex.NewCommand(binPath(), "run", "test", "--config", configPth)
cmd.SetDir("go_toolkit_step_template")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
func Test_GlobalFlagPRTriggerCheck(t *testing.T) {
configPth := "global_flag_test_bitrise.yml"
secretsPth := "global_flag_test_secrets.yml"
prModeEnv := os.Getenv(configs.PRModeEnvKey)
prIDEnv := os.Getenv(configs.PullRequestIDEnvKey)
// cleanup Envs after these tests
defer func() {
require.NoError(t, os.Setenv(configs.PRModeEnvKey, prModeEnv))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, prIDEnv))
}()
t.Log("global flag sets pr mode")
{
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
cmd := cmdex.NewCommand(binPath(), "--pr", "trigger-check", "deprecated_pr", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
t.Log("global flag sets pr mode")
{
require.NoError(t, os.Setenv("PR", "false"))
require.NoError(t, os.Setenv("PULL_REQUEST_ID", ""))
cmd := cmdex.NewCommand(binPath(), "--pr=true", "trigger-check", "deprecated_pr", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
t.Log("global flag sets NOT pr mode")
{
require.NoError(t, os.Setenv("PR", "true"))
require.NoError(t, os.Setenv("PULL_REQUEST_ID", "ID"))
cmd := cmdex.NewCommand(binPath(), "--pr=true", "trigger-check", "master", "--config", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"master","workflow":"deprecated_pr"}`, out)
}
t.Log("global flag sets NOT pr mode")
{
require.NoError(t, os.Setenv("PR", "true"))
require.NoError(t, os.Setenv("PULL_REQUEST_ID", "ID"))
cmd := cmdex.NewCommand(binPath(), "--pr=false", "trigger-check", "master", "--config", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"master","workflow":"deprecated_code_push"}`, out)
}
}
func checkGoConfiguration(goConfig GoConfigurationModel) (bool, ToolkitCheckResult, error) {
cmdEnvs := os.Environ()
if len(goConfig.GOROOT) > 0 {
cmdEnvs = append(cmdEnvs, "GOROOT="+goConfig.GOROOT)
}
verOut, err := cmdex.NewCommand(goConfig.GoBinaryPath, "version").SetEnvs(cmdEnvs).RunAndReturnTrimmedOutput()
if err != nil {
return false, ToolkitCheckResult{}, fmt.Errorf("Failed to check go version, error: %s", err)
}
verStr, err := parseGoVersionFromGoVersionOutput(verOut)
if err != nil {
return false, ToolkitCheckResult{}, fmt.Errorf("Failed to parse go version, error: %s", err)
}
checkRes := ToolkitCheckResult{
Path: goConfig.GoBinaryPath,
Version: verStr,
}
// version check
isVersionOk, err := versions.IsVersionGreaterOrEqual(verStr, minGoVersionForToolkit)
if err != nil {
return false, checkRes, fmt.Errorf("Failed to validate installed go version, error: %s", err)
}
if !isVersionOk {
return true, checkRes, nil
}
return false, checkRes, nil
}
func jwtConfigFromP12KeyFile(pth, email string) (*jwt.Config, error) {
cmd := cmdex.NewCommand("openssl", "pkcs12", "-in", pth, "-passin", "pass:notasecret", "-nodes")
var outBuffer bytes.Buffer
outWriter := bufio.NewWriter(&outBuffer)
cmd.SetStdout(outWriter)
var errBuffer bytes.Buffer
errWriter := bufio.NewWriter(&errBuffer)
cmd.SetStderr(errWriter)
if err := cmd.Run(); err != nil {
if !errorutil.IsExitStatusError(err) {
return nil, err
}
return nil, errors.New(string(errBuffer.Bytes()))
}
return &jwt.Config{
Email: email,
PrivateKey: outBuffer.Bytes(),
TokenURL: google.JWTTokenURL,
Scopes: []string{androidpublisher.AndroidpublisherScope},
}, nil
}
func runLogCommand(cmdSlice []string, dir string) (string, error) {
out, err := cmdex.NewCommand(cmdSlice[0], cmdSlice[1:]...).SetDir(dir).RunAndReturnTrimmedCombinedOutput()
if err != nil {
return "", err
}
return strings.Trim(out, `"`), nil
}
func Test_ValidateTest(t *testing.T) {
tmpDir, err := pathutil.NormalizedOSTempDirPath("__validate_test__")
require.NoError(t, err)
defer func() {
require.NoError(t, os.RemoveAll(tmpDir))
}()
t.Log("valid bitrise.yml")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-c", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "Config is valid: \x1b[32;1mtrue\x1b[0m", out)
}
t.Log("valid - warning test - `-p` flag is deprecated")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-p", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "Config is valid: \x1b[32;1mtrue\x1b[0m\nWarning(s):\n- 'path' key is deprecated, use 'config' instead!", out)
}
t.Log("valid - invalid workflow id")
{
configPth := filepath.Join(tmpDir, "bitrise.yml")
require.NoError(t, fileutil.WriteStringToFile(configPth, invalidWorkflowIDBitriseYML))
cmd := cmdex.NewCommand(binPath(), "validate", "-c", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
expected := "Config is valid: \x1b[32;1mtrue\x1b[0m\nWarning(s):\n- invalid workflow ID (invalid:id): doesn't conform to: [A-Za-z0-9-_.]"
require.Equal(t, expected, out)
}
t.Log("invalid - empty bitrise.yml")
{
configPth := filepath.Join(tmpDir, "bitrise.yml")
require.NoError(t, fileutil.WriteStringToFile(configPth, emptyBitriseYML))
cmd := cmdex.NewCommand(binPath(), "validate", "-c", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := fmt.Sprintf("Config is valid: \x1b[31;1mfalse\x1b[0m\nError: \x1b[31;1mConfig (path:%s) is not valid: empty config\x1b[0m", configPth)
require.Equal(t, expected, out)
}
}
func Test_ValidateTestJSON(t *testing.T) {
tmpDir, err := pathutil.NormalizedOSTempDirPath("__validate_test__")
require.NoError(t, err)
defer func() {
require.NoError(t, os.RemoveAll(tmpDir))
}()
t.Log("valid bitrise.yml")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-c", "trigger_params_test_bitrise.yml", "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "{\"data\":{\"config\":{\"is_valid\":true}}}", out)
}
t.Log("valid - warning test - `-p` flag is deprecated")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-p", "trigger_params_test_bitrise.yml", "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "{\"data\":{\"config\":{\"is_valid\":true}},\"warnings\":[\"'path' key is deprecated, use 'config' instead!\"]}", out)
}
t.Log("valid - invalid workflow id")
{
configPth := filepath.Join(tmpDir, "bitrise.yml")
require.NoError(t, fileutil.WriteStringToFile(configPth, invalidWorkflowIDBitriseYML))
cmd := cmdex.NewCommand(binPath(), "validate", "-c", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
expected := "{\"data\":{\"config\":{\"is_valid\":true,\"warnings\":[\"invalid workflow ID (invalid:id): doesn't conform to: [A-Za-z0-9-_.]\"]}}}"
require.Equal(t, expected, out)
}
t.Log("invalid - empty bitrise.yml")
{
configPth := filepath.Join(tmpDir, "bitrise.yml")
require.NoError(t, fileutil.WriteStringToFile(configPth, emptyBitriseYML))
cmd := cmdex.NewCommand(binPath(), "validate", "-c", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := fmt.Sprintf("{\"data\":{\"config\":{\"is_valid\":false,\"error\":\"Config (path:%s) is not valid: empty config\"}}}", configPth)
require.Equal(t, expected, out)
}
}
func swiftVersion() (string, error) {
cmd := cmdex.NewCommand("swift", "-version")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return "", err
}
return out, nil
}
// XcodeBuildVersion ...
func XcodeBuildVersion() (XcodebuildVersionModel, error) {
cmd := cmdex.NewCommand("xcodebuild", "-version")
versionOut, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return XcodebuildVersionModel{}, err
}
return createXcodeVersionFromOutput(versionOut)
}
// GetOsVersionSimulatorInfosMap ...
func GetOsVersionSimulatorInfosMap() (OsVersionSimulatorInfosMap, error) {
cmd := cmdex.NewCommand("xcrun", "simctl", "list")
simctlListOut, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return OsVersionSimulatorInfosMap{}, err
}
return getOsVersionSimulatorInfosMapFromSimctlList(simctlListOut)
}
// XcprettyVersion ...
func XcprettyVersion() (*version.Version, error) {
cmd := cmdex.NewCommand("xcpretty", "--version")
versionOut, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return nil, err
}
return parseXcprettyVersionOut(versionOut)
}
func Test_InvalidTriggerCheck(t *testing.T) {
configPth := "trigger_check_test_empty_bitrise.yml"
secretsPth := "trigger_check_test_secrets.yml"
t.Log("Empty trigger pattern - PR mode : from secrets - is_pull_request_allowed : true")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "", "--config", configPth, "--inventory", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
t.Log("Empty triggered workflow id - PR mode : from secrets - is_pull_request_allowed : true")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "trigger_empty_workflow_id", "--config", configPth, "--inventory", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
}
}
func Test_TriggerCheck(t *testing.T) {
configPth := "trigger_check_test_bitrise.yml"
secretsPth := "trigger_check_test_secrets.yml"
t.Log("PR mode : from secrets - is_pull_request_allowed : true")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "pr_allowed", "--config", configPth, "--inventory", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"pr_allowed","workflow":"pr_allowed"}`, out, out)
}
t.Log("Not PR mode - is_pull_request_allowed : true")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "pr_allowed", "--config", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"pr_allowed","workflow":"pr_allowed"}`, out)
}
t.Log("Not PR mode - is_pull_request_allowed : false")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "only_code_push", "--config", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"only_code_push","workflow":"only_code_push"}`, out, out)
}
t.Log("PR mode : from secrets - is_pull_request_allowed : false")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "only_code_push", "--config", configPth, "--inventory", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"only_code_push","workflow":"fall_back"}`, out)
}
t.Log("Not PR mode - is_pull_request_allowed : false")
{
cmd := cmdex.NewCommand(binPath(), "trigger-check", "fall_back", "--config", configPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
require.Equal(t, `{"pattern":"fall_back","workflow":"fall_back"}`, out)
}
}
func Test_EnvstoreTest(t *testing.T) {
configPth := "envstore_test_bitrise.yml"
t.Log("exit_code_test_fail")
{
cmd := cmdex.NewCommand(binPath(), "run", "envstore_test", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
func zip(sourceDir, destinationZipPth string) error {
parentDir := filepath.Dir(sourceDir)
dirName := filepath.Base(sourceDir)
cmd := cmdex.NewCommand("/usr/bin/zip", "-rTy", destinationZipPth, dirName)
cmd.SetDir(parentDir)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return fmt.Errorf("Failed to zip dir: %s, output: %s, error: %s", sourceDir, out, err)
}
return nil
}
func Test_SecretValidateTest(t *testing.T) {
tmpDir, err := pathutil.NormalizedOSTempDirPath("__validate_test__")
require.NoError(t, err)
defer func() {
require.NoError(t, os.RemoveAll(tmpDir))
}()
t.Log("valid secret")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-i", "global_flag_test_secrets.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "Secret is valid: \x1b[32;1mtrue\x1b[0m", out)
}
t.Log("invalid - empty secret")
{
secretsPth := filepath.Join(tmpDir, "secrets.yml")
require.NoError(t, fileutil.WriteStringToFile(secretsPth, emptySecret))
cmd := cmdex.NewCommand(binPath(), "validate", "-i", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := "Secret is valid: \x1b[31;1mfalse\x1b[0m\nError: \x1b[31;1mempty config\x1b[0m"
require.Equal(t, expected, out)
}
t.Log("invalid - invalid secret model")
{
secretsPth := filepath.Join(tmpDir, "secrets.yml")
require.NoError(t, fileutil.WriteStringToFile(secretsPth, invalidSecret))
cmd := cmdex.NewCommand(binPath(), "validate", "-i", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := "Secret is valid: \x1b[31;1mfalse\x1b[0m\nError: \x1b[31;1mInvalid invetory format: yaml: unmarshal errors:\n line 1: cannot unmarshal !!seq into models.EnvsYMLModel\x1b[0m"
require.Equal(t, expected, out)
}
}
func Test_SecretValidateTestJSON(t *testing.T) {
tmpDir, err := pathutil.NormalizedOSTempDirPath("__validate_test__")
require.NoError(t, err)
defer func() {
require.NoError(t, os.RemoveAll(tmpDir))
}()
t.Log("valid secret")
{
cmd := cmdex.NewCommand(binPath(), "validate", "-i", "global_flag_test_secrets.yml", "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err)
require.Equal(t, "{\"data\":{\"secrets\":{\"is_valid\":true}}}", out)
}
t.Log("invalid - empty config")
{
secretsPth := filepath.Join(tmpDir, "secrets.yml")
require.NoError(t, fileutil.WriteStringToFile(secretsPth, emptySecret))
cmd := cmdex.NewCommand(binPath(), "validate", "-i", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := "{\"data\":{\"secrets\":{\"is_valid\":false,\"error\":\"empty config\"}}}"
require.Equal(t, expected, out)
}
t.Log("invalid - invalid secret model")
{
secretsPth := filepath.Join(tmpDir, "secrets.yml")
require.NoError(t, fileutil.WriteStringToFile(secretsPth, invalidSecret))
cmd := cmdex.NewCommand(binPath(), "validate", "-i", secretsPth, "--format", "json")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.Error(t, err, out)
expected := "{\"data\":{\"secrets\":{\"is_valid\":false,\"error\":\"Invalid invetory format: yaml: unmarshal errors:\\n line 1: cannot unmarshal !!seq into models.EnvsYMLModel\"}}}"
require.Equal(t, expected, out)
}
}
// EnvmanClear ...
func EnvmanClear(envstorePth string) error {
logLevel := log.GetLevel().String()
args := []string{"--loglevel", logLevel, "--path", envstorePth, "clear"}
out, err := cmdex.NewCommand("envman", args...).RunAndReturnTrimmedCombinedOutput()
if err != nil {
errorMsg := err.Error()
if errorutil.IsExitStatusError(err) && out != "" {
errorMsg = out
}
return fmt.Errorf("failed to clear envstore (%s), error: %s", envstorePth, errorMsg)
}
return nil
}
func Test_GlobalFlagCI(t *testing.T) {
configPth := "global_flag_test_bitrise.yml"
secretsPth := "global_flag_test_secrets.yml"
ciModeEnv := os.Getenv(configs.CIModeEnvKey)
// cleanup Envs after these tests
defer func() {
require.NoError(t, os.Setenv(configs.CIModeEnvKey, ciModeEnv))
}()
t.Log("Should run in ci mode")
{
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "false"))
cmd := cmdex.NewCommand(binPath(), "--ci", "run", "fail_in_not_ci_mode", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("Should run in ci mode")
{
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "false"))
cmd := cmdex.NewCommand(binPath(), "--ci=true", "run", "fail_in_not_ci_mode", "--config", configPth, "--inventory", secretsPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("Should run in ci mode")
{
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "true"))
cmd := cmdex.NewCommand(binPath(), "--ci=false", "run", "fail_in_ci_mode", "--config", configPth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
// NewFromFile ...
func NewFromFile(pth string) (Model, error) {
cmd := cmdex.NewCommand("security", "cms", "-D", "-i", pth)
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return Model{}, fmt.Errorf("command failed, error: %s", err)
}
outSplit := strings.Split(out, "\n")
if len(outSplit) > 0 {
if strings.Contains(outSplit[0], notValidParameterErrorMessage) {
fixedOutSplit := outSplit[1:len(outSplit)]
out = strings.Join(fixedOutSplit, "\n")
}
}
return newFromProfileContent(out)
}
func installGoTar(goTarGzPath string) error {
installToPath := goToolkitInstallToPath()
if err := os.RemoveAll(installToPath); err != nil {
return fmt.Errorf("Failed to remove previous Go toolkit install (path: %s), error: %s", installToPath, err)
}
if err := pathutil.EnsureDirExist(installToPath); err != nil {
return fmt.Errorf("Failed create Go toolkit directory (path: %s), error: %s", installToPath, err)
}
cmd := cmdex.NewCommand("tar", "-C", installToPath, "-xzf", goTarGzPath)
if combinedOut, err := cmd.RunAndReturnTrimmedCombinedOutput(); err != nil {
log.Errorln(" [!] Failed to uncompress Go toolkit, output:")
log.Errorln(combinedOut)
return fmt.Errorf("Failed to uncompress Go toolkit, error: %s", err)
}
return nil
}
// NewRubyCommandModel ...
func NewRubyCommandModel() (RubyCommandModel, error) {
whichRuby, err := cmdex.NewCommand("which", "ruby").RunAndReturnTrimmedCombinedOutput()
if err != nil {
return RubyCommandModel{}, err
}
command := RubyCommandModel{}
if whichRuby == systemRubyPth {
command.rubyInstallType = SystemRuby
} else if whichRuby == brewRubyPth {
command.rubyInstallType = BrewRuby
} else if cmdExist([]string{"rvm", "-v"}) {
command.rubyInstallType = RVMRuby
} else if cmdExist([]string{"rbenv", "-v"}) {
command.rubyInstallType = RbenvRuby
} else {
return RubyCommandModel{}, errors.New("unkown ruby installation type")
}
return command, nil
}
func runGradleTask(gradleTool, buildFile, tasks, options string) error {
optionSlice, err := shellquote.Split(options)
if err != nil {
return err
}
taskSlice, err := shellquote.Split(tasks)
if err != nil {
return err
}
cmdSlice := []string{gradleTool, "--build-file", buildFile}
cmdSlice = append(cmdSlice, taskSlice...)
cmdSlice = append(cmdSlice, optionSlice...)
log.Detail(cmdex.PrintableCommandArgs(false, cmdSlice))
fmt.Println()
cmd := cmdex.NewCommand(cmdSlice[0], cmdSlice[1:]...)
cmd.SetStdout(os.Stdout)
cmd.SetStderr(os.Stderr)
return cmd.Run()
}
// CreateProvisioningProfileModelFromFile ...
func CreateProvisioningProfileModelFromFile(filePth string) (ProvisioningProfileModel, error) {
profileContent, err := cmdex.NewCommand("security", "cms", "-D", "-i", filePth).RunAndReturnTrimmedCombinedOutput()
if err != nil {
return ProvisioningProfileModel{},
fmt.Errorf("Failed to retrieve information about Provisioning Profile, error: %s",
err)
}
log.Debugln("profileContent: ", profileContent)
var provProfileData ProvisioningProfileModel
if err := plist.NewDecoder(strings.NewReader(profileContent)).Decode(&provProfileData); err != nil {
return provProfileData,
fmt.Errorf("Failed to parse Provisioning Profile content, error: %s", err)
}
if provProfileData.UUID == "" {
return provProfileData,
fmt.Errorf("No UUID found in the Provisioning Profile (%#v)", provProfileData)
}
return provProfileData, nil
}
func find(dir, nameInclude, nameExclude string) ([]string, error) {
cmdSlice := []string{"find", dir}
cmdSlice = append(cmdSlice, "-name", nameInclude)
cmdSlice = append(cmdSlice, "!", "-name", nameExclude)
log.Detail(cmdex.PrintableCommandArgs(false, cmdSlice))
out, err := cmdex.NewCommand(cmdSlice[0], cmdSlice[1:]...).RunAndReturnTrimmedOutput()
if err != nil {
return []string{}, err
}
split := strings.Split(out, "\n")
files := []string{}
for _, item := range split {
trimmed := strings.TrimSpace(item)
if trimmed != "" {
files = append(files, trimmed)
}
}
return files, nil
}
func Test_TriggerParams(t *testing.T) {
t.Log("deprecated trigger with pattern - pr allowed")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "deprecated_pr_allowed", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("deprecated trigger with pattern - pr not allowed")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "--pattern", "deprecated_only_code_push", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("deprecated trigger with push-branch")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "--push-branch", "code-push", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("deprecated trigger with pr-source-branch")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "--pr-source-branch", "pull_request_source_branch", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("deprecated trigger with pr-target-branch")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "--pr-target-branch", "pull_request_taget_branch", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
t.Log("deprecated trigger with tag")
{
cmd := cmdex.NewCommand(binPath(), "trigger", "--tag", "tag", "--config", "trigger_params_test_bitrise.yml")
out, err := cmd.RunAndReturnTrimmedCombinedOutput()
require.NoError(t, err, out)
}
}
func exportEnvironmentWithEnvman(keyStr, valueStr string) error {
cmd := cmdex.NewCommand("envman", "add", "--key", keyStr)
cmd.SetStdin(strings.NewReader(valueStr))
return cmd.Run()
}