added support for delete resource in sdk

Author: melvinodsa

golang/README.md

@@ -122,18 +122,51 @@ package main
 import (
     "context"
     "fmt"
+    "log"
     "github.com/melvinodsa/go-iam-sdk/golang"
 )
 
 func main() {
-    service := golang.NewService("https://your-iam-api.com", "username", "password")
+    // Initialize the service
+    service := golang.NewService("https://your-iam-api.com", "client-id", "secret")
+    ctx := context.Background()
 
     // Verify authentication code
-    result, err := service.Verify(context.Background(), "auth-code")
+    token, err := service.Verify(ctx, "auth-code")
     if err != nil {
-        panic(err)
+        log.Fatalf("Failed to verify code: %v", err)
     }
+    fmt.Printf("Access Token: %s\n", token)
 
-    fmt.Printf("Verification result: %+v\n", result)
+    // Get current user information
+    user, err := service.Me(ctx, token)
+    if err != nil {
+        log.Fatalf("Failed to fetch user: %v", err)
+    }
+    fmt.Printf("User: %s (%s)\n", user.Name, user.Email)
+
+    // Create a resource
+    resource := &golang.Resource{
+        Name:        "Test Resource",
+        Description: "A test resource",
+        Key:         "test-key",
+        Enabled:     true,
+        ProjectId:   "project-123",
+        CreatedBy:   "admin",
+        UpdatedBy:   "admin",
+    }
+    
+    err = service.CreateResource(ctx, resource, token)
+    if err != nil {
+        log.Fatalf("Failed to create resource: %v", err)
+    }
+    fmt.Println("Resource created successfully")
+
+    // Delete a resource
+    err = service.DeleteResource(ctx, "resource-id", token)
+    if err != nil {
+        log.Fatalf("Failed to delete resource: %v", err)
+    }
+    fmt.Println("Resource deleted successfully")
 }
 ```

golang/service.go

@@ -6,4 +6,5 @@ type Service interface {
 	Verify(ctx context.Context, code string) (string, error)
 	Me(ctx context.Context, token string) (*User, error)
 	CreateResource(ctx context.Context, resource *Resource, token string) error
+	DeleteResource(ctx context.Context, resourceID string, token string) error
 }

golang/service_impl.go

@@ -134,3 +134,39 @@ func (s *serviceImpl) CreateResource(ctx context.Context, resource *Resource, to
 
 	return nil
 }
+
+// DeleteResource deletes a resource with the provided ID and token.
+// It returns an error if the deletion fails.
+func (s *serviceImpl) DeleteResource(ctx context.Context, resourceID string, token string) error {
+	url := fmt.Sprintf("%s/resource/v1/%s", s.baseURL, resourceID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, url, nil)
+	if err != nil {
+		return fmt.Errorf("error creating request: %w", err)
+	}
+
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("error making request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var statusError error
+	if resp.StatusCode != http.StatusOK {
+		statusError = fmt.Errorf("failed to delete resource: %s", resp.Status)
+	}
+
+	result := ResourceResponse{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		if statusError != nil {
+			return fmt.Errorf("%w: %s", statusError, err)
+		}
+		return fmt.Errorf("error decoding response: %w", err)
+	}
+
+	if !result.Success {
+		return fmt.Errorf("failed to delete resource: %s. Status: %s", result.Message, resp.Status)
+	}
+
+	return nil
+}

golang/service_test.go

@@ -115,3 +115,51 @@ func TestCreateResource(t *testing.T) {
 		}
 	})
 }
+
+func TestDeleteResource(t *testing.T) {
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") == "Bearer valid-token" {
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"success":true,"message":"Resource deleted successfully"}`))
+		} else {
+			w.WriteHeader(http.StatusUnauthorized)
+			w.Write([]byte(`{"success":false,"message":"Invalid token"}`))
+		}
+	}
+
+	ts := httptest.NewServer(http.HandlerFunc(handler))
+	defer ts.Close()
+
+	service := NewService(ts.URL, "client-id", "secret")
+
+	t.Run("Valid Token", func(t *testing.T) {
+		err := service.DeleteResource(context.Background(), "resource-123", "valid-token")
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+	})
+
+	t.Run("Invalid Token", func(t *testing.T) {
+		err := service.DeleteResource(context.Background(), "resource-123", "invalid-token")
+		if err == nil {
+			t.Fatal("expected an error, got none")
+		}
+	})
+
+	t.Run("Non-existent Resource", func(t *testing.T) {
+		// Override handler for this test to return 404
+		notFoundHandler := func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(`{"success":false,"message":"Resource not found"}`))
+		}
+		
+		notFoundServer := httptest.NewServer(http.HandlerFunc(notFoundHandler))
+		defer notFoundServer.Close()
+		
+		notFoundService := NewService(notFoundServer.URL, "client-id", "secret")
+		err := notFoundService.DeleteResource(context.Background(), "non-existent", "valid-token")
+		if err == nil {
+			t.Fatal("expected an error, got none")
+		}
+	})
+}

python/README.md

@@ -72,6 +72,16 @@ except Exception as error:
     print(f"Failed to create resource: {error}")
 ```
 
+### Delete a Resource
+
+```python
+try:
+    service.delete_resource("resource-id", token)
+    print("Resource deleted successfully")
+except Exception as error:
+    print(f"Failed to delete resource: {error}")
+```
+
 ## Classes
 
 The SDK provides the following main classes:

python/goiam/service.py

@@ -51,3 +51,17 @@ def create_resource(self, resource: Resource, token: str) -> None:
             Exception: If creation fails
         """
         pass
+
+    @abstractmethod
+    def delete_resource(self, resource_id: str, token: str) -> None:
+        """
+        Delete a resource by ID
+
+        Args:
+            resource_id: ID of the resource to delete
+            token: Bearer token for authentication
+
+        Raises:
+            Exception: If deletion fails
+        """
+        pass

python/goiam/service_impl.py

@@ -140,6 +140,40 @@ def create_resource(self, resource: Resource, token: str) -> None:
         except Exception as e:
             raise Exception(f"Failed to create resource: {str(e)}")
 
+    def delete_resource(self, resource_id: str, token: str) -> None:
+        """
+        Delete a resource by ID
+
+        Args:
+            resource_id: ID of the resource to delete
+            token: Bearer token for authentication
+
+        Raises:
+            Exception: If deletion fails
+        """
+        url = f"{self.base_url}/resource/v1/{resource_id}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        try:
+            response = self.session.delete(url, headers=headers)
+
+            if response.status_code != 200:
+                raise Exception(
+                    f"Failed to delete resource: {response.status_code} {response.reason}"
+                )
+
+            resource_response = ResourceResponse(response.json())
+
+            if not resource_response.success:
+                raise Exception(
+                    f"Failed to delete resource: {resource_response.message}"
+                )
+
+        except requests.RequestException as e:
+            raise Exception(f"Request failed: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Failed to delete resource: {str(e)}")
+
 
 def new_service(base_url: str, client_id: str, secret: str) -> Service:
     """

python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "goiam-python"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python SDK for Go IAM - A lightweight Identity and Access Management server"
 readme = "README.md"
 license = { file = "LICENSE" }

python/test_service.py

@@ -107,6 +107,47 @@ def test_create_resource_failure(self, mock_post):
 
         self.assertIn("Failed to create resource", str(context.exception))
 
+    @patch("goiam.service_impl.requests.Session.delete")
+    def test_delete_resource_success(self, mock_delete):
+        # Mock successful response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "success": True,
+            "message": "Resource deleted successfully",
+        }
+        mock_delete.return_value = mock_response
+
+        # Should not raise an exception
+        self.service.delete_resource("resource-123", "valid-token")
+        mock_delete.assert_called_once()
+
+    @patch("goiam.service_impl.requests.Session.delete")
+    def test_delete_resource_failure(self, mock_delete):
+        # Mock failure response
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_response.reason = "Not Found"
+        mock_delete.return_value = mock_response
+
+        with self.assertRaises(Exception) as context:
+            self.service.delete_resource("non-existent", "valid-token")
+
+        self.assertIn("Failed to delete resource", str(context.exception))
+
+    @patch("goiam.service_impl.requests.Session.delete")
+    def test_delete_resource_unauthorized(self, mock_delete):
+        # Mock unauthorized response
+        mock_response = Mock()
+        mock_response.status_code = 401
+        mock_response.reason = "Unauthorized"
+        mock_delete.return_value = mock_response
+
+        with self.assertRaises(Exception) as context:
+            self.service.delete_resource("resource-id", "invalid-token")
+
+        self.assertIn("Failed to delete resource", str(context.exception))
+
 
 if __name__ == "__main__":
     unittest.main()