1 package mapper
2
3 import (
4 "time"
5
6 helmApi "github.com/fluxcd/helm-controller/api/v2beta1"
7 "google.golang.org/api/compute/v1"
8 corev1 "k8s.io/api/core/v1"
9 apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
10 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
11
12 "edge-infra.dev/pkg/edge/api/graph/model"
13 "edge-infra.dev/pkg/edge/constants"
14 )
15
16 func getTestHelmRelease() *helmApi.HelmRelease {
17 return &helmApi.HelmRelease{
18 TypeMeta: metav1.TypeMeta{
19 APIVersion: helmApi.GroupVersion.Group + "/" + helmApi.GroupVersion.Version,
20 Kind: "HelmRelease",
21 },
22 ObjectMeta: metav1.ObjectMeta{
23 Name: "test-helm-release",
24 Namespace: "test-ns",
25 CreationTimestamp: metav1.Now(),
26 },
27 Spec: helmApi.HelmReleaseSpec{
28 Chart: &helmApi.HelmChartTemplate{
29 Spec: helmApi.HelmChartTemplateSpec{
30 Chart: "test-helm-chart",
31 Version: "2.0.x",
32 SourceRef: helmApi.CrossNamespaceObjectReference{
33 Name: "test-helm-release",
34 },
35 },
36 },
37 Values: &apiextensionsv1.JSON{
38 Raw: []byte(configValues),
39 },
40 TargetNamespace: "test-target-ns",
41 Timeout: &metav1.Duration{
42 Duration: time.Duration(HelmReleaseTimeout) * time.Minute,
43 },
44 },
45 Status: helmApi.HelmReleaseStatus{
46 ObservedGeneration: 0,
47 Conditions: []metav1.Condition{{
48 Type: "Ready",
49 Status: "True",
50 LastTransitionTime: metav1.Now(),
51 Reason: "test reason",
52 Message: "reconciliation successful",
53 }, {
54 Type: helmApi.ReleasedCondition,
55 Status: "False",
56 LastTransitionTime: metav1.Now(),
57 Reason: "test failure",
58 Message: "install failed",
59 }},
60
61
62
63
64
65 },
66 }
67 }
68
69 func GetTestHelmRepositorySecret() *model.SecretManagerResponse {
70 n := time.Now().String()
71 w := "edge-tenant"
72 return &model.SecretManagerResponse{
73 Name: "secret-name",
74 Created: &n,
75 Workload: &w,
76 Values: []*model.KeyValuesOutput{{Key: constants.HelmURL, Value: "https://test.ncr.com"}, {Key: constants.HelmRepoName, Value: "test-helm-release"}},
77 }
78 }
79
80 func getTestHelmReleaseData(helmReleases []helmApi.HelmRelease) map[string][]*string {
81 helmReleasesData := make(map[string][]*string)
82 helmVersion := make([]*string, 0)
83 versions := []string{"0.3.0", "0.2.0", "0.1.4", "0.1.3", "0.1.2", "0.1.1"}
84 for index := range versions {
85 helmVersion = append(helmVersion, &versions[index])
86 }
87 for _, helmData := range helmReleases {
88 helmReleasesData[helmData.Spec.Chart.Spec.SourceRef.Name] = getHelmChartVersions(helmData.Spec.Chart.Spec.Chart, helmVersion).Versions
89 }
90 return helmReleasesData
91 }
92
93 func getHelmChartVersions(name string, versions []*string) *model.HelmChartResponse {
94 return &model.HelmChartResponse{
95 Name: name,
96 Versions: versions,
97 }
98 }
99
100 func getCreateHelmReleaseCreate(actionNs, targetNamespace string) *helmApi.HelmRelease {
101 labels := map[string]string{
102 "parent-cluster": Region,
103 SecretManagerSecretLabel: "",
104 }
105 helmRelease := &helmApi.HelmRelease{
106 TypeMeta: metav1.TypeMeta{
107 APIVersion: helmApi.GroupVersion.String(),
108 Kind: "HelmRelease",
109 },
110 ObjectMeta: metav1.ObjectMeta{
111 Name: name,
112 Namespace: actionNs,
113 Labels: labels,
114 },
115 Spec: helmApi.HelmReleaseSpec{
116 Interval: metav1.Duration{
117 Duration: time.Duration(2) * time.Minute,
118 },
119 ReleaseName: name,
120 TargetNamespace: targetNamespace,
121 Chart: &helmApi.HelmChartTemplate{
122 Spec: helmApi.HelmChartTemplateSpec{
123 Chart: helmChart,
124 Version: version,
125 SourceRef: helmApi.CrossNamespaceObjectReference{
126 Kind: "HelmRepository",
127 Name: helmRepository,
128 },
129 },
130 },
131 Timeout: &metav1.Duration{
132 Duration: time.Duration(HelmReleaseTimeout) * time.Minute,
133 },
134 },
135 }
136 return helmRelease
137 }
138
139 func getTestServiceAccountSecret(name string, data []byte) *corev1.Secret {
140 labels := map[string]string{
141 "edge-type": "service_account",
142 }
143 return &corev1.Secret{
144 TypeMeta: metav1.TypeMeta{
145 APIVersion: "v1",
146 Kind: "ServiceAccount",
147 },
148 ObjectMeta: metav1.ObjectMeta{
149 Name: name,
150 Namespace: "test",
151 Labels: labels,
152 CreationTimestamp: metav1.Now(),
153 },
154 Data: map[string][]byte{
155 "key.json": data,
156 },
157 }
158 }
159
160 func getTestServiceAccount() *model.ServiceAccount {
161 return &model.ServiceAccount{
162 ProjectID: &projectID,
163 PrivateKeyID: &privateKeyID,
164 PrivateKey: &privateKey,
165 ClientEmail: &clientEmail,
166 TokenURI: &tokenURI,
167 }
168 }
169
170 func getTestZoneList() *compute.ZoneList {
171 return &compute.ZoneList{
172 Items: []*compute.Zone{getTestZone("us-east1-a"), getTestZone("us-central2-b")},
173 }
174 }
175
176 func getTestZone(name string) *compute.Zone {
177 return &compute.Zone{
178 Name: name,
179 }
180 }
181
182 func getTestMachineList() *compute.MachineTypeList {
183 return &compute.MachineTypeList{
184 Items: []*compute.MachineType{getTestMachineType("n1-standard-2", 4, 61440)},
185 }
186 }
187
188 func getTestMachineType(name string, numCPUs int64, memoryMb int64) *compute.MachineType {
189 return &compute.MachineType{
190 Name: name,
191 GuestCpus: numCPUs,
192 MemoryMb: memoryMb,
193 }
194 }
195
196 func getTestGkeVersions() []string {
197 return []string{"1.4-gke-test", "1.4.5-gke-test"}
198 }
199
200 func getTestStringArr(str1, str2 string) []*string {
201 return []*string{&str1, &str2}
202 }
203
204 func getTestMachineInfo(name string, numCPUs int, memoryGB int) *model.MachineTypeInfo {
205 return &model.MachineTypeInfo{
206 Name: name,
207 GuestCPUs: numCPUs,
208 MemoryGb: memoryGB,
209 }
210 }
211
212 func getTestSecret(org, secretType, name string) *corev1.Secret {
213 labels := map[string]string{
214 "edge-type": secretType,
215 }
216 return &corev1.Secret{
217 TypeMeta: metav1.TypeMeta{
218 APIVersion: "v1",
219 Kind: "Secret",
220 },
221 ObjectMeta: metav1.ObjectMeta{
222 Name: name,
223 Namespace: org,
224 Labels: labels,
225 CreationTimestamp: metav1.Now(),
226 },
227 }
228 }
229
230 func getSecret(namespace, name, kubeconfig string) *corev1.Secret {
231 return &corev1.Secret{
232 TypeMeta: metav1.TypeMeta{
233 APIVersion: "v1",
234 Kind: "Secret",
235 },
236 ObjectMeta: metav1.ObjectMeta{
237 Name: name,
238 Namespace: namespace,
239 },
240 Data: map[string][]byte{
241 "kubeconfig.yaml": []byte(kubeconfig),
242 },
243 }
244 }
245
View as plain text