1 package services
2
3 import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "strings"
8 "testing"
9 "time"
10
11 "github.com/DATA-DOG/go-sqlmock"
12 kustomizeApi "github.com/fluxcd/kustomize-controller/api/v1"
13 "github.com/golang/mock/gomock"
14 "github.com/google/go-containerregistry/pkg/name"
15 "github.com/stretchr/testify/assert"
16
17 "edge-infra.dev/pkg/edge/api/graph/model"
18 "edge-infra.dev/pkg/edge/api/mocks"
19 sqlquery "edge-infra.dev/pkg/edge/api/sql"
20 "edge-infra.dev/pkg/edge/api/types"
21 ctypes "edge-infra.dev/pkg/edge/constants/api/cluster"
22 palletconst "edge-infra.dev/pkg/edge/constants/api/pallet"
23 "edge-infra.dev/pkg/f8n/warehouse/oci"
24 "edge-infra.dev/pkg/f8n/warehouse/pallet"
25 "edge-infra.dev/test/fixtures"
26 )
27
28 func TestCreateKustomizations(t *testing.T) {
29 kus, err := CreateKustomizations(context.Background(), "test-bucket", "test-cluster-id", "latest")
30 assert.NoError(t, err)
31 assert.Equal(t, 1, len(kus))
32 names := map[string]bool{}
33 paths := map[string]bool{}
34 for _, k := range kus {
35 fluxKustomize := &kustomizeApi.Kustomization{}
36 err := json.Unmarshal([]byte(k), fluxKustomize)
37 assert.NoError(t, err)
38 assert.Equal(t, "test-bucket", fluxKustomize.Spec.SourceRef.Name)
39 paths[fluxKustomize.Spec.Path] = true
40 names[fluxKustomize.Name] = true
41 }
42 _, ok := names["flux-config-kustomization"]
43 assert.True(t, ok)
44 }
45
46 func TestCreateKustomizations2(t *testing.T) {
47 kus, err := CreateKustomizations(context.Background(), "edge-bucket", "test-cluster-edge-id", "latest")
48 assert.NoError(t, err)
49 assert.Equal(t, 1, len(kus))
50 names := map[string]bool{}
51 paths := map[string]bool{}
52 for _, k := range kus {
53 fluxKustomize := &kustomizeApi.Kustomization{}
54 err := json.Unmarshal([]byte(k), fluxKustomize)
55 assert.NoError(t, err)
56 assert.Equal(t, "edge-bucket", fluxKustomize.Spec.SourceRef.Name)
57 paths[fluxKustomize.Spec.Path] = true
58 names[fluxKustomize.Name] = true
59 }
60 _, ok := paths["./test-cluster-edge-id/fluxcfg/"]
61 assert.True(t, ok)
62 _, ok = names["flux-config-kustomization"]
63 assert.True(t, ok)
64 }
65
66 func TestGetInstallManifests(t *testing.T) {
67 mock := gomock.NewController(t)
68 c := mocks.NewMockArtifactRegistryClient(mock)
69 path, err := fixtures.Layout()
70 assert.NoError(t, err)
71
72 c.EXPECT().
73 Get(gomock.Any(), gomock.Any(), gomock.Any()).
74 DoAndReturn(func(_ string, artifactName string, _ string) (oci.Artifact, error) {
75 if artifactName == "k8s-admission-controller" {
76 return getPallet(path, artifactName, "latest")
77 }
78
79
80 return getPallet(path, "edge-bsl", "latest")
81 }).AnyTimes()
82
83 testClusterEdgeID := "498e13f0-a6fb-4589-9ee8-18f2529dc61b"
84 db, dbmock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
85 if err != nil {
86 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
87 }
88 defer db.Close()
89 callExpectQueryFn := func() *sqlmock.ExpectedQuery {
90 return dbmock.ExpectQuery(sqlquery.GetClusterFleetVersion).
91 WithArgs(testClusterEdgeID).
92 WillReturnRows(sqlmock.NewRows([]string{"fleet_version"}).AddRow("latest"))
93 }
94
95 bsService := NewBootstrapService("top-level", c, db)
96 cluster := &model.Cluster{ClusterEdgeID: testClusterEdgeID, ProjectID: "test-project"}
97
98 type test struct {
99 provider string
100 pallets []types.Pallet
101 palletTypes string
102
103 expectQueryHook func() *sqlmock.ExpectedQuery
104 expectManifestsLen int
105 }
106 tests := []test{
107 {
108 provider: ctypes.Generic,
109 palletTypes: "bootstrap",
110 pallets: palletconst.BootstrapPallets,
111 expectQueryHook: callExpectQueryFn,
112 expectManifestsLen: 36,
113 },
114 {
115 provider: ctypes.GKE,
116 palletTypes: "bootstrap",
117 pallets: palletconst.BootstrapPallets,
118 expectQueryHook: callExpectQueryFn,
119 expectManifestsLen: 36,
120 },
121 {
122 provider: ctypes.GKE,
123 palletTypes: "prebootstrap",
124 pallets: palletconst.PreBootstrapPallets,
125 expectQueryHook: callExpectQueryFn,
126 expectManifestsLen: 23,
127 },
128 {
129 provider: ctypes.DSDS,
130 palletTypes: "prebootstrap",
131 pallets: palletconst.PreBootstrapPallets,
132 expectQueryHook: callExpectQueryFn,
133 expectManifestsLen: 23,
134 },
135 {
136 provider: ctypes.DSDS,
137 palletTypes: "prebootstrapstatic",
138 pallets: palletconst.PreBootstrapStaticPallets,
139 expectQueryHook: callExpectQueryFn,
140 expectManifestsLen: 1,
141 },
142 }
143
144 for _, tc := range tests {
145 name := fmt.Sprintf("expect_%d_manifests_for_%s_%s", tc.expectManifestsLen, tc.provider, tc.palletTypes)
146 tc.expectQueryHook()
147 t.Run(name, func(t *testing.T) {
148 manifests, err := bsService.GetManifests(
149 context.Background(),
150 tc.provider,
151 tc.pallets,
152 cluster,
153 )
154 assert.NoError(t, err)
155 assert.Len(t, manifests, tc.expectManifestsLen)
156 })
157 }
158 }
159
160 func getPallet(path *fixtures.Path, palletName string, fleetVersion string) (pallet.Pallet, error) {
161 palletIdentifier := strings.Join([]string{palletName, fleetVersion}, ":")
162 palletRef, err := name.ParseReference(palletIdentifier)
163 if err != nil {
164 return nil, err
165 }
166
167 artifact, err := path.Get(palletRef)
168 if err != nil {
169 return nil, err
170 }
171
172 return pallet.New(artifact)
173 }
174
175 func TestCreateClusterBootstrapTokenEntry(t *testing.T) {
176 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
177 if err != nil {
178 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
179 }
180 defer db.Close()
181 secretName := "secret-name"
182 clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a200"
183 expireAt := time.Now().Add(time.Minute)
184 mock.ExpectExec(sqlquery.CreateClusterBootstrapToken).WithArgs(sqlmock.AnyArg(), secretName, clusterEdgeID, expireAt).WillReturnResult(sqlmock.NewResult(1, 1))
185 bsService := NewBootstrapService("top-level", nil, db)
186
187 err = bsService.CreateClusterBootstrapTokenEntry(context.Background(), clusterEdgeID, secretName, expireAt)
188 assert.NoError(t, err)
189 assert.NoError(t, mock.ExpectationsWereMet())
190 }
191
192 func TestDeleteExpiredClusterBootstrapTokens(t *testing.T) {
193 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
194 if err != nil {
195 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
196 }
197 defer db.Close()
198 clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a200"
199 mock.ExpectExec(sqlquery.DeleteExpiredClusterBootstrapTokens).WithArgs(clusterEdgeID).WillReturnResult(sqlmock.NewResult(1, 1))
200 bsService := NewBootstrapService("top-level", nil, db)
201
202 err = bsService.DeleteExpiredClusterBootstrapTokens(context.Background(), clusterEdgeID)
203 assert.NoError(t, err)
204 assert.NoError(t, mock.ExpectationsWereMet())
205 }
206
View as plain text