get.porter.sh/porter@v1.3.0/pkg/storage/parameterset_test.go (about)

     1  package storage
     2  
     3  import (
     4  	"context"
     5  	"strings"
     6  	"testing"
     7  
     8  	"get.porter.sh/porter/pkg/cnab"
     9  	"get.porter.sh/porter/pkg/schema"
    10  	"get.porter.sh/porter/pkg/secrets"
    11  	"get.porter.sh/porter/tests"
    12  	"github.com/cnabio/cnab-go/bundle"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestNewParameterSet(t *testing.T) {
    18  	ps := NewParameterSet("dev", "myparams",
    19  		secrets.SourceMap{
    20  			Name: "password",
    21  			Source: secrets.Source{
    22  				Strategy: "env",
    23  				Hint:     "DB_PASSWORD",
    24  			},
    25  		})
    26  
    27  	assert.Equal(t, DefaultParameterSetSchemaVersion, ps.SchemaVersion, "SchemaVersion was not set")
    28  	assert.Equal(t, "myparams", ps.Name, "Name was not set")
    29  	assert.Equal(t, "dev", ps.Namespace, "Namespace was not set")
    30  	assert.NotEmpty(t, ps.Status.Created, "Created was not set")
    31  	assert.NotEmpty(t, ps.Status.Modified, "Modified was not set")
    32  	assert.Equal(t, ps.Status.Created, ps.Status.Modified, "Created and Modified should have the same timestamp")
    33  	assert.Equal(t, SchemaTypeParameterSet, ps.SchemaType, "incorrect SchemaType")
    34  	assert.Equal(t, DefaultParameterSetSchemaVersion, ps.SchemaVersion, "incorrect SchemaVersion")
    35  	assert.Len(t, ps.Parameters, 1, "Parameters should be initialized with 1 value")
    36  }
    37  
    38  func TestParameterSet_String(t *testing.T) {
    39  	t.Run("global namespace", func(t *testing.T) {
    40  		ps := ParameterSet{ParameterSetSpec: ParameterSetSpec{Name: "myparams"}}
    41  		assert.Equal(t, "/myparams", ps.String())
    42  	})
    43  
    44  	t.Run("local namespace", func(t *testing.T) {
    45  		ps := ParameterSet{ParameterSetSpec: ParameterSetSpec{Namespace: "dev", Name: "myparams"}}
    46  		assert.Equal(t, "dev/myparams", ps.String())
    47  	})
    48  }
    49  
    50  func TestDisplayParameterSet_Validate(t *testing.T) {
    51  	t.Parallel()
    52  
    53  	testcases := []struct {
    54  		name          string
    55  		schemaType    string
    56  		schemaVersion cnab.SchemaVersion
    57  		wantError     string
    58  	}{
    59  		{
    60  			name:          "schemaType: none",
    61  			schemaType:    "",
    62  			schemaVersion: DefaultParameterSetSchemaVersion,
    63  			wantError:     ""},
    64  		{
    65  			name:          "schemaType: ParameterSet",
    66  			schemaType:    SchemaTypeParameterSet,
    67  			schemaVersion: DefaultParameterSetSchemaVersion,
    68  			wantError:     ""},
    69  		{
    70  			name:          "schemaType: PARAMETERSET",
    71  			schemaType:    strings.ToUpper(SchemaTypeParameterSet),
    72  			schemaVersion: DefaultParameterSetSchemaVersion,
    73  			wantError:     ""},
    74  		{
    75  			name:          "schemaType: parameterset",
    76  			schemaType:    strings.ToUpper(SchemaTypeParameterSet),
    77  			schemaVersion: DefaultParameterSetSchemaVersion,
    78  			wantError:     ""},
    79  		{
    80  			name:          "schemaType: CredentialSet",
    81  			schemaType:    SchemaTypeCredentialSet,
    82  			schemaVersion: DefaultParameterSetSchemaVersion,
    83  			wantError:     "invalid schemaType CredentialSet, expected ParameterSet"},
    84  		{
    85  			name:          "validate embedded ps",
    86  			schemaType:    SchemaTypeParameterSet,
    87  			schemaVersion: "", // this is required
    88  			wantError:     "invalid schema version"},
    89  	}
    90  
    91  	for _, tc := range testcases {
    92  		tc := tc
    93  		t.Run(tc.name, func(t *testing.T) {
    94  			t.Parallel()
    95  			ps := ParameterSet{ParameterSetSpec: ParameterSetSpec{
    96  				SchemaType:    tc.schemaType,
    97  				SchemaVersion: tc.schemaVersion,
    98  			}}
    99  			err := ps.Validate(context.Background(), schema.CheckStrategyExact)
   100  			if tc.wantError == "" {
   101  				require.NoError(t, err)
   102  			} else {
   103  				tests.RequireErrorContains(t, err, tc.wantError)
   104  			}
   105  		})
   106  	}
   107  }
   108  
   109  func TestParameterSet_Validate_DefaultSchemaType(t *testing.T) {
   110  	ps := NewParameterSet("", "myps")
   111  	ps.SchemaType = ""
   112  	require.NoError(t, ps.Validate(context.Background(), schema.CheckStrategyExact))
   113  	assert.Equal(t, SchemaTypeParameterSet, ps.SchemaType)
   114  }
   115  
   116  func TestParameterSetValidateBundle(t *testing.T) {
   117  	t.Run("valid - parameter specified", func(t *testing.T) {
   118  		spec := map[string]bundle.Parameter{
   119  			"kubeconfig": {},
   120  		}
   121  		ps := ParameterSet{ParameterSetSpec: ParameterSetSpec{
   122  			Parameters: []secrets.SourceMap{
   123  				{Name: "kubeconfig", ResolvedValue: "top secret param"},
   124  			}}}
   125  
   126  		err := ps.ValidateBundle(spec, "install")
   127  		require.NoError(t, err, "expected Validate to pass because the parameter was specified")
   128  	})
   129  
   130  	t.Run("valid - parameter not required or specified", func(t *testing.T) {
   131  		spec := map[string]bundle.Parameter{
   132  			"kubeconfig": {ApplyTo: []string{"install"}, Required: false},
   133  		}
   134  		ps := ParameterSet{}
   135  		err := ps.ValidateBundle(spec, "install")
   136  		require.NoError(t, err, "expected Validate to pass because the parameter isn't required")
   137  	})
   138  
   139  	t.Run("valid - missing inapplicable parameter", func(t *testing.T) {
   140  		spec := map[string]bundle.Parameter{
   141  			"kubeconfig": {ApplyTo: []string{"install"}, Required: true},
   142  		}
   143  		ps := ParameterSet{}
   144  		err := ps.ValidateBundle(spec, "custom")
   145  		require.NoError(t, err, "expected Validate to pass because the parameter isn't applicable to the custom action")
   146  	})
   147  
   148  	t.Run("invalid - missing required parameter", func(t *testing.T) {
   149  		spec := map[string]bundle.Parameter{
   150  			"kubeconfig": {ApplyTo: []string{"install"}, Required: true},
   151  		}
   152  		ps := ParameterSet{}
   153  		err := ps.ValidateBundle(spec, "install")
   154  		require.Error(t, err, "expected Validate to fail because the parameter applies to the specified action and is required")
   155  		assert.Contains(t, err.Error(), `parameter "kubeconfig" is required`)
   156  	})
   157  }