@growsober/sdk 1.0.5 → 1.0.8

package/src/__tests__/e2e.test.ts

@@ -3,11 +3,41 @@
  *
  * Tests all SDK endpoints against the real API.
  * Run with: npx ts-node src/__tests__/e2e.test.ts
+ *
+ * Covers:
+ * - Authentication
+ * - Users
+ * - Events (with venue, creator, brand sponsor)
+ * - Bookings
+ * - Event Chat (new roles: ATTENDEE, CREATOR, VENUE_REP, BRAND_REP)
+ * - Hubs
+ * - Venues (new - replaces businesses)
+ * - Creators (new)
+ * - Brands (new)
+ * - Unified Rewards (venue + brand rewards)
+ * - Library (content workflow)
+ * - Support (check-ins, wins, Jack AI)
+ * - Creator Products (sessions/packages with booking flow)
+ * - Badges & Rewards
+ * - Badge Awarding (business logic tests for automatic badge awarding)
+ *   - CHECK_IN_STREAK badge on check-in
+ *   - WINS_LOGGED badge on logging wins
+ *   - MOOD_LOGS_COUNT badge on mood logging
+ *   - REFLECTIONS_COUNT badge on submitting reflections
+ *   - EVENTS_HOSTED badge on publishing events
+ *   - EVENTS_ATTENDED badge progress tracking
+ * - Reward Flow (full redemption lifecycle)
+ *   - Creating rewards for badges (venue/brand)
+ *   - User earns badge -> reward becomes available
+ *   - Redeem reward (get redemption details)
+ *   - Cannot redeem without badge
+ *   - Cannot redeem twice (per user limit)
+ *   - Reward verification endpoint
  */
 
 import axios, { AxiosInstance } from 'axios';
 
-const BASE_URL = 'http://localhost:3001/api/v1';
+const BASE_URL = process.env.API_URL || 'http://localhost:3001/api/v1';
 const TEST_EMAIL = `e2e-${Date.now()}@growsober.com`;
 const TEST_PASSWORD = 'SecurePass123!';
 
@@ -19,6 +49,7 @@ const c = {
   yellow: '\x1b[33m',
   cyan: '\x1b[36m',
   dim: '\x1b[2m',
+  bold: '\x1b[1m',
 };
 
 // State shared across tests
@@ -31,6 +62,20 @@ const state: {
   bookingId?: string;
   chatId?: string;
   conversationId?: string;
+  // New state for restructured models
+  venueId?: string;
+  creatorId?: string;
+  brandId?: string;
+  availabilityId?: string;
+  rewardId?: string;
+  badgeId?: string;
+  contentId?: string;
+  // Creator products
+  productId?: string;
+  productBookingId?: string;
+  // Second user for ownership tests
+  secondUserToken?: string;
+  secondUserId?: string;
 } = {
   accessToken: '',
   refreshToken: '',
@@ -40,6 +85,7 @@ const state: {
 // Stats
 let passed = 0;
 let failed = 0;
+let skipped = 0;
 
 // Create axios client
 function api(token?: string): AxiosInstance {
@@ -66,9 +112,20 @@ async function test(name: string, fn: () => Promise<void>): Promise<boolean> {
   }
 }
 
-// Unwrap API response
-function unwrap<T>(res: { data: { data: T } }): T {
-  return res.data.data;
+// Skip test with reason
+function skip(name: string, reason: string): void {
+  console.log(`${c.yellow}SKIP${c.reset} ${name} ${c.dim}(${reason})${c.reset}`);
+  skipped++;
+}
+
+// Unwrap API response (handles both wrapped and unwrapped)
+function unwrap<T>(res: { data: any }): T {
+  return res.data?.data !== undefined ? res.data.data : res.data;
+}
+
+// Section header
+function section(name: string): void {
+  console.log(`\n${c.cyan}--- ${name} ---${c.reset}\n`);
 }
 
 // ============================================================================
@@ -76,16 +133,16 @@ function unwrap<T>(res: { data: { data: T } }): T {
 // ============================================================================
 
 async function runTests() {
-  console.log(`\n${c.cyan}${'='.repeat(60)}${c.reset}`);
-  console.log(`${c.cyan}  GrowSober API E2E Tests${c.reset}`);
-  console.log(`${c.cyan}${'='.repeat(60)}${c.reset}`);
+  console.log(`\n${c.cyan}${'='.repeat(70)}${c.reset}`);
+  console.log(`${c.cyan}  GrowSober API E2E Tests - Full Coverage${c.reset}`);
+  console.log(`${c.cyan}${'='.repeat(70)}${c.reset}`);
   console.log(`${c.dim}Base URL: ${BASE_URL}${c.reset}`);
   console.log(`${c.dim}Test Email: ${TEST_EMAIL}${c.reset}\n`);
 
   // Health check
   const health = await api().get('/health');
   if (health.status !== 200) {
-    console.log(`${c.red}API is not reachable${c.reset}`);
+    console.log(`${c.red}API is not reachable at ${BASE_URL}${c.reset}`);
     process.exit(1);
   }
   console.log(`${c.green}API is healthy${c.reset}\n`);
@@ -93,7 +150,7 @@ async function runTests() {
   // =========================================================================
   // AUTH
   // =========================================================================
-  console.log(`\n${c.cyan}--- AUTHENTICATION ---${c.reset}\n`);
+  section('AUTHENTICATION');
 
   await test('Register new user', async () => {
     const res = await api().post('/auth/register', {
@@ -142,10 +199,23 @@ async function runTests() {
     if (res.status !== 401) throw new Error(`Expected 401, got ${res.status}`);
   });
 
+  // Register second user for ownership tests
+  await test('Register second user for ownership tests', async () => {
+    const res = await api().post('/auth/register', {
+      email: `e2e-second-${Date.now()}@growsober.com`,
+      password: TEST_PASSWORD,
+      name: 'E2E Second User',
+    });
+    if (res.status !== 201) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    state.secondUserToken = data.accessToken;
+    state.secondUserId = data.user.id;
+  });
+
   // =========================================================================
   // USERS
   // =========================================================================
-  console.log(`\n${c.cyan}--- USERS ---${c.reset}\n`);
+  section('USERS');
 
   await test('Get current user profile', async () => {
     const res = await api(state.accessToken).get('/users/me');
@@ -171,9 +241,416 @@ async function runTests() {
   });
 
   // =========================================================================
-  // EVENTS
+  // VENUES (New - replaces Businesses)
+  // =========================================================================
+  section('VENUES');
+
+  await test('List venues', async () => {
+    const res = await api().get('/venues');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Get first venue if exists for further tests
+    if (data?.venues?.length > 0) {
+      state.venueId = data.venues[0].id;
+    }
+  });
+
+  await test('Get featured venues', async () => {
+    const res = await api().get('/venues/featured');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get nearby venues', async () => {
+    const res = await api().get('/venues/nearby', {
+      params: { lat: 51.5074, long: -0.1278, radius: 10 },
+    });
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  if (state.venueId) {
+    await test('Get venue by ID', async () => {
+      const res = await api().get(`/venues/${state.venueId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get venue owners', async () => {
+      const res = await api(state.accessToken).get(`/venues/${state.venueId}/owners`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get venue events', async () => {
+      const res = await api().get(`/venues/${state.venueId}/events`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+  } else {
+    skip('Get venue by ID', 'No venues in database');
+    skip('Get venue owners', 'No venues in database');
+    skip('Get venue events', 'No venues in database');
+  }
+
+  // =========================================================================
+  // CREATORS (New)
+  // =========================================================================
+  section('CREATORS');
+
+  await test('List creators', async () => {
+    const res = await api().get('/creators');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Create creator profile', async () => {
+    const res = await api(state.accessToken).post('/creators', {
+      slug: `e2e-creator-${Date.now()}`,
+      displayName: 'E2E Test Creator',
+      bio: 'A test creator for E2E tests',
+      canFacilitate: true,
+      canCreateContent: true,
+      isInfluencer: false,
+      specialties: ['meditation', 'sobriety-coaching'],
+      certifications: ['Test Cert 1'],
+    });
+    if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    const data = unwrap<any>(res);
+    state.creatorId = data.id;
+  });
+
+  if (state.creatorId) {
+    await test('Get creator by ID', async () => {
+      const res = await api().get(`/creators/${state.creatorId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get my creator profile', async () => {
+      const res = await api(state.accessToken).get('/creators/me');
+      // Returns 200 with null or creator data
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get creator by user ID', async () => {
+      const res = await api(state.accessToken).get(`/creators/user/${state.userId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Update creator profile', async () => {
+      const res = await api(state.accessToken).patch(`/creators/${state.creatorId}`, {
+        bio: 'Updated bio for E2E testing',
+        sessionRate: 50,
+      });
+      if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    });
+
+    await test('Add creator availability', async () => {
+      const res = await api(state.accessToken).post(`/creators/${state.creatorId}/availability`, {
+        dayOfWeek: 1, // Monday
+        startTime: '09:00',
+        endTime: '17:00',
+        timezone: 'Europe/London',
+        isRecurring: true,
+      });
+      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      const data = unwrap<any>(res);
+      state.availabilityId = data.id;
+    });
+
+    await test('Get creator availability', async () => {
+      const res = await api().get(`/creators/${state.creatorId}/availability`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get creator content (published)', async () => {
+      const res = await api().get(`/creators/${state.creatorId}/content`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Get creator events', async () => {
+      const res = await api().get(`/creators/${state.creatorId}/events`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    // Test ownership - second user cannot update
+    await test('Second user cannot update another creator profile (403)', async () => {
+      const res = await api(state.secondUserToken).patch(`/creators/${state.creatorId}`, {
+        bio: 'Hacked bio',
+      });
+      if (res.status !== 403) throw new Error(`Expected 403, got ${res.status}`);
+    });
+  }
+
+  // =========================================================================
+  // CREATOR PRODUCTS (Sessions/Packages)
+  // =========================================================================
+  section('CREATOR PRODUCTS');
+
+  if (state.creatorId) {
+    await test('Create creator product (1-on-1 session)', async () => {
+      const res = await api(state.accessToken).post(`/creators/${state.creatorId}/products`, {
+        title: 'E2E Test 1-on-1 Session',
+        description: 'A test coaching session for E2E testing',
+        type: 'SESSION_1ON1',
+        price: 5000, // £50 in pence
+        currency: 'GBP',
+        durationMinutes: 60,
+        maxParticipants: 1,
+        deliveryMethod: 'VIDEO_CALL',
+      });
+      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      const data = unwrap<any>(res);
+      state.productId = data.id;
+    });
+
+    await test('Create second product (workshop)', async () => {
+      const res = await api(state.accessToken).post(`/creators/${state.creatorId}/products`, {
+        title: 'E2E Test Workshop',
+        description: 'A group workshop for E2E testing',
+        type: 'WORKSHOP',
+        price: 2500, // £25 in pence
+        currency: 'GBP',
+        durationMinutes: 90,
+        maxParticipants: 10,
+        deliveryMethod: 'VIDEO_CALL',
+      });
+      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    });
+
+    await test('Get creator products', async () => {
+      const res = await api(state.accessToken).get(`/creators/${state.creatorId}/products`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+      const data = unwrap<any>(res);
+      const products = data.products || data;
+      if (!Array.isArray(products) || products.length < 2) {
+        throw new Error('Expected at least 2 products for creator');
+      }
+    });
+
+    if (state.productId) {
+      await test('Get product by ID (public)', async () => {
+        const res = await api().get(`/products/${state.productId}`);
+        if (res.status !== 200) throw new Error(`Status ${res.status}`);
+        const data = unwrap<any>(res);
+        if (!data.title || !data.price) throw new Error('Missing expected product fields');
+      });
+
+      await test('Update product', async () => {
+        const res = await api(state.accessToken).put(`/creators/${state.creatorId}/products/${state.productId}`, {
+          price: 6000, // Update to £60
+          description: 'Updated description for E2E testing',
+        });
+        if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+        const data = unwrap<any>(res);
+        if (data.price !== 6000) throw new Error('Price not updated correctly');
+      });
+
+      // Second user books the product
+      await test('Book product (as second user)', async () => {
+        const scheduledAt = new Date();
+        scheduledAt.setDate(scheduledAt.getDate() + 14); // 2 weeks from now
+        scheduledAt.setHours(10, 0, 0, 0);
+
+        const res = await api(state.secondUserToken).post(`/products/${state.productId}/book`, {
+          scheduledAt: scheduledAt.toISOString(),
+          timezone: 'Europe/London',
+          clientNotes: 'E2E test booking',
+        });
+        if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+        const data = unwrap<any>(res);
+        state.productBookingId = data.id;
+      });
+
+      if (state.productBookingId) {
+        await test('Get product booking details', async () => {
+          const res = await api(state.secondUserToken).get(`/users/me/product-bookings/${state.productBookingId}`);
+          if (res.status !== 200) throw new Error(`Status ${res.status}`);
+          const data = unwrap<any>(res);
+          if (!data.scheduledAt || !data.status) throw new Error('Missing booking fields');
+        });
+
+        await test('Get user product bookings', async () => {
+          const res = await api(state.secondUserToken).get('/users/me/product-bookings');
+          if (res.status !== 200) throw new Error(`Status ${res.status}`);
+          const data = unwrap<any>(res);
+          const bookings = Array.isArray(data) ? data : (data.data || []);
+          if (!Array.isArray(bookings) || bookings.length === 0) {
+            throw new Error('Expected at least one product booking');
+          }
+        });
+
+        await test('Get creator bookings (as creator)', async () => {
+          const res = await api(state.accessToken).get(`/creators/${state.creatorId}/products/bookings`);
+          if (res.status !== 200) throw new Error(`Status ${res.status}`);
+          const data = unwrap<any>(res);
+          const bookings = Array.isArray(data) ? data : (data.data || []);
+          if (!Array.isArray(bookings) || bookings.length === 0) {
+            throw new Error('Expected at least one booking for creator products');
+          }
+        });
+
+        await test('Update product booking', async () => {
+          const newScheduledAt = new Date();
+          newScheduledAt.setDate(newScheduledAt.getDate() + 21); // 3 weeks from now
+          newScheduledAt.setHours(14, 0, 0, 0);
+
+          const res = await api(state.secondUserToken).put(`/users/me/product-bookings/${state.productBookingId}`, {
+            scheduledAt: newScheduledAt.toISOString(),
+            clientNotes: 'Rescheduled - E2E test',
+          });
+          if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+        });
+
+        await test('Cancel product booking', async () => {
+          const res = await api(state.secondUserToken).delete(`/users/me/product-bookings/${state.productBookingId}`, {
+            data: { reason: 'E2E test cleanup' },
+          });
+          if (res.status !== 200 && res.status !== 204) throw new Error(`Status ${res.status}`);
+        });
+      }
+
+      // Second user cannot delete creator's product
+      await test('Second user cannot delete product (403)', async () => {
+        const res = await api(state.secondUserToken).delete(`/creators/${state.creatorId}/products/${state.productId}`);
+        if (res.status !== 403) throw new Error(`Expected 403, got ${res.status}`);
+      });
+    }
+  } else {
+    skip('Create creator product', 'No creator ID available');
+    skip('Create second product', 'No creator ID available');
+    skip('Get creator products', 'No creator ID available');
+    skip('Get product by ID', 'No product ID available');
+    skip('Update product', 'No product ID available');
+    skip('Book product', 'No product ID available');
+    skip('Get product booking details', 'No booking ID available');
+    skip('Get user product bookings', 'No booking ID available');
+    skip('Get creator bookings', 'No booking ID available');
+    skip('Update product booking', 'No booking ID available');
+    skip('Cancel product booking', 'No booking ID available');
+    skip('Second user cannot delete product', 'No product ID available');
+  }
+
+  // Test public products listing
+  await test('List all public products', async () => {
+    const res = await api().get('/products');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // May have products array or paginated response
+    const products = data.products || data;
+    if (!Array.isArray(products)) throw new Error('Expected products array');
+  });
+
+  // =========================================================================
+  // BRANDS (New)
+  // =========================================================================
+  section('BRANDS');
+
+  await test('List brands', async () => {
+    const res = await api().get('/brands');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get featured brands', async () => {
+    const res = await api().get('/brands/featured');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Create brand', async () => {
+    const res = await api(state.accessToken).post('/brands', {
+      slug: `e2e-brand-${Date.now()}`,
+      name: 'E2E Test Brand',
+      description: 'A test brand for E2E testing',
+      website: 'https://example.com',
+      email: 'brand@example.com',
+    });
+    if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    const data = unwrap<any>(res);
+    state.brandId = data.id;
+  });
+
+  if (state.brandId) {
+    await test('Get brand by ID', async () => {
+      const res = await api().get(`/brands/${state.brandId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    await test('Update brand', async () => {
+      const res = await api(state.accessToken).patch(`/brands/${state.brandId}`, {
+        description: 'Updated brand description',
+      });
+      if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    });
+
+    await test('Get brand owners', async () => {
+      const res = await api(state.accessToken).get(`/brands/${state.brandId}/owners`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    // Add second user as brand manager
+    await test('Add brand owner (manager role)', async () => {
+      const res = await api(state.accessToken).post(`/brands/${state.brandId}/owners`, {
+        userId: state.secondUserId,
+        role: 'MANAGER',
+      });
+      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    });
+
+    // Manager can update brand
+    await test('Manager can update brand', async () => {
+      const res = await api(state.secondUserToken).patch(`/brands/${state.brandId}`, {
+        description: 'Updated by manager',
+      });
+      if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    });
+
+    await test('Get brand creators (partnerships)', async () => {
+      const res = await api(state.accessToken).get(`/brands/${state.brandId}/creators`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    // Add creator partnership if creator exists
+    if (state.creatorId) {
+      await test('Add creator partnership to brand', async () => {
+        const res = await api(state.accessToken).post(`/brands/${state.brandId}/creators`, {
+          creatorId: state.creatorId,
+          commissionRate: 0.15,
+          isActive: true,
+        });
+        if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      });
+
+      await test('Update creator partnership', async () => {
+        const res = await api(state.accessToken).patch(
+          `/brands/${state.brandId}/creators/${state.creatorId}`,
+          {
+            commissionRate: 0.20,
+          }
+        );
+        if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      });
+    }
+
+    await test('Get brand sponsored events', async () => {
+      const res = await api().get(`/brands/${state.brandId}/events`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+
+    // Remove the manager
+    await test('Remove brand owner', async () => {
+      const res = await api(state.accessToken).delete(
+        `/brands/${state.brandId}/owners/${state.secondUserId}`
+      );
+      if (res.status !== 200 && res.status !== 204) throw new Error(`Status ${res.status}`);
+    });
+
+    // Second user should now be forbidden
+    await test('Removed owner cannot access brand (403)', async () => {
+      const res = await api(state.secondUserToken).patch(`/brands/${state.brandId}`, {
+        description: 'Should fail',
+      });
+      if (res.status !== 403) throw new Error(`Expected 403, got ${res.status}`);
+    });
+  }
+
+  // =========================================================================
+  // EVENTS (with new fields: venueId, creatorId, sponsorBrandId, gatheringType)
   // =========================================================================
-  console.log(`\n${c.cyan}--- EVENTS ---${c.reset}\n`);
+  section('EVENTS');
 
   await test('List events', async () => {
     const res = await api().get('/events');
@@ -185,15 +662,23 @@ async function runTests() {
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
   });
 
-  await test('Create event', async () => {
-    const res = await api(state.accessToken).post('/events', {
+  await test('Create event with creator and brand sponsor', async () => {
+    const eventData: any = {
       title: 'E2E Test Event',
       description: 'A test event created by E2E tests',
-      startDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(), // 7 days from now
+      startDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
       totalSpots: 20,
       locationName: 'Test Location',
       locationAddress: '123 Test Street',
-    });
+      gatheringType: 'FACILITATOR_LED',
+    };
+
+    // Add creator and brand if available
+    if (state.creatorId) eventData.creatorId = state.creatorId;
+    if (state.brandId) eventData.sponsorBrandId = state.brandId;
+    if (state.venueId) eventData.venueId = state.venueId;
+
+    const res = await api(state.accessToken).post('/events', eventData);
     if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
     const data = unwrap<any>(res);
     state.eventId = data.id;
@@ -203,11 +688,18 @@ async function runTests() {
     await test('Get event by ID', async () => {
       const res = await api().get(`/events/${state.eventId}`);
       if (res.status !== 200) throw new Error(`Status ${res.status}`);
+      const data = unwrap<any>(res);
+      // Verify new fields are present
+      if (!('gatheringType' in data)) throw new Error('Missing gatheringType field');
+      if (!('venueId' in data)) throw new Error('Missing venueId field');
+      if (!('creatorId' in data)) throw new Error('Missing creatorId field');
+      if (!('sponsorBrandId' in data)) throw new Error('Missing sponsorBrandId field');
     });
 
     await test('Update event', async () => {
       const res = await api(state.accessToken).put(`/events/${state.eventId}`, {
         title: 'E2E Test Event (Updated)',
+        description: 'Updated description for E2E testing',
       });
       if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
     });
@@ -226,13 +718,12 @@ async function runTests() {
   // =========================================================================
   // BOOKINGS
   // =========================================================================
-  console.log(`\n${c.cyan}--- BOOKINGS ---${c.reset}\n`);
+  section('BOOKINGS');
 
   if (state.eventId) {
     await test('RSVP to event', async () => {
       const res = await api(state.accessToken).post(`/events/${state.eventId}/book`);
-      // 201 for new booking, 409 if already exists
-      if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}`);
       if (res.status === 201) {
         const data = unwrap<any>(res);
         state.bookingId = data.id;
@@ -246,9 +737,9 @@ async function runTests() {
   }
 
   // =========================================================================
-  // EVENT CHAT
+  // EVENT CHAT (New roles: ATTENDEE, CREATOR, VENUE_REP, BRAND_REP)
   // =========================================================================
-  console.log(`\n${c.cyan}--- EVENT CHAT ---${c.reset}\n`);
+  section('EVENT CHAT');
 
   if (state.eventId) {
     await test('Get or create event chat', async () => {
@@ -260,25 +751,33 @@ async function runTests() {
 
     await test('Join event chat', async () => {
       const res = await api(state.accessToken).post(`/events/${state.eventId}/chat/join`);
-      // 200 for join, 403 if no booking (but we just booked)
-      if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
     });
 
     await test('Send chat message', async () => {
       const res = await api(state.accessToken).post(`/events/${state.eventId}/chat/messages`, {
         content: 'Hello from E2E test!',
       });
-      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      if (res.status !== 201) throw new Error(`Status ${res.status}`);
     });
 
     await test('Get chat messages', async () => {
       const res = await api(state.accessToken).get(`/events/${state.eventId}/chat/messages`);
-      if (res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
     });
 
-    await test('Get chat members', async () => {
+    await test('Get chat members (check for new roles)', async () => {
       const res = await api(state.accessToken).get(`/events/${state.eventId}/chat/members`);
       if (res.status !== 200) throw new Error(`Status ${res.status}`);
+      const data = unwrap<any>(res);
+      // Verify members have role field
+      if (Array.isArray(data) && data.length > 0) {
+        const validRoles = ['ATTENDEE', 'CREATOR', 'VENUE_REP', 'BRAND_REP', 'MODERATOR', 'ADMIN'];
+        const member = data[0];
+        if (!validRoles.includes(member.role)) {
+          throw new Error(`Invalid role: ${member.role}`);
+        }
+      }
     });
 
     await test('Mark chat as read', async () => {
@@ -287,16 +786,74 @@ async function runTests() {
     });
   }
 
+  // =========================================================================
+  // BADGES & UNIFIED REWARDS
+  // =========================================================================
+  section('BADGES & UNIFIED REWARDS');
+
+  await test('Get all badges', async () => {
+    const res = await api(state.accessToken).get('/badges');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    if (Array.isArray(data) && data.length > 0) {
+      state.badgeId = data[0].id;
+    }
+  });
+
+  await test('Get my badges', async () => {
+    const res = await api(state.accessToken).get('/badges/users/me/badges');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get next badges (with progress)', async () => {
+    const res = await api(state.accessToken).get('/badges/next');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get available rewards', async () => {
+    const res = await api(state.accessToken).get('/rewards/available');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get rewards wallet', async () => {
+    const res = await api(state.accessToken).get('/rewards/wallet');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Verify wallet structure - badges may be empty array for new users
+    if (data.badges === undefined) throw new Error('Missing badges in wallet');
+    if (data.stats === undefined) throw new Error('Missing stats in wallet');
+  });
+
+  if (state.badgeId) {
+    await test('Get rewards for badge', async () => {
+      const res = await api(state.accessToken).get(`/rewards/badge/${state.badgeId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+  }
+
+  if (state.venueId) {
+    await test('Get rewards for venue', async () => {
+      const res = await api(state.accessToken).get(`/rewards/venue/${state.venueId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+  }
+
+  if (state.brandId) {
+    await test('Get rewards for brand', async () => {
+      const res = await api(state.accessToken).get(`/rewards/brand/${state.brandId}`);
+      if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    });
+  }
+
   // =========================================================================
   // HUBS
   // =========================================================================
-  console.log(`\n${c.cyan}--- HUBS ---${c.reset}\n`);
+  section('HUBS');
 
   await test('List hubs', async () => {
     const res = await api().get('/hubs');
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
-    // Get first hub if exists
-    const data = res.data.data;
+    const data = unwrap<any>(res);
     if (Array.isArray(data) && data.length > 0) {
       state.hubId = data[0].id;
     }
@@ -310,9 +867,8 @@ async function runTests() {
 
     await test('Join hub', async () => {
       const res = await api(state.accessToken).post(`/hubs/${state.hubId}/join`);
-      // 200/201 for join, 409 if already member
       if (res.status !== 200 && res.status !== 201 && res.status !== 409) {
-        throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+        throw new Error(`Status ${res.status}`);
       }
     });
 
@@ -322,16 +878,37 @@ async function runTests() {
     });
   }
 
+  // =========================================================================
+  // LIBRARY (Content workflow)
+  // =========================================================================
+  section('LIBRARY');
+
+  await test('Get library content', async () => {
+    const res = await api(state.accessToken).get('/library');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Get featured content', async () => {
+    const res = await api(state.accessToken).get('/library/featured');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  // Content workflow tests (if creator exists)
+  if (state.creatorId) {
+    // Note: /library/creator/:id endpoint not implemented yet
+    // skip('Get content by creator', 'Endpoint not implemented');
+  }
+
   // =========================================================================
   // JACK AI (Support Conversations)
   // =========================================================================
-  console.log(`\n${c.cyan}--- JACK AI ---${c.reset}\n`);
+  section('JACK AI');
 
   await test('Start Jack conversation', async () => {
     const res = await api(state.accessToken).post('/support/jack/conversations/new', {
       message: 'Hello Jack!',
     });
-    if (res.status !== 201 && res.status !== 200) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    if (res.status !== 201 && res.status !== 200) throw new Error(`Status ${res.status}`);
     const data = unwrap<any>(res);
     state.conversationId = data.conversation?.id || data.id;
   });
@@ -348,7 +925,9 @@ async function runTests() {
 
   if (state.conversationId) {
     await test('Get Jack conversation by ID', async () => {
-      const res = await api(state.accessToken).get(`/support/jack/conversations/${state.conversationId}`);
+      const res = await api(state.accessToken).get(
+        `/support/jack/conversations/${state.conversationId}`
+      );
       if (res.status !== 200) throw new Error(`Status ${res.status}`);
     });
   }
@@ -356,18 +935,17 @@ async function runTests() {
   // =========================================================================
   // SUPPORT (Check-ins, Wins)
   // =========================================================================
-  console.log(`\n${c.cyan}--- SUPPORT ---${c.reset}\n`);
+  section('SUPPORT');
 
   await test('Create daily check-in', async () => {
     const res = await api(state.accessToken).post('/support/check-ins', {
       date: new Date().toISOString().split('T')[0],
-      mood: 4, // Valid range 1-5
-      energy: 4, // Valid range 1-5
+      mood: 4,
+      energy: 4,
       stayedSober: true,
       notes: 'E2E test check-in',
     });
-    // 201 for new, 409 if exists
-    if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}`);
   });
 
   await test('Get check-ins', async () => {
@@ -389,9 +967,9 @@ async function runTests() {
     const res = await api(state.accessToken).post('/support/wins', {
       title: 'Completed E2E tests',
       description: 'Successfully ran all API tests',
-      category: 'PERSONAL', // Valid: SOBRIETY, HEALTH, RELATIONSHIP, CAREER, PERSONAL, FINANCIAL, OTHER
+      category: 'PERSONAL',
     });
-    if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+    if (res.status !== 201) throw new Error(`Status ${res.status}`);
   });
 
   await test('Get wins', async () => {
@@ -407,7 +985,7 @@ async function runTests() {
   // =========================================================================
   // NOTIFICATIONS
   // =========================================================================
-  console.log(`\n${c.cyan}--- NOTIFICATIONS ---${c.reset}\n`);
+  section('NOTIFICATIONS');
 
   await test('Get notifications', async () => {
     const res = await api(state.accessToken).get('/notifications');
@@ -422,7 +1000,7 @@ async function runTests() {
   // =========================================================================
   // SUBSCRIPTIONS
   // =========================================================================
-  console.log(`\n${c.cyan}--- SUBSCRIPTIONS ---${c.reset}\n`);
+  section('SUBSCRIPTIONS');
 
   await test('Get subscription plans', async () => {
     const res = await api(state.accessToken).get('/subscriptions/plans');
@@ -431,44 +1009,384 @@ async function runTests() {
 
   await test('Get my subscription', async () => {
     const res = await api(state.accessToken).get('/subscriptions/me');
-    // 200 if subscribed, 404 if not
     if (res.status !== 200 && res.status !== 404) throw new Error(`Status ${res.status}`);
   });
 
   // =========================================================================
-  // LIBRARY
+  // MAP
   // =========================================================================
-  console.log(`\n${c.cyan}--- LIBRARY ---${c.reset}\n`);
+  section('MAP');
 
-  await test('Get library content', async () => {
-    const res = await api(state.accessToken).get('/library');
+  await test('Get map hubs', async () => {
+    const res = await api(state.accessToken).get('/map/hubs');
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
   });
 
-  await test('Get featured content', async () => {
-    const res = await api(state.accessToken).get('/library/featured');
+  await test('Get map events', async () => {
+    const res = await api(state.accessToken).get('/map/events');
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
   });
 
   // =========================================================================
-  // MAP
+  // BADGE AWARDING (Business Logic Tests)
   // =========================================================================
-  console.log(`\n${c.cyan}--- MAP ---${c.reset}\n`);
+  section('BADGE AWARDING');
 
-  await test('Get map hubs', async () => {
-    const res = await api(state.accessToken).get('/map/hubs');
+  // Test badge progress tracking after actions
+  // Note: These tests verify the badge awarding integration works correctly.
+  // Actual badge earning depends on thresholds in seed data.
+
+  // Get initial badge state
+  let initialBadgeCount = 0;
+  let initialBadges: string[] = [];
+
+  await test('Get initial user badges before badge tests', async () => {
+    const res = await api(state.accessToken).get('/badges/users/me/badges');
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    initialBadgeCount = Array.isArray(data) ? data.length : 0;
+    initialBadges = Array.isArray(data) ? data.map((b: any) => b.badgeId) : [];
   });
 
-  await test('Get map events', async () => {
-    const res = await api(state.accessToken).get('/map/events');
+  // Check-in Streak Badge Tests
+  await test('Check-in updates streak and triggers badge check', async () => {
+    // Create a check-in for a previous day (to test streak logic)
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStr = yesterday.toISOString().split('T')[0];
+
+    const res = await api(state.accessToken).post('/support/check-ins', {
+      date: yesterdayStr,
+      mood: 4,
+      energy: 3,
+      stayedSober: true,
+      notes: 'Badge test check-in',
+    });
+    // Accept 201 (created) or 409 (already exists - re-running test)
+    if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Verify streak is tracked after check-in', async () => {
+    const res = await api(state.accessToken).get('/support/check-ins/streak');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Should have at least 1 check-in now (from earlier test)
+    if (data.totalCheckIns === undefined) throw new Error('Missing totalCheckIns in streak data');
+  });
+
+  // Wins Badge Tests
+  await test('Log win updates count and triggers badge check', async () => {
+    const res = await api(state.accessToken).post('/support/wins', {
+      title: 'Badge awarding test win',
+      description: 'Testing that logging wins triggers badge check',
+      category: 'PERSONAL', // Valid WinCategory enum value
+    });
+    if (res.status !== 201) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Verify wins count is tracked', async () => {
+    const res = await api(state.accessToken).get('/support/wins/count');
     if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Should have totalWins or count
+    if (data.totalWins === undefined && typeof data !== 'number' && data.count === undefined) {
+      throw new Error('Expected wins count in response');
+    }
+  });
+
+  // Mood Log Badge Tests
+  await test('Log mood updates count and triggers badge check', async () => {
+    const res = await api(state.accessToken).post('/support/mood-logs', {
+      mood: 4, // Required field (1-5)
+      energy: 3, // Optional (1-5)
+      tags: ['hopeful'], // Optional array of strings
+      note: 'Badge test mood log', // Optional note
+    });
+    if (res.status !== 201) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Verify mood logs are tracked', async () => {
+    const res = await api(state.accessToken).get('/support/mood-logs');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Handle both array and { data: array } formats
+    const logs = Array.isArray(data) ? data : (data.data || data.moodLogs || []);
+    // Should have at least 1 mood log
+    if (!Array.isArray(logs) || logs.length === 0) {
+      throw new Error('Expected at least one mood log');
+    }
+  });
+
+  // Reflection Badge Tests
+  await test('Submit reflection updates count and triggers badge check', async () => {
+    // Calculate weekStart - needs to be a Monday in YYYY-MM-DD format
+    const now = new Date();
+    const dayOfWeek = now.getDay();
+    const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+    const monday = new Date(now);
+    monday.setDate(now.getDate() - daysToMonday);
+    const weekStart = monday.toISOString().split('T')[0];
+
+    const res = await api(state.accessToken).post('/support/reflections', {
+      weekStart, // Required field
+      overallRating: 4,
+      biggestWin: 'Badge test reflection - testing the badge integration',
+      challenges: 'Testing automated badge checks',
+      goals: ['Continue improving the platform'],
+      notes: 'E2E test reflection',
+    });
+    // Accept 201 (created) or 409 (already exists for this week)
+    if (res.status !== 201 && res.status !== 409) throw new Error(`Status ${res.status}`);
+  });
+
+  await test('Verify reflections are tracked', async () => {
+    const res = await api(state.accessToken).get('/support/reflections');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+  });
+
+  // Events Hosted Badge Tests (awarded on publish)
+  await test('Publishing event awards EVENTS_HOSTED badge to hosts', async () => {
+    // The event was already published in EVENTS section
+    // Verify the badge check was triggered by checking next badges
+    const res = await api(state.accessToken).get('/badges/next');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Should return badge progress data
+    if (!Array.isArray(data)) throw new Error('Expected array of next badges');
+  });
+
+  // Events Attended Badge Tests
+  // Note: EVENTS_ATTENDED badge is awarded when booking is checked-in
+  // This requires a host to check-in the booking, which we can't do in E2E easily
+  // So we just verify the badge progress tracking works
+
+  await test('Badge progress shows EVENTS_ATTENDED tracking', async () => {
+    const res = await api(state.accessToken).get('/badges/next');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // Look for events attended badge in progress
+    const eventsAttendedBadge = data.find(
+      (b: any) => b.badge?.type === 'EVENTS_ATTENDED' || b.badge?.slug?.includes('event')
+    );
+    // May or may not exist depending on seed data, but API should work
+  });
+
+  // Verify badge state after all actions
+  await test('Verify badges after all badge-triggering actions', async () => {
+    const res = await api(state.accessToken).get('/badges/users/me/badges');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    const currentBadgeCount = Array.isArray(data) ? data.length : 0;
+    // Depending on thresholds, user may have earned new badges
+    // At minimum, the API should return successfully
+  });
+
+  // =========================================================================
+  // REWARD FLOW
+  // =========================================================================
+  section('REWARD FLOW');
+
+  // Store reward-related state
+  let testBadgeIdForReward: string | undefined;
+  let testRewardId: string | undefined;
+  let redemptionId: string | undefined;
+
+  // Get a badge to use for reward tests
+  await test('Get available badges for reward test', async () => {
+    const res = await api(state.accessToken).get('/badges');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    if (Array.isArray(data) && data.length > 0) {
+      testBadgeIdForReward = data[0].id;
+    }
+  });
+
+  // Create a brand reward for testing (user owns brand from earlier tests)
+  // Note: We use brand since we created one in the BRANDS section
+  if (state.brandId) {
+    await test('Create brand reward for badge', async () => {
+      if (!testBadgeIdForReward) {
+        throw new Error('No badge available to create reward for');
+      }
+      const res = await api(state.accessToken).post(`/brands/${state.brandId}/rewards`, {
+        badgeId: testBadgeIdForReward,
+        title: 'E2E Brand Test Reward',
+        description: 'A test brand reward for E2E testing',
+        redeemType: 'ONLINE',
+        code: 'E2E-TEST-CODE',
+        perUserLimit: 1,
+      });
+      if (res.status !== 201) throw new Error(`Status ${res.status}: ${JSON.stringify(res.data)}`);
+      const data = unwrap<any>(res);
+      testRewardId = data.id;
+    });
+  } else {
+    skip('Create brand reward for badge', 'No brand available (brand not created)');
+  }
+
+  // Test reward availability
+  await test('Get available rewards for user', async () => {
+    const res = await api(state.accessToken).get('/rewards/available');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // API returns { data: rewards[] }
+    const rewards = data.data || data;
+    if (!Array.isArray(rewards)) throw new Error('Expected array of available rewards');
+  });
+
+  // Test user cannot redeem without earning the badge
+  await test('Cannot redeem reward without earning required badge (400)', async () => {
+    if (!testRewardId || !testBadgeIdForReward) {
+      console.log(`  ${c.dim}(Skipped: No test reward created)${c.reset}`);
+      return;
+    }
+
+    // First check if user has the badge
+    const badgeRes = await api(state.accessToken).get('/badges/users/me/badges');
+    const badges = unwrap<any>(badgeRes);
+    const hasBadge = Array.isArray(badges) && badges.some(
+      (b: any) => b.badgeId === testBadgeIdForReward
+    );
+
+    if (!hasBadge) {
+      // User doesn't have badge, should get 400 when trying to redeem
+      const res = await api(state.accessToken).post(`/rewards/${testRewardId}/redeem`);
+      if (res.status !== 400) {
+        throw new Error(`Expected 400 (need badge first), got ${res.status}`);
+      }
+    } else {
+      // User has the badge, test passes (we'll test redemption below)
+      console.log(`  ${c.dim}(User already has required badge - will test redemption)${c.reset}`);
+    }
+  });
+
+  // Test redemption flow - check if user can redeem
+  await test('Check badge ownership and test redemption flow', async () => {
+    if (!testRewardId || !testBadgeIdForReward) {
+      console.log(`  ${c.dim}(Skipped: No test reward created)${c.reset}`);
+      return;
+    }
+
+    // Check if user has earned the badge
+    const badgeRes = await api(state.accessToken).get('/badges/users/me/badges');
+    if (badgeRes.status !== 200) throw new Error(`Status ${badgeRes.status}`);
+    const badges = unwrap<any>(badgeRes);
+    const userHasBadge = Array.isArray(badges) && badges.some(
+      (b: any) => b.badgeId === testBadgeIdForReward
+    );
+
+    if (userHasBadge) {
+      // User has badge, test the full redemption flow
+      const redeemRes = await api(state.accessToken).post(`/rewards/${testRewardId}/redeem`);
+      if (redeemRes.status !== 201) {
+        throw new Error(`Redeem failed: ${redeemRes.status}: ${JSON.stringify(redeemRes.data)}`);
+      }
+      const redeemData = unwrap<any>(redeemRes);
+      redemptionId = redeemData.id;
+      console.log(`  ${c.dim}(Redemption successful: ${redemptionId})${c.reset}`);
+    } else {
+      console.log(`  ${c.dim}(User has not earned required badge - redemption test skipped)${c.reset}`);
+    }
+  });
+
+  await test('Cannot redeem same reward twice (400)', async () => {
+    if (!testRewardId || !redemptionId) {
+      console.log(`  ${c.dim}(Skipped: No prior redemption to test)${c.reset}`);
+      return;
+    }
+    const res = await api(state.accessToken).post(`/rewards/${testRewardId}/redeem`);
+    if (res.status !== 400) {
+      throw new Error(`Expected 400 (already redeemed), got ${res.status}`);
+    }
+  });
+
+  await test('Get redeemed rewards', async () => {
+    const res = await api(state.accessToken).get('/rewards/redeemed');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // API returns { data: redemptions[] }
+    const redemptions = data.data || data;
+    if (!Array.isArray(redemptions)) throw new Error('Expected array of redeemed rewards');
+    // If we redeemed, should have at least one
+    if (redemptionId && redemptions.length === 0) {
+      throw new Error('Expected at least one redeemed reward');
+    }
+  });
+
+  await test('Rewards wallet shows correct stats', async () => {
+    const res = await api(state.accessToken).get('/rewards/wallet');
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    if (data.stats === undefined) throw new Error('Missing stats in wallet');
+    // After redemption, should have at least 1 redeemed
+    if (redemptionId && data.stats.totalRedeemedRewards < 1) {
+      throw new Error('Expected at least 1 redeemed reward in wallet stats');
+    }
+  });
+
+  // Test getting rewards by badge
+  await test('Get rewards for specific badge', async () => {
+    if (!testBadgeIdForReward) {
+      console.log(`  ${c.dim}(Skipped: No badge ID available)${c.reset}`);
+      return;
+    }
+    const res = await api(state.accessToken).get(`/rewards/badge/${testBadgeIdForReward}`);
+    if (res.status !== 200) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // API returns { data: rewards[] }
+    const rewards = data.data || data;
+    if (!Array.isArray(rewards)) throw new Error('Expected array of rewards');
+  });
+
+  // Verify reward redemption verification endpoint
+  await test('Verify redemption endpoint works', async () => {
+    // This would normally be called by venue/brand staff
+    // We'll test with an invalid token to ensure endpoint exists
+    const res = await api(state.accessToken).post('/rewards/verify', {
+      qrToken: 'invalid-test-token',
+    });
+    // POST defaults to 201, but either 200 or 201 is acceptable
+    if (res.status !== 200 && res.status !== 201) throw new Error(`Status ${res.status}`);
+    const data = unwrap<any>(res);
+    // API returns { data: { valid: boolean } }
+    const result = data.data || data;
+    if (result.valid !== false) {
+      throw new Error('Expected valid: false for invalid token');
+    }
   });
 
   // =========================================================================
   // CLEANUP
   // =========================================================================
-  console.log(`\n${c.cyan}--- CLEANUP ---${c.reset}\n`);
+  section('CLEANUP');
+
+  // Cleanup creator products
+  if (state.productId && state.creatorId) {
+    await test('Delete creator product', async () => {
+      const res = await api(state.accessToken).delete(
+        `/creators/${state.creatorId}/products/${state.productId}`
+      );
+      if (res.status !== 200 && res.status !== 204) throw new Error(`Status ${res.status}`);
+    });
+  }
+
+  if (state.availabilityId && state.creatorId) {
+    await test('Remove creator availability', async () => {
+      const res = await api(state.accessToken).delete(
+        `/creators/${state.creatorId}/availability/${state.availabilityId}`
+      );
+      if (res.status !== 200 && res.status !== 204) throw new Error(`Status ${res.status}`);
+    });
+  }
+
+  if (state.creatorId && state.brandId) {
+    await test('Remove creator from brand partnership', async () => {
+      const res = await api(state.accessToken).delete(
+        `/brands/${state.brandId}/creators/${state.creatorId}`
+      );
+      if (res.status !== 200 && res.status !== 204) throw new Error(`Status ${res.status}`);
+    });
+  }
 
   if (state.bookingId) {
     await test('Cancel booking', async () => {
@@ -487,16 +1405,30 @@ async function runTests() {
   // =========================================================================
   // SUMMARY
   // =========================================================================
-  console.log(`\n${c.cyan}${'='.repeat(60)}${c.reset}`);
+  console.log(`\n${c.cyan}${'='.repeat(70)}${c.reset}`);
   console.log(`${c.cyan}  TEST SUMMARY${c.reset}`);
-  console.log(`${c.cyan}${'='.repeat(60)}${c.reset}`);
-  console.log(`${c.green}Passed: ${passed}${c.reset}`);
-  console.log(`${c.red}Failed: ${failed}${c.reset}`);
-  console.log(`Total:  ${passed + failed}`);
-  console.log(`${c.cyan}${'='.repeat(60)}${c.reset}\n`);
+  console.log(`${c.cyan}${'='.repeat(70)}${c.reset}`);
+  console.log(`${c.green}Passed:  ${passed}${c.reset}`);
+  console.log(`${c.red}Failed:  ${failed}${c.reset}`);
+  console.log(`${c.yellow}Skipped: ${skipped}${c.reset}`);
+  console.log(`${c.bold}Total:   ${passed + failed + skipped}${c.reset}`);
+  console.log(`${c.cyan}${'='.repeat(70)}${c.reset}\n`);
+
+  // IDs for debugging
+  console.log(`${c.dim}Test IDs:${c.reset}`);
+  console.log(`${c.dim}  User:     ${state.userId}${c.reset}`);
+  console.log(`${c.dim}  Creator:  ${state.creatorId || 'N/A'}${c.reset}`);
+  console.log(`${c.dim}  Product:  ${state.productId || 'N/A'}${c.reset}`);
+  console.log(`${c.dim}  Brand:    ${state.brandId || 'N/A'}${c.reset}`);
+  console.log(`${c.dim}  Event:    ${state.eventId || 'N/A'}${c.reset}`);
+  console.log(`${c.dim}  Venue:    ${state.venueId || 'N/A'}${c.reset}`);
+  console.log('');
 
   process.exit(failed > 0 ? 1 : 0);
 }
 
 // Run tests
-runTests().catch(console.error);
+runTests().catch((e) => {
+  console.error(`${c.red}Unexpected error:${c.reset}`, e);
+  process.exit(1);
+});