Issue 540 - fix: remove hardcoded value and add test cases

pkg/plugin/implementation/dediregistry/dediregistry_test.go

@@ -22,55 +22,29 @@ func TestValidate(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name: "empty baseURL",
+			name: "empty url",
 			config: &Config{
-				BaseURL:      "",
-				ApiKey:       "test-key",
-				NamespaceID:  "test-namespace",
-				RegistryName: "test-registry",
-			},
-			wantErr: true,
-		},
-		{
-			name: "empty apiKey",
-			config: &Config{
-				BaseURL:      "https://test.com",
-				ApiKey:       "",
-				NamespaceID:  "test-namespace",
-				RegistryName: "test-registry",
-			},
-			wantErr: true,
-		},
-		{
-			name: "empty namespaceID",
-			config: &Config{
-				BaseURL:      "https://test.com",
-				ApiKey:       "test-key",
-				NamespaceID:  "",
-				RegistryName: "test-registry",
-			},
-			wantErr: true,
-		},
-		{
-			name: "empty registryName",
-			config: &Config{
-				BaseURL:      "https://test.com",
-				ApiKey:       "test-key",
-				NamespaceID:  "test-namespace",
-				RegistryName: "",
+				URL: "",
 			},
 			wantErr: true,
 		},
 		{
 			name: "valid config",
 			config: &Config{
-				BaseURL:      "https://test.com",
-				ApiKey:       "test-key",
-				NamespaceID:  "test-namespace",
-				RegistryName: "test-registry",
+				URL:          "https://test.com/dedi",
+				RegistryName: "subscribers.beckn.one",
+				Timeout:      30,
 			},
 			wantErr: false,
 		},
+		{
+			name: "missing registry name",
+			config: &Config{
+				URL:     "https://test.com/dedi",
+				Timeout: 30,
+			},
+			wantErr: true,
+		},
 	}
 
 	for _, tt := range tests {
@@ -87,10 +61,8 @@ func TestNew(t *testing.T) {
 	ctx := context.Background()
 
 	validConfig := &Config{
-		BaseURL:      "https://test.com",
-		ApiKey:       "test-key",
-		NamespaceID:  "test-namespace",
-		RegistryName: "test-registry",
+		URL:          "https://test.com/dedi",
+		RegistryName: "subscribers.beckn.one",
 		Timeout:      30,
 	}
 
@@ -125,32 +97,26 @@ func TestLookup(t *testing.T) {
 			if r.Method != "GET" {
 				t.Errorf("Expected GET request, got %s", r.Method)
 			}
-			if r.URL.Path != "/dedi/lookup/test-namespace/test-registry/bap-network" {
+			if r.URL.Path != "/dedi/lookup/dev.np2.com/subscribers.beckn.one/test-key-id" {
 				t.Errorf("Unexpected path: %s", r.URL.Path)
 			}
-			// Verify Authorization header
-			if auth := r.Header.Get("Authorization"); auth != "Bearer test-key" {
-				t.Errorf("Expected Bearer test-key, got %s", auth)
-			}
+			// No authorization header expected
 
-			// Return mock response using actual DeDI format
+			// Return mock response using new DeDi wrapper format
 			response := map[string]interface{}{
-				"message": "Resource retrieved successfully",
+				"message": "Record retrieved from registry cache",
 				"data": map[string]interface{}{
-					"record_name": "bap-network",
+					"record_id": "76EU8vY9TkuJ9T62Sc3FyQLf5Kt9YAVgbZhryX6mFi56ipefkP9d9a",
 					"details": map[string]interface{}{
-						"key_id":              "b692d295-5425-40f5-af77-d62646841dca",
-						"signing_public_key": "test-public-key",
+						"url":                "http://dev.np2.com/beckn/bap",
+						"type":               "BAP",
+						"domain":             "energy",
+						"subscriber_id":      "dev.np2.com",
+						"signing_public_key": "384qqkIIpxo71WaJPsWqQNWUDGAFnfnJPxuDmtuBiLo=",
 						"encr_public_key":    "test-encr-key",
-						"status":             "SUBSCRIBED",
-						"created":            "2023-01-01T00:00:00Z",
-						"updated":            "2023-01-01T00:00:00Z",
-						"valid_from":         "2023-01-01T00:00:00Z",
-						"valid_until":        "2024-01-01T00:00:00Z",
 					},
-					"state":      "live",
-					"created_at": "2023-01-01T00:00:00Z",
-					"updated_at": "2023-01-01T00:00:00Z",
+					"created_at": "2025-10-27T11:45:27.963Z",
+					"updated_at": "2025-10-27T11:46:23.563Z",
 				},
 			}
 			w.Header().Set("Content-Type", "application/json")
@@ -159,10 +125,8 @@ func TestLookup(t *testing.T) {
 		defer server.Close()
 
 		config := &Config{
-			BaseURL:      server.URL,
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          server.URL + "/dedi",
+			RegistryName: "subscribers.beckn.one",
 			Timeout:      30,
 		}
 
@@ -174,8 +138,9 @@ func TestLookup(t *testing.T) {
 
 		req := &model.Subscription{
 			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
+				SubscriberID: "dev.np2.com",
 			},
+			KeyID: "test-key-id",
 		}
 		results, err := client.Lookup(ctx, req)
 		if err != nil {
@@ -189,24 +154,23 @@ func TestLookup(t *testing.T) {
 		}
 
 		subscription := results[0]
-		if subscription.Subscriber.SubscriberID != "bap-network" {
-			t.Errorf("Expected subscriber_id bap-network, got %s", subscription.Subscriber.SubscriberID)
+		if subscription.Subscriber.SubscriberID != "dev.np2.com" {
+			t.Errorf("Expected subscriber_id dev.np2.com, got %s", subscription.Subscriber.SubscriberID)
 		}
-		if subscription.SigningPublicKey != "test-public-key" {
-			t.Errorf("Expected signing_public_key test-public-key, got %s", subscription.SigningPublicKey)
+		if subscription.SigningPublicKey != "384qqkIIpxo71WaJPsWqQNWUDGAFnfnJPxuDmtuBiLo=" {
+			t.Errorf("Expected signing_public_key 384qqkIIpxo71WaJPsWqQNWUDGAFnfnJPxuDmtuBiLo=, got %s", subscription.SigningPublicKey)
 		}
-		if subscription.Status != "SUBSCRIBED" {
-			t.Errorf("Expected status SUBSCRIBED, got %s", subscription.Status)
+
+		if subscription.KeyID != "test-key-id" {
+			t.Errorf("Expected keyID test-key-id, got %s", subscription.KeyID)
 		}
 	})
 
 	// Test empty subscriber ID
 	t.Run("empty subscriber ID", func(t *testing.T) {
 		config := &Config{
-			BaseURL:      "https://test.com",
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          "https://test.com/dedi",
+			RegistryName: "subscribers.beckn.one",
 		}
 
 		client, closer, err := New(ctx, config)
@@ -219,6 +183,7 @@ func TestLookup(t *testing.T) {
 			Subscriber: model.Subscriber{
 				SubscriberID: "",
 			},
+			KeyID: "test-key-id",
 		}
 		_, err = client.Lookup(ctx, req)
 		if err == nil {
@@ -229,6 +194,34 @@ func TestLookup(t *testing.T) {
 		}
 	})
 
+	// Test empty key ID
+	t.Run("empty key ID", func(t *testing.T) {
+		config := &Config{
+			URL:          "https://test.com/dedi",
+			RegistryName: "subscribers.beckn.one",
+		}
+
+		client, closer, err := New(ctx, config)
+		if err != nil {
+			t.Fatalf("New() error = %v", err)
+		}
+		defer closer()
+
+		req := &model.Subscription{
+			Subscriber: model.Subscriber{
+				SubscriberID: "dev.np2.com",
+			},
+			KeyID: "",
+		}
+		_, err = client.Lookup(ctx, req)
+		if err == nil {
+			t.Error("Expected error for empty key ID, got nil")
+		}
+		if err.Error() != "key_id is required for DeDi lookup" {
+			t.Errorf("Expected specific error message, got %v", err)
+		}
+	})
+
 	// Test HTTP error response
 	t.Run("http error response", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -238,10 +231,8 @@ func TestLookup(t *testing.T) {
 		defer server.Close()
 
 		config := &Config{
-			BaseURL:      server.URL,
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          server.URL + "/dedi",
+			RegistryName: "subscribers.beckn.one",
 		}
 
 		client, closer, err := New(ctx, config)
@@ -252,8 +243,9 @@ func TestLookup(t *testing.T) {
 
 		req := &model.Subscription{
 			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
+				SubscriberID: "dev.np2.com",
 			},
+			KeyID: "test-key-id",
 		}
 		_, err = client.Lookup(ctx, req)
 		if err == nil {
@@ -261,14 +253,13 @@ func TestLookup(t *testing.T) {
 		}
 	})
 
-	// Test missing required fields
+	// Test missing signing_public_key
 	t.Run("missing signing_public_key", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			response := map[string]interface{}{
 				"data": map[string]interface{}{
 					"details": map[string]interface{}{
-						"key_id": "test-key-id",
-						"status": "SUBSCRIBED",
+						"subscriber_id": "dev.np2.com",
 					},
 				},
 			}
@@ -278,10 +269,8 @@ func TestLookup(t *testing.T) {
 		defer server.Close()
 
 		config := &Config{
-			BaseURL:      server.URL,
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          server.URL + "/dedi",
+			RegistryName: "subscribers.beckn.one",
 		}
 
 		client, closer, err := New(ctx, config)
@@ -292,8 +281,9 @@ func TestLookup(t *testing.T) {
 
 		req := &model.Subscription{
 			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
+				SubscriberID: "dev.np2.com",
 			},
+			KeyID: "test-key-id",
 		}
 		_, err = client.Lookup(ctx, req)
 		if err == nil {
@@ -310,10 +300,8 @@ func TestLookup(t *testing.T) {
 		defer server.Close()
 
 		config := &Config{
-			BaseURL:      server.URL,
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          server.URL + "/dedi",
+			RegistryName: "subscribers.beckn.one",
 		}
 
 		client, closer, err := New(ctx, config)
@@ -324,8 +312,9 @@ func TestLookup(t *testing.T) {
 
 		req := &model.Subscription{
 			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
+				SubscriberID: "dev.np2.com",
 			},
+			KeyID: "test-key-id",
 		}
 		_, err = client.Lookup(ctx, req)
 		if err == nil {
@@ -333,33 +322,6 @@ func TestLookup(t *testing.T) {
 		}
 	})
 
-	// Test network error
-	t.Run("network error", func(t *testing.T) {
-		config := &Config{
-			BaseURL:      "http://invalid-url-that-does-not-exist.local",
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
-			Timeout:      1,
-		}
-
-		client, closer, err := New(ctx, config)
-		if err != nil {
-			t.Fatalf("New() error = %v", err)
-		}
-		defer closer()
-
-		req := &model.Subscription{
-			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
-			},
-		}
-		_, err = client.Lookup(ctx, req)
-		if err == nil {
-			t.Error("Expected network error, got nil")
-		}
-	})
-
 	// Test missing data field
 	t.Run("missing data field", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -372,10 +334,8 @@ func TestLookup(t *testing.T) {
 		defer server.Close()
 
 		config := &Config{
-			BaseURL:      server.URL,
-			ApiKey:       "test-key",
-			NamespaceID:  "test-namespace",
-			RegistryName: "test-registry",
+			URL:          server.URL + "/dedi",
+			RegistryName: "subscribers.beckn.one",
 		}
 
 		client, closer, err := New(ctx, config)
@@ -386,12 +346,39 @@ func TestLookup(t *testing.T) {
 
 		req := &model.Subscription{
 			Subscriber: model.Subscriber{
-				SubscriberID: "bap-network",
+				SubscriberID: "dev.np2.com",
 			},
+			KeyID: "test-key-id",
 		}
 		_, err = client.Lookup(ctx, req)
 		if err == nil {
 			t.Error("Expected error for missing data field, got nil")
 		}
 	})
-}
+
+	// Test network error
+	t.Run("network error", func(t *testing.T) {
+		config := &Config{
+			URL:          "http://invalid-url-that-does-not-exist.local/dedi",
+			RegistryName: "subscribers.beckn.one",
+			Timeout:      1,
+		}
+
+		client, closer, err := New(ctx, config)
+		if err != nil {
+			t.Fatalf("New() error = %v", err)
+		}
+		defer closer()
+
+		req := &model.Subscription{
+			Subscriber: model.Subscriber{
+				SubscriberID: "dev.np2.com",
+			},
+			KeyID: "test-key-id",
+		}
+		_, err = client.Lookup(ctx, req)
+		if err == nil {
+			t.Error("Expected network error, got nil")
+		}
+	})
+}