update status if hash mismatch but id not nil

bruelea · bruelea · commit 69ccfaedfbb0 · 2025-03-21T13:38:35.000+01:00
diff --git a/api/v1/iprangeclaim_types.go b/api/v1/iprangeclaim_types.go
@@ -181,7 +181,7 @@ var ConditionIpRangeAssignedFalse = metav1.Condition{
 	Message: "Failed to fetch new IP Range from NetBox",
 }
 
-var ConditionIpRangeAssignedFalseSizeMissmatch = metav1.Condition{
+var ConditionIpRangeAssignedFalseSizeMismatch = metav1.Condition{
 	Type:    "IPRangeAssigned",
 	Status:  "False",
 	Reason:  "IPRangeCRNotCreated",
diff --git a/internal/controller/expected_netboxmock_calls_test.go b/internal/controller/expected_netboxmock_calls_test.go
@@ -92,7 +92,7 @@ func mockIpAddressListWithHashFilter(ipamMock *mock_interfaces.MockIpamInterface
 		}).MinTimes(1)
 }
 
-func mockIpAddressListWithHashFilterMissmatch(ipamMock *mock_interfaces.MockIpamInterface, catchUnexpectedParams chan error) {
+func mockIpAddressListWithHashFilterMismatch(ipamMock *mock_interfaces.MockIpamInterface, catchUnexpectedParams chan error) {
 	ipamMock.EXPECT().IpamIPAddressesList(gomock.Any(), gomock.Any(), gomock.Any()).
 		DoAndReturn(func(params interface{}, authInfo interface{}, opts ...interface{}) (*ipam.IpamIPAddressesListOK, error) {
 			got := params.(*ipam.IpamIPAddressesListParams)
@@ -104,7 +104,7 @@ func mockIpAddressListWithHashFilterMissmatch(ipamMock *mock_interfaces.MockIpam
 				return &ipam.IpamIPAddressesListOK{Payload: nil}, err
 			}
 			fmt.Printf("NETBOXMOCK\t ipam.IpamIPAddressesList (empty reslut) was called with expected input,\n")
-			return &ipam.IpamIPAddressesListOK{Payload: mockedResponseIPAddressListWithHash(customFieldsWithHashMissmatch)}, nil
+			return &ipam.IpamIPAddressesListOK{Payload: mockedResponseIPAddressListWithHash(customFieldsWithHashMismatch)}, nil
 		}).MinTimes(1)
 }
 
diff --git a/internal/controller/ipaddress_controller.go b/internal/controller/ipaddress_controller.go
@@ -170,25 +170,38 @@ func (r *IpAddressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	netboxIpAddressModel, err := r.NetboxClient.ReserveOrUpdateIpAddress(ipAddressModel)
 	if err != nil {
-		if errors.Is(err, api.ErrRestorationHashMissmatch) && o.Status.IpAddressId == 0 {
-			// if there is a restoration has missmatch and the IpAddressId status field is not set,
-			// delete the ip address so it can be recreated by the ip address claim controller
-			logger.Info("restoration hash missmatch, deleting ip address custom resource", "ipaddress", o.Spec.IpAddress)
-			err = r.Client.Delete(ctx, o)
-			if err != nil {
-				updateStatusErr := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpaddressReadyFalse,
-					corev1.EventTypeWarning, err.Error())
+		if errors.Is(err, api.ErrRestorationHashMismatch) {
+			if o.Status.IpAddressId == 0 {
+				// if there is a restoration hash mismatch and the IpAddressId status field is not set,
+				// delete the ip address so it can be recreated by the ip address claim controller
+				// this will only affect resources that are created by a claim controller (and have a restoration hash custom field
+				logger.Info("restoration hash mismatch, deleting ip address custom resource", "ipaddress", o.Spec.IpAddress)
+				err = r.Client.Delete(ctx, o)
+				if err != nil {
+					if updateStatusErr := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpaddressReadyFalse,
+						corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
+						return ctrl.Result{}, fmt.Errorf("failed to update ip address status: %w, "+
+							"after deletion of ip address cr failed: %w", updateStatusErr, err)
+					}
+					return ctrl.Result{Requeue: true}, nil
+				}
+				return ctrl.Result{}, nil
+			}
+		} else {
+			if updateStatusErr := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpaddressReadyFalse,
+				corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
 				return ctrl.Result{}, fmt.Errorf("failed to update ip address status: %w, "+
-					"after deletion of ip address cr failed: %w", updateStatusErr, err)
+					"after reservation of ip in netbox failed: %w", updateStatusErr, err)
 			}
-			return ctrl.Result{}, nil
+			return ctrl.Result{Requeue: true}, nil
 		}
+
 		if updateStatusErr := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpaddressReadyFalse,
-			corev1.EventTypeWarning, o.Spec.IpAddress); updateStatusErr != nil {
+			corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to update ip address status: %w, "+
 				"after reservation of ip in netbox failed: %w", updateStatusErr, err)
 		}
-		return ctrl.Result{}, nil
+		return ctrl.Result{Requeue: true}, nil
 	}
 
 	// 3. unlock lease of parent prefix
diff --git a/internal/controller/ipaddress_controller_test.go b/internal/controller/ipaddress_controller_test.go
@@ -52,7 +52,7 @@ var _ = Describe("IpAddress Controller", Ordered, func() {
 		cr *netboxv1.IpAddress, // our CR as typed object
 		IpamMocksIpAddress []func(*mock_interfaces.MockIpamInterface, chan error),
 		TenancyMocks []func(*mock_interfaces.MockTenancyInterface, chan error),
-		restorationHashMissmatch bool, // To check for deletion if restoration hash does not match
+		restorationHashMismatch bool, // To check for deletion if restoration hash does not match
 		expectedConditionReady bool, // Expected state of the ConditionReady condition
 		expectedCRStatus netboxv1.IpAddressStatus, // Expected status of the CR
 	) {
@@ -85,7 +85,7 @@ var _ = Describe("IpAddress Controller", Ordered, func() {
 
 		createdCR := &netboxv1.IpAddress{}
 
-		if restorationHashMissmatch {
+		if restorationHashMismatch {
 			Eventually(func() bool {
 				err := k8sClient.Get(ctx, types.NamespacedName{Name: cr.GetName(), Namespace: cr.GetNamespace()}, createdCR)
 				return apierrors.IsNotFound(err)
@@ -163,10 +163,10 @@ var _ = Describe("IpAddress Controller", Ordered, func() {
 				mockTenancyTenancyTenantsList,
 			},
 			false, false, ExpectedIpAddressFailedStatus),
-		Entry("Create IpAddress CR, restoration hash missmatch",
+		Entry("Create IpAddress CR, restoration hash mismatch",
 			defaultIpAddressCreatedByClaim(true),
 			[]func(*mock_interfaces.MockIpamInterface, chan error){
-				mockIpAddressListWithHashFilterMissmatch,
+				mockIpAddressListWithHashFilterMismatch,
 			},
 			[]func(*mock_interfaces.MockTenancyInterface, chan error){
 				mockTenancyTenancyTenantsList,
diff --git a/internal/controller/iprange_controller.go b/internal/controller/iprange_controller.go
@@ -143,27 +143,37 @@ func (r *IpRangeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	netboxIpRangeModel, err := r.NetboxClient.ReserveOrUpdateIpRange(ipRangeModel)
 	if err != nil {
-		if errors.Is(err, api.ErrRestorationHashMissmatch) && o.Status.IpRangeId == 0 {
-			// if there is a restoration has missmatch and the IpRangeId status field is not set,
-			// delete the ip range so it can be recreated by the ip range claim controller
-			logger.Info("restoration hash missmatch, deleting ip range custom resource", "ip-range-start", o.Spec.StartAddress, "ip-range-end", o.Spec.EndAddress)
-			err = r.Client.Delete(ctx, o)
-			if err != nil {
-				if err := r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse,
+		if errors.Is(err, api.ErrRestorationHashMismatch) {
+			if o.Status.IpRangeId == 0 {
+				// if there is a restoration hash mismatch and the IpRangeId status field is not set,
+				// delete the ip range so it can be recreated by the ip range claim controller
+				// this will only affect resources that are created by a claim controller (and have a restoration hash custom field
+				logger.Info("restoration hash mismatch, deleting ip range custom resource", "ip-range-start", o.Spec.StartAddress, "ip-range-end", o.Spec.EndAddress)
+				err = r.Client.Delete(ctx, o)
+				if err != nil {
+					if err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse,
+						corev1.EventTypeWarning, "", err); err != nil {
+						return ctrl.Result{}, err
+					}
+					return ctrl.Result{Requeue: true}, nil
+				}
+				return ctrl.Result{}, nil
+			} else {
+				if err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse,
 					corev1.EventTypeWarning, "", err); err != nil {
 					return ctrl.Result{}, err
 				}
+				return ctrl.Result{Requeue: true}, nil
 			}
-			return ctrl.Result{}, nil
 		}
 
-		if loggingErr := r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse,
-			corev1.EventTypeWarning, fmt.Sprintf("%s-%s ", o.Spec.StartAddress, o.Spec.EndAddress), err); loggingErr != nil {
-			return ctrl.Result{}, fmt.Errorf("logging error: %w. Original error from ReserveOrUpdateIpRange: %w", loggingErr, err)
+		if err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse,
+			corev1.EventTypeWarning, fmt.Sprintf("%s-%s ", o.Spec.StartAddress, o.Spec.EndAddress), err); err != nil {
+			return ctrl.Result{}, err
 		}
 
 		// The decision to not return the error message (just logging it) is to not trigger printing the stacktrace on api errors
-		return ctrl.Result{}, nil
+		return ctrl.Result{Requeue: true}, nil
 	}
 
 	// 3. unlock lease of parent prefix
diff --git a/internal/controller/iprangeclaim_controller.go b/internal/controller/iprangeclaim_controller.go
@@ -322,7 +322,7 @@ func (r *IpRangeClaimReconciler) restoreOrAssignIpRangeAndSetCondition(ctx conte
 		availableIpRanges, err := r.NetboxClient.GetAvailableIpAddressesByIpRange(ipRangeModel.Id)
 		if len(availableIpRanges.Payload) != o.Spec.Size {
 			ll.Unlock()
-			err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalseSizeMissmatch, corev1.EventTypeWarning, "", err)
+			err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalseSizeMismatch, corev1.EventTypeWarning, "", err)
 			if err != nil {
 				return nil, ctrl.Result{}, err
 			}
diff --git a/internal/controller/netbox_testdata_test.go b/internal/controller/netbox_testdata_test.go
@@ -57,7 +57,7 @@ var customFieldsCR = map[string]string{"example_field": "example value"}
 var customFieldsWithHashCR = map[string]string{"example_field": "example value", "netboxOperatorRestorationHash": restorationHash}
 
 var customFieldsWithHash = map[string]interface{}{"example_field": "example value", "netboxOperatorRestorationHash": restorationHash}
-var customFieldsWithHashMissmatch = map[string]interface{}{"example_field": "example value", "netboxOperatorRestorationHash": "different hash"}
+var customFieldsWithHashMismatch = map[string]interface{}{"example_field": "example value", "netboxOperatorRestorationHash": "different hash"}
 
 var netboxLabel = "Status"
 var value = "active"
diff --git a/internal/controller/prefix_controller.go b/internal/controller/prefix_controller.go
@@ -184,25 +184,37 @@ func (r *PrefixReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctr
 
 	netboxPrefixModel, err := r.NetboxClient.ReserveOrUpdatePrefix(prefixModel)
 	if err != nil {
-		if errors.Is(err, api.ErrRestorationHashMissmatch) && prefix.Status.PrefixId == 0 {
-			// if there is a restoration has missmatch and the PrefixId status field is not set,
-			// delete the prefix so it can be recreated by the prefix claim controller
-			logger.Info("restoration hash missmatch, deleting prefix custom resource", "prefix", prefix.Spec.Prefix)
-			err = r.Client.Delete(ctx, prefix)
-			if err != nil {
-				updateStatusErr := r.SetConditionAndCreateEvent(ctx, prefix, netboxv1.ConditionIpaddressReadyFalse,
-					corev1.EventTypeWarning, err.Error())
-				return ctrl.Result{}, fmt.Errorf("failed to update prefix status: %w, "+
-					"after deletion of prefix cr failed: %w", updateStatusErr, err)
+		if errors.Is(err, api.ErrRestorationHashMismatch) {
+			if prefix.Status.PrefixId == 0 {
+				// if there is a restoration hash mismatch and the PrefixId status field is not set,
+				// delete the prefix so it can be recreated by the prefix claim controller
+				// this will only affect resources that are created by a claim controller (and have a restoration hash custom field
+				logger.Info("restoration hash mismatch, deleting prefix custom resource", "prefix", prefix.Spec.Prefix)
+				err = r.Client.Delete(ctx, prefix)
+				if err != nil {
+					if updateStatusErr := r.SetConditionAndCreateEvent(ctx, prefix, netboxv1.ConditionPrefixReadyFalse,
+						corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
+						return ctrl.Result{}, fmt.Errorf("failed to update prefix status: %w, "+
+							"after deletion of prefix cr failed: %w", updateStatusErr, err)
+					}
+					return ctrl.Result{Requeue: true}, nil
+				}
+				return ctrl.Result{}, nil
+			} else {
+				if updateStatusErr := r.SetConditionAndCreateEvent(ctx, prefix, netboxv1.ConditionPrefixReadyFalse,
+					corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
+					return ctrl.Result{}, fmt.Errorf("failed to update prefix status: %w, "+
+						"after deletion of prefix cr failed: %w", updateStatusErr, err)
+				}
+				return ctrl.Result{Requeue: true}, nil
 			}
-			return ctrl.Result{}, nil
 		}
-		if updateStatusErr := r.SetConditionAndCreateEvent(ctx, prefix, netboxv1.ConditionIpaddressReadyFalse,
-			corev1.EventTypeWarning, prefix.Spec.Prefix); updateStatusErr != nil {
+		if updateStatusErr := r.SetConditionAndCreateEvent(ctx, prefix, netboxv1.ConditionPrefixReadyFalse,
+			corev1.EventTypeWarning, err.Error()); updateStatusErr != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to update prefix status: %w, "+
 				"after reservation of prefix netbox failed: %w", updateStatusErr, err)
 		}
-		return ctrl.Result{}, nil
+		return ctrl.Result{Requeue: true}, nil
 	}
 
 	/* 3. unlock lease of parent prefix */
diff --git a/pkg/netbox/api/errors.go b/pkg/netbox/api/errors.go
@@ -23,5 +23,5 @@ var (
 	ErrParentPrefixNotFound            = errors.New("parent prefix not found")
 	ErrWrongMatchingPrefixSubnetFormat = errors.New("wrong matchingPrefix subnet format")
 	ErrInvalidIpFamily                 = errors.New("invalid IP Family")
-	ErrRestorationHashMissmatch        = errors.New("restoration hash missmatch")
+	ErrRestorationHashMismatch         = errors.New("restoration hash mismatch")
 )
diff --git a/pkg/netbox/api/ip_address.go b/pkg/netbox/api/ip_address.go
@@ -70,7 +70,7 @@ func (r *NetboxClient) ReserveOrUpdateIpAddress(ipAddress *models.IPAddress) (*n
 				//update ip address since it does exist and the restoration hash matches
 				return r.UpdateIpAddress(ipToUpdate.ID, desiredIPAddress)
 			}
-			return nil, fmt.Errorf("%w, assigned ip address %s", ErrRestorationHashMissmatch, ipAddress.IpAddress)
+			return nil, fmt.Errorf("%w, assigned ip address %s", ErrRestorationHashMismatch, ipAddress.IpAddress)
 		}
 	}
 
diff --git a/pkg/netbox/api/ip_address_test.go b/pkg/netbox/api/ip_address_test.go
@@ -62,8 +62,10 @@ func TestIPAddress(t *testing.T) {
 		}
 	}
 
+	expectedHash := "fioaf9289rjfhaeuih"
+
 	customFields := map[string]interface{}{
-		config.GetOperatorConfig().NetboxRestorationHashFieldName: "fioaf9289rjfhaeuih",
+		config.GetOperatorConfig().NetboxRestorationHashFieldName: expectedHash,
 	}
 
 	// example output IP address
@@ -331,12 +333,12 @@ func TestIPAddress(t *testing.T) {
 			Ipam: mockIPAddress,
 		}
 
-		ipAddressModel := ipAddressModel("fioaf9289rjfhaeuih")
+		ipAddressModel := ipAddressModel(expectedHash)
 		_, err := client.ReserveOrUpdateIpAddress(ipAddressModel)
 		AssertNil(t, err)
 	})
 
-	t.Run("Check ReserveOrUpdate with hash missmatch", func(t *testing.T) {
+	t.Run("Check ReserveOrUpdate with hash mismatch", func(t *testing.T) {
 		inputList := ipam.NewIpamIPAddressesListParams().WithAddress(&ipAddress)
 		outputList := &ipam.IpamIPAddressesListOK{
 			Payload: &ipam.IpamIPAddressesListOKBody{
@@ -358,6 +360,6 @@ func TestIPAddress(t *testing.T) {
 
 		ipAddressModel := ipAddressModel("iwfohs7v82fe9w0")
 		_, err := client.ReserveOrUpdateIpAddress(ipAddressModel)
-		AssertError(t, err, "restoration hash missmatch, assigned ip address 10.112.140.0")
+		AssertError(t, err, "restoration hash mismatch, assigned ip address 10.112.140.0")
 	})
 }
diff --git a/pkg/netbox/api/ip_range.go b/pkg/netbox/api/ip_range.go
@@ -73,7 +73,7 @@ func (r *NetboxClient) ReserveOrUpdateIpRange(ipRange *models.IpRange) (*netboxM
 				//update ip address since it does exist and the restoration hash matches
 				return r.UpdateIpRange(ipRangeToUpdate.ID, desiredIpRange)
 			}
-			return nil, fmt.Errorf("%w, assigned ip range %s-%s", ErrRestorationHashMissmatch, ipRange.StartAddress, ipRange.EndAddress)
+			return nil, fmt.Errorf("%w, assigned ip range %s-%s", ErrRestorationHashMismatch, ipRange.StartAddress, ipRange.EndAddress)
 		}
 	}
 
diff --git a/pkg/netbox/api/ip_range_test.go b/pkg/netbox/api/ip_range_test.go
@@ -184,13 +184,14 @@ func TestIpRange(t *testing.T) {
 		assert.Equal(t, expectedIPRange().Tenant.Slug, actual.Tenant.Slug)
 	})
 
-	t.Run("ReserveOrUpdate, restoration hash missmatch", func(t *testing.T) {
+	t.Run("ReserveOrUpdate, restoration hash mismatch", func(t *testing.T) {
 
 		// ip range mock input
 		listInput := ipam.NewIpamIPRangesListParams().
 			WithStartAddress(&startAddress).
 			WithEndAddress(&endAddress)
 
+		wrongHash := "89hqvs0ud89qhdi"
 		// ip range mock output
 		listOutput := &ipam.IpamIPRangesListOK{
 			Payload: &ipam.IpamIPRangesListOKBody{
@@ -200,7 +201,7 @@ func TestIpRange(t *testing.T) {
 						StartAddress: &startAddress,
 						EndAddress:   &endAddress,
 						CustomFields: map[string]interface{}{
-							config.GetOperatorConfig().NetboxRestorationHashFieldName: "different hash",
+							config.GetOperatorConfig().NetboxRestorationHashFieldName: wrongHash,
 						},
 						Comments:    expectedIPRange().Comments,
 						Description: expectedIPRange().Description,
@@ -217,18 +218,19 @@ func TestIpRange(t *testing.T) {
 			Ipam: mockIpam,
 		}
 
+		expectedHash := "ffjrep8b29fdaikb"
 		_, err := client.ReserveOrUpdateIpRange(&models.IpRange{
 			StartAddress: startAddress,
 			EndAddress:   endAddress,
 			Metadata: &models.NetboxMetadata{
 				Custom: map[string]string{
-					config.GetOperatorConfig().NetboxRestorationHashFieldName: "hash",
+					config.GetOperatorConfig().NetboxRestorationHashFieldName: expectedHash,
 				},
 			},
 		})
 
 		// assert error return
-		AssertError(t, err, "restoration hash missmatch, assigned ip range 10.112.140.1-10.112.140.3")
+		AssertError(t, err, "restoration hash mismatch, assigned ip range 10.112.140.1-10.112.140.3")
 	})
 
 	t.Run("ReserveOrUpdate, update existing ip range", func(t *testing.T) {
diff --git a/pkg/netbox/api/prefix.go b/pkg/netbox/api/prefix.go
@@ -83,7 +83,7 @@ func (r *NetboxClient) ReserveOrUpdatePrefix(prefix *models.Prefix) (*netboxMode
 				//update ip address since it does exist and the restoration hash matches
 				return r.UpdatePrefix(prefixToUpdate.ID, desiredPrefix)
 			}
-			return nil, fmt.Errorf("%w, assigned prefix %s", ErrRestorationHashMissmatch, prefix.Prefix)
+			return nil, fmt.Errorf("%w, assigned prefix %s", ErrRestorationHashMismatch, prefix.Prefix)
 		}
 	}
 
diff --git a/pkg/netbox/api/prefix_test.go b/pkg/netbox/api/prefix_test.go
@@ -482,19 +482,20 @@ func TestPrefix_ReserveOrUpdate(t *testing.T) {
 		assert.Nil(t, err)
 	})
 
-	t.Run("restoration hash missmatch", func(t *testing.T) {
+	t.Run("restoration hash mismatch", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		mockIpam := mock_interfaces.NewMockIpamInterface(ctrl)
 
+		wrongHash := "89327r7fhui"
 		//prefix mock output
 		prefixListOutput := &ipam.IpamPrefixesListOK{
 			Payload: &ipam.IpamPrefixesListOKBody{
 				Results: []*netboxModels.Prefix{
 					{
 						ID: prefixId,
 						CustomFields: map[string]interface{}{
-							config.GetOperatorConfig().NetboxRestorationHashFieldName: "hash",
+							config.GetOperatorConfig().NetboxRestorationHashFieldName: wrongHash,
 						},
 						Display: prefix,
 						Prefix:  &prefix,
@@ -509,16 +510,17 @@ func TestPrefix_ReserveOrUpdate(t *testing.T) {
 			Ipam: mockIpam,
 		}
 
+		expectedHash := "jfioaw0e9gh"
 		prefixModel := models.Prefix{
 			Prefix: prefix,
 			Metadata: &models.NetboxMetadata{
-				Custom: map[string]string{config.GetOperatorConfig().NetboxRestorationHashFieldName: "hash-not-matching"},
+				Custom: map[string]string{config.GetOperatorConfig().NetboxRestorationHashFieldName: expectedHash},
 			},
 		}
 
 		_, err := netboxClient.ReserveOrUpdatePrefix(&prefixModel)
 		// skip assertion on retured values as the payload of IpamPrefixesCreate() is returened
 		// without manipulation by the code
-		AssertError(t, err, "restoration hash missmatch, assigned prefix 10.112.140.0/24")
+		AssertError(t, err, "restoration hash mismatch, assigned prefix 10.112.140.0/24")
 	})
 }

Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ var ConditionIpRangeAssignedFalse = metav1.Condition{`
`181`	`181`	`Message: "Failed to fetch new IP Range from NetBox",`
`182`	`182`	`}`
`183`	`183`
`184`		`-var ConditionIpRangeAssignedFalseSizeMissmatch = metav1.Condition{`
	`184`	`+var ConditionIpRangeAssignedFalseSizeMismatch = metav1.Condition{`
`185`	`185`	`Type: "IPRangeAssigned",`
`186`	`186`	`Status: "False",`
`187`	`187`	`Reason: "IPRangeCRNotCreated",`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ func mockIpAddressListWithHashFilter(ipamMock *mock_interfaces.MockIpamInterface`
`92`	`92`	`}).MinTimes(1)`
`93`	`93`	`}`
`94`	`94`
`95`		`-func mockIpAddressListWithHashFilterMissmatch(ipamMock *mock_interfaces.MockIpamInterface, catchUnexpectedParams chan error) {`
	`95`	`+func mockIpAddressListWithHashFilterMismatch(ipamMock *mock_interfaces.MockIpamInterface, catchUnexpectedParams chan error) {`
`96`	`96`	`ipamMock.EXPECT().IpamIPAddressesList(gomock.Any(), gomock.Any(), gomock.Any()).`
`97`	`97`	`DoAndReturn(func(params interface{}, authInfo interface{}, opts ...interface{}) (*ipam.IpamIPAddressesListOK, error) {`
`98`	`98`	`got := params.(*ipam.IpamIPAddressesListParams)`
`@@ -104,7 +104,7 @@ func mockIpAddressListWithHashFilterMissmatch(ipamMock *mock_interfaces.MockIpam`
`104`	`104`	`return &ipam.IpamIPAddressesListOK{Payload: nil}, err`
`105`	`105`	`}`
`106`	`106`	`fmt.Printf("NETBOXMOCK\t ipam.IpamIPAddressesList (empty reslut) was called with expected input,\n")`
`107`		`- return &ipam.IpamIPAddressesListOK{Payload: mockedResponseIPAddressListWithHash(customFieldsWithHashMissmatch)}, nil`
	`107`	`+ return &ipam.IpamIPAddressesListOK{Payload: mockedResponseIPAddressListWithHash(customFieldsWithHashMismatch)}, nil`
`108`	`108`	`}).MinTimes(1)`
`109`	`109`	`}`
`110`	`110`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ func (r *IpRangeClaimReconciler) restoreOrAssignIpRangeAndSetCondition(ctx conte`
`322`	`322`	`availableIpRanges, err := r.NetboxClient.GetAvailableIpAddressesByIpRange(ipRangeModel.Id)`
`323`	`323`	`if len(availableIpRanges.Payload) != o.Spec.Size {`
`324`	`324`	`ll.Unlock()`
`325`		`- err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalseSizeMissmatch, corev1.EventTypeWarning, "", err)`
	`325`	`+ err = r.logErrorSetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalseSizeMismatch, corev1.EventTypeWarning, "", err)`
`326`	`326`	`if err != nil {`
`327`	`327`	`return nil, ctrl.Result{}, err`
`328`	`328`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,5 +23,5 @@ var (`
`23`	`23`	`ErrParentPrefixNotFound = errors.New("parent prefix not found")`
`24`	`24`	`ErrWrongMatchingPrefixSubnetFormat = errors.New("wrong matchingPrefix subnet format")`
`25`	`25`	`ErrInvalidIpFamily = errors.New("invalid IP Family")`
`26`		`- ErrRestorationHashMissmatch = errors.New("restoration hash missmatch")`
	`26`	`+ ErrRestorationHashMismatch = errors.New("restoration hash mismatch")`
`27`	`27`	`)`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ func (r NetboxClient) ReserveOrUpdateIpAddress(ipAddress models.IPAddress) (*n`
`70`	`70`	`//update ip address since it does exist and the restoration hash matches`
`71`	`71`	`return r.UpdateIpAddress(ipToUpdate.ID, desiredIPAddress)`
`72`	`72`	`}`
`73`		`- return nil, fmt.Errorf("%w, assigned ip address %s", ErrRestorationHashMissmatch, ipAddress.IpAddress)`
	`73`	`+ return nil, fmt.Errorf("%w, assigned ip address %s", ErrRestorationHashMismatch, ipAddress.IpAddress)`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`