device_delete_service_test.go

Documentation: edge-infra.dev/pkg/edge/device-registrar/services

     1  package services
     2  
     3  import (
     4  	"context"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"testing"
     8  
     9  	"github.com/gin-gonic/gin"
    10  	"github.com/stretchr/testify/assert"
    11  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    12  	"k8s.io/apimachinery/pkg/types"
    13  	"sigs.k8s.io/controller-runtime/pkg/client"
    14  	"sigs.k8s.io/controller-runtime/pkg/client/fake"
    15  
    16  	api "edge-infra.dev/pkg/edge/device-registrar/api/v1alpha1"
    17  )
    18  
    19  func injectmockClientDelete(router *gin.Engine, mockClient client.Client, t *testing.T) {
    20  	router.Use(
    21  		// Inject the mock client into the context
    22  		func(c *gin.Context) {
    23  			c.Set("k8sClient", mockClient)
    24  			c.Next()
    25  
    26  			k8sClient, exists := c.Get("k8sClient")
    27  
    28  			// Assert that k8sClient is not nil and exists
    29  			assert.True(t, exists, "k8sClient should exist in the context")
    30  			assert.NotNil(t, k8sClient, "k8sClient should not be nil")
    31  		},
    32  	)
    33  }
    34  
    35  func TestDeleteDeviceEndpoint(t *testing.T) {
    36  	router, scheme := setupTest()
    37  	mockClient := GenerateMockClient(scheme, "")
    38  	injectmockClientDelete(router, mockClient, t)
    39  
    40  	// Inject the mock client into the Gin context
    41  	router.Use(func(c *gin.Context) {
    42  		c.Set("k8sClient", mockClient)
    43  		c.Next()
    44  	})
    45  
    46  	// Define the endpoint
    47  	router.DELETE("/devices/:name", func(c *gin.Context) {
    48  		DeleteDeviceService(c)
    49  		c.Status(http.StatusNoContent)
    50  	})
    51  
    52  	// Create a test context
    53  	ctx := context.TODO()
    54  
    55  	// Create a test device
    56  	device := &api.ExternalDevice{
    57  		ObjectMeta: metav1.ObjectMeta{
    58  			Name:      "test-device-name",
    59  			Namespace: "device-registrar-clients",
    60  		},
    61  		Spec: api.ExternalDeviceSpec{
    62  			Name: "test-device-name",
    63  		},
    64  	}
    65  	err := mockClient.Create(ctx, device)
    66  	assert.NoError(t, err)
    67  
    68  	// Verify the device exists
    69  	retrievedDevice := &api.ExternalDevice{}
    70  	err = mockClient.Get(ctx, types.NamespacedName{Name: "test-device-name", Namespace: "device-registrar-clients"}, retrievedDevice)
    71  	assert.NoError(t, err)
    72  
    73  	// Create a new HTTP request
    74  	req, err := http.NewRequest(http.MethodDelete, "/devices/test-device-name", nil)
    75  	assert.NoError(t, err)
    76  
    77  	// Create a response recorder
    78  	w := httptest.NewRecorder()
    79  
    80  	// Serve the request
    81  	router.ServeHTTP(w, req)
    82  
    83  	// Assert the response
    84  	assert.Equal(t, http.StatusNoContent, w.Code)
    85  
    86  	// Verify the device has been deleted
    87  	err = mockClient.Get(ctx, types.NamespacedName{Name: "test-device-name", Namespace: "device-registrar-clients"}, retrievedDevice)
    88  	assert.Error(t, err)
    89  	assert.True(t, client.IgnoreNotFound(err) == nil)
    90  }
    91  
    92  func TestDeleteDeviceNotFound(t *testing.T) {
    93  	router, scheme := setupTest()
    94  	mockClient := GenerateMockClient(scheme, "")
    95  	injectmockClientDelete(router, mockClient, t)
    96  
    97  	// Inject the mock client into the Gin context
    98  	router.Use(func(c *gin.Context) {
    99  		c.Set("k8sClient", mockClient)
   100  		c.Next()
   101  	})
   102  
   103  	// Define the endpoint
   104  	router.DELETE("/devices/:name", func(c *gin.Context) {
   105  		DeleteDeviceService(c)
   106  		c.Status(http.StatusNoContent)
   107  	})
   108  
   109  	// Create a new HTTP request
   110  	req, err := http.NewRequest(http.MethodDelete, "/devices/test-device-name", nil)
   111  	assert.NoError(t, err)
   112  
   113  	// Create a response recorder
   114  	w := httptest.NewRecorder()
   115  
   116  	// Serve the request
   117  	router.ServeHTTP(w, req)
   118  
   119  	// Assert the response
   120  	assert.Equal(t, http.StatusNotFound, w.Code)
   121  }
   122  
   123  func TestDeleteDeviceNoName(t *testing.T) {
   124  	router, scheme := setupTest()
   125  	mockClient := fake.NewClientBuilder().WithScheme(scheme).Build()
   126  	injectmockClientDelete(router, mockClient, t)
   127  
   128  	// Define the endpoint
   129  	router.DELETE("/devices/", func(c *gin.Context) {
   130  		DeleteDeviceService(c)
   131  		c.Status(http.StatusBadRequest)
   132  	})
   133  
   134  	// Create a new HTTP request without the name parameter
   135  	req, err := http.NewRequest(http.MethodDelete, "/devices/", nil)
   136  	assert.NoError(t, err)
   137  
   138  	// Create a response recorder
   139  	w := httptest.NewRecorder()
   140  
   141  	// Serve the request
   142  	router.ServeHTTP(w, req)
   143  
   144  	// Assert the response
   145  	assert.Equal(t, http.StatusBadRequest, w.Code)
   146  	assert.JSONEq(t, `{"error":"name is required"}`, w.Body.String())
   147  }
   148
View as plain text