Attemped unit tests + refactoring code

backend/internal/handlers/friendship/friendship.go

@@ -1,28 +1,43 @@
 package friendship
 
 import (
-	"fmt"
 	"github.com/GenerateNU/nightlife/internal/models"
 	"github.com/gofiber/fiber/v2"
-	"log"
+	"github.com/google/uuid"
 )
 
 // POST endpoint to create friendship between two users in DB
 func (s *Service) CreateFriendship(c *fiber.Ctx) error {
-	fmt.Println("Creating a friendship")
+    var req models.Friendship
 
-	var req models.Friendship
+    // Parse the request body and check for errors
+    if err := c.BodyParser(&req); err != nil {
+        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+            "error": "Cannot parse JSON",
+        })
+    }
 
-	if err := c.BodyParser(&req); err != nil {
-		log.Printf("Error parsing JSON: %v, Request: %+v", err, req)
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
-			"error": "Cannot parse JSON",
-		})
-	}
+    // Ensure both user ids are present
+    if req.UserID1 == uuid.Nil || req.UserID2 == uuid.Nil {
+        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+            "error": "Both user_id1 and user_id2 are required",
+        })
+    }
 
-	if err := s.store.CreateFriendship(c.Context(), req); err != nil {
-		return err
-	}
+    // Set default friendship status if not provided (just an edge case)
+    if req.FriendshipStatus == "" {
+        req.FriendshipStatus = models.Pending
+    }
 
-	return c.Status(fiber.StatusCreated).JSON(req)
+    // Call CreateFriendship method to interact with db
+    if err := s.store.CreateFriendship(c.Context(), req); err != nil {
+        return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+            "error": "Failed to create friendship",
+        })
+    }
+
+    // On success, return 201 and req body
+    return c.Status(fiber.StatusCreated).JSON(req)
 }
+
+

backend/internal/handlers/friendship/friendship_test.go

@@ -0,0 +1,229 @@
+	package friendship
+
+	import (
+		"bytes"
+		"context"
+		"encoding/json"
+		"errors"
+		"github.com/GenerateNU/nightlife/internal/models"
+		"github.com/gofiber/fiber/v2"
+		"github.com/google/uuid"
+		"net/http"
+		"net/http/httptest"
+		"testing"
+	)
+
+	// Mock Service structure
+	type MockStore struct {
+		// Add fields for your mocked functions
+		CreateFriendshipFn         func(ctx context.Context, friendship models.Friendship) error
+		CreatePreferencesFn        func(ctx context.Context, preferences models.Preferences) error
+		UpdateProfilePreferencesFn func(ctx context.Context, userID uuid.UUID, pref1, pref2, pref3, pref4 string) error
+		DeleteAccountFn            func(ctx context.Context, userID uuid.UUID) error
+		RemoveFriendFn             func(ctx context.Context, userID uuid.UUID, friendID string) error
+		GetProfileByColumnFn       func(ctx context.Context, column, value string) (models.Profile, error)
+		GetAllUsersFn              func(ctx context.Context) ([]models.Profile, error)
+		GetAllUserRatingsFn        func(ctx context.Context, userID uuid.UUID) ([]models.UserRating, error)
+		DeleteVenueFn              func(ctx context.Context, venueID uuid.UUID) error
+		DeleteReviewForVenueFn     func(ctx context.Context, reviewID int8) error
+		GetAllVenueRatingsFn       func(ctx context.Context, venueID uuid.UUID) ([]models.VenueRatings, error)
+		GetAllTestsFn              func(ctx context.Context) ([]models.Test, error)
+	}
+
+	// Implement all the Store interface methods for the mock
+
+	// Implement the CreateFriendship method for the MockStore
+	func (m *MockStore) CreateFriendship(ctx context.Context, friendship models.Friendship) error {
+		if m.CreateFriendshipFn != nil {
+			return m.CreateFriendshipFn(ctx, friendship)
+		}
+		return nil
+	}
+
+	// Implement the CreatePreferences method for the MockStore
+	func (m *MockStore) CreatePreferences(ctx context.Context, preferences models.Preferences) error {
+		if m.CreatePreferencesFn != nil {
+			return m.CreatePreferencesFn(ctx, preferences)
+		}
+		return nil
+	}
+
+	// Implement the UpdateProfilePreferences method for the MockStore
+	func (m *MockStore) UpdateProfilePreferences(ctx context.Context, userID uuid.UUID, pref1, pref2, pref3, pref4 string) error {
+		if m.UpdateProfilePreferencesFn != nil {
+			return m.UpdateProfilePreferencesFn(ctx, userID, pref1, pref2, pref3, pref4)
+		}
+		return nil
+	}
+
+	// Implement the DeleteAccount method for the MockStore
+	func (m *MockStore) DeleteAccount(ctx context.Context, userID uuid.UUID) error {
+		if m.DeleteAccountFn != nil {
+			return m.DeleteAccountFn(ctx, userID)
+		}
+		return nil
+	}
+
+	// Implement the RemoveFriend method for the MockStore
+	func (m *MockStore) RemoveFriend(ctx context.Context, userID uuid.UUID, friendID string) error {
+		if m.RemoveFriendFn != nil {
+			return m.RemoveFriendFn(ctx, userID, friendID)
+		}
+		return nil
+	}
+
+	// Implement the GetProfileByColumn method for the MockStore
+	func (m *MockStore) GetProfileByColumn(ctx context.Context, column, value string) (models.Profile, error) {
+		if m.GetProfileByColumnFn != nil {
+			return m.GetProfileByColumnFn(ctx, column, value)
+		}
+		return models.Profile{}, nil
+	}
+
+	// Implement the GetAllUsers method for the MockStore
+	func (m *MockStore) GetAllUsers(ctx context.Context) ([]models.Profile, error) {
+		if m.GetAllUsersFn != nil {
+			return m.GetAllUsersFn(ctx)
+		}
+		return nil, nil
+	}
+
+	// Implement the GetAllUserRatings method for the MockStore
+	func (m *MockStore) GetAllUserRatings(ctx context.Context, userID uuid.UUID) ([]models.UserRating, error) {
+		if m.GetAllUserRatingsFn != nil {
+			return m.GetAllUserRatingsFn(ctx, userID)
+		}
+		return nil, nil
+	}
+
+	// Implement the DeleteVenue method for the MockStore
+	func (m *MockStore) DeleteVenue(ctx context.Context, venueID uuid.UUID) error {
+		if m.DeleteVenueFn != nil {
+			return m.DeleteVenueFn(ctx, venueID)
+		}
+		return nil
+	}
+
+	// Implement the DeleteReviewForVenue method for the MockStore
+	func (m *MockStore) DeleteReviewForVenue(ctx context.Context, reviewID int8) error {
+		if m.DeleteReviewForVenueFn != nil {
+			return m.DeleteReviewForVenueFn(ctx, reviewID)
+		}
+		return nil
+	}
+
+	// Implement the GetAllVenueRatings method for the MockStore
+	func (m *MockStore) GetAllVenueRatings(ctx context.Context, venueID uuid.UUID) ([]models.VenueRatings, error) {
+		if m.GetAllVenueRatingsFn != nil {
+			return m.GetAllVenueRatingsFn(ctx, venueID)
+		}
+		return nil, nil
+	}
+
+	// Implement the GetAllTests method for the MockStore
+	func (m *MockStore) GetAllTests(ctx context.Context) ([]models.Test, error) {
+		if m.GetAllTestsFn != nil {
+			return m.GetAllTestsFn(ctx)
+		}
+		return nil, nil
+	}
+
+	// Implement the Close method for the MockStore to satisfy the storage.Storage interface
+	func (m *MockStore) Close() {
+
+	}
+
+	// Test for the POST endpoint CreateFriendship
+	func TestCreateFriendship(t *testing.T) {
+		// Create a new Fiber app
+		app := fiber.New()
+
+		// Set up the mock store
+		mockStore := &MockStore{}
+
+		// Set up the service with the mock store
+		service := &Service{
+			store: mockStore,
+		}
+
+		// Add the route to Fiber
+		app.Post("/add-friend", service.CreateFriendship)
+
+		// Define the test cases
+		tests := []struct {
+			name           string
+			inputJSON      string
+			mockResponse   error
+			expectedStatus int
+			expectedBody   string
+		}{
+			{
+				name:           "successful creation",
+				inputJSON:      `{"user_id1": "00000000-0000-0000-0000-000000000001", "user_id2": "00000000-0000-0000-0000-000000000002"}`,
+				mockResponse:   nil,
+				expectedStatus: fiber.StatusCreated,
+				expectedBody:   `{"user_id1":"00000000-0000-0000-0000-000000000001","user_id2":"00000000-0000-0000-0000-000000000002"}`,
+			},
+			{
+				name:           "invalid JSON body",
+				inputJSON:      `{"invalid_json"}`,
+				mockResponse:   nil,
+				expectedStatus: fiber.StatusBadRequest,
+				expectedBody:   `{"error":"Cannot parse JSON"}`,
+			},
+			{
+				name:           "store error",
+				inputJSON:      `{"user_id1": "00000000-0000-0000-0000-000000000001", "user_id2": "00000000-0000-0000-0000-000000000002"}`,
+				mockResponse:   errors.New("db error"),
+				expectedStatus: fiber.StatusInternalServerError,
+				expectedBody:   `{"error":"Failed to create friendship"}`, 
+			},
+		}
+
+		// Iterate over the test cases
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				// Mock the CreateFriendship function behavior based on the test case
+				mockStore.CreateFriendshipFn = func(ctx context.Context, friendship models.Friendship) error {
+					return tt.mockResponse
+				}
+
+				// Create the HTTP request
+				req := httptest.NewRequest(http.MethodPost, "/add-friend", bytes.NewBuffer([]byte(tt.inputJSON)))
+				req.Header.Set("Content-Type", "application/json")
+
+				// Test the request using Fiber's app.Test() method
+				resp, err := app.Test(req, -1)
+				if err != nil {
+					t.Fatalf("Error making the request: %v", err)
+				}
+
+				// Check the status code
+				if resp.StatusCode != tt.expectedStatus {
+					t.Errorf("expected status %d, got %d", tt.expectedStatus, resp.StatusCode)
+				}
+
+				// Check the response body
+				if tt.expectedBody != "" {
+					var response map[string]interface{}
+					if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
+						t.Fatalf("Error unmarshalling response: %v", err)
+					}
+
+					// Convert the expected response from string to a map for comparison
+					expectedResponse := make(map[string]interface{})
+					if err := json.Unmarshal([]byte(tt.expectedBody), &expectedResponse); err != nil {
+						t.Fatalf("Error unmarshalling expected body: %v", err)
+					}
+
+					// Compare the actual response to the expected one
+					for key, value := range expectedResponse {
+						if response[key] != value {
+							t.Errorf("expected %v for key %v, got %v", value, key, response[key])
+						}
+					}
+				}
+			})
+		}
+	}
+

backend/internal/handlers/friendship/routes.go

@@ -1,7 +1,6 @@
 package friendship
 
 import (
-	//"github.com/GenerateNU/nightlife/internal/auth"
 	"github.com/GenerateNU/nightlife/internal/types"
 	"github.com/gofiber/fiber/v2"
 )
@@ -13,9 +12,8 @@ func Routes(app *fiber.App, params types.Params) {
 
 	//create a grouping
 	protected := app.Group("/friendships")
-	//.Use(auth.Protected(&params.Supabase))
 
 	//create a route
-	protected.Post("/api/friendship", service.CreateFriendship)
+	protected.Post("/add-friend", service.CreateFriendship)
 
 }