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

package integration

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

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

	t.Run("Register", func(t *testing.T) {
		testData := map[string]interface{}{
			"email":      "testflow@example.com",
			"password":   "test123456",
			"first_name": "Flow",
			"last_name":  "Test",
		}

		resp, err := config.Request("POST", "/auth/register", testData, "")
		if err != nil {
			t.Fatalf("Failed to register: %v", err)
		}
		defer resp.Body.Close()

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

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

		if _, ok := result["token"]; !ok {
			t.Error("Token not found in response")
		}

		if _, ok := result["user"]; !ok {
			t.Error("User data not found in response")
		}
	})

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

		resp, err := config.Request("POST", "/auth/login", map[string]interface{}{
			"email":    user.Email,
			"password": user.Password,
		}, "")
		if err != nil {
			t.Fatalf("Failed to login: %v", err)
		}
		defer resp.Body.Close()

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

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

		if _, ok := result["token"]; !ok {
			t.Error("Token not found in response")
		}

		cookies := resp.Cookies()
		foundRefreshToken := false
		for _, cookie := range cookies {
			if cookie.Name == "refresh_token" {
				foundRefreshToken = true
				break
			}
		}
		if !foundRefreshToken {
			t.Error("Refresh token cookie not set")
		}
	})

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

		loginResp, err := config.Request("POST", "/auth/login", map[string]interface{}{
			"email":    user.Email,
			"password": user.Password,
		}, "")
		if err != nil {
			t.Fatalf("Failed to login: %v", err)
		}
		loginResp.Body.Close()

		var refreshToken string
		for _, cookie := range loginResp.Cookies() {
			if cookie.Name == "refresh_token" {
				refreshToken = cookie.Value
				break
			}
		}

		resp, err := config.Request("POST", "/auth/refresh", map[string]interface{}{
			"refresh_token": refreshToken,
		}, "")
		if err != nil {
			t.Fatalf("Failed to refresh token: %v", err)
		}
		defer resp.Body.Close()

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

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

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

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

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

		if msg, ok := result["message"].(string); !ok || msg != "Successfully logged out" {
			t.Error("Logout message not as expected")
		}
	})

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

		resp, err := config.Request("POST", "/auth/reset-password", map[string]interface{}{
			"email": user.Email,
		}, "")
		if err != nil {
			t.Fatalf("Failed to request password reset: %v", err)
		}
		defer resp.Body.Close()

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

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

		resetToken, ok := result["token"].(string)
		if !ok {
			t.Fatal("Reset token not found in response")
		}

		newPassword := "newpassword789"
		resp, err = config.Request("POST", "/auth/reset-password/confirm", map[string]interface{}{
			"token":        resetToken,
			"new_password": newPassword,
		}, "")
		if err != nil {
			t.Fatalf("Failed to confirm password reset: %v", err)
		}
		defer resp.Body.Close()

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

		newToken, err := config.GetAuthToken(user.Email, newPassword)
		if err != nil {
			t.Errorf("Failed to login with new password: %v", err)
		}
		if newToken == "" {
			t.Error("Failed to get token with new password")
		}
	})

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

		resp, err := config.Request("POST", "/auth/mobile/login", map[string]interface{}{
			"email":    user.Email,
			"password": user.Password,
		}, "")
		if err != nil {
			t.Fatalf("Failed to mobile login: %v", err)
		}
		defer resp.Body.Close()

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

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

		requiredFields := []string{"access_token", "refresh_token", "expires_at", "user"}
		for _, field := range requiredFields {
			if _, ok := result[field]; !ok {
				t.Errorf("Required field %s not found in response", field)
			}
		}
	})
}