github.com/replicatedcom/ship@v0.50.0/pkg/specs/replicatedapp/resolver_test.go (about) 1 package replicatedapp 2 3 import ( 4 "fmt" 5 "reflect" 6 "testing" 7 8 "github.com/golang/mock/gomock" 9 "github.com/replicatedhq/ship/pkg/api" 10 "github.com/replicatedhq/ship/pkg/constants" 11 state2 "github.com/replicatedhq/ship/pkg/state" 12 "github.com/replicatedhq/ship/pkg/test-mocks/state" 13 "github.com/replicatedhq/ship/pkg/testing/logger" 14 "github.com/replicatedhq/ship/pkg/testing/matchers" 15 "github.com/spf13/afero" 16 "github.com/spf13/viper" 17 "github.com/stretchr/testify/require" 18 ) 19 20 func TestPersistSpec(t *testing.T) { 21 22 r := &resolver{ 23 FS: afero.Afero{Fs: afero.NewMemMapFs()}, 24 } 25 26 req := require.New(t) 27 28 desiredSpec := []byte("my cool spec") 29 err := r.persistSpec(desiredSpec) 30 req.NoError(err) 31 32 persistedSpec, err := r.FS.ReadFile(constants.ReleasePath) 33 req.NoError(err) 34 req.True(reflect.DeepEqual(desiredSpec, persistedSpec)) 35 } 36 37 func TestPersistRelease(t *testing.T) { 38 happyPathSpec := state2.ShipRelease{ 39 ID: "12345", 40 Spec: ` 41 --- 42 assets: 43 v1: [] 44 `, 45 } 46 47 tests := []struct { 48 name string 49 inputRelease *state2.ShipRelease 50 inputSelector *Selector 51 shaSummer shaSummer 52 license *license 53 expectCalls func(t *testing.T, stateManager *state.MockManager) 54 expectRelease *api.Release 55 }{ 56 { 57 name: "happy path", 58 inputRelease: &happyPathSpec, 59 inputSelector: &Selector{ 60 CustomerID: "kfbr", 61 InstallationID: "392", 62 }, 63 shaSummer: func(resolver state2.ShipRelease) string { 64 return "abcdef" 65 }, 66 license: &license{}, 67 expectCalls: func(t *testing.T, stateManager *state.MockManager) { 68 stateManager.EXPECT().SerializeAppMetadata(&matchers.Is{ 69 Test: func(v interface{}) bool { 70 rm := v.(api.ReleaseMetadata) 71 t.Log("testing release metadata", fmt.Sprintf("%v", rm)) 72 return rm.ReleaseID == "12345" && 73 rm.CustomerID == "kfbr" && 74 rm.InstallationID == "392" 75 }, 76 }) 77 stateManager.EXPECT().SerializeContentSHA("abcdef") 78 contents := state2.UpstreamContents{AppRelease: &happyPathSpec} 79 stateManager.EXPECT().SerializeUpstreamContents(&contents) 80 }, 81 expectRelease: &api.Release{ 82 Spec: api.Spec{ 83 Assets: api.Assets{ 84 V1: []api.Asset{}, 85 }, 86 }, 87 Metadata: api.ReleaseMetadata{ 88 ReleaseID: "12345", 89 CustomerID: "kfbr", 90 InstallationID: "392", 91 Images: []api.Image{}, 92 GithubContents: []api.GithubContent{}, 93 }, 94 }, 95 }, 96 } 97 for _, test := range tests { 98 t.Run(test.name, func(t *testing.T) { 99 req := require.New(t) 100 mc := gomock.NewController(t) 101 stateManager := state.NewMockManager(mc) 102 defer mc.Finish() 103 104 test.expectCalls(t, stateManager) 105 106 resolver := &resolver{ 107 Logger: &logger.TestLogger{T: t}, 108 StateManager: stateManager, 109 ShaSummer: test.shaSummer, 110 Dater: func() string { return "" }, 111 } 112 113 result, err := resolver.persistRelease(test.inputRelease, test.license, test.inputSelector) 114 115 req.NoError(err) 116 req.Equal(test.expectRelease, result) 117 }) 118 } 119 } 120 121 func Test_resolver_updateUpstream(t *testing.T) { 122 tests := []struct { 123 name string 124 initUpstream string 125 selector Selector 126 expectUpstream string 127 }{ 128 { 129 name: "replicated.app", 130 initUpstream: "replicated.app", 131 selector: Selector{ 132 CustomerID: "abc", 133 InstallationID: "xyz", 134 }, 135 expectUpstream: "replicated.app/?customer_id=abc&installation_id=xyz", 136 }, 137 { 138 name: "staging.replicated.app", 139 initUpstream: "staging.replicated.app", 140 selector: Selector{ 141 CustomerID: "abc", 142 InstallationID: "xyz", 143 }, 144 expectUpstream: "staging.replicated.app/?customer_id=abc&installation_id=xyz", 145 }, 146 { 147 name: "slug app", 148 initUpstream: "replicated.app/abc", 149 selector: Selector{ 150 AppSlug: "abc", 151 LicenseID: "xyz", 152 }, 153 expectUpstream: "replicated.app/abc/?license_id=xyz", 154 }, 155 } 156 for _, tt := range tests { 157 t.Run(tt.name, func(t *testing.T) { 158 req := require.New(t) 159 160 fs := afero.Afero{Fs: afero.NewMemMapFs()} 161 162 realState, err := state2.NewDisposableManager(&logger.TestLogger{T: t}, fs, viper.New()) 163 req.NoError(err) 164 165 resolver := &resolver{ 166 Logger: &logger.TestLogger{T: t}, 167 StateManager: realState, 168 } 169 170 req.NoError(realState.SerializeUpstream(tt.initUpstream)) 171 172 err = resolver.updateUpstream(tt.selector) 173 req.NoError(err) 174 175 afterState, err := realState.CachedState() 176 req.NoError(err) 177 178 req.Equal(tt.expectUpstream, afterState.Upstream()) 179 }) 180 } 181 }