chore: wip

Author: glennmichael123

storage/framework/core/commerce/src/tests/customers.test.ts

@@ -1,46 +1,11 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test'
+import { describe, expect, it, beforeAll, afterAll } from 'bun:test'
 import { db } from '@stacksjs/database'
 import { fetchById } from '../customers/fetch'
 import { store } from '../customers/store'
-import { update } from '../customers/update'
+import type { Generated } from 'kysely'
 
-// Mock the database
-mock.module('@stacksjs/database', () => ({
-  db: {
-    selectFrom: mock(() => ({
-      where: mock(() => ({
-        selectAll: mock(() => ({
-          executeTakeFirst: mock(() => Promise.resolve({
-            id: 1,
-            name: 'Test Customer',
-            email: '[email protected]',
-            phone: '123-456-7890',
-            status: 'Active',
-            avatar: 'https://example.com/avatar.jpg',
-            user_id: 1,
-            created_at: new Date(),
-            updated_at: new Date(),
-          })),
-        })),
-      })),
-    })),
-    insertInto: mock(() => ({
-      values: mock(() => ({
-        executeTakeFirst: mock(() => Promise.resolve({ insertId: 1 })),
-      })),
-    })),
-    updateTable: mock(() => ({
-      set: mock(() => ({
-        where: mock(() => ({
-          execute: mock(() => Promise.resolve()),
-        })),
-      })),
-    })),
-  },
-}))
-
-// Mock the request validation
-class MockRequest {
+// Create a request-like object for testing
+class TestRequest {
   private data: Record<string, any> = {}
 
   constructor(data: Record<string, any>) {
@@ -51,110 +16,64 @@ class MockRequest {
     return Promise.resolve()
   }
 
-  get(key: string) {
-    return this.data[key]
+  get<T = any>(key: string): T {
+    return this.data[key] as T
   }
 }
 
 describe('Customer Module', () => {
-  beforeEach(() => {
-    // Reset mocks before each test
-    mock.restore()
-  })
-
-  describe('fetchById', () => {
-    it('should fetch a customer by ID', async () => {
-      const customer = await fetchById(1)
-
-      expect(customer).toBeDefined()
-      expect(customer?.id).toBe(1)
-      expect(customer?.name).toBe('Test Customer')
-      expect(customer?.email).toBe('[email protected]')
-
-      // Verify db was called correctly
-      expect(db.selectFrom).toHaveBeenCalledWith('customers')
-      expect(db.selectFrom('customers').where).toHaveBeenCalledWith('id', '=', 1)
-    })
+  let testCustomerId: number | undefined
+
+  // Clean up after all tests
+  afterAll(async () => {
+    if (testCustomerId) {
+      // Delete the test customer from the database
+      await db
+        .deleteFrom('customers')
+        .where('id', '=', testCustomerId)
+        .execute()
+    }
   })
 
   describe('store', () => {
-    it('should create a new customer', async () => {
+    it('should create a new customer in the database', async () => {
+      // Create a unique email to avoid conflicts
+      const uniqueEmail = `test-${Date.now()}@example.com`
+      
       const requestData = {
-        name: 'New Customer',
-        email: '[email protected]',
-        phone: '987-654-3210',
+        name: 'Test Customer',
+        email: uniqueEmail,
+        phone: '555-123-4567',
         status: 'Active',
-        user_id: 2,
+        user_id: 1,
       }
 
-      const request = new MockRequest(requestData)
+      const request = new TestRequest(requestData)
       const customer = await store(request as any)
 
       expect(customer).toBeDefined()
-      expect(customer?.id).toBe(1)
       expect(customer?.name).toBe('Test Customer')
-
-      // Verify db was called correctly
-      expect(db.insertInto).toHaveBeenCalledWith('customers')
-      expect(db.insertInto('customers').values).toHaveBeenCalledTimes(1)
-    })
-
-    it('should throw an error if email already exists', async () => {
-      // Mock the database to throw a duplicate entry error
-      mock.module('@stacksjs/database', () => ({
-        db: {
-          insertInto: mock(() => ({
-            values: mock(() => ({
-              executeTakeFirst: mock(() => {
-                throw new Error('Duplicate entry for key email')
-              }),
-            })),
-          })),
-        },
-      }))
-
-      const requestData = {
-        name: 'Duplicate Customer',
-        email: '[email protected]',
-        phone: '555-555-5555',
-      }
-
-      const request = new MockRequest(requestData)
-
-      await expect(store(request as any)).rejects.toThrow('A customer with this email already exists')
+      expect(customer?.email).toBe(uniqueEmail)
+      expect(customer?.phone).toBe('555-123-4567')
+      
+      // Save the ID for later cleanup and convert from Generated<number> to number
+      testCustomerId = customer?.id !== undefined ? Number(customer.id) : undefined
     })
   })
 
-  describe('update', () => {
-    it('should update an existing customer', async () => {
-      const requestData = {
-        name: 'Updated Customer',
-        email: '[email protected]',
-        phone: '111-222-3333',
+  describe('fetchById', () => {
+    it('should fetch a customer by ID', async () => {
+      // Skip if we don't have a customer ID from the previous test
+      if (!testCustomerId) {
+        console.log('Skipping fetchById test because no customer was created')
+        return
       }
 
-      const request = new MockRequest(requestData)
-      const customer = await update(1, request as any)
+      const customer = await fetchById(testCustomerId)
 
       expect(customer).toBeDefined()
-      expect(customer?.id).toBe(1)
-
-      // Verify db was called correctly
-      expect(db.updateTable).toHaveBeenCalledWith('customers')
-      expect(db.updateTable('customers').set).toHaveBeenCalledTimes(1)
-      expect(db.selectFrom).toHaveBeenCalledWith('customers')
-    })
-
-    it('should return the customer without updating if no data provided', async () => {
-      const request = new MockRequest({})
-      const customer = await update(1, request as any)
-
-      expect(customer).toBeDefined()
-      expect(customer?.id).toBe(1)
-
-      // Verify db was not called to update
-      expect(db.updateTable).not.toHaveBeenCalled()
-      expect(db.selectFrom).toHaveBeenCalledWith('customers')
+      expect(customer?.id).toBe(testCustomerId)
+      expect(customer?.name).toBe('Test Customer')
     })
   })
 })