func TestValidate(t *testing.T) {
// No key-value
env := EnvironmentItemModel{
OptionsKey: EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
Description: pointers.NewStringPtr("test_description"),
Summary: pointers.NewStringPtr("test_summary"),
ValueOptions: []string{"test_key2", "test_value2"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(true),
IsDontChangeValue: pointers.NewBoolPtr(false),
},
}
require.NotEqual(t, nil, env.Validate())
// Empty key
env = EnvironmentItemModel{
"": "test_value",
}
require.NotEqual(t, nil, env.Validate())
// Valid env
env = EnvironmentItemModel{
"test_key": "test_value",
}
require.Equal(t, nil, env.Validate())
}
// Convert ...
func (oldStep StepModel) Convert() (stepmanModels.StepModel, error) {
inputs, err := oldStep.getInputEnvironments()
if err != nil {
return stepmanModels.StepModel{}, err
}
outputs, err := oldStep.getOutputEnvironments()
if err != nil {
return stepmanModels.StepModel{}, err
}
newStep := stepmanModels.StepModel{
Title: pointers.NewStringPtr(oldStep.Name),
Description: pointers.NewStringPtr(oldStep.Description),
Website: pointers.NewStringPtr(oldStep.Website),
Source: oldStep.getSource(),
HostOsTags: oldStep.HostOsTags,
ProjectTypeTags: oldStep.ProjectTypeTags,
TypeTags: oldStep.TypeTags,
IsRequiresAdminUser: pointers.NewBoolPtr(oldStep.IsRequiresAdminUser),
IsAlwaysRun: pointers.NewBoolPtr(oldStep.IsAlwaysRun),
Inputs: inputs,
Outputs: outputs,
}
return newStep, nil
}
// FillMissingDefaults ...
func (env *EnvironmentItemModel) FillMissingDefaults() error {
options, err := env.GetOptions()
if err != nil {
return err
}
if options.Title == nil {
options.Title = pointers.NewStringPtr("")
}
if options.Description == nil {
options.Description = pointers.NewStringPtr("")
}
if options.Summary == nil {
options.Summary = pointers.NewStringPtr("")
}
if options.IsRequired == nil {
options.IsRequired = pointers.NewBoolPtr(DefaultIsRequired)
}
if options.IsExpand == nil {
options.IsExpand = pointers.NewBoolPtr(DefaultIsExpand)
}
if options.IsDontChangeValue == nil {
options.IsDontChangeValue = pointers.NewBoolPtr(DefaultIsDontChangeValue)
}
(*env)[OptionsKey] = options
return nil
}
func (input InputModel) getOptions() envmanModels.EnvironmentItemOptionsModel {
return envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(input.Title),
Description: pointers.NewStringPtr(input.Description),
ValueOptions: input.ValueOptions,
IsRequired: pointers.NewBoolPtr(input.IsRequired),
IsExpand: pointers.NewBoolPtr(input.IsExpand),
IsDontChangeValue: pointers.NewBoolPtr(input.IsDontChangeValue),
}
}
// MergeEnvironmentWith ...
func MergeEnvironmentWith(env *envmanModels.EnvironmentItemModel, otherEnv envmanModels.EnvironmentItemModel) error {
// merge key-value
key, _, err := env.GetKeyValuePair()
if err != nil {
return err
}
otherKey, otherValue, err := otherEnv.GetKeyValuePair()
if err != nil {
return err
}
if otherKey != key {
return errors.New("Env keys are diferent")
}
(*env)[key] = otherValue
//merge options
options, err := env.GetOptions()
if err != nil {
return err
}
otherOptions, err := otherEnv.GetOptions()
if err != nil {
return err
}
if otherOptions.Title != nil {
options.Title = pointers.NewStringPtr(*otherOptions.Title)
}
if otherOptions.Description != nil {
options.Description = pointers.NewStringPtr(*otherOptions.Description)
}
if otherOptions.Summary != nil {
options.Summary = pointers.NewStringPtr(*otherOptions.Summary)
}
if len(otherOptions.ValueOptions) > 0 {
options.ValueOptions = otherOptions.ValueOptions
}
if otherOptions.IsRequired != nil {
options.IsRequired = pointers.NewBoolPtr(*otherOptions.IsRequired)
}
if otherOptions.IsExpand != nil {
options.IsExpand = pointers.NewBoolPtr(*otherOptions.IsExpand)
}
if otherOptions.IsDontChangeValue != nil {
options.IsDontChangeValue = pointers.NewBoolPtr(*otherOptions.IsDontChangeValue)
}
if otherOptions.IsTemplate != nil {
options.IsTemplate = pointers.NewBoolPtr(*otherOptions.IsTemplate)
}
(*env)[envmanModels.OptionsKey] = options
return nil
}
func TestValidateStepInputOutputModel(t *testing.T) {
// Filled env
env := envmanModels.EnvironmentItemModel{
"test_key": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
Description: pointers.NewStringPtr("test_description"),
Summary: pointers.NewStringPtr("test_summary"),
ValueOptions: []string{"test_key2", "test_value2"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(false),
IsDontChangeValue: pointers.NewBoolPtr(true),
},
}
step := StepModel{
Inputs: []envmanModels.EnvironmentItemModel{env},
}
require.NoError(t, step.ValidateInputAndOutputEnvs(true))
// Empty key
env = envmanModels.EnvironmentItemModel{
"": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
Description: pointers.NewStringPtr("test_description"),
Summary: pointers.NewStringPtr("test_summary"),
ValueOptions: []string{"test_key2", "test_value2"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(false),
IsDontChangeValue: pointers.NewBoolPtr(true),
},
}
step = StepModel{
Inputs: []envmanModels.EnvironmentItemModel{env},
}
require.Error(t, step.ValidateInputAndOutputEnvs(true))
// Title is empty
env = envmanModels.EnvironmentItemModel{
"test_key": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Description: pointers.NewStringPtr("test_description"),
ValueOptions: []string{"test_key2", "test_value2"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(false),
IsDontChangeValue: pointers.NewBoolPtr(true),
},
}
step = StepModel{
Inputs: []envmanModels.EnvironmentItemModel{env},
}
require.Error(t, step.ValidateInputAndOutputEnvs(true))
}
func TestMergeEnvironmentWith(t *testing.T) {
diffEnv := envmanModels.EnvironmentItemModel{
"test_key": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
Description: pointers.NewStringPtr("test_description"),
Summary: pointers.NewStringPtr("test_summary"),
ValueOptions: []string{"test_valu_options1", "test_valu_options2"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(false),
IsDontChangeValue: pointers.NewBoolPtr(true),
IsTemplate: pointers.NewBoolPtr(true),
},
}
t.Log("Different keys")
{
env := envmanModels.EnvironmentItemModel{
"test_key1": "test_value",
}
require.Error(t, MergeEnvironmentWith(&env, diffEnv))
}
t.Log("Normal merge")
{
env := envmanModels.EnvironmentItemModel{
"test_key": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
SkipIfEmpty: pointers.NewBoolPtr(true),
Category: pointers.NewStringPtr("test"),
},
}
require.NoError(t, MergeEnvironmentWith(&env, diffEnv))
options, err := env.GetOptions()
require.NoError(t, err)
diffOptions, err := diffEnv.GetOptions()
require.NoError(t, err)
require.Equal(t, *diffOptions.Title, *options.Title)
require.Equal(t, *diffOptions.Description, *options.Description)
require.Equal(t, *diffOptions.Summary, *options.Summary)
require.Equal(t, len(diffOptions.ValueOptions), len(options.ValueOptions))
require.Equal(t, *diffOptions.IsRequired, *options.IsRequired)
require.Equal(t, *diffOptions.IsExpand, *options.IsExpand)
require.Equal(t, *diffOptions.IsDontChangeValue, *options.IsDontChangeValue)
require.Equal(t, *diffOptions.IsTemplate, *options.IsTemplate)
require.Equal(t, true, *options.SkipIfEmpty)
require.Equal(t, "test", *options.Category)
}
}
func TestValidateStepInputOutputModel(t *testing.T) {
// Filled env
env := envmanModels.EnvironmentItemModel{
testKey: testValue,
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(testTitle),
Description: pointers.NewStringPtr(testDescription),
Summary: pointers.NewStringPtr(testSummary),
ValueOptions: testValueOptions,
IsRequired: pointers.NewBoolPtr(testTrue),
IsExpand: pointers.NewBoolPtr(testFalse),
IsDontChangeValue: pointers.NewBoolPtr(testTrue),
},
}
err := ValidateStepInputOutputModel(env, true)
if err != nil {
t.Fatal(err)
}
// Empty key
env = envmanModels.EnvironmentItemModel{
"": testValue,
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(testTitle),
Description: pointers.NewStringPtr(testDescription),
Summary: pointers.NewStringPtr(testSummary),
ValueOptions: testValueOptions,
IsRequired: pointers.NewBoolPtr(testTrue),
IsExpand: pointers.NewBoolPtr(testFalse),
IsDontChangeValue: pointers.NewBoolPtr(testTrue),
},
}
err = ValidateStepInputOutputModel(env, true)
if err == nil {
t.Fatal("Empty key, should fail")
}
// Title is empty
env = envmanModels.EnvironmentItemModel{
testKey: testValue,
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Description: pointers.NewStringPtr(testDescription),
ValueOptions: testValueOptions,
IsRequired: pointers.NewBoolPtr(testTrue),
IsExpand: pointers.NewBoolPtr(testFalse),
IsDontChangeValue: pointers.NewBoolPtr(testTrue),
},
}
err = ValidateStepInputOutputModel(env, true)
if err == nil {
t.Fatal("Empty Title, should fail")
}
}
// FillMissingDefaults ...
func (step *StepModel) FillMissingDefaults() error {
if step.Title == nil {
step.Title = pointers.NewStringPtr("")
}
if step.Description == nil {
step.Description = pointers.NewStringPtr("")
}
if step.Summary == nil {
step.Summary = pointers.NewStringPtr("")
}
if step.Website == nil {
step.Website = pointers.NewStringPtr("")
}
if step.SourceCodeURL == nil {
step.SourceCodeURL = pointers.NewStringPtr("")
}
if step.SupportURL == nil {
step.SupportURL = pointers.NewStringPtr("")
}
if step.IsRequiresAdminUser == nil {
step.IsRequiresAdminUser = pointers.NewBoolPtr(DefaultIsRequiresAdminUser)
}
if step.IsAlwaysRun == nil {
step.IsAlwaysRun = pointers.NewBoolPtr(DefaultIsAlwaysRun)
}
if step.IsSkippable == nil {
step.IsSkippable = pointers.NewBoolPtr(DefaultIsSkippable)
}
if step.RunIf == nil {
step.RunIf = pointers.NewStringPtr("")
}
if step.Timeout == nil {
step.Timeout = pointers.NewIntPtr(DefaultTimeout)
}
for _, input := range step.Inputs {
err := input.FillMissingDefaults()
if err != nil {
return err
}
}
for _, output := range step.Outputs {
err := output.FillMissingDefaults()
if err != nil {
return err
}
}
return nil
}
// CastToBoolPtr ...
func CastToBoolPtr(value interface{}) (*bool, bool) {
castedValue, ok := CastToBool(value)
if !ok {
return nil, false
}
return pointers.NewBoolPtr(castedValue), true
}
func addEnv(key string, value string, expand, replace bool) error {
// Validate input
if key == "" {
return errors.New("Key is not specified, required.")
}
// Load envs, or create if not exist
environments, err := envman.ReadEnvsOrCreateEmptyList()
if err != nil {
return err
}
// Add or update envlist
newEnv := models.EnvironmentItemModel{
key: value,
models.OptionsKey: models.EnvironmentItemOptionsModel{
IsExpand: pointers.NewBoolPtr(expand),
},
}
if err := newEnv.NormalizeEnvironmentItemModel(); err != nil {
return err
}
newEnvSlice, err := envman.UpdateOrAddToEnvlist(environments, newEnv, replace)
if err != nil {
return err
}
if err := envman.WriteEnvMapToFile(envman.CurrentEnvStoreFilePath, newEnvSlice); err != nil {
return err
}
return nil
}
func TestGetLatestStepVersion(t *testing.T) {
defaultIsRequiresAdminUser := DefaultIsRequiresAdminUser
step := StepModel{
Title: pointers.NewStringPtr("name 1"),
Description: pointers.NewStringPtr("desc 1"),
Website: pointers.NewStringPtr("web/1"),
SourceCodeURL: pointers.NewStringPtr("fork/1"),
Source: StepSourceModel{
Git: "https://git.url",
},
HostOsTags: []string{"osx"},
ProjectTypeTags: []string{"ios"},
TypeTags: []string{"test"},
IsRequiresAdminUser: pointers.NewBoolPtr(defaultIsRequiresAdminUser),
Inputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_1": "Value 1",
},
envmanModels.EnvironmentItemModel{
"KEY_2": "Value 2",
},
},
Outputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_3": "Value 3",
},
},
}
collection := StepCollectionModel{
FormatVersion: "1.0.0",
GeneratedAtTimeStamp: 0,
Steps: StepHash{
"step": StepGroupModel{
Versions: map[string]StepModel{
"1.0.0": step,
"2.0.0": step,
},
LatestVersionNumber: "2.0.0",
},
},
SteplibSource: "source",
DownloadLocations: []DownloadLocationModel{
DownloadLocationModel{
Type: "zip",
Src: "amazon/",
},
DownloadLocationModel{
Type: "git",
Src: "step.git",
},
},
}
latest, err := collection.GetLatestStepVersion("step")
require.Equal(t, nil, err)
require.Equal(t, "2.0.0", latest)
}
func TestGetStep(t *testing.T) {
defaultIsRequiresAdminUser := DefaultIsRequiresAdminUser
step := StepModel{
Title: pointers.NewStringPtr(title),
Description: pointers.NewStringPtr(desc),
Website: pointers.NewStringPtr(website),
SourceCodeURL: pointers.NewStringPtr(fork),
Source: StepSourceModel{
Git: git,
},
HostOsTags: []string{"osx"},
ProjectTypeTags: []string{"ios"},
TypeTags: []string{"test"},
IsRequiresAdminUser: pointers.NewBoolPtr(defaultIsRequiresAdminUser),
Inputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_1": "Value 1",
},
envmanModels.EnvironmentItemModel{
"KEY_2": "Value 2",
},
},
Outputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_3": "Value 3",
},
},
}
collection := StepCollectionModel{
FormatVersion: "1.0.0",
GeneratedAtTimeStamp: 0,
Steps: StepHash{
"step": StepGroupModel{
Versions: map[string]StepModel{
"1.0.0": step,
},
},
},
SteplibSource: "source",
DownloadLocations: []DownloadLocationModel{
DownloadLocationModel{
Type: "zip",
Src: "amazon/",
},
DownloadLocationModel{
Type: "git",
Src: "step.git",
},
},
}
step, found := collection.GetStep("step", "1.0.0")
if !found {
t.Fatal("Step not found (step) (1.0.0)")
}
}
//
// Converted inputs should:
// * contain all spec inputs
// * keep all original input value (except empty value: "")
// * keep original IsExpand value
//
// originalInputs: readed from StepLib
// diffInputs: readed from workflow to convert
//
func convertStepsInputs(originalInputs, diffInputs []envmanModels.EnvironmentItemModel, conversionMap map[string]string) ([]envmanModels.EnvironmentItemModel, error) {
convertedInputs := []envmanModels.EnvironmentItemModel{}
for _, originalInput := range originalInputs {
originalInputKey, originalInputValue, err := originalInput.GetKeyValuePair()
if err != nil {
return []envmanModels.EnvironmentItemModel{}, err
}
originalInputOptions, err := originalInput.GetOptions()
if err != nil {
return []envmanModels.EnvironmentItemModel{}, err
}
conversionInputKey, found := conversionMap[originalInputKey]
if found == false {
convertedInputs = append(convertedInputs, originalInput)
continue
}
diffInput, found, err := GetInputByKey(diffInputs, conversionInputKey)
if err != nil {
return []envmanModels.EnvironmentItemModel{}, err
}
if !found {
convertedInputs = append(convertedInputs, originalInput)
continue
}
_, diffInputValue, err := diffInput.GetKeyValuePair()
if err != nil {
return []envmanModels.EnvironmentItemModel{}, err
}
if diffInputValue == "" {
diffInputValue = originalInputValue
}
diffInputOptions, err := diffInput.GetOptions()
if err != nil {
return []envmanModels.EnvironmentItemModel{}, err
}
if diffInputOptions.IsExpand != nil {
originalInputOptions.IsExpand = pointers.NewBoolPtr(*diffInputOptions.IsExpand)
}
convertedInput := envmanModels.EnvironmentItemModel{
originalInputKey: diffInputValue,
envmanModels.OptionsKey: originalInputOptions,
}
convertedInputs = append(convertedInputs, convertedInput)
}
return convertedInputs, nil
}
func TestRemoveDefaults(t *testing.T) {
defaultIsRequired := models.DefaultIsRequired
defaultIsExpand := models.DefaultIsExpand
defaultIsDontChangeValue := models.DefaultIsDontChangeValue
// Filled env
env := models.EnvironmentItemModel{
testKey: testValue,
models.OptionsKey: models.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(testTitle),
Description: pointers.NewStringPtr(testEmptyString),
ValueOptions: []string{},
IsRequired: pointers.NewBoolPtr(defaultIsRequired),
IsExpand: pointers.NewBoolPtr(defaultIsExpand),
IsDontChangeValue: pointers.NewBoolPtr(defaultIsDontChangeValue),
},
}
err := removeDefaults(&env)
if err != nil {
t.Fatal(err)
}
opts, err := env.GetOptions()
if err != nil {
t.Fatal(err)
}
if opts.Title == nil {
t.Fatal("Removed Title")
}
if opts.Description != nil {
t.Fatal("Failed to remove default Description")
}
if opts.IsRequired != nil {
t.Fatal("Failed to remove default IsRequired")
}
if opts.IsExpand != nil {
t.Fatal("Failed to remove default IsExpand")
}
if opts.IsDontChangeValue != nil {
t.Fatal("Failed to remove default IsDontChangeValue")
}
}
func TestRemoveDefaults(t *testing.T) {
// Filled env
env := models.EnvironmentItemModel{
"test_key": "test_value",
models.OptionsKey: models.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
IsTemplate: pointers.NewBoolPtr(!models.DefaultIsTemplate),
Description: pointers.NewStringPtr(""),
Summary: pointers.NewStringPtr(""),
ValueOptions: []string{},
IsRequired: pointers.NewBoolPtr(models.DefaultIsRequired),
IsDontChangeValue: pointers.NewBoolPtr(models.DefaultIsDontChangeValue),
IsExpand: pointers.NewBoolPtr(models.DefaultIsExpand),
SkipIfEmpty: pointers.NewBoolPtr(models.DefaultSkipIfEmpty),
},
}
require.Equal(t, nil, removeDefaults(&env))
opts, err := env.GetOptions()
require.Equal(t, nil, err)
require.NotEqual(t, (*string)(nil), opts.Title)
require.Equal(t, "test_title", *opts.Title)
require.NotEqual(t, (*bool)(nil), opts.IsTemplate)
require.Equal(t, !models.DefaultIsTemplate, *opts.IsTemplate)
require.Equal(t, (*string)(nil), opts.Description)
require.Equal(t, (*string)(nil), opts.Summary)
require.Equal(t, 0, len(opts.ValueOptions))
require.Equal(t, (*bool)(nil), opts.IsRequired)
require.Equal(t, (*bool)(nil), opts.IsDontChangeValue)
require.Equal(t, (*bool)(nil), opts.IsExpand)
require.Equal(t, (*bool)(nil), opts.SkipIfEmpty)
}
func addEnv(key string, value string, expand, replace, skipIfEmpty bool) error {
// Load envs, or create if not exist
environments, err := envman.ReadEnvsOrCreateEmptyList()
if err != nil {
return err
}
// Validate input
validatedValue, err := validateEnv(key, value, environments)
if err != nil {
return err
}
value = validatedValue
// Add or update envlist
newEnv := models.EnvironmentItemModel{
key: value,
models.OptionsKey: models.EnvironmentItemOptionsModel{
IsExpand: pointers.NewBoolPtr(expand),
SkipIfEmpty: pointers.NewBoolPtr(skipIfEmpty),
},
}
if err := newEnv.NormalizeValidateFillDefaults(); err != nil {
return err
}
newEnvSlice, err := envman.UpdateOrAddToEnvlist(environments, newEnv, replace)
if err != nil {
return err
}
if err := envman.WriteEnvMapToFile(envman.CurrentEnvStoreFilePath, newEnvSlice); err != nil {
return err
}
return nil
}
func TestValidate(t *testing.T) {
// No key-value
env := EnvironmentItemModel{
OptionsKey: EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(testTitle),
Description: pointers.NewStringPtr(testDescription),
Summary: pointers.NewStringPtr(testSummary),
ValueOptions: testValueOptions,
IsRequired: pointers.NewBoolPtr(testTrue),
IsExpand: pointers.NewBoolPtr(testTrue),
IsDontChangeValue: pointers.NewBoolPtr(testFalse),
},
}
err := env.Validate()
if err == nil {
t.Fatal("Should be invalid env, no key-value")
}
// Empty key
env = EnvironmentItemModel{
"": testValue,
}
err = env.Validate()
if err == nil {
t.Fatal("Should be invalid env, no empty key")
}
// Valid env
env = EnvironmentItemModel{
testKey: testValue,
}
err = env.Validate()
if err != nil {
t.Fatal(err)
}
}
func TestParseFromInterfaceMap(t *testing.T) {
envOptions := EnvironmentItemOptionsModel{}
model := map[string]interface{}{}
// Normal
model["title"] = "test_title"
model["value_options"] = []string{"test_key2", "test_value2"}
model["is_expand"] = true
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
// title is not a string
model = map[string]interface{}{}
model["title"] = true
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
// value_options is not a string slice
model = map[string]interface{}{}
model["value_options"] = []interface{}{true, false}
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
// is_required is not a bool
model = map[string]interface{}{}
model["is_required"] = pointers.NewBoolPtr(true)
require.NotEqual(t, nil, envOptions.ParseFromInterfaceMap(model))
model = map[string]interface{}{}
model["is_required"] = "YeS"
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
model = map[string]interface{}{}
model["is_required"] = "NO"
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
model = map[string]interface{}{}
model["is_required"] = "y"
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
model = map[string]interface{}{}
model["skip_if_empty"] = "true"
require.Equal(t, nil, envOptions.ParseFromInterfaceMap(model))
// other_key is not supported key
model = map[string]interface{}{}
model["other_key"] = true
require.NotEqual(t, nil, envOptions.ParseFromInterfaceMap(model))
}
func TestParseFromInterfaceMap(t *testing.T) {
envOptions := EnvironmentItemOptionsModel{}
model := map[string]interface{}{}
// Normal
model["title"] = testTitle
model["value_options"] = testValueOptions
model["is_expand"] = testTrue
err := envOptions.ParseFromInterfaceMap(model)
if err != nil {
t.Fatal(err)
}
// title is not a string
model = map[string]interface{}{}
model["title"] = true
err = envOptions.ParseFromInterfaceMap(model)
if err == nil {
t.Fatal("Title value is not a string, should be error")
}
// value_options is not a string slice
model = map[string]interface{}{}
model["value_options"] = []interface{}{true, false}
err = envOptions.ParseFromInterfaceMap(model)
if err == nil {
t.Fatal("value_options is not a string slice, should be error")
}
// is_required is not a bool
model = map[string]interface{}{}
model["is_required"] = pointers.NewBoolPtr(testTrue)
err = envOptions.ParseFromInterfaceMap(model)
if err == nil {
t.Fatal("is_required is not a bool, should be error")
}
// other_key is not supported key
model = map[string]interface{}{}
model["other_key"] = testTrue
err = envOptions.ParseFromInterfaceMap(model)
if err == nil {
t.Fatal("other_key is not a supported key, should be error")
}
}
func TestGetOptions(t *testing.T) {
// Filled env
env := EnvironmentItemModel{
testKey: testValue,
OptionsKey: EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(testTitle),
IsExpand: pointers.NewBoolPtr(testFalse),
},
}
opts, err := env.GetOptions()
if err != nil {
t.Fatal(err)
}
if opts.Title == nil || *opts.Title != testTitle {
t.Fatal("Title is nil, or not correct")
}
if opts.IsExpand == nil || *opts.IsExpand != testFalse {
t.Fatal("IsExpand is nil, or not correct")
}
// Missing opts
env = EnvironmentItemModel{
testKey: testValue,
}
_, err = env.GetOptions()
if err != nil {
t.Fatal(err)
}
// Wrong opts
env = EnvironmentItemModel{
testKey: testValue,
OptionsKey: map[interface{}]interface{}{
"title": testTitle,
"test": testDescription,
},
}
_, err = env.GetOptions()
if err == nil {
t.Fatal(err)
}
}
// ConvertStep ...
//
// Converted step should:
// * keep original Title
// * keep original IsAlwaysRun
//
// newStepID: the id of the new step in new StepLib
// diffStep: readed from workflow to convert
//
func ConvertStep(diffStep stepmanModels.StepModel, newStepID string, inputConversionMap map[string]string) (stepmanModels.StepModel, string, error) {
originalStep, version, err := GetStepFromNewSteplib(newStepID, BitriseVerifiedStepLibGitURI)
if err != nil {
return stepmanModels.StepModel{}, "", err
}
if diffStep.Title != nil {
originalStep.Title = pointers.NewStringPtr(*diffStep.Title)
}
if diffStep.IsAlwaysRun != nil {
originalStep.IsAlwaysRun = pointers.NewBoolPtr(*diffStep.IsAlwaysRun)
}
// Merge new StepLib version inputs, with old workflow defined
mergedInputs, err := convertStepsInputs(originalStep.Inputs, diffStep.Inputs, inputConversionMap)
if err != nil {
return stepmanModels.StepModel{}, "", err
}
originalStep.Inputs = mergedInputs
return originalStep, version, nil
}
func TestGetOptions(t *testing.T) {
// Filled env
env := EnvironmentItemModel{
"test_key": "test_value",
OptionsKey: EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("test_title"),
IsExpand: pointers.NewBoolPtr(false),
},
}
opts, err := env.GetOptions()
require.Equal(t, nil, err)
require.NotEqual(t, nil, opts.Title)
require.Equal(t, "test_title", *opts.Title)
require.NotEqual(t, nil, opts.IsExpand)
require.Equal(t, false, *opts.IsExpand)
// Missing opts
env = EnvironmentItemModel{
"test_key": "test_value",
}
_, err = env.GetOptions()
require.Equal(t, nil, err)
// Wrong opts
env = EnvironmentItemModel{
"test_key": "test_value",
OptionsKey: map[interface{}]interface{}{
"title": "test_title",
"test": "test_description",
},
}
_, err = env.GetOptions()
require.NotEqual(t, nil, err)
}
// MergeStepWith ...
func MergeStepWith(step, otherStep stepmanModels.StepModel) (stepmanModels.StepModel, error) {
if otherStep.Title != nil {
step.Title = pointers.NewStringPtr(*otherStep.Title)
}
if otherStep.Description != nil {
step.Description = pointers.NewStringPtr(*otherStep.Description)
}
if otherStep.Summary != nil {
step.Summary = pointers.NewStringPtr(*otherStep.Summary)
}
if otherStep.Website != nil {
step.Website = pointers.NewStringPtr(*otherStep.Website)
}
if otherStep.SourceCodeURL != nil {
step.SourceCodeURL = pointers.NewStringPtr(*otherStep.SourceCodeURL)
}
if otherStep.SupportURL != nil {
step.SupportURL = pointers.NewStringPtr(*otherStep.SupportURL)
}
if otherStep.PublishedAt != nil {
step.PublishedAt = pointers.NewTimePtr(*otherStep.PublishedAt)
}
if otherStep.Source.Git != "" {
step.Source.Git = otherStep.Source.Git
}
if otherStep.Source.Commit != "" {
step.Source.Commit = otherStep.Source.Commit
}
if len(otherStep.Dependencies) > 0 {
step.Dependencies = otherStep.Dependencies
}
if len(otherStep.Deps.Brew) > 0 || len(otherStep.Deps.AptGet) > 0 || len(otherStep.Deps.CheckOnly) > 0 {
step.Deps = otherStep.Deps
}
if len(otherStep.HostOsTags) > 0 {
step.HostOsTags = otherStep.HostOsTags
}
if len(otherStep.ProjectTypeTags) > 0 {
step.ProjectTypeTags = otherStep.ProjectTypeTags
}
if len(otherStep.TypeTags) > 0 {
step.TypeTags = otherStep.TypeTags
}
if otherStep.IsRequiresAdminUser != nil {
step.IsRequiresAdminUser = pointers.NewBoolPtr(*otherStep.IsRequiresAdminUser)
}
if otherStep.IsAlwaysRun != nil {
step.IsAlwaysRun = pointers.NewBoolPtr(*otherStep.IsAlwaysRun)
}
if otherStep.IsSkippable != nil {
step.IsSkippable = pointers.NewBoolPtr(*otherStep.IsSkippable)
}
if otherStep.RunIf != nil {
step.RunIf = pointers.NewStringPtr(*otherStep.RunIf)
}
for _, input := range step.Inputs {
key, _, err := input.GetKeyValuePair()
if err != nil {
return stepmanModels.StepModel{}, err
}
otherInput, found := getInputByKey(otherStep, key)
if found {
err := MergeEnvironmentWith(&input, otherInput)
if err != nil {
return stepmanModels.StepModel{}, err
}
}
}
for _, output := range step.Outputs {
key, _, err := output.GetKeyValuePair()
if err != nil {
return stepmanModels.StepModel{}, err
}
otherOutput, found := getOutputByKey(otherStep, key)
if found {
err := MergeEnvironmentWith(&output, otherOutput)
if err != nil {
return stepmanModels.StepModel{}, err
}
}
}
return step, nil
}
func TestIsCIMode(t *testing.T) {
ciModeEnv := os.Getenv(configs.CIModeEnvKey)
defer func() {
require.NoError(t, os.Setenv(configs.CIModeEnvKey, ciModeEnv))
}()
t.Log("Should be false for: ciGlobalFlag: nil, ciModeEnv: 'false'")
{
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "false"))
ci, err := isCIMode(nil, []envmanModels.EnvironmentItemModel{})
require.NoError(t, err)
require.Equal(t, false, ci)
}
t.Log("Should be false for: ciGlobalFlag: false, ciModeEnv: 'false' secrets: false")
{
inventoryStr := `
envs:
- CI: "false"
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "false"))
ci, err := isCIMode(pointers.NewBoolPtr(false), inventory.Envs)
require.NoError(t, err)
require.Equal(t, false, ci)
}
t.Log("Should be true for: ciGlobalFlag: true, ciModeEnv: 'false'")
{
require.NoError(t, os.Setenv(configs.CIModeEnvKey, ""))
ci, err := isCIMode(pointers.NewBoolPtr(true), []envmanModels.EnvironmentItemModel{})
require.NoError(t, err)
require.Equal(t, true, ci)
}
t.Log("Should be true for: ciGlobalFlag: true, ciModeEnv: '' secrets: false")
{
inventoryStr := `
envs:
- CI: "false"
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.CIModeEnvKey, ""))
ci, err := isCIMode(pointers.NewBoolPtr(true), inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, ci)
}
t.Log("Should be true for: ciGlobalFlag: nil, ciModeEnv: 'true' secrets: false")
{
inventoryStr := `
envs:
- CI: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.CIModeEnvKey, "true"))
ci, err := isCIMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, ci)
}
t.Log("Should be true for: ciGlobalFlag: nil, ciModeEnv: '' secrets: true")
{
inventoryStr := `
envs:
- CI: "true"
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.CIModeEnvKey, ""))
ci, err := isCIMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, ci)
}
}
func TestIsPRMode(t *testing.T) {
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("Should be false for: prGlobalFlag: nil, prModeEnv: '', prIDEnv: ''")
{
require.NoError(t, os.Setenv(configs.PRModeEnvKey, ""))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, []envmanModels.EnvironmentItemModel{})
require.NoError(t, err)
require.Equal(t, false, pr)
}
t.Log("Should be false for: prGlobalFlag: nil, prModeEnv: '', prIDEnv: '', secrets: false")
{
inventoryStr := `
envs:
- PR: "false"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, ""))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, false, pr)
}
t.Log("Should be false for: prGlobalFlag: nil, prModeEnv: 'false', prIDEnv: '', secrets: ''")
{
inventoryStr := `
envs:
- PR: ""
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, false, pr)
}
t.Log("Should be false for: prGlobalFlag: false, prModeEnv: 'true', prIDEnv: 'ID', secrets: 'true'")
{
inventoryStr := `
envs:
- PR: "true"
- PULL_REQUEST_ID: "ID"
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "true"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, "ID"))
pr, err := isPRMode(pointers.NewBoolPtr(false), inventory.Envs)
require.NoError(t, err)
require.Equal(t, false, pr)
}
t.Log("Should be true for: prGlobalFlag: true, prModeEnv: '', prIDEnv: ''")
{
require.NoError(t, os.Setenv(configs.PRModeEnvKey, ""))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(pointers.NewBoolPtr(true), []envmanModels.EnvironmentItemModel{})
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: true, prModeEnv: '', prIDEnv: '', secrets: false")
{
inventoryStr := `
envs:
- PR: "false"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, ""))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(pointers.NewBoolPtr(true), inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: nil, prModeEnv: 'true', prIDEnv: '', secrets: false")
{
inventoryStr := `
envs:
- PR: "false"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "true"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: nil, prModeEnv: 'false', prIDEnv: 'some', secrets: false")
{
inventoryStr := `
envs:
- PR: "false"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, "some"))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: nil, prModeEnv: '', prIDEnv: '', secrets: true")
{
inventoryStr := `
envs:
- PR: "true"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, ""))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: nil, prModeEnv: 'false', prIDEnv: '', secrets: true")
{
inventoryStr := `
envs:
- PR: ""
- PULL_REQUEST_ID: "some"
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(nil, inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
t.Log("Should be true for: prGlobalFlag: true, prModeEnv: 'false', prIDEnv: '', secrets: false")
{
inventoryStr := `
envs:
- PR: "false"
- PULL_REQUEST_ID: ""
`
inventory, err := bitrise.InventoryModelFromYAMLBytes([]byte(inventoryStr))
require.NoError(t, err)
require.NoError(t, os.Setenv(configs.PRModeEnvKey, "false"))
require.NoError(t, os.Setenv(configs.PullRequestIDEnvKey, ""))
pr, err := isPRMode(pointers.NewBoolPtr(true), inventory.Envs)
require.NoError(t, err)
require.Equal(t, true, pr)
}
}
func TestMergeStepWith(t *testing.T) {
desc := "desc 1"
summ := "sum 1"
website := "web/1"
fork := "fork/1"
published := time.Date(2012, time.January, 1, 0, 0, 0, 0, time.UTC)
stepData := stepmanModels.StepModel{
Description: pointers.NewStringPtr(desc),
Summary: pointers.NewStringPtr(summ),
Website: pointers.NewStringPtr(website),
SourceCodeURL: pointers.NewStringPtr(fork),
PublishedAt: pointers.NewTimePtr(published),
HostOsTags: []string{"osx"},
ProjectTypeTags: []string{"ios"},
TypeTags: []string{"test"},
IsRequiresAdminUser: pointers.NewBoolPtr(true),
Inputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_1": "Value 1",
},
envmanModels.EnvironmentItemModel{
"KEY_2": "Value 2",
},
},
Outputs: []envmanModels.EnvironmentItemModel{},
}
diffTitle := "name 2"
newSuppURL := "supp"
runIfStr := ""
stepDiffToMerge := stepmanModels.StepModel{
Title: pointers.NewStringPtr(diffTitle),
HostOsTags: []string{"linux"},
Source: &stepmanModels.StepSourceModel{
Git: "https://git.url",
},
Dependencies: []stepmanModels.DependencyModel{
stepmanModels.DependencyModel{
Manager: "brew",
Name: "test",
},
},
SupportURL: pointers.NewStringPtr(newSuppURL),
RunIf: pointers.NewStringPtr(runIfStr),
Inputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_2": "Value 2 CHANGED",
},
},
Timeout: pointers.NewIntPtr(1),
Toolkit: &stepmanModels.StepToolkitModel{
Go: &stepmanModels.GoStepToolkitModel{
PackageName: "test",
},
},
}
mergedStepData, err := MergeStepWith(stepData, stepDiffToMerge)
require.NoError(t, err)
require.Equal(t, "name 2", *mergedStepData.Title)
require.Equal(t, "desc 1", *mergedStepData.Description)
require.Equal(t, "sum 1", *mergedStepData.Summary)
require.Equal(t, "web/1", *mergedStepData.Website)
require.Equal(t, "fork/1", *mergedStepData.SourceCodeURL)
require.Equal(t, true, (*mergedStepData.PublishedAt).Equal(time.Date(2012, time.January, 1, 0, 0, 0, 0, time.UTC)))
require.Equal(t, "linux", mergedStepData.HostOsTags[0])
require.Equal(t, "", *mergedStepData.RunIf)
require.Equal(t, 1, len(mergedStepData.Dependencies))
require.Equal(t, "test", mergedStepData.Toolkit.Go.PackageName)
require.Equal(t, 1, *mergedStepData.Timeout)
dep := mergedStepData.Dependencies[0]
require.Equal(t, "brew", dep.Manager)
require.Equal(t, "test", dep.Name)
// inputs
input0 := mergedStepData.Inputs[0]
key0, value0, err := input0.GetKeyValuePair()
require.NoError(t, err)
require.Equal(t, "KEY_1", key0)
require.Equal(t, "Value 1", value0)
input1 := mergedStepData.Inputs[1]
key1, value1, err := input1.GetKeyValuePair()
require.NoError(t, err)
require.Equal(t, "KEY_2", key1)
require.Equal(t, "Value 2 CHANGED", value1)
}
func TestRemoveEnvironmentRedundantFields(t *testing.T) {
t.Log("Trivial remove - all fields should be default value")
{
env := envmanModels.EnvironmentItemModel{
"TEST_KEY": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr(""),
Description: pointers.NewStringPtr(""),
Summary: pointers.NewStringPtr(""),
ValueOptions: []string{},
IsRequired: pointers.NewBoolPtr(envmanModels.DefaultIsRequired),
IsExpand: pointers.NewBoolPtr(envmanModels.DefaultIsExpand),
IsDontChangeValue: pointers.NewBoolPtr(envmanModels.DefaultIsDontChangeValue),
IsTemplate: pointers.NewBoolPtr(envmanModels.DefaultIsTemplate),
},
}
require.NoError(t, removeEnvironmentRedundantFields(&env))
options, err := env.GetOptions()
require.NoError(t, err)
require.Equal(t, (*string)(nil), options.Title)
require.Equal(t, (*string)(nil), options.Description)
require.Equal(t, (*string)(nil), options.Summary)
require.Equal(t, 0, len(options.ValueOptions))
require.Equal(t, (*bool)(nil), options.IsRequired)
require.Equal(t, (*bool)(nil), options.IsExpand)
require.Equal(t, (*bool)(nil), options.IsDontChangeValue)
require.Equal(t, (*bool)(nil), options.IsTemplate)
}
t.Log("Trivial don't remove - no fields should be default value")
{
env := envmanModels.EnvironmentItemModel{
"TEST_KEY": "test_value",
envmanModels.OptionsKey: envmanModels.EnvironmentItemOptionsModel{
Title: pointers.NewStringPtr("t"),
Description: pointers.NewStringPtr("d"),
Summary: pointers.NewStringPtr("s"),
ValueOptions: []string{"i"},
IsRequired: pointers.NewBoolPtr(true),
IsExpand: pointers.NewBoolPtr(false),
IsDontChangeValue: pointers.NewBoolPtr(true),
IsTemplate: pointers.NewBoolPtr(true),
},
}
require.NoError(t, removeEnvironmentRedundantFields(&env))
options, err := env.GetOptions()
require.NoError(t, err)
require.Equal(t, "t", *options.Title)
require.Equal(t, "d", *options.Description)
require.Equal(t, "s", *options.Summary)
require.Equal(t, "i", options.ValueOptions[0])
require.Equal(t, true, *options.IsRequired)
require.Equal(t, false, *options.IsExpand)
require.Equal(t, true, *options.IsDontChangeValue)
require.Equal(t, true, *options.IsTemplate)
}
t.Log("No options - opts field shouldn't exist")
{
env := envmanModels.EnvironmentItemModel{
"TEST_KEY": "test_value",
}
require.NoError(t, removeEnvironmentRedundantFields(&env))
_, ok := env[envmanModels.OptionsKey]
require.Equal(t, false, ok)
}
}
func TestGetDownloadLocations(t *testing.T) {
defaultIsRequiresAdminUser := DefaultIsRequiresAdminUser
// Zip & git download locations
step := StepModel{
Title: pointers.NewStringPtr("name 1"),
Description: pointers.NewStringPtr("desc 1"),
Website: pointers.NewStringPtr("web/1"),
SourceCodeURL: pointers.NewStringPtr("fork/1"),
Source: StepSourceModel{
Git: "https://git.url",
},
HostOsTags: []string{"osx"},
ProjectTypeTags: []string{"ios"},
TypeTags: []string{"test"},
IsRequiresAdminUser: pointers.NewBoolPtr(defaultIsRequiresAdminUser),
Inputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_1": "Value 1",
},
envmanModels.EnvironmentItemModel{
"KEY_2": "Value 2",
},
},
Outputs: []envmanModels.EnvironmentItemModel{
envmanModels.EnvironmentItemModel{
"KEY_3": "Value 3",
},
},
}
collection := StepCollectionModel{
FormatVersion: "1.0.0",
GeneratedAtTimeStamp: 0,
Steps: StepHash{
"step": StepGroupModel{
Versions: map[string]StepModel{
"1.0.0": step,
},
},
},
SteplibSource: "source",
DownloadLocations: []DownloadLocationModel{
DownloadLocationModel{
Type: "zip",
Src: "amazon/",
},
DownloadLocationModel{
Type: "git",
Src: "step.git",
},
},
}
locations, err := collection.GetDownloadLocations("step", "1.0.0")
require.Equal(t, nil, err)
zipFound := false
gitFount := false
zipIdx := -1
gitIdx := -1
for idx, location := range locations {
if location.Type == "zip" {
if location.Src != "amazon/step/1.0.0/step.zip" {
t.Fatalf("Incorrect zip location (%s)", location.Src)
}
zipFound = true
zipIdx = idx
} else if location.Type == "git" {
if location.Src != "https://git.url" {
t.Fatalf("Incorrect git location (%s)", location.Src)
}
gitFount = true
gitIdx = idx
}
}
require.Equal(t, true, zipFound)
require.Equal(t, true, gitFount)
if gitIdx < zipIdx {
t.Fatal("Incorrect download locations order")
}
}
func run(c *cli.Context) error {
PrintBitriseHeaderASCIIArt(version.VERSION)
//
// Expand cli.Context
var prGlobalFlagPtr *bool
if c.GlobalIsSet(PRKey) {
prGlobalFlagPtr = pointers.NewBoolPtr(c.GlobalBool(PRKey))
}
var ciGlobalFlagPtr *bool
if c.GlobalIsSet(CIKey) {
ciGlobalFlagPtr = pointers.NewBoolPtr(c.GlobalBool(CIKey))
}
workflowToRunID := c.String(WorkflowKey)
if workflowToRunID == "" && len(c.Args()) > 0 {
workflowToRunID = c.Args()[0]
}
bitriseConfigBase64Data := c.String(ConfigBase64Key)
bitriseConfigPath := c.String(ConfigKey)
deprecatedBitriseConfigPath := c.String(PathKey)
if bitriseConfigPath == "" && deprecatedBitriseConfigPath != "" {
log.Warn("'path' key is deprecated, use 'config' instead!")
bitriseConfigPath = deprecatedBitriseConfigPath
}
inventoryBase64Data := c.String(InventoryBase64Key)
inventoryPath := c.String(InventoryKey)
jsonParams := c.String(JSONParamsKey)
jsonParamsBase64 := c.String(JSONParamsBase64Key)
runParams, err := parseRunParams(
workflowToRunID,
bitriseConfigPath, bitriseConfigBase64Data,
inventoryPath, inventoryBase64Data,
jsonParams, jsonParamsBase64)
if err != nil {
return fmt.Errorf("Failed to parse command params, error: %s", err)
}
//
// Inventory validation
inventoryEnvironments, err := CreateInventoryFromCLIParams(runParams.InventoryBase64Data, runParams.InventoryPath)
if err != nil {
log.Fatalf("Failed to create inventory, error: %s", err)
}
// Config validation
bitriseConfig, warnings, err := CreateBitriseConfigFromCLIParams(runParams.BitriseConfigBase64Data, runParams.BitriseConfigPath)
for _, warning := range warnings {
log.Warnf("warning: %s", warning)
}
if err != nil {
log.Fatalf("Failed to create bitrise config, error: %s", err)
}
// Workflow id validation
if runParams.WorkflowToRunID == "" {
// no workflow specified
// list all the available ones and then exit
log.Error("No workfow specified!")
fmt.Println()
printAvailableWorkflows(bitriseConfig)
os.Exit(1)
}
if strings.HasPrefix(runParams.WorkflowToRunID, "_") {
// util workflow specified
// print about util workflows and then exit
log.Error("Utility workflows can't be triggered directly")
fmt.Println()
printAboutUtilityWorkflowsText()
os.Exit(1)
}
//
//
// Main
isPRMode, err := isPRMode(prGlobalFlagPtr, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check PR mode, error: %s", err)
}
if err := registerPrMode(isPRMode); err != nil {
log.Fatalf("Failed to register PR mode, error: %s", err)
}
isCIMode, err := isCIMode(ciGlobalFlagPtr, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check CI mode, error: %s", err)
}
if err := registerCIMode(isCIMode); err != nil {
log.Fatalf("Failed to register CI mode, error: %s", err)
}
log.Infoln(colorstring.Green("Running workflow:"), runParams.WorkflowToRunID)
runAndExit(bitriseConfig, inventoryEnvironments, runParams.WorkflowToRunID)
//
return nil
}