handler_test.go

package main

import (
	"bytes"
	"database/sql"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"

	"github.com/gin-gonic/gin"
	_ "github.com/lib/pq"
	"gopkg.in/gomail.v2"
)

// 🚨 TESTING PROBLEM #1: Complex Test Setup
// We need a real database, email server, and payment API to test this handler
func TestCreateOrder_Success(t *testing.T) {
	// 🚨 PROBLEM: Need to set up a real test database
	db, err := setupTestDatabase()
	if err != nil {
		t.Fatalf("Failed to setup test database: %v", err)
	}
	defer teardownTestDatabase(db)

	// 🚨 PROBLEM: Need to seed test data - couples test to specific schema
	seedTestData(db, t)

	// 🚨 PROBLEM: Need a mock email server or skip email entirely
	// Here we're using a broken dialer that will fail - but order will still be created!
	mailer := gomail.NewDialer("localhost", 1025, "", "")

	// 🚨 PROBLEM: Stripe requires test API keys - must be configured
	os.Setenv("STRIPE_KEY", "sk_test_fake_key_that_will_fail")

	handler := &OrderHandler{
		db:     db,
		mailer: mailer,
	}

	// 🚨 PROBLEM: Need to set up HTTP test infrastructure
	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.POST("/orders", handler.CreateOrder)

	// Create test request
	requestBody := CreateOrderRequest{
		CustomerID:    1,
		CustomerEmail: "test@example.com",
		Items: []Item{
			{ProductID: 1, Quantity: 2},
		},
		DiscountCode: "SAVE10",
	}

	bodyBytes, _ := json.Marshal(requestBody)
	req := httptest.NewRequest("POST", "/orders", bytes.NewBuffer(bodyBytes))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	// 🚨 TESTING PROBLEM #2: This test will FAIL because:
	// 1. Stripe API call will fail (fake key)
	// 2. Email will fail (no SMTP server)
	// 3. But we can't test business logic in isolation!
	router.ServeHTTP(w, req)

	// 🚨 TESTING PROBLEM #3: We can't assert on business logic
	// We can only check HTTP status codes, not internal behavior
	if w.Code != http.StatusOK {
		t.Errorf("Expected status 200, got %d", w.Code)
		t.Logf("Response body: %s", w.Body.String())
	}

	// 🚨 TESTING PROBLEM #4: To verify the order was created, we need more DB queries
	// This couples our test to the database schema
	var orderCount int
	db.QueryRow("SELECT COUNT(*) FROM orders WHERE customer_id = $1", 1).Scan(&orderCount)
	if orderCount != 1 {
		t.Errorf("Expected 1 order, found %d", orderCount)
	}
}

// 🚨 TESTING PROBLEM #5: Testing edge cases is a nightmare
func TestCreateOrder_PaymentFails(t *testing.T) {
	// How do we simulate a payment failure?
	// 1. Mock the entire Stripe SDK? (complex)
	// 2. Use Stripe's test mode with specific card numbers? (requires real API calls)
	// 3. Dependency injection? (not possible with this design)
	
	t.Skip("Can't test payment failures without major refactoring")
}

func TestCreateOrder_InsufficientStock(t *testing.T) {
	// 🚨 PROBLEM: Need to set up database with specific stock levels
	db, err := setupTestDatabase()
	if err != nil {
		t.Fatalf("Failed to setup test database: %v", err)
	}
	defer teardownTestDatabase(db)

	// Seed product with low stock
	_, err = db.Exec(
		"INSERT INTO products (id, name, price, stock) VALUES ($1, $2, $3, $4)",
		999, "Low Stock Product", 50.0, 1,
	)
	if err != nil {
		t.Fatalf("Failed to seed data: %v", err)
	}

	mailer := gomail.NewDialer("localhost", 1025, "", "")
	handler := &OrderHandler{db: db, mailer: mailer}

	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.POST("/orders", handler.CreateOrder)

	// Try to order more than available
	requestBody := CreateOrderRequest{
		CustomerID:    1,
		CustomerEmail: "test@example.com",
		Items: []Item{
			{ProductID: 999, Quantity: 10}, // Only 1 in stock!
		},
	}

	bodyBytes, _ := json.Marshal(requestBody)
	req := httptest.NewRequest("POST", "/orders", bytes.NewBuffer(bodyBytes))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	router.ServeHTTP(w, req)

	// 🚨 TESTING PROBLEM #6: We can test the HTTP response, but not the business rule directly
	if w.Code != http.StatusBadRequest {
		t.Errorf("Expected status 400, got %d", w.Code)
	}

	// 🚨 TESTING PROBLEM #7: Error message is buried in JSON response
	var response map[string]interface{}
	json.Unmarshal(w.Body.Bytes(), &response)
	
	errorMsg, ok := response["error"].(string)
	if !ok || errorMsg == "" {
		t.Error("Expected error message in response")
	}
}

func TestCreateOrder_DiscountCalculation(t *testing.T) {
	// 🚨 TESTING PROBLEM #8: Can't test discount logic without full HTTP request
	// The business logic (discount calculation) is buried in the handler
	// We need database, HTTP server, everything... just to test math!

	t.Skip("Discount logic is untestable in isolation - requires full integration test")
}

// 🚨 TESTING PROBLEM #9: Test helpers are complex and fragile
func setupTestDatabase() (*sql.DB, error) {
	// Need a real Postgres instance running
	dbURL := os.Getenv("TEST_DATABASE_URL")
	if dbURL == "" {
		dbURL = "postgres://postgres:postgres@localhost/test_orders?sslmode=disable"
	}

	db, err := sql.Open("postgres", dbURL)
	if err != nil {
		return nil, err
	}

	// Create schema
	schema := `
		CREATE TABLE IF NOT EXISTS products (
			id SERIAL PRIMARY KEY,
			name VARCHAR(255) NOT NULL,
			price DECIMAL(10,2) NOT NULL,
			stock INT NOT NULL
		);

		CREATE TABLE IF NOT EXISTS orders (
			id SERIAL PRIMARY KEY,
			customer_id INT NOT NULL,
			total DECIMAL(10,2) NOT NULL,
			payment_id VARCHAR(255),
			status VARCHAR(50),
			created_at TIMESTAMP
		);

		CREATE TABLE IF NOT EXISTS order_items (
			id SERIAL PRIMARY KEY,
			order_id INT REFERENCES orders(id),
			product_id INT REFERENCES products(id),
			quantity INT NOT NULL,
			price DECIMAL(10,2) NOT NULL
		);
	`

	_, err = db.Exec(schema)
	return db, err
}

func teardownTestDatabase(db *sql.DB) {
	// Clean up
	db.Exec("DROP TABLE IF EXISTS order_items")
	db.Exec("DROP TABLE IF EXISTS orders")
	db.Exec("DROP TABLE IF EXISTS products")
	db.Close()
}

func seedTestData(db *sql.DB, t *testing.T) {
	// Insert test products
	_, err := db.Exec(
		"INSERT INTO products (id, name, price, stock) VALUES ($1, $2, $3, $4)",
		1, "Test Product", 50.0, 100,
	)
	if err != nil {
		t.Fatalf("Failed to seed products: %v", err)
	}
}

// 🚨 TESTING PROBLEM #10: Test execution is SLOW
// - Each test needs DB setup/teardown: ~500ms-1s
// - HTTP round-trip overhead: ~10-50ms
// - Total: A simple test that should take <1ms takes 500ms+
//
// With hexagonal architecture:
// - Business logic tests: <1ms (no DB, no HTTP, just Go code)
// - Integration tests: Still slow, but rare and isolated