Skip to content

Commit 2fd79eb

Browse files
glennmichael123glennmichael123
committed
chore: wip
1 parent 1f8644c commit 2fd79eb

File tree

2 files changed

+122
-218
lines changed

2 files changed

+122
-218
lines changed

‎storage/framework/core/commerce/src/orders/destroy.ts

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,13 @@ import { db } from '@stacksjs/database'
88
*/
99
export async function destroy(id: number): Promise<boolean> {
1010
try {
11-
// Perform the delete operation
1211
const result = await db
1312
.deleteFrom('orders')
1413
.where('id', '=', id)
1514
.executeTakeFirst()
1615

17-
// Return true if any row was affected (deleted)
16+
console.log(result)
17+
1818
return Number(result.numDeletedRows) > 0
1919
}
2020
catch (error) {

‎storage/framework/core/commerce/src/tests/orders.test.ts

Lines changed: 120 additions & 216 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it } from 'bun:test'
22
import { refreshDatabase } from '@stacksjs/testing'
33
import { destroy, bulkDestroy, softDelete, bulkSoftDelete } from '../orders/destroy'
44
import { fetchById, fetchAll } from '../orders/fetch'
5+
import { db } from '@stacksjs/database'
56

67
// Create a request-like object for testing
78
class TestRequest {
@@ -20,245 +21,148 @@ class TestRequest {
2021
}
2122
}
2223

24+
// Helper function to create test orders
25+
async function createTestOrder(orderData = {}) {
26+
const defaultData = {
27+
status: 'PENDING',
28+
total_amount: 100.50,
29+
tax_amount: 8.50,
30+
discount_amount: 0,
31+
delivery_fee: 5.00,
32+
tip_amount: 10.00,
33+
order_type: 'DELIVERY',
34+
delivery_address: '123 Test Street',
35+
special_instructions: 'Please knock',
36+
estimated_delivery_time: '2023-03-16T18:30:00.000Z',
37+
customer_id: 1,
38+
coupon_id: 0
39+
}
40+
41+
const finalData = { ...defaultData, ...orderData }
42+
const result = await db.insertInto('orders').values(finalData).executeTakeFirst()
43+
const orderId = Number(result?.insertId) || Number(result?.numInsertedOrUpdatedRows)
44+
return await fetchById(orderId)
45+
}
46+
2347
beforeEach(async () => {
2448
await refreshDatabase()
2549
})
2650

2751
describe('Order Module', () => {
28-
// Since the store.ts file doesn't have actual order creation functions,
29-
// we'll use the ORM's create method for creating test orders
30-
31-
async function createTestOrder(orderData: Record<string, any> = {}) {
32-
// Default order data
33-
const defaultData = {
34-
status: 'PENDING',
35-
total_amount: 100.50,
36-
tax_amount: 8.50,
37-
discount_amount: 0,
38-
delivery_fee: 5.00,
39-
tip_amount: 10.00,
40-
order_type: 'DELIVERY',
41-
delivery_address: '123 Test Street',
42-
special_instructions: 'Please knock',
43-
estimated_delivery_time: '2023-03-16T18:30:00.000Z',
44-
customer_id: 1,
45-
coupon_id: 0 // Adding coupon_id as required field with default value
46-
}
47-
48-
// Merge default data with provided data
49-
const finalData = { ...defaultData, ...orderData }
50-
51-
// Insert the order directly using database
52-
const { db } = await import('@stacksjs/database')
53-
const result = await db
54-
.insertInto('orders')
55-
.values(finalData)
56-
.executeTakeFirst()
57-
58-
const orderId = Number(result.insertId)
59-
60-
// Fetch the created order
61-
return await fetchById(orderId)
62-
}
63-
64-
describe('fetchById', () => {
65-
it('should fetch an order by ID', async () => {
66-
// Create a test order
67-
const uniqueAddress = `Test Address ${Date.now()}`
68-
const order = await createTestOrder({
69-
delivery_address: uniqueAddress
70-
})
71-
72-
// Make sure we have a valid order ID before proceeding
73-
expect(order).toBeDefined()
74-
const orderId = order?.id !== undefined ? Number(order.id) : undefined
75-
76-
expect(orderId).toBeDefined()
77-
if (!orderId) {
78-
throw new Error('Failed to create test order')
79-
}
80-
81-
// Now fetch the order
82-
const fetchedOrder = await fetchById(orderId)
83-
84-
expect(fetchedOrder).toBeDefined()
85-
expect(fetchedOrder?.id).toBe(orderId)
86-
expect(fetchedOrder?.delivery_address).toBe(uniqueAddress)
87-
expect(fetchedOrder?.status).toBe('PENDING')
88-
})
89-
90-
it('should return undefined when trying to fetch a non-existent order', async () => {
91-
// Use a very large ID that is unlikely to exist
92-
const nonExistentId = 99999999
93-
94-
// Attempt to fetch and expect undefined
95-
const fetchedOrder = await fetchById(nonExistentId)
96-
expect(fetchedOrder).toBeUndefined()
97-
})
52+
it('should fetch an order by ID', async () => {
53+
const uniqueAddress = `Test Address ${Date.now()}`
54+
const order = await createTestOrder({ delivery_address: uniqueAddress })
55+
56+
const orderId = Number(order?.id)
57+
const fetchedOrder = await fetchById(orderId)
58+
59+
expect(fetchedOrder).toBeDefined()
60+
expect(fetchedOrder?.id).toBe(orderId)
61+
expect(fetchedOrder?.delivery_address).toBe(uniqueAddress)
62+
expect(fetchedOrder?.status).toBe('PENDING')
9863
})
9964

100-
describe('fetchAll', () => {
101-
it('should fetch all orders with their items', async () => {
102-
// Create multiple test orders
103-
await createTestOrder({ delivery_address: 'Address 1' })
104-
await createTestOrder({ delivery_address: 'Address 2' })
105-
await createTestOrder({ delivery_address: 'Address 3' })
65+
it('should return undefined when fetching non-existent order', async () => {
66+
const fetchedOrder = await fetchById(99999999)
67+
expect(fetchedOrder).toBeUndefined()
68+
})
10669

107-
// Fetch all orders
108-
const orders = await fetchAll()
109-
110-
// Check that we have at least the 3 orders we created
111-
expect(orders.length).toBeGreaterThanOrEqual(3)
112-
113-
// Check that orders have expected properties
114-
orders.forEach(order => {
115-
expect(order).toHaveProperty('id')
116-
expect(order).toHaveProperty('status')
117-
expect(order).toHaveProperty('total_amount')
118-
expect(order).toHaveProperty('items')
119-
expect(Array.isArray(order.items)).toBe(true)
120-
})
70+
it('should fetch all orders with their items', async () => {
71+
await createTestOrder({ delivery_address: 'Address 1' })
72+
await createTestOrder({ delivery_address: 'Address 2' })
73+
await createTestOrder({ delivery_address: 'Address 3' })
74+
75+
const orders = await fetchAll()
76+
77+
expect(orders.length).toBeGreaterThanOrEqual(3)
78+
79+
orders.forEach(order => {
80+
expect(order).toHaveProperty('id')
81+
expect(order).toHaveProperty('status')
82+
expect(order).toHaveProperty('total_amount')
83+
expect(order).toHaveProperty('items')
84+
expect(Array.isArray(order.items)).toBe(true)
12185
})
12286
})
12387

124-
describe('destroy', () => {
125-
it('should delete an order from the database', async () => {
126-
// Create a test order
127-
const order = await createTestOrder()
128-
const orderId = order?.id !== undefined ? Number(order.id) : undefined
129-
130-
// Make sure we have a valid order ID before proceeding
131-
expect(orderId).toBeDefined()
132-
if (!orderId) {
133-
throw new Error('Failed to create test order')
134-
}
88+
it('should delete an order from the database', async () => {
89+
const order = await createTestOrder()
90+
const orderId = Number(order?.id)
91+
92+
let fetchedOrder = await fetchById(orderId)
93+
expect(fetchedOrder).toBeDefined()
13594

136-
// Verify the order exists
137-
let fetchedOrder = await fetchById(orderId)
138-
expect(fetchedOrder).toBeDefined()
95+
const result = await destroy(orderId)
96+
expect(result).toBe(true)
13997

140-
// Delete the order
141-
const result = await destroy(orderId)
142-
expect(result).toBe(true)
98+
fetchedOrder = await fetchById(orderId)
99+
expect(fetchedOrder).toBeUndefined()
100+
})
143101

144-
// Verify the order no longer exists
145-
fetchedOrder = await fetchById(orderId)
146-
expect(fetchedOrder).toBeUndefined()
147-
})
102+
it('should soft delete an order by updating status to CANCELED', async () => {
103+
const order = await createTestOrder({ status: 'PENDING' })
104+
const orderId = Number(order?.id)
105+
106+
let fetchedOrder = await fetchById(orderId)
107+
expect(fetchedOrder).toBeDefined()
108+
expect(fetchedOrder?.status).toBe('PENDING')
148109

149-
it('should return false when trying to delete a non-existent order', async () => {
150-
// Use a very large ID that is unlikely to exist
151-
const nonExistentId = 99999999
110+
const result = await softDelete(orderId)
111+
expect(result).toBe(true)
152112

153-
// Attempt to delete
154-
const result = await destroy(nonExistentId)
155-
expect(result).toBe(false)
156-
})
113+
fetchedOrder = await fetchById(orderId)
114+
expect(fetchedOrder).toBeDefined()
115+
expect(fetchedOrder?.status).toBe('CANCELED')
157116
})
158117

159-
describe('softDelete', () => {
160-
it('should soft delete an order by updating status to CANCELED', async () => {
161-
// Create a test order
162-
const order = await createTestOrder({ status: 'PENDING' })
163-
const orderId = order?.id !== undefined ? Number(order.id) : undefined
164-
165-
// Make sure we have a valid order ID before proceeding
166-
expect(orderId).toBeDefined()
167-
if (!orderId) {
168-
throw new Error('Failed to create test order')
169-
}
170-
171-
// Verify the order exists and status is PENDING
172-
let fetchedOrder = await fetchById(orderId)
173-
expect(fetchedOrder).toBeDefined()
174-
expect(fetchedOrder?.status).toBe('PENDING')
118+
it('should delete multiple orders from the database', async () => {
119+
const order1 = await createTestOrder()
120+
const order2 = await createTestOrder()
121+
const order3 = await createTestOrder()
122+
123+
const orderIds = [
124+
Number(order1?.id),
125+
Number(order2?.id),
126+
Number(order3?.id)
127+
]
128+
129+
const deletedCount = await bulkDestroy(orderIds)
130+
expect(deletedCount).toBe(3)
131+
132+
for (const id of orderIds) {
133+
const fetchedOrder = await fetchById(id)
134+
expect(fetchedOrder).toBeUndefined()
135+
}
136+
})
175137

176-
// Soft delete the order
177-
const result = await softDelete(orderId)
178-
expect(result).toBe(true)
138+
it('should return 0 when bulk-deleting empty array', async () => {
139+
const deletedCount = await bulkDestroy([])
140+
expect(deletedCount).toBe(0)
141+
})
179142

180-
// Verify the order still exists but status is now CANCELED
181-
fetchedOrder = await fetchById(orderId)
143+
it('should soft delete multiple orders by updating status to CANCELED', async () => {
144+
const order1 = await createTestOrder({ status: 'PENDING' })
145+
const order2 = await createTestOrder({ status: 'PROCESSING' })
146+
const order3 = await createTestOrder({ status: 'SHIPPED' })
147+
148+
const orderIds = [
149+
Number(order1?.id),
150+
Number(order2?.id),
151+
Number(order3?.id)
152+
]
153+
154+
const updatedCount = await bulkSoftDelete(orderIds)
155+
expect(updatedCount).toBe(3)
156+
157+
for (const id of orderIds) {
158+
const fetchedOrder = await fetchById(id)
182159
expect(fetchedOrder).toBeDefined()
183160
expect(fetchedOrder?.status).toBe('CANCELED')
184-
})
185-
186-
it('should return false when trying to soft delete a non-existent order', async () => {
187-
// Use a very large ID that is unlikely to exist
188-
const nonExistentId = 99999999
189-
190-
// Attempt to soft delete
191-
const result = await softDelete(nonExistentId)
192-
expect(result).toBe(false)
193-
})
194-
})
195-
196-
describe('bulkDestroy', () => {
197-
it('should delete multiple orders from the database', async () => {
198-
// Create multiple test orders
199-
const order1 = await createTestOrder()
200-
const order2 = await createTestOrder()
201-
const order3 = await createTestOrder()
202-
203-
const orderIds = [
204-
order1?.id !== undefined ? Number(order1.id) : 0,
205-
order2?.id !== undefined ? Number(order2.id) : 0,
206-
order3?.id !== undefined ? Number(order3.id) : 0,
207-
].filter(id => id !== 0)
208-
209-
// Ensure we have created the orders
210-
expect(orderIds.length).toBe(3)
211-
212-
// Delete the orders
213-
const deletedCount = await bulkDestroy(orderIds)
214-
expect(deletedCount).toBe(3)
215-
216-
// Verify the orders no longer exist
217-
for (const id of orderIds) {
218-
const fetchedOrder = await fetchById(id)
219-
expect(fetchedOrder).toBeUndefined()
220-
}
221-
})
222-
223-
it('should return 0 when trying to delete an empty array of orders', async () => {
224-
// Try to delete with an empty array
225-
const deletedCount = await bulkDestroy([])
226-
expect(deletedCount).toBe(0)
227-
})
161+
}
228162
})
229163

230-
describe('bulkSoftDelete', () => {
231-
it('should soft delete multiple orders by updating status to CANCELED', async () => {
232-
// Create multiple test orders
233-
const order1 = await createTestOrder({ status: 'PENDING' })
234-
const order2 = await createTestOrder({ status: 'PROCESSING' })
235-
const order3 = await createTestOrder({ status: 'SHIPPED' })
236-
237-
const orderIds = [
238-
order1?.id !== undefined ? Number(order1.id) : 0,
239-
order2?.id !== undefined ? Number(order2.id) : 0,
240-
order3?.id !== undefined ? Number(order3.id) : 0,
241-
].filter(id => id !== 0)
242-
243-
// Ensure we have created the orders
244-
expect(orderIds.length).toBe(3)
245-
246-
// Soft delete the orders
247-
const updatedCount = await bulkSoftDelete(orderIds)
248-
expect(updatedCount).toBe(3)
249-
250-
// Verify the orders still exist but status is now CANCELED
251-
for (const id of orderIds) {
252-
const fetchedOrder = await fetchById(id)
253-
expect(fetchedOrder).toBeDefined()
254-
expect(fetchedOrder?.status).toBe('CANCELED')
255-
}
256-
})
257-
258-
it('should return 0 when trying to soft delete an empty array of orders', async () => {
259-
// Try to soft delete with an empty array
260-
const updatedCount = await bulkSoftDelete([])
261-
expect(updatedCount).toBe(0)
262-
})
164+
it('should return 0 when bulk-soft-deleting empty array', async () => {
165+
const updatedCount = await bulkSoftDelete([])
166+
expect(updatedCount).toBe(0)
263167
})
264168
})

0 commit comments

Comments
 (0)