nim-dagger/tests/codex/helpers/mockmarket.nim

148 lines
4.8 KiB
Nim
Raw Normal View History

2022-03-28 10:28:22 +00:00
import std/sequtils
2022-05-19 19:56:03 +00:00
import pkg/codex/market
2022-03-23 12:57:48 +00:00
2022-03-30 10:51:28 +00:00
export market
2022-03-23 12:57:48 +00:00
type
MockMarket* = ref object of Market
requested*: seq[StorageRequest]
fulfilled*: seq[Fulfillment]
filled*: seq[Slot]
2022-07-04 12:14:56 +00:00
signer: Address
2022-03-28 10:28:22 +00:00
subscriptions: Subscriptions
Fulfillment* = object
2022-07-05 08:37:55 +00:00
requestId*: array[32, byte]
proof*: seq[byte]
host*: Address
Slot* = object
requestId*: array[32, byte]
slotIndex*: UInt256
proof*: seq[byte]
host*: Address
2022-03-28 10:28:22 +00:00
Subscriptions = object
onRequest: seq[RequestSubscription]
onFulfillment: seq[FulfillmentSubscription]
onSlotFilled: seq[SlotFilledSubscription]
2022-03-28 10:28:22 +00:00
RequestSubscription* = ref object of Subscription
market: MockMarket
callback: OnRequest
FulfillmentSubscription* = ref object of Subscription
market: MockMarket
requestId: array[32, byte]
callback: OnFulfillment
SlotFilledSubscription* = ref object of Subscription
market: MockMarket
requestId: array[32, byte]
slotIndex: UInt256
callback: OnSlotFilled
2022-03-23 12:57:48 +00:00
2022-07-04 12:14:56 +00:00
proc new*(_: type MockMarket): MockMarket =
MockMarket(signer: Address.example)
method getSigner*(market: MockMarket): Future[Address] {.async.} =
return market.signer
method requestStorage*(market: MockMarket,
request: StorageRequest):
Future[StorageRequest] {.async.} =
market.requested.add(request)
var subscriptions = market.subscriptions.onRequest
for subscription in subscriptions:
subscription.callback(request.id, request.ask)
return request
2022-03-28 10:28:22 +00:00
2022-06-15 12:12:34 +00:00
method getRequest(market: MockMarket,
id: array[32, byte]): Future[?StorageRequest] {.async.} =
for request in market.requested:
if request.id == id:
return some request
return none StorageRequest
method getHost(market: MockMarket,
requestId: array[32, byte],
slotIndex: UInt256): Future[?Address] {.async.} =
for slot in market.filled:
if slot.requestId == requestId and slot.slotIndex == slotIndex:
return some slot.host
return none Address
proc emitSlotFilled*(market: MockMarket,
requestId: array[32, byte],
slotIndex: UInt256) =
var subscriptions = market.subscriptions.onSlotFilled
for subscription in subscriptions:
if subscription.requestId == requestId and
subscription.slotIndex == slotIndex:
subscription.callback(requestId, slotIndex)
proc emitRequestFulfilled*(market: MockMarket, requestId: array[32, byte]) =
var subscriptions = market.subscriptions.onFulfillment
for subscription in subscriptions:
if subscription.requestId == requestId:
subscription.callback(requestId)
proc fillSlot*(market: MockMarket,
requestId: array[32, byte],
slotIndex: UInt256,
proof: seq[byte],
host: Address) =
let slot = Slot(
requestId: requestId,
slotIndex: slotIndex,
proof: proof,
host: host
)
market.filled.add(slot)
market.emitSlotFilled(requestId, slotIndex)
method fillSlot*(market: MockMarket,
requestId: array[32, byte],
slotIndex: UInt256,
proof: seq[byte]) {.async.} =
market.fillSlot(requestId, slotIndex, proof, market.signer)
2022-03-28 10:28:22 +00:00
method subscribeRequests*(market: MockMarket,
callback: OnRequest):
Future[Subscription] {.async.} =
let subscription = RequestSubscription(
market: market,
callback: callback
)
market.subscriptions.onRequest.add(subscription)
return subscription
method subscribeFulfillment*(market: MockMarket,
requestId: array[32, byte],
callback: OnFulfillment):
Future[Subscription] {.async.} =
let subscription = FulfillmentSubscription(
market: market,
requestId: requestId,
callback: callback
)
market.subscriptions.onFulfillment.add(subscription)
return subscription
method subscribeSlotFilled*(market: MockMarket,
requestId: array[32, byte],
slotIndex: UInt256,
callback: OnSlotFilled):
Future[Subscription] {.async.} =
let subscription = SlotFilledSubscription(
market: market,
requestId: requestId,
slotIndex: slotIndex,
callback: callback
)
market.subscriptions.onSlotFilled.add(subscription)
return subscription
2022-03-28 10:28:22 +00:00
method unsubscribe*(subscription: RequestSubscription) {.async.} =
subscription.market.subscriptions.onRequest.keepItIf(it != subscription)
method unsubscribe*(subscription: FulfillmentSubscription) {.async.} =
subscription.market.subscriptions.onFulfillment.keepItIf(it != subscription)
method unsubscribe*(subscription: SlotFilledSubscription) {.async.} =
subscription.market.subscriptions.onSlotFilled.keepItIf(it != subscription)