nim-dagger/tests/codex/testsales.nim

132 lines
4.3 KiB
Nim
Raw Normal View History

2022-03-30 10:51:28 +00:00
import pkg/asynctest
import pkg/chronos
2022-05-19 19:56:03 +00:00
import pkg/codex/sales
2022-03-30 10:51:28 +00:00
import ./helpers/mockmarket
2022-05-17 15:02:03 +00:00
import ./helpers/mockclock
2022-03-30 10:51:28 +00:00
import ./examples
suite "Sales":
let availability = Availability.init(
size=100.u256,
duration=60.u256,
minPrice=42.u256
)
2022-07-05 13:04:25 +00:00
var request = StorageRequest(
2022-07-05 07:39:59 +00:00
ask: StorageAsk(
duration: 60.u256,
size: 100.u256,
maxPrice:42.u256
),
content: StorageContent(
cid: "some cid"
)
)
2022-07-05 08:37:55 +00:00
let proof = seq[byte].example
2022-03-31 09:34:33 +00:00
2022-03-30 10:51:28 +00:00
var sales: Sales
var market: MockMarket
2022-05-17 15:02:03 +00:00
var clock: MockClock
2022-03-30 10:51:28 +00:00
setup:
market = MockMarket.new()
2022-05-17 15:02:03 +00:00
clock = MockClock.new()
sales = Sales.new(market, clock)
sales.store = proc(_: string) {.async.} = discard
2022-07-05 08:37:55 +00:00
sales.prove = proc(_: string): Future[seq[byte]] {.async.} = return proof
await sales.start()
2022-07-05 13:04:25 +00:00
request.expiry = (clock.now() + 42).u256
2022-03-31 09:34:33 +00:00
teardown:
await sales.stop()
2022-03-30 10:51:28 +00:00
test "has no availability initially":
check sales.available.len == 0
test "can add available storage":
let availability1 = Availability.example
let availability2 = Availability.example
sales.add(availability1)
check sales.available.contains(availability1)
sales.add(availability2)
check sales.available.contains(availability1)
check sales.available.contains(availability2)
test "can remove available storage":
sales.add(availability)
sales.remove(availability)
check sales.available.len == 0
test "generates unique ids for storage availability":
let availability1 = Availability.init(1.u256, 2.u256, 3.u256)
let availability2 = Availability.init(1.u256, 2.u256, 3.u256)
2022-03-30 10:51:28 +00:00
check availability1.id != availability2.id
2022-07-05 08:29:02 +00:00
test "makes storage unavailable when matching request comes in":
2022-07-05 07:39:59 +00:00
sales.add(availability)
discard await market.requestStorage(request)
2022-07-05 08:29:02 +00:00
check sales.available.len == 0
2022-07-05 07:39:59 +00:00
test "ignores request when no matching storage is available":
sales.add(availability)
var tooBig = request
tooBig.ask.size = request.ask.size + 1
discard await market.requestStorage(tooBig)
2022-07-05 08:29:02 +00:00
check sales.available == @[availability]
2022-03-30 10:51:28 +00:00
test "retrieves and stores data locally":
var storingCid: string
sales.store = proc(cid: string) {.async.} = storingCid = cid
2022-03-30 10:51:28 +00:00
sales.add(availability)
discard await market.requestStorage(request)
check storingCid == request.content.cid
2022-03-30 15:28:56 +00:00
test "makes storage available again when data retrieval fails":
let error = newException(IOError, "data retrieval failed")
sales.store = proc(cid: string) {.async.} = raise error
sales.add(availability)
discard await market.requestStorage(request)
check sales.available == @[availability]
2022-07-05 08:24:33 +00:00
test "generates proof of storage":
var provingCid: string
sales.prove = proc(cid: string): Future[seq[byte]] {.async.} = provingCid = cid
sales.add(availability)
discard await market.requestStorage(request)
check provingCid == request.content.cid
2022-07-05 08:37:55 +00:00
test "fulfills request":
sales.add(availability)
discard await market.requestStorage(request)
check market.fulfilled.len == 1
check market.fulfilled[0].requestId == request.id
check market.fulfilled[0].proof == proof
check market.fulfilled[0].host == await market.getSigner()
2022-07-05 08:51:01 +00:00
test "calls onSale when request is fulfilled":
var soldAvailability: Availability
var soldRequest: StorageRequest
sales.onSale = proc(availability: Availability, request: StorageRequest) =
soldAvailability = availability
soldRequest = request
sales.add(availability)
discard await market.requestStorage(request)
check soldAvailability == availability
check soldRequest == request
test "makes storage available again when other host fulfills request":
let otherHost = Address.example
sales.store = proc(_: string) {.async.} = await sleepAsync(1.hours)
sales.add(availability)
discard await market.requestStorage(request)
market.fulfillRequest(request.id, proof, otherHost)
check sales.available == @[availability]
2022-07-05 13:04:25 +00:00
test "makes storage available again when request expires":
sales.store = proc(_: string) {.async.} = await sleepAsync(1.hours)
2022-07-05 13:04:25 +00:00
sales.add(availability)
discard await market.requestStorage(request)
clock.set(request.expiry.truncate(int64))
await sleepAsync(2.seconds)
check sales.available == @[availability]