Merge pull request #12 from maniac-en/mudassir/endpoints

chore: addeds logs and tests

Author: MudassirDev

db/queries/collections.sql

@@ -13,3 +13,7 @@ RETURNING *;
 -- name: DeleteCollection :exec
 DELETE FROM collections
 WHERE id = ?;
+
+-- name: GetCollection :one
+SELECT * FROM collections
+WHERE id = ?;

internal/collections/collections.go

@@ -28,7 +28,7 @@ func (c *CollectionsManager) GetAllCollections(ctx context.Context) ([]database.
 }
 
 func (c *CollectionsManager) CreateCollection(ctx context.Context, name string) (database.Collection, error) {
-	if err := validateCollectionName(name); err != nil {
+	if err := validateName(name); err != nil {
 		log.Error("invalid collection name", "name", name, "error", err)
 		return database.Collection{}, err
 	}
@@ -44,7 +44,7 @@ func (c *CollectionsManager) CreateCollection(ctx context.Context, name string)
 }
 
 func (c *CollectionsManager) UpdateCollectionName(ctx context.Context, name string, collectionId int) (database.Collection, error) {
-	if err := validateCollectionName(name); err != nil {
+	if err := validateName(name); err != nil {
 		log.Error("invalid collection name", "name", name, "error", err)
 		return database.Collection{}, err
 	}
@@ -74,7 +74,7 @@ func (c *CollectionsManager) DeleteCollection(ctx context.Context, id int) error
 	return nil
 }
 
-func validateCollectionName(name string) error {
+func validateName(name string) error {
 	name = strings.TrimSpace(name)
 	if name == "" {
 		return fmt.Errorf("collection name cannot be empty")

internal/collections/collections_test.go

@@ -0,0 +1,273 @@
+package collections_test
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+
+	"github.com/maniac-en/req/internal/collections"
+	"github.com/maniac-en/req/internal/database"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func setupTestDB(t *testing.T) (*sql.DB, *database.Queries, func()) {
+	t.Helper()
+
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("failed to open test db: %v", err)
+	}
+
+	schema, err := os.ReadFile("testdata/schema.sql")
+	if err != nil {
+		t.Fatalf("failed to read schema: %v", err)
+	}
+	_, err = db.Exec(string(schema))
+	if err != nil {
+		t.Fatalf("failed to execute schema: %v", err)
+	}
+
+	queries := database.New(db)
+
+	cleanup := func() {
+		db.Close()
+	}
+	return db, queries, cleanup
+}
+
+func TestCreateCollection(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, err := manager.CreateCollection(ctx, "Test Collection")
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if collection.Name != "Test Collection" {
+		t.Errorf("expected name to be 'Test Collection', got %s", collection.Name)
+	}
+}
+
+func TestCreateCollection_Validation(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	_, err := manager.CreateCollection(ctx, "")
+	if err == nil {
+		t.Errorf("expected error for empty name")
+	}
+
+	longName := make([]byte, 101)
+	for i := range longName {
+		longName[i] = 'a'
+	}
+	_, err = manager.CreateCollection(ctx, string(longName))
+	if err == nil {
+		t.Errorf("expected error for long name")
+	}
+
+	_, err = manager.CreateCollection(ctx, "Invalid/Name")
+	if err == nil {
+		t.Errorf("expected error for invalid characters")
+	}
+}
+
+func TestUpdateCollectionName(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "Old Name")
+	updated, err := manager.UpdateCollectionName(ctx, "New Name", int(collection.ID))
+	if err != nil {
+		t.Fatalf("update failed: %v", err)
+	}
+	if updated.Name != "New Name" {
+		t.Errorf("expected name to be 'New Name', got %s", updated.Name)
+	}
+}
+
+func TestDeleteCollection(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "ToDelete")
+	err := manager.DeleteCollection(ctx, int(collection.ID))
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	collections, _ := manager.GetAllCollections(ctx)
+	if len(collections) != 0 {
+		t.Errorf("expected 0 collections after delete")
+	}
+}
+
+func TestGetAllCollections(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	manager.CreateCollection(ctx, "One")
+	manager.CreateCollection(ctx, "Two")
+
+	all, err := manager.GetAllCollections(ctx)
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if len(all) != 2 {
+		t.Errorf("expected 2 collections, got %d", len(all))
+	}
+}
+
+func TestCreateEndpoint(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "API Group")
+	endpoint, err := manager.CreateEndpoint(ctx, "Get Users", "GET", "/users", collection.ID)
+	if err != nil {
+		t.Fatalf("endpoint creation failed: %v", err)
+	}
+	if endpoint.Name != "Get Users" {
+		t.Errorf("expected endpoint name 'Get Users', got %s", endpoint.Name)
+	}
+}
+
+func TestUpdateEndpoint(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "Test")
+	ep, _ := manager.CreateEndpoint(ctx, "Original", "GET", "/", collection.ID)
+
+	updated, err := manager.UpdateEndpoint(ctx, ep.ID, "Updated", "POST", "/new", "hdr", "q", "body")
+	if err != nil {
+		t.Fatalf("update failed: %v", err)
+	}
+	if updated.Method != "POST" || updated.Url != "/new" {
+		t.Errorf("update did not apply correctly")
+	}
+}
+
+func TestGetEndpoint(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "Test")
+	ep, _ := manager.CreateEndpoint(ctx, "TestEp", "GET", "/test", collection.ID)
+	fetched, err := manager.GetEndpoint(ctx, ep.ID)
+	if err != nil {
+		t.Fatalf("failed to fetch: %v", err)
+	}
+	if fetched.ID != ep.ID {
+		t.Errorf("expected ID %d, got %d", ep.ID, fetched.ID)
+	}
+}
+
+func TestGetEndpoints(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	collection, _ := manager.CreateCollection(ctx, "Batch")
+	manager.CreateEndpoint(ctx, "One", "GET", "/1", collection.ID)
+	manager.CreateEndpoint(ctx, "Two", "GET", "/2", collection.ID)
+
+	eps, err := manager.GetEndpoints(ctx, collection.ID)
+	if err != nil {
+		t.Fatalf("expected no error: %v", err)
+	}
+	if len(eps) != 2 {
+		t.Errorf("expected 2 endpoints, got %d", len(eps))
+	}
+}
+
+func TestCreateEndpoint_InvalidCollectionID(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	_, err := manager.CreateEndpoint(ctx, "Name", "GET", "/url", 999)
+	if err == nil {
+		t.Errorf("expected error for invalid collection ID")
+	}
+}
+
+func TestUpdateEndpoint_NonExistent(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	_, err := manager.UpdateEndpoint(ctx, 999, "Updated", "POST", "/new", "hdr", "q", "body")
+	if err == nil {
+		t.Errorf("expected error for non-existent endpoint")
+	}
+}
+
+func TestGetEndpoint_NotFound(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	_, err := manager.GetEndpoint(ctx, 999)
+	if err == nil {
+		t.Errorf("expected error for non-existent endpoint")
+	}
+}
+
+func newBrokenTestDB(t *testing.T) *database.Queries {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("failed to open sqlite memory db: %v", err)
+	}
+	db.Close()
+	return database.New(db)
+}
+
+func TestGetEndpoints_DBError(t *testing.T) {
+	db := newBrokenTestDB(t)
+
+	manager := collections.NewCollectionsManager(db)
+	ctx := context.Background()
+
+	_, err := manager.GetEndpoints(ctx, 999)
+
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+
+	t.Logf("got expected error: %v", err)
+}
+
+func TestDeleteCollection_InvalidID(t *testing.T) {
+	_, queries, cleanup := setupTestDB(t)
+	defer cleanup()
+	manager := collections.NewCollectionsManager(queries)
+	ctx := context.Background()
+
+	err := manager.DeleteCollection(ctx, 999)
+	if err != nil {
+		t.Logf("received expected delete error: %v", err)
+	}
+}