Skip to content

Commit 5d77e88

Browse files
vishesh92vishesh92
committed
Add unit tests
1 parent 6c161a7 commit 5d77e88

9 files changed

Lines changed: 240 additions & 18 deletions

‎pkg/cloud/affinity_groups_test.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ var _ = Describe("AffinityGroup Unit Tests", func() {
4747
mockClient = cloudstack.NewMockClient(mockCtrl)
4848
ags = mockClient.AffinityGroup.(*cloudstack.MockAffinityGroupServiceIface)
4949
vms = mockClient.VirtualMachine.(*cloudstack.MockVirtualMachineServiceIface)
50-
client = cloud.NewClientFromCSAPIClient(mockClient)
50+
client = cloud.NewClientFromCSAPIClient(mockClient, nil)
5151
dummies.SetDummyVars()
5252
})
5353

‎pkg/cloud/client.go‎

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -221,12 +221,9 @@ func (c *client) NewClientInDomainAndAccount(domain string, account string) (Cli
221221
}
222222

223223
// NewClientFromCSAPIClient creates a client from a CloudStack-Go API client. Used only for testing.
224-
func NewClientFromCSAPIClient(cs *cloudstack.CloudStackClient) Client {
225-
c := &client{
226-
cs: cs,
227-
csAsync: cs,
228-
customMetrics: metrics.NewCustomMetrics(),
229-
user: &User{
224+
func NewClientFromCSAPIClient(cs *cloudstack.CloudStackClient, user *User) Client {
225+
if user == nil {
226+
user = &User{
230227
Account: Account{
231228
Domain: Domain{
232229
CPUAvailable: "Unlimited",
@@ -237,7 +234,14 @@ func NewClientFromCSAPIClient(cs *cloudstack.CloudStackClient) Client {
237234
MemoryAvailable: "Unlimited",
238235
VMAvailable: "Unlimited",
239236
},
240-
}}
237+
}
238+
}
239+
c := &client{
240+
cs: cs,
241+
csAsync: cs,
242+
customMetrics: metrics.NewCustomMetrics(),
243+
user: user,
244+
}
241245
return c
242246
}
243247

‎pkg/cloud/instance.go‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ func (c *client) ResolveServiceOffering(csMachine *infrav1.CloudStackMachine, zo
9191
csOffering, count, err := c.cs.ServiceOffering.GetServiceOfferingByID(csMachine.Spec.Offering.ID)
9292
if err != nil {
9393
c.customMetrics.EvaluateErrorAndIncrementAcsReconciliationErrorCounter(err)
94-
return *csOffering, multierror.Append(retErr, errors.Wrapf(
94+
return cloudstack.ServiceOffering{}, multierror.Append(retErr, errors.Wrapf(
9595
err, "could not get Service Offering by ID %s", csMachine.Spec.Offering.ID))
9696
} else if count != 1 {
9797
return *csOffering, multierror.Append(retErr, errors.Errorf(
@@ -107,7 +107,7 @@ func (c *client) ResolveServiceOffering(csMachine *infrav1.CloudStackMachine, zo
107107
csOffering, count, err := c.cs.ServiceOffering.GetServiceOfferingByName(csMachine.Spec.Offering.Name, cloudstack.WithZone(zoneID))
108108
if err != nil {
109109
c.customMetrics.EvaluateErrorAndIncrementAcsReconciliationErrorCounter(err)
110-
return *csOffering, multierror.Append(retErr, errors.Wrapf(
110+
return cloudstack.ServiceOffering{}, multierror.Append(retErr, errors.Wrapf(
111111
err, "could not get Service Offering ID from %s in zone %s", csMachine.Spec.Offering.Name, zoneID))
112112
} else if count != 1 {
113113
return *csOffering, multierror.Append(retErr, errors.Errorf(
@@ -225,7 +225,7 @@ func (c *client) CheckAccountLimits(fd *infrav1.CloudStackFailureDomain, offerin
225225

226226
if c.user.Account.VMAvailable != "Unlimited" {
227227
vmAvailable, err := strconv.ParseInt(c.user.Account.VMAvailable, 10, 0)
228-
if err == nil && vmAvailable <= 0 {
228+
if err == nil && vmAvailable < 1 {
229229
return fmt.Errorf("VM Limit in account has reached it's maximum value")
230230
}
231231
}
@@ -250,7 +250,7 @@ func (c *client) CheckDomainLimits(fd *infrav1.CloudStackFailureDomain, offering
250250

251251
if c.user.Account.Domain.VMAvailable != "Unlimited" {
252252
vmAvailable, err := strconv.ParseInt(c.user.Account.Domain.VMAvailable, 10, 0)
253-
if err == nil && vmAvailable > 0 {
253+
if err == nil && vmAvailable < 1 {
254254
return fmt.Errorf("VM Limit in domain has reached it's maximum value")
255255
}
256256
}

‎pkg/cloud/instance_test.go‎

Lines changed: 219 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ var _ = Describe("Instance", func() {
6666
ts = mockClient.Template.(*cloudstack.MockTemplateServiceIface)
6767
vs = mockClient.Volume.(*cloudstack.MockVolumeServiceIface)
6868
as = mockClient.Address.(*cloudstack.MockAddressServiceIface)
69-
client = cloud.NewClientFromCSAPIClient(mockClient)
69+
client = cloud.NewClientFromCSAPIClient(mockClient, nil)
7070

7171
dummies.SetDummyVars()
7272
})
@@ -128,6 +128,8 @@ var _ = Describe("Instance", func() {
128128
expectVMNotFound := func() {
129129
vms.EXPECT().GetVirtualMachinesMetricByID(*dummies.CSMachine1.Spec.InstanceID).Return(nil, -1, notFoundError)
130130
vms.EXPECT().GetVirtualMachinesMetricByName(dummies.CSMachine1.Name).Return(nil, -1, notFoundError)
131+
}
132+
expectPublicIPAddress := func() {
131133
aslp := &cloudstack.ListPublicIpAddressesParams{}
132134
as.EXPECT().NewListPublicIpAddressesParams().Return(aslp)
133135
as.EXPECT().ListPublicIpAddresses(aslp).Return(&cloudstack.ListPublicIpAddressesResponse{
@@ -151,14 +153,29 @@ var _ = Describe("Instance", func() {
151153

152154
It("returns errors occurring while fetching service offering information", func() {
153155
expectVMNotFound()
156+
expectPublicIPAddress()
154157
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).Return(&cloudstack.ServiceOffering{}, -1, unknownError)
155158
Ω(client.GetOrCreateVMInstance(
156159
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
157160
ShouldNot(Succeed())
158161
})
159162

163+
It("returns errors occurring if not enough public IPs available", func() {
164+
expectVMNotFound()
165+
166+
aslp := &cloudstack.ListPublicIpAddressesParams{}
167+
as.EXPECT().NewListPublicIpAddressesParams().Return(aslp)
168+
as.EXPECT().ListPublicIpAddresses(aslp).Return(&cloudstack.ListPublicIpAddressesResponse{
169+
Count: 2, PublicIpAddresses: []*cloudstack.PublicIpAddress{{State: "Allocated"}, {State: "Allocated"}},
170+
}, nil)
171+
Ω(client.GetOrCreateVMInstance(
172+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
173+
ShouldNot(Succeed())
174+
})
175+
160176
It("returns errors if more than one service offering found", func() {
161177
expectVMNotFound()
178+
expectPublicIPAddress()
162179
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).Return(&cloudstack.ServiceOffering{
163180
Id: dummies.CSMachine1.Spec.Offering.ID,
164181
Name: dummies.CSMachine1.Spec.Offering.Name,
@@ -170,6 +187,7 @@ var _ = Describe("Instance", func() {
170187

171188
It("returns errors while fetching template", func() {
172189
expectVMNotFound()
190+
expectPublicIPAddress()
173191
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
174192
Return(&cloudstack.ServiceOffering{
175193
Id: dummies.CSMachine1.Spec.Offering.ID,
@@ -184,6 +202,7 @@ var _ = Describe("Instance", func() {
184202

185203
It("returns errors when more than one template found", func() {
186204
expectVMNotFound()
205+
expectPublicIPAddress()
187206
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
188207
Return(&cloudstack.ServiceOffering{
189208
Id: dummies.CSMachine1.Spec.Offering.ID,
@@ -197,6 +216,7 @@ var _ = Describe("Instance", func() {
197216

198217
It("returns errors when more than one diskoffering found", func() {
199218
expectVMNotFound()
219+
expectPublicIPAddress()
200220
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
201221
Return(&cloudstack.ServiceOffering{
202222
Id: dummies.CSMachine1.Spec.Offering.ID,
@@ -211,6 +231,7 @@ var _ = Describe("Instance", func() {
211231

212232
It("returns errors when fetching diskoffering", func() {
213233
expectVMNotFound()
234+
expectPublicIPAddress()
214235
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
215236
Return(&cloudstack.ServiceOffering{
216237
Id: dummies.CSMachine1.Spec.Offering.ID,
@@ -226,6 +247,7 @@ var _ = Describe("Instance", func() {
226247

227248
It("returns errors when disk size not zero for non-customized disk offering", func() {
228249
expectVMNotFound()
250+
expectPublicIPAddress()
229251
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 1
230252
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
231253
Return(&cloudstack.ServiceOffering{
@@ -242,6 +264,7 @@ var _ = Describe("Instance", func() {
242264

243265
It("returns errors when disk size zero for customized disk offering", func() {
244266
expectVMNotFound()
267+
expectPublicIPAddress()
245268
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
246269
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
247270
Return(&cloudstack.ServiceOffering{
@@ -258,8 +281,203 @@ var _ = Describe("Instance", func() {
258281
ShouldNot(Succeed())
259282
})
260283

284+
Context("when account & domains have limits", func() {
285+
It("returns errors when there are not enough available CPU in account", func() {
286+
expectVMNotFound()
287+
expectPublicIPAddress()
288+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
289+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
290+
Return(&cloudstack.ServiceOffering{
291+
Id: dummies.CSMachine1.Spec.Offering.ID,
292+
Name: dummies.CSMachine1.Spec.Offering.Name,
293+
Cpunumber: 2,
294+
Memory: 1024,
295+
}, 1, nil)
296+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
297+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
298+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
299+
user := &cloud.User{
300+
Account: cloud.Account{
301+
Domain: cloud.Domain{
302+
CPUAvailable: "20",
303+
MemoryAvailable: "2048",
304+
VMAvailable: "20",
305+
},
306+
CPUAvailable: "1",
307+
MemoryAvailable: "2048",
308+
VMAvailable: "20",
309+
},
310+
}
311+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
312+
Ω(c.GetOrCreateVMInstance(
313+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
314+
Should(MatchError(MatchRegexp("CPU available .* in account can't fulfil the requirement:.*")))
315+
})
316+
317+
It("returns errors when there are not enough available CPU in domain", func() {
318+
expectVMNotFound()
319+
expectPublicIPAddress()
320+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
321+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
322+
Return(&cloudstack.ServiceOffering{
323+
Id: dummies.CSMachine1.Spec.Offering.ID,
324+
Name: dummies.CSMachine1.Spec.Offering.Name,
325+
Cpunumber: 2,
326+
Memory: 1024,
327+
}, 1, nil)
328+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
329+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
330+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
331+
user := &cloud.User{
332+
Account: cloud.Account{
333+
Domain: cloud.Domain{
334+
CPUAvailable: "1",
335+
MemoryAvailable: "2048",
336+
VMAvailable: "20",
337+
},
338+
CPUAvailable: "20",
339+
MemoryAvailable: "2048",
340+
VMAvailable: "20",
341+
},
342+
}
343+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
344+
Ω(c.GetOrCreateVMInstance(
345+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
346+
Should(MatchError(MatchRegexp("CPU available .* in domain can't fulfil the requirement:.*")))
347+
})
348+
349+
It("returns errors when there is not enough available memory in account", func() {
350+
expectVMNotFound()
351+
expectPublicIPAddress()
352+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
353+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
354+
Return(&cloudstack.ServiceOffering{
355+
Id: dummies.CSMachine1.Spec.Offering.ID,
356+
Name: dummies.CSMachine1.Spec.Offering.Name,
357+
Cpunumber: 2,
358+
Memory: 1024,
359+
}, 1, nil)
360+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
361+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
362+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
363+
user := &cloud.User{
364+
Account: cloud.Account{
365+
Domain: cloud.Domain{
366+
CPUAvailable: "20",
367+
MemoryAvailable: "2048",
368+
VMAvailable: "20",
369+
},
370+
CPUAvailable: "20",
371+
MemoryAvailable: "512",
372+
VMAvailable: "20",
373+
},
374+
}
375+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
376+
Ω(c.GetOrCreateVMInstance(
377+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
378+
Should(MatchError(MatchRegexp("memory available .* in account can't fulfil the requirement:.*")))
379+
})
380+
381+
It("returns errors when there is not enough available memory in domain", func() {
382+
expectVMNotFound()
383+
expectPublicIPAddress()
384+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
385+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
386+
Return(&cloudstack.ServiceOffering{
387+
Id: dummies.CSMachine1.Spec.Offering.ID,
388+
Name: dummies.CSMachine1.Spec.Offering.Name,
389+
Cpunumber: 2,
390+
Memory: 1024,
391+
}, 1, nil)
392+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
393+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
394+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
395+
user := &cloud.User{
396+
Account: cloud.Account{
397+
Domain: cloud.Domain{
398+
CPUAvailable: "20",
399+
MemoryAvailable: "512",
400+
VMAvailable: "20",
401+
},
402+
CPUAvailable: "20",
403+
MemoryAvailable: "2048",
404+
VMAvailable: "20",
405+
},
406+
}
407+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
408+
Ω(c.GetOrCreateVMInstance(
409+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
410+
Should(MatchError(MatchRegexp("memory available .* in domain can't fulfil the requirement:.*")))
411+
})
412+
413+
It("returns errors when there is not enough available VM limit in account", func() {
414+
expectVMNotFound()
415+
expectPublicIPAddress()
416+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
417+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
418+
Return(&cloudstack.ServiceOffering{
419+
Id: dummies.CSMachine1.Spec.Offering.ID,
420+
Name: dummies.CSMachine1.Spec.Offering.Name,
421+
Cpunumber: 2,
422+
Memory: 1024,
423+
}, 1, nil)
424+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
425+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
426+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
427+
user := &cloud.User{
428+
Account: cloud.Account{
429+
Domain: cloud.Domain{
430+
CPUAvailable: "20",
431+
MemoryAvailable: "2048",
432+
VMAvailable: "20",
433+
},
434+
CPUAvailable: "20",
435+
MemoryAvailable: "2048",
436+
VMAvailable: "0",
437+
},
438+
}
439+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
440+
Ω(c.GetOrCreateVMInstance(
441+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
442+
Should(MatchError("VM Limit in account has reached it's maximum value"))
443+
})
444+
445+
It("returns errors when there is not enough available VM limit in domain", func() {
446+
expectVMNotFound()
447+
expectPublicIPAddress()
448+
dummies.CSMachine1.Spec.DiskOffering.CustomSize = 0
449+
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
450+
Return(&cloudstack.ServiceOffering{
451+
Id: dummies.CSMachine1.Spec.Offering.ID,
452+
Name: dummies.CSMachine1.Spec.Offering.Name,
453+
Cpunumber: 2,
454+
Memory: 1024,
455+
}, 1, nil)
456+
ts.EXPECT().GetTemplateID(dummies.CSMachine1.Spec.Template.Name, executableFilter, dummies.Zone1.ID).Return(dummies.CSMachine1.Spec.Template.ID, 1, nil)
457+
dos.EXPECT().GetDiskOfferingID(dummies.CSMachine1.Spec.DiskOffering.Name, gomock.Any()).Return(diskOfferingFakeID, 1, nil)
458+
dos.EXPECT().GetDiskOfferingByID(diskOfferingFakeID).Return(&cloudstack.DiskOffering{Iscustomized: false}, 1, nil)
459+
user := &cloud.User{
460+
Account: cloud.Account{
461+
Domain: cloud.Domain{
462+
CPUAvailable: "20",
463+
MemoryAvailable: "2048",
464+
VMAvailable: "0",
465+
},
466+
CPUAvailable: "20",
467+
MemoryAvailable: "2048",
468+
VMAvailable: "10",
469+
},
470+
}
471+
c := cloud.NewClientFromCSAPIClient(mockClient, user)
472+
Ω(c.GetOrCreateVMInstance(
473+
dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSFailureDomain1, dummies.CSAffinityGroup, "")).
474+
Should(MatchError("VM Limit in domain has reached it's maximum value"))
475+
})
476+
})
477+
261478
It("handles deployment errors", func() {
262479
expectVMNotFound()
480+
expectPublicIPAddress()
263481
sos.EXPECT().GetServiceOfferingByName(dummies.CSMachine1.Spec.Offering.Name, gomock.Any()).
264482
Return(&cloudstack.ServiceOffering{
265483
Id: offeringFakeID,

‎pkg/cloud/isolated_network_test.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ var _ = Describe("Network", func() {
5858
as = mockClient.Address.(*csapi.MockAddressServiceIface)
5959
lbs = mockClient.LoadBalancer.(*csapi.MockLoadBalancerServiceIface)
6060
rs = mockClient.Resourcetags.(*csapi.MockResourcetagsServiceIface)
61-
client = cloud.NewClientFromCSAPIClient(mockClient)
61+
client = cloud.NewClientFromCSAPIClient(mockClient, nil)
6262
dummies.SetDummyVars()
6363
})
6464

‎pkg/cloud/network_test.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ var _ = Describe("Network", func() {
4343
mockClient = csapi.NewMockClient(mockCtrl)
4444
ns = mockClient.Network.(*csapi.MockNetworkServiceIface)
4545
rs = mockClient.Resourcetags.(*csapi.MockResourcetagsServiceIface)
46-
client = cloud.NewClientFromCSAPIClient(mockClient)
46+
client = cloud.NewClientFromCSAPIClient(mockClient, nil)
4747
dummies.SetDummyVars()
4848
})
4949

0 commit comments

Comments
 (0)