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  }