Skip to content

Commit c9970a2

Browse files
jonathan-innisjonathan-innis
authoredSep 22, 2022
test: Update WithOffset so that failures point to outer call to helper function (#2530)
·
v1.3.3v0.16.3
1 parent 0d52f87 commit c9970a2

File tree

2 files changed

+95
-64
lines changed

2 files changed

+95
-64
lines changed
 

‎pkg/test/expectations/expectations.go

+56-30
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ See the License for the specific language governing permissions and
1212
limitations under the License.
1313
*/
1414

15+
//nolint:revive
1516
package expectations
1617

1718
import (
@@ -48,20 +49,32 @@ const (
4849
)
4950

5051
func ExpectPodExists(ctx context.Context, c client.Client, name string, namespace string) *v1.Pod {
52+
return ExpectPodExistsWithOffset(1, ctx, c, name, namespace)
53+
}
54+
55+
func ExpectPodExistsWithOffset(offset int, ctx context.Context, c client.Client, name string, namespace string) *v1.Pod {
5156
pod := &v1.Pod{}
52-
Expect(c.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, pod)).To(Succeed())
57+
ExpectWithOffset(offset+1, c.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, pod)).To(Succeed())
5358
return pod
5459
}
5560

5661
func ExpectNodeExists(ctx context.Context, c client.Client, name string) *v1.Node {
62+
return ExpectNodeExistsWithOffset(1, ctx, c, name)
63+
}
64+
65+
func ExpectNodeExistsWithOffset(offset int, ctx context.Context, c client.Client, name string) *v1.Node {
5766
node := &v1.Node{}
58-
Expect(c.Get(ctx, client.ObjectKey{Name: name}, node)).To(Succeed())
67+
ExpectWithOffset(offset+1, c.Get(ctx, client.ObjectKey{Name: name}, node)).To(Succeed())
5968
return node
6069
}
6170

6271
func ExpectNotFound(ctx context.Context, c client.Client, objects ...client.Object) {
72+
ExpectNotFoundWithOffset(1, ctx, c, objects...)
73+
}
74+
75+
func ExpectNotFoundWithOffset(offset int, ctx context.Context, c client.Client, objects ...client.Object) {
6376
for _, object := range objects {
64-
EventuallyWithOffset(1, func() bool {
77+
EventuallyWithOffset(offset+1, func() bool {
6578
return errors.IsNotFound(c.Get(ctx, types.NamespacedName{Name: object.GetName(), Namespace: object.GetNamespace()}, object))
6679
}, ReconcilerPropagationTime, RequestInterval).Should(BeTrue(), func() string {
6780
return fmt.Sprintf("expected %s to be deleted, but it still exists", client.ObjectKeyFromObject(object))
@@ -70,61 +83,65 @@ func ExpectNotFound(ctx context.Context, c client.Client, objects ...client.Obje
7083
}
7184

7285
func ExpectScheduled(ctx context.Context, c client.Client, pod *v1.Pod) *v1.Node {
73-
p := ExpectPodExists(ctx, c, pod.Name, pod.Namespace)
86+
p := ExpectPodExistsWithOffset(1, ctx, c, pod.Name, pod.Namespace)
7487
Expect(p.Spec.NodeName).ToNot(BeEmpty(), fmt.Sprintf("expected %s/%s to be scheduled", pod.Namespace, pod.Name))
75-
return ExpectNodeExists(ctx, c, p.Spec.NodeName)
88+
return ExpectNodeExistsWithOffset(1, ctx, c, p.Spec.NodeName)
7689
}
7790

7891
func ExpectNotScheduled(ctx context.Context, c client.Client, pod *v1.Pod) *v1.Pod {
79-
p := ExpectPodExists(ctx, c, pod.Name, pod.Namespace)
80-
Eventually(p.Spec.NodeName).Should(BeEmpty(), fmt.Sprintf("expected %s/%s to not be scheduled", pod.Namespace, pod.Name))
92+
p := ExpectPodExistsWithOffset(1, ctx, c, pod.Name, pod.Namespace)
93+
EventuallyWithOffset(1, p.Spec.NodeName).Should(BeEmpty(), fmt.Sprintf("expected %s/%s to not be scheduled", pod.Namespace, pod.Name))
8194
return p
8295
}
8396

8497
func ExpectApplied(ctx context.Context, c client.Client, objects ...client.Object) {
98+
ExpectAppliedWithOffset(1, ctx, c, objects...)
99+
}
100+
101+
func ExpectAppliedWithOffset(offset int, ctx context.Context, c client.Client, objects ...client.Object) {
85102
for _, object := range objects {
86103
current := object.DeepCopyObject().(client.Object)
87104
statuscopy := object.DeepCopyObject().(client.Object) // Snapshot the status, since create/update may override
88105
deletecopy := object.DeepCopyObject().(client.Object) // Snapshot the status, since create/update may override
89106
// Create or Update
90107
if err := c.Get(ctx, client.ObjectKeyFromObject(current), current); err != nil {
91108
if errors.IsNotFound(err) {
92-
ExpectWithOffset(1, c.Create(ctx, object)).To(Succeed())
109+
ExpectWithOffset(offset+1, c.Create(ctx, object)).To(Succeed())
93110
} else {
94-
ExpectWithOffset(1, err).ToNot(HaveOccurred())
111+
ExpectWithOffset(offset+1, err).ToNot(HaveOccurred())
95112
}
96113
} else {
97114
object.SetResourceVersion(current.GetResourceVersion())
98-
ExpectWithOffset(1, c.Update(ctx, object)).To(Succeed())
115+
ExpectWithOffset(offset+1, c.Update(ctx, object)).To(Succeed())
99116
}
100117
// Update status
101118
statuscopy.SetResourceVersion(object.GetResourceVersion())
102-
ExpectWithOffset(1, c.Status().Update(ctx, statuscopy)).To(Or(Succeed(), MatchError("the server could not find the requested resource"))) // Some objects do not have a status
119+
ExpectWithOffset(offset+1, c.Status().Update(ctx, statuscopy)).To(Or(Succeed(), MatchError("the server could not find the requested resource"))) // Some objects do not have a status
103120
// Delete if timestamp set
104121
if deletecopy.GetDeletionTimestamp() != nil {
105-
ExpectWithOffset(1, c.Delete(ctx, deletecopy)).To(Succeed())
122+
ExpectWithOffset(offset+1, c.Delete(ctx, deletecopy)).To(Succeed())
106123
}
107124
}
108125
}
109126

110127
func ExpectDeleted(ctx context.Context, c client.Client, objects ...client.Object) {
111128
for _, object := range objects {
112129
if err := c.Delete(ctx, object, &client.DeleteOptions{GracePeriodSeconds: ptr.Int64(0)}); !errors.IsNotFound(err) {
113-
Expect(err).To(BeNil())
130+
ExpectWithOffset(1, err).To(BeNil())
114131
}
115-
ExpectNotFound(ctx, c, object)
132+
ExpectNotFoundWithOffset(1, ctx, c, object)
116133
}
117134
}
118135

119136
func ExpectCleanedUp(ctx context.Context, c client.Client) {
120137
wg := sync.WaitGroup{}
121138
namespaces := &v1.NamespaceList{}
122-
Expect(c.List(ctx, namespaces)).To(Succeed())
139+
ExpectWithOffset(1, c.List(ctx, namespaces)).To(Succeed())
123140
nodes := &v1.NodeList{}
124-
Expect(c.List(ctx, nodes)).To(Succeed())
141+
ExpectWithOffset(1, c.List(ctx, nodes)).To(Succeed())
125142
for i := range nodes.Items {
126143
nodes.Items[i].SetFinalizers([]string{})
127-
Expect(c.Update(ctx, &nodes.Items[i])).To(Succeed())
144+
ExpectWithOffset(1, c.Update(ctx, &nodes.Items[i])).To(Succeed())
128145
}
129146
for _, object := range []client.Object{
130147
&v1.Pod{},
@@ -139,7 +156,7 @@ func ExpectCleanedUp(ctx context.Context, c client.Client) {
139156
for _, namespace := range namespaces.Items {
140157
wg.Add(1)
141158
go func(object client.Object, namespace string) {
142-
Expect(c.DeleteAllOf(ctx, object, client.InNamespace(namespace),
159+
ExpectWithOffset(1, c.DeleteAllOf(ctx, object, client.InNamespace(namespace),
143160
&client.DeleteAllOfOptions{DeleteOptions: client.DeleteOptions{GracePeriodSeconds: ptr.Int64(0)}})).ToNot(HaveOccurred())
144161
wg.Done()
145162
}(object, namespace.Name)
@@ -149,26 +166,30 @@ func ExpectCleanedUp(ctx context.Context, c client.Client) {
149166
}
150167

151168
func ExpectProvisioned(ctx context.Context, c client.Client, controller *provisioning.Controller, pods ...*v1.Pod) (result []*v1.Pod) {
152-
ExpectProvisionedNoBinding(ctx, c, controller, pods...)
169+
ExpectProvisionedNoBindingWithOffset(1, ctx, c, controller, pods...)
153170

154171
recorder := controller.Recorder().(*test.EventRecorder)
155172
recorder.ForEachBinding(func(pod *v1.Pod, node *v1.Node) {
156-
ExpectManualBinding(ctx, c, pod, node)
173+
ExpectManualBindingWithOffset(1, ctx, c, pod, node)
157174
})
158175
// reset bindings so we don't try to bind these same pods again if a new provisioning is performed in the same test
159176
recorder.ResetBindings()
160177

161178
// Update objects after reconciling
162179
for _, pod := range pods {
163-
result = append(result, ExpectPodExists(ctx, c, pod.GetName(), pod.GetNamespace()))
180+
result = append(result, ExpectPodExistsWithOffset(1, ctx, c, pod.GetName(), pod.GetNamespace()))
164181
}
165182
return
166183
}
167184

168185
func ExpectProvisionedNoBinding(ctx context.Context, c client.Client, controller *provisioning.Controller, pods ...*v1.Pod) (result []*v1.Pod) {
186+
return ExpectProvisionedNoBindingWithOffset(1, ctx, c, controller, pods...)
187+
}
188+
189+
func ExpectProvisionedNoBindingWithOffset(offset int, ctx context.Context, c client.Client, controller *provisioning.Controller, pods ...*v1.Pod) (result []*v1.Pod) {
169190
// Persist objects
170191
for _, pod := range pods {
171-
ExpectApplied(ctx, c, pod)
192+
ExpectAppliedWithOffset(offset+1, ctx, c, pod)
172193
}
173194

174195
// shuffle the pods to try to detect any issues where we rely on pod order within a batch, we shuffle a copy of
@@ -184,31 +205,36 @@ func ExpectProvisionedNoBinding(ctx context.Context, c client.Client, controller
184205

185206
// Update objects after reconciling
186207
for _, pod := range pods {
187-
result = append(result, ExpectPodExists(ctx, c, pod.GetName(), pod.GetNamespace()))
208+
result = append(result, ExpectPodExistsWithOffset(offset+1, ctx, c, pod.GetName(), pod.GetNamespace()))
188209
}
189210
return
190211
}
191212

192213
func ExpectReconcileSucceeded(ctx context.Context, reconciler reconcile.Reconciler, key client.ObjectKey) reconcile.Result {
193214
result, err := reconciler.Reconcile(ctx, reconcile.Request{NamespacedName: key})
194-
Expect(err).ToNot(HaveOccurred())
215+
ExpectWithOffset(1, err).ToNot(HaveOccurred())
195216
return result
196217
}
197218

198219
func ExpectMetric(prefix string) *prometheus.MetricFamily {
199220
metrics, err := metrics.Registry.Gather()
200-
Expect(err).To(BeNil())
221+
ExpectWithOffset(1, err).To(BeNil())
201222
var selected *prometheus.MetricFamily
202223
for _, mf := range metrics {
203224
if mf.GetName() == prefix {
204225
selected = mf
205226
}
206227
}
207-
Expect(selected).ToNot(BeNil(), fmt.Sprintf("expected to find a '%s' metric", prefix))
228+
ExpectWithOffset(1, selected).ToNot(BeNil(), fmt.Sprintf("expected to find a '%s' metric", prefix))
208229
return selected
209230
}
231+
210232
func ExpectManualBinding(ctx context.Context, c client.Client, pod *v1.Pod, node *v1.Node) {
211-
ExpectWithOffset(1, c.Create(ctx, &v1.Binding{
233+
ExpectManualBindingWithOffset(1, ctx, c, pod, node)
234+
}
235+
236+
func ExpectManualBindingWithOffset(offset int, ctx context.Context, c client.Client, pod *v1.Pod, node *v1.Node) {
237+
ExpectWithOffset(offset+1, c.Create(ctx, &v1.Binding{
212238
TypeMeta: pod.TypeMeta,
213239
ObjectMeta: metav1.ObjectMeta{
214240
Name: pod.ObjectMeta.Name,
@@ -223,9 +249,9 @@ func ExpectManualBinding(ctx context.Context, c client.Client, pod *v1.Pod, node
223249

224250
func ExpectSkew(ctx context.Context, c client.Client, namespace string, constraint *v1.TopologySpreadConstraint) Assertion {
225251
nodes := &v1.NodeList{}
226-
Expect(c.List(ctx, nodes)).To(Succeed())
252+
ExpectWithOffset(1, c.List(ctx, nodes)).To(Succeed())
227253
pods := &v1.PodList{}
228-
Expect(c.List(ctx, pods, scheduling.TopologyListOptions(namespace, constraint.LabelSelector))).To(Succeed())
254+
ExpectWithOffset(1, c.List(ctx, pods, scheduling.TopologyListOptions(namespace, constraint.LabelSelector))).To(Succeed())
229255
skew := map[string]int{}
230256
for i, pod := range pods.Items {
231257
if scheduling.IgnoredForTopology(&pods.Items[i]) {
@@ -244,5 +270,5 @@ func ExpectSkew(ctx context.Context, c client.Client, namespace string, constrai
244270
}
245271
}
246272
}
247-
return Expect(skew)
273+
return ExpectWithOffset(1, skew)
248274
}

‎test/pkg/environment/expectations.go

+39-34
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ func (env *Environment) BeforeEach() {
101101
Expect(env.Client.List(env.Context, &pods)).To(Succeed())
102102
if debugE2E {
103103
for i := range pods.Items {
104-
fmt.Println(env.getPodInformation(&pods.Items[i]))
104+
fmt.Println(getPodInformation(&pods.Items[i]))
105105
}
106106
}
107107
for i := range pods.Items {
@@ -125,10 +125,10 @@ func (env *Environment) BeforeEach() {
125125

126126
func (env *Environment) getNodeInformation(n *v1.Node) string {
127127
pods, _ := nodeutils.GetNodePods(env, env.Client, n)
128-
return fmt.Sprintf("node %s ready=%s initialized=%s pods=%d taints=%v", n.Name, nodeutils.GetCondition(n, v1.NodeReady).Status, n.Labels[v1alpha5.LabelNodeInitialized], len(pods), n.Spec.Taints)
128+
return fmt.Sprintf("node %s ready=%s schedulable=%t initialized=%s pods=%d taints=%v", n.Name, nodeutils.GetCondition(n, v1.NodeReady).Status, !n.Spec.Unschedulable, n.Labels[v1alpha5.LabelNodeInitialized], len(pods), n.Spec.Taints)
129129
}
130130

131-
func (env *Environment) getPodInformation(p *v1.Pod) string {
131+
func getPodInformation(p *v1.Pod) string {
132132
var containerInfo strings.Builder
133133
for _, c := range p.Status.ContainerStatuses {
134134
if containerInfo.Len() > 0 {
@@ -153,7 +153,12 @@ func getEventInformation(k types.NamespacedName, el *v1.EventList) string {
153153
if source == "" {
154154
source = e.ReportingController
155155
}
156-
sb.WriteString(fmt.Sprintf("type=%s reason=%s from=%s message=%s\n",
156+
eventTime := e.EventTime
157+
if eventTime.IsZero() {
158+
eventTime = metav1.NewMicroTime(e.FirstTimestamp.Time)
159+
}
160+
sb.WriteString(fmt.Sprintf("time=%s type=%s reason=%s from=%s message=%s\n",
161+
eventTime.Format(time.RFC3339),
157162
e.Type,
158163
e.Reason,
159164
source,
@@ -173,15 +178,15 @@ func (env *Environment) startPodMonitor(stop <-chan struct{}) {
173178
podInformer := factory.Core().V1().Pods().Informer()
174179
podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
175180
AddFunc: func(obj interface{}) {
176-
fmt.Printf("[CREATED] %s\n", env.getPodInformation(obj.(*v1.Pod)))
181+
fmt.Printf("[CREATED %s] %s\n", time.Now().Format(time.RFC3339), getPodInformation(obj.(*v1.Pod)))
177182
},
178183
UpdateFunc: func(oldObj interface{}, newObj interface{}) {
179-
if env.getPodInformation(oldObj.(*v1.Pod)) != env.getPodInformation(newObj.(*v1.Pod)) {
180-
fmt.Printf("[UPDATED] %s\n", env.getPodInformation(newObj.(*v1.Pod)))
184+
if getPodInformation(oldObj.(*v1.Pod)) != getPodInformation(newObj.(*v1.Pod)) {
185+
fmt.Printf("[UPDATED %s] %s\n", time.Now().Format(time.RFC3339), getPodInformation(newObj.(*v1.Pod)))
181186
}
182187
},
183188
DeleteFunc: func(obj interface{}) {
184-
fmt.Printf("[DELETED] %s\n", env.getPodInformation(obj.(*v1.Pod)))
189+
fmt.Printf("[DELETED %s] %s\n", time.Now().Format(time.RFC3339), getPodInformation(obj.(*v1.Pod)))
185190
},
186191
})
187192
factory.Start(stop)
@@ -196,16 +201,16 @@ func (env *Environment) startNodeMonitor(stop <-chan struct{}) {
196201
AddFunc: func(obj interface{}) {
197202
node := obj.(*v1.Node)
198203
if _, ok := node.Labels[TestLabelName]; ok {
199-
fmt.Printf("[CREATED] %s\n", env.getNodeInformation(obj.(*v1.Node)))
204+
fmt.Printf("[CREATED %s] %s\n", time.Now().Format(time.RFC3339), env.getNodeInformation(obj.(*v1.Node)))
200205
}
201206
},
202207
UpdateFunc: func(oldObj interface{}, newObj interface{}) {
203208
if env.getNodeInformation(oldObj.(*v1.Node)) != env.getNodeInformation(newObj.(*v1.Node)) {
204-
fmt.Printf("[UPDATED] %s\n", env.getNodeInformation(newObj.(*v1.Node)))
209+
fmt.Printf("[UPDATED %s] %s\n", time.Now().Format(time.RFC3339), env.getNodeInformation(newObj.(*v1.Node)))
205210
}
206211
},
207212
DeleteFunc: func(obj interface{}) {
208-
fmt.Printf("[DELETED] %s\n", env.getNodeInformation(obj.(*v1.Node)))
213+
fmt.Printf("[DELETED %s] %s\n", time.Now().Format(time.RFC3339), env.getNodeInformation(obj.(*v1.Node)))
209214
},
210215
})
211216
factory.Start(stop)
@@ -282,28 +287,28 @@ func (env *Environment) dumpPodEvents(testStartTime time.Time) {
282287
func (env *Environment) ExpectCreated(objects ...client.Object) {
283288
for _, object := range objects {
284289
object.SetLabels(lo.Assign(object.GetLabels(), map[string]string{TestLabelName: env.ClusterName}))
285-
Expect(env.Client.Create(env, object)).To(Succeed())
290+
ExpectWithOffset(1, env.Client.Create(env, object)).To(Succeed())
286291
}
287292
}
288293

289294
func (env *Environment) ExpectDeleted(objects ...client.Object) {
290295
for _, object := range objects {
291-
Expect(env.Client.Delete(env, object, &client.DeleteOptions{GracePeriodSeconds: ptr.Int64(0)})).To(Succeed())
296+
ExpectWithOffset(1, env.Client.Delete(env, object, &client.DeleteOptions{GracePeriodSeconds: ptr.Int64(0)})).To(Succeed())
292297
}
293298
}
294299

295300
func (env *Environment) ExpectUpdate(objects ...client.Object) {
296301
for _, o := range objects {
297302
current := o.DeepCopyObject().(client.Object)
298-
Expect(env.Client.Get(env.Context, client.ObjectKeyFromObject(current), current)).To(Succeed())
303+
ExpectWithOffset(1, env.Client.Get(env.Context, client.ObjectKeyFromObject(current), current)).To(Succeed())
299304
o.SetResourceVersion(current.GetResourceVersion())
300-
Expect(env.Client.Update(env.Context, o)).To(Succeed())
305+
ExpectWithOffset(1, env.Client.Update(env.Context, o)).To(Succeed())
301306
}
302307
}
303308

304309
func (env *Environment) EventuallyExpectHealthy(pods ...*v1.Pod) {
305310
for _, pod := range pods {
306-
Eventually(func(g Gomega) {
311+
EventuallyWithOffset(1, func(g Gomega) {
307312
g.Expect(env.Client.Get(env, client.ObjectKeyFromObject(pod), pod)).To(Succeed())
308313
g.Expect(pod.Status.Conditions).To(ContainElement(And(
309314
HaveField("Type", Equal(v1.PodReady)),
@@ -314,7 +319,7 @@ func (env *Environment) EventuallyExpectHealthy(pods ...*v1.Pod) {
314319
}
315320

316321
func (env *Environment) EventuallyExpectKarpenterWithEnvVar(envVar v1.EnvVar) {
317-
Eventually(func(g Gomega) {
322+
EventuallyWithOffset(1, func(g Gomega) {
318323
labelMap := map[string]string{"app.kubernetes.io/instance": "karpenter"}
319324
listOptions := metav1.ListOptions{LabelSelector: labels.SelectorFromSet(labelMap).String()}
320325
podList, err := env.KubeClient.CoreV1().Pods("karpenter").List(env.Context, listOptions)
@@ -335,7 +340,7 @@ func (env *Environment) EventuallyExpectKarpenterWithEnvVar(envVar v1.EnvVar) {
335340
}
336341

337342
func (env *Environment) EventuallyExpectHealthyPodCount(selector labels.Selector, numPods int) {
338-
Eventually(func(g Gomega) {
343+
EventuallyWithOffset(1, func(g Gomega) {
339344
g.Expect(env.Monitor.RunningPodsCount(selector)).To(Equal(numPods))
340345
}).Should(Succeed())
341346
}
@@ -350,36 +355,36 @@ func (env *Environment) ExpectUniqueNodeNames(selector labels.Selector, uniqueNa
350355
}
351356

352357
func (env *Environment) eventuallyExpectScaleDown() {
353-
Eventually(func(g Gomega) {
358+
EventuallyWithOffset(1, func(g Gomega) {
354359
// expect the current node count to be what it was when the test started
355360
g.Expect(env.Monitor.NodeCount()).To(Equal(env.StartingNodeCount))
356361
}).Should(Succeed(), fmt.Sprintf("expected scale down to %d nodes, had %d", env.StartingNodeCount, env.Monitor.NodeCount()))
357362
}
358363

359364
func (env *Environment) EventuallyExpectNotFound(objects ...client.Object) {
360365
for _, object := range objects {
361-
Eventually(func(g Gomega) {
366+
EventuallyWithOffset(1, func(g Gomega) {
362367
err := env.Client.Get(env, client.ObjectKeyFromObject(object), object)
363368
g.Expect(errors.IsNotFound(err)).To(BeTrue())
364-
}).WithOffset(1).Should(Succeed(), fmt.Sprintf("expcted %s to be deleted", client.ObjectKeyFromObject(object)))
369+
}).Should(Succeed(), fmt.Sprintf("expcted %s to be deleted", client.ObjectKeyFromObject(object)))
365370
}
366371
}
367372

368373
func (env *Environment) ExpectCreatedNodeCount(comparator string, nodeCount int) {
369-
Expect(env.Monitor.CreatedNodes()).To(BeNumerically(comparator, nodeCount),
374+
ExpectWithOffset(1, env.Monitor.CreatedNodes()).To(BeNumerically(comparator, nodeCount),
370375
fmt.Sprintf("expected %d created nodes, had %d", nodeCount, env.Monitor.CreatedNodes()))
371376
}
372377

373378
func (env *Environment) EventuallyExpectCreatedNodeCount(comparator string, nodeCount int) {
374-
Eventually(func(g Gomega) {
379+
EventuallyWithOffset(1, func(g Gomega) {
375380
g.Expect(env.Monitor.CreatedNodes()).To(BeNumerically(comparator, nodeCount),
376381
fmt.Sprintf("expected %d created nodes, had %d", nodeCount, env.Monitor.CreatedNodes()))
377382
}).Should(Succeed())
378383
}
379384

380385
func (env *Environment) GetNode(nodeName string) v1.Node {
381386
var node v1.Node
382-
Expect(env.Client.Get(env.Context, types.NamespacedName{Name: nodeName}, &node)).To(Succeed())
387+
ExpectWithOffset(1, env.Client.Get(env.Context, types.NamespacedName{Name: nodeName}, &node)).To(Succeed())
383388
return node
384389
}
385390

@@ -390,21 +395,21 @@ func (env *Environment) ExpectInstance(nodeName string) Assertion {
390395
func (env *Environment) GetInstance(nodeName string) ec2.Instance {
391396
node := env.GetNode(nodeName)
392397
providerIDSplit := strings.Split(node.Spec.ProviderID, "/")
393-
Expect(len(providerIDSplit)).ToNot(Equal(0))
398+
ExpectWithOffset(1, len(providerIDSplit)).ToNot(Equal(0))
394399
instanceID := providerIDSplit[len(providerIDSplit)-1]
395400
instance, err := env.EC2API.DescribeInstances(&ec2.DescribeInstancesInput{
396401
InstanceIds: aws.StringSlice([]string{instanceID}),
397402
})
398-
Expect(err).ToNot(HaveOccurred())
399-
Expect(instance.Reservations).To(HaveLen(1))
400-
Expect(instance.Reservations[0].Instances).To(HaveLen(1))
403+
ExpectWithOffset(1, err).ToNot(HaveOccurred())
404+
ExpectWithOffset(1, instance.Reservations).To(HaveLen(1))
405+
ExpectWithOffset(1, instance.Reservations[0].Instances).To(HaveLen(1))
401406
return *instance.Reservations[0].Instances[0]
402407
}
403408

404409
func (env *Environment) GetVolume(volumeID *string) ec2.Volume {
405410
dvo, err := env.EC2API.DescribeVolumes(&ec2.DescribeVolumesInput{VolumeIds: []*string{volumeID}})
406-
Expect(err).ToNot(HaveOccurred())
407-
Expect(len(dvo.Volumes)).To(Equal(1))
411+
ExpectWithOffset(1, err).ToNot(HaveOccurred())
412+
ExpectWithOffset(1, len(dvo.Volumes)).To(Equal(1))
408413
return *dvo.Volumes[0]
409414
}
410415

@@ -424,7 +429,7 @@ func (env *Environment) expectNoCrashes() {
424429

425430
// print any events in the karpenter namespace which may indicate liveness probes failing, etc.
426431
var events v1.EventList
427-
Expect(env.Client.List(env.Context, &events)).To(Succeed())
432+
ExpectWithOffset(1, env.Client.List(env.Context, &events)).To(Succeed())
428433
for _, ev := range events.Items {
429434
if ev.InvolvedObject.Namespace == "karpenter" {
430435
if crashInfo.Len() > 0 {
@@ -434,7 +439,7 @@ func (env *Environment) expectNoCrashes() {
434439
}
435440
}
436441

437-
Expect(crashed).To(BeFalse(), fmt.Sprintf("expected karpenter containers to not crash: %s", crashInfo.String()))
442+
ExpectWithOffset(1, crashed).To(BeFalse(), fmt.Sprintf("expected karpenter containers to not crash: %s", crashInfo.String()))
438443
}
439444

440445
var (
@@ -464,13 +469,13 @@ func (env *Environment) printControllerLogs(options *v1.PodLogOptions) {
464469
}
465470

466471
func (env *Environment) EventuallyExpectMinUtilization(resource v1.ResourceName, comparator string, value float64) {
467-
Eventually(func(g Gomega) {
472+
EventuallyWithOffset(1, func(g Gomega) {
468473
g.Expect(env.Monitor.MinUtilization(resource)).To(BeNumerically(comparator, value))
469474
}).Should(Succeed())
470475
}
471476

472477
func (env *Environment) EventuallyExpectAvgUtilization(resource v1.ResourceName, comparator string, value float64) {
473-
Eventually(func(g Gomega) {
478+
EventuallyWithOffset(1, func(g Gomega) {
474479
g.Expect(env.Monitor.AvgUtilization(resource)).To(BeNumerically(comparator, value))
475480
}, 10*time.Minute).Should(Succeed())
476481
}

0 commit comments

Comments
 (0)
Please sign in to comment.