tp/main_dc/yalarba/api_yal/tests/integration/object_test.go

package integration

import (
	"fmt"
	"testing"
	"api_yal/tests/testutils"
)

func TestObjectEndpoints(t *testing.T) {
	config := testutils.NewTestConfig()

	t.Run("CreateObject", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		objectData := testutils.CreateObjectRequest{
			ShortName:        "Test Cafe",
			LongName:         "Test Cafe on Main Street",
			Type:             "cafe",
			Phone:            "+71234567890",
			Email:            "cafe@test.com",
			Site:             "https://cafe.test.com",
			ShortDescription: "A test cafe",
			Description:      "This is a test cafe for API testing",
			Address:          "123 Test Street",
			Latitude:         55.751244,
			Longitude:        37.618423,
			IsActive:         true,
			IsVerified:       false,
		}

		resp, err := config.Request("POST", "/objects", objectData, user.Token)
		if err != nil {
			t.Fatalf("Failed to create object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 201 {
			t.Errorf("Expected status 201, got %d", resp.StatusCode)
		}

		var createdObject map[string]interface{}
		if err := config.ParseResponse(resp, &createdObject); err != nil {
			t.Fatalf("Failed to parse response: %v", err)
		}

		if _, ok := createdObject["id"]; !ok {
			t.Error("Object ID not found in response")
		}

		if name, ok := createdObject["short_name"].(string); !ok || name != "Test Cafe" {
			t.Error("Object name mismatch")
		}
	})

	t.Run("GetObjectByID", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		objectID := config.CreateTestObject(t, user.Token)

		resp, err := config.Request("GET", "/objects/"+fmt.Sprintf("%d", objectID), nil, "")
		if err != nil {
			t.Fatalf("Failed to get object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			t.Errorf("Expected status 200, got %d", resp.StatusCode)
		}

		var object map[string]interface{}
		if err := config.ParseResponse(resp, &object); err != nil {
			t.Fatalf("Failed to parse response: %v", err)
		}

		if id, ok := object["id"].(float64); !ok || uint(id) != objectID {
			t.Errorf("Object ID mismatch: expected %d, got %v", objectID, id)
		}
	})

	t.Run("GetNonExistentObject", func(t *testing.T) {
		resp, err := config.Request("GET", "/objects/999999", nil, "")
		if err != nil {
			t.Fatalf("Failed to get object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 404 {
			t.Errorf("Expected status 404, got %d", resp.StatusCode)
		}
	})

	t.Run("UpdateObject", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		objectID := config.CreateTestObject(t, user.Token)

		updateData := map[string]interface{}{
			"short_name":        "Updated Cafe Name",
			"description":       "Updated description",
			"short_description": "Updated short desc",
		}

		resp, err := config.Request("PUT", "/objects/"+fmt.Sprintf("%d", objectID), updateData, user.Token)
		if err != nil {
			t.Fatalf("Failed to update object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			t.Errorf("Expected status 200, got %d", resp.StatusCode)
		}

		var updatedObject map[string]interface{}
		if err := config.ParseResponse(resp, &updatedObject); err != nil {
			t.Fatalf("Failed to parse response: %v", err)
		}

		if name, ok := updatedObject["short_name"].(string); !ok || name != "Updated Cafe Name" {
			t.Error("Object name not updated")
		}
	})

	t.Run("UpdateObjectUnauthorized", func(t *testing.T) {
		user1 := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user1)

		user2 := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user2)

		objectID := config.CreateTestObject(t, user1.Token)

		resp, err := config.Request("PUT", "/objects/"+fmt.Sprintf("%d", objectID), map[string]interface{}{
			"short_name": "Hacked Name",
		}, user2.Token)
		if err != nil {
			t.Fatalf("Failed to update object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 403 {
			t.Errorf("Expected status 403, got %d", resp.StatusCode)
		}
	})

	t.Run("ListObjects", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		for i := 0; i < 3; i++ {
			config.CreateTestObject(t, user.Token)
		}

		resp, err := config.Request("GET", "/objects?page=1&page_size=10", nil, "")
		if err != nil {
			t.Fatalf("Failed to list objects: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			t.Errorf("Expected status 200, got %d", resp.StatusCode)
		}

		var listResponse map[string]interface{}
		if err := config.ParseResponse(resp, &listResponse); err != nil {
			t.Fatalf("Failed to parse response: %v", err)
		}

		if _, ok := listResponse["items"]; !ok {
			t.Error("Items field not found in response")
		}
	})

	t.Run("SearchObjects", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		config.CreateTestObject(t, user.Token)

		resp, err := config.Request("GET", "/objects/search?q=Test", nil, "")
		if err != nil {
			t.Fatalf("Failed to search objects: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			t.Errorf("Expected status 200, got %d", resp.StatusCode)
		}

		var searchResults map[string]interface{}
		if err := config.ParseResponse(resp, &searchResults); err != nil {
			t.Fatalf("Failed to parse response: %v", err)
		}

		t.Logf("Search results: %+v", searchResults)
	})

	t.Run("NearbyObjects", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		resp, err := config.Request("GET", "/objects/nearby?lat=55.751244&lng=37.618423&radius=1000", nil, "")
		if err != nil {
			t.Fatalf("Failed to get nearby objects: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			t.Errorf("Expected status 200, got %d", resp.StatusCode)
		}
	})

	t.Run("DeleteObject", func(t *testing.T) {
		user := config.CreateTestUser(t)
		defer config.CleanupTestUser(t, user)

		objectID := config.CreateTestObject(t, user.Token)

		resp, err := config.Request("DELETE", "/objects/"+fmt.Sprintf("%d", objectID), nil, user.Token)
		if err != nil {
			t.Fatalf("Failed to delete object: %v", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != 204 {
			t.Errorf("Expected status 204, got %d", resp.StatusCode)
		}

		getResp, err := config.Request("GET", "/objects/"+fmt.Sprintf("%d", objectID), nil, "")
		if err != nil {
			t.Fatalf("Failed to get object: %v", err)
		}
		defer getResp.Body.Close()

		if getResp.StatusCode != 404 {
			t.Errorf("Expected status 404 for deleted object, got %d", getResp.StatusCode)
		}
	})
}