nim-dagger/tests/codex/testsales.nim

117 lines
3.7 KiB
Nim
Raw Normal View History

2022-03-30 15:28:56 +00:00
import std/times
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
)
let request = StorageRequest(ask: StorageAsk(
duration: 60.u256,
size: 100.u256,
maxPrice:42.u256
))
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)
await sales.start()
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
# test "offers available storage when matching request comes in":
# sales.add(availability)
# discard await market.requestStorage(request)
# check market.offered.len == 1
# check market.offered[0].price == 42.u256
# 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)
# check market.offered.len == 0
2022-03-30 10:51:28 +00:00
test "makes storage unavailable when offer is submitted":
sales.add(availability)
discard await market.requestStorage(request)
2022-03-30 10:51:28 +00:00
check sales.available.len == 0
2022-03-30 15:28:56 +00:00
# test "sets expiry time of offer":
# sales.add(availability)
# let now = clock.now().u256
# discard await market.requestStorage(request)
# check market.offered[0].expiry == now + sales.offerExpiryInterval
# test "calls onSale when offer is selected":
# var sold: StorageOffer
# sales.onSale = proc(offer: StorageOffer) =
# sold = offer
# sales.add(availability)
# discard await market.requestStorage(request)
# let offer = market.offered[0]
# await market.selectOffer(offer.id)
# check sold == offer
# test "does not call onSale when a different offer is selected":
# var didSell: bool
# sales.onSale = proc(offer: StorageOffer) =
# didSell = true
# sales.add(availability)
# let request = await market.requestStorage(request)
# var otherOffer = StorageOffer(requestId: request.id, price: 1.u256)
# otherOffer = await market.offerStorage(otherOffer)
# await market.selectOffer(otherOffer.id)
# check not didSell
# test "makes storage available again when different offer is selected":
# sales.add(availability)
# let request = await market.requestStorage(request)
# var otherOffer = StorageOffer(requestId: request.id, price: 1.u256)
# otherOffer = await market.offerStorage(otherOffer)
# await market.selectOffer(otherOffer.id)
# check sales.available.contains(availability)
# test "makes storage available again when offer expires":
# sales.add(availability)
# discard await market.requestStorage(request)
# let offer = market.offered[0]
# clock.set(offer.expiry.truncate(int64))
# await sleepAsync(chronos.seconds(2))
# check sales.available.contains(availability)