mirror of
https://github.com/logos-storage/logos-storage-nim.git
synced 2026-01-03 22:13:12 +00:00
539 lines
19 KiB
Nim
539 lines
19 KiB
Nim
import std/random
|
|
import std/times
|
|
import pkg/questionable
|
|
import pkg/questionable/results
|
|
import pkg/chronos
|
|
import pkg/datastore
|
|
|
|
import pkg/codex/stores
|
|
import pkg/codex/errors
|
|
import pkg/codex/sales
|
|
import pkg/codex/clock
|
|
import pkg/codex/utils/json
|
|
|
|
import ../../asynctest
|
|
import ../examples
|
|
import ../helpers
|
|
|
|
const CONCURRENCY_TESTS_COUNT = 1000
|
|
|
|
asyncchecksuite "Reservations module":
|
|
var
|
|
repo: RepoStore
|
|
repoDs: Datastore
|
|
metaDs: Datastore
|
|
reservations: Reservations
|
|
collateralPerByte: UInt256
|
|
let
|
|
repoTmp = TempLevelDb.new()
|
|
metaTmp = TempLevelDb.new()
|
|
|
|
setup:
|
|
randomize(1.int64) # create reproducible results
|
|
repoDs = repoTmp.newDb()
|
|
metaDs = metaTmp.newDb()
|
|
repo = RepoStore.new(repoDs, metaDs)
|
|
reservations = Reservations.new(repo)
|
|
collateralPerByte = uint8.example.u256
|
|
|
|
teardown:
|
|
await repoTmp.destroyDb()
|
|
await metaTmp.destroyDb()
|
|
|
|
proc createAvailability(enabled = true, until = 0.SecondsSince1970): Availability =
|
|
let example = Availability.example(collateralPerByte)
|
|
let totalSize = rand(100000 .. 200000).uint64
|
|
let totalCollateral = totalSize.u256 * collateralPerByte
|
|
let availability = waitFor reservations.createAvailability(
|
|
totalSize, example.duration, example.minPricePerBytePerSecond, totalCollateral,
|
|
enabled, until,
|
|
)
|
|
return availability.get
|
|
|
|
proc createReservation(availability: Availability): Reservation =
|
|
let size = rand(1 ..< availability.freeSize.int)
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let reservation = waitFor reservations.createReservation(
|
|
availability.id, size.uint64, RequestId.example, uint64.example, 1.u256,
|
|
validUntil,
|
|
)
|
|
return reservation.get
|
|
|
|
test "availability can be serialised and deserialised":
|
|
let availability = Availability.example
|
|
let serialised = %availability
|
|
check Availability.fromJson(serialised).get == availability
|
|
|
|
test "has no availability initially":
|
|
check (await reservations.all(Availability)).get.len == 0
|
|
|
|
test "generates unique ids for storage availability":
|
|
let availability1 = Availability.init(
|
|
1.uint64, 2.uint64, 3.uint64, 4.u256, 5.u256, true, 0.SecondsSince1970
|
|
)
|
|
let availability2 = Availability.init(
|
|
1.uint64, 2.uint64, 3.uint64, 4.u256, 5.u256, true, 0.SecondsSince1970
|
|
)
|
|
check availability1.id != availability2.id
|
|
|
|
test "can reserve available storage":
|
|
let availability = createAvailability()
|
|
check availability.id != AvailabilityId.default
|
|
|
|
test "creating availability reserves bytes in repo":
|
|
let orig = repo.available.uint
|
|
let availability = createAvailability()
|
|
check repo.available.uint == orig - availability.freeSize
|
|
|
|
test "can get all availabilities":
|
|
let availability1 = createAvailability()
|
|
let availability2 = createAvailability()
|
|
let availabilities = !(await reservations.all(Availability))
|
|
check:
|
|
# perform unordered checks
|
|
availabilities.len == 2
|
|
availabilities.contains(availability1)
|
|
availabilities.contains(availability2)
|
|
|
|
test "reserved availability exists":
|
|
let availability = createAvailability()
|
|
|
|
let exists = await reservations.exists(availability.key.get)
|
|
|
|
check exists
|
|
|
|
test "reservation can be created":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
check reservation.id != ReservationId.default
|
|
|
|
test "can get all reservations":
|
|
let availability1 = createAvailability()
|
|
let availability2 = createAvailability()
|
|
let reservation1 = createReservation(availability1)
|
|
let reservation2 = createReservation(availability2)
|
|
let availabilities = !(await reservations.all(Availability))
|
|
let reservations = !(await reservations.all(Reservation))
|
|
check:
|
|
# perform unordered checks
|
|
availabilities.len == 2
|
|
reservations.len == 2
|
|
reservations.contains(reservation1)
|
|
reservations.contains(reservation2)
|
|
|
|
test "can get reservations of specific availability":
|
|
let availability1 = createAvailability()
|
|
let availability2 = createAvailability()
|
|
let reservation1 = createReservation(availability1)
|
|
let reservation2 = createReservation(availability2)
|
|
let reservations = !(await reservations.all(Reservation, availability1.id))
|
|
|
|
check:
|
|
# perform unordered checks
|
|
reservations.len == 1
|
|
reservations.contains(reservation1)
|
|
not reservations.contains(reservation2)
|
|
|
|
test "cannot create reservation with non-existant availability":
|
|
let availability = Availability.example
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let created = await reservations.createReservation(
|
|
availability.id, uint64.example, RequestId.example, uint64.example, 1.u256,
|
|
validUntil,
|
|
)
|
|
check created.isErr
|
|
check created.error of NotExistsError
|
|
|
|
test "cannot create reservation larger than availability size":
|
|
let availability = createAvailability()
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let created = await reservations.createReservation(
|
|
availability.id,
|
|
availability.totalSize + 1,
|
|
RequestId.example,
|
|
uint64.example,
|
|
UInt256.example,
|
|
validUntil,
|
|
)
|
|
check created.isErr
|
|
check created.error of BytesOutOfBoundsError
|
|
|
|
test "cannot create reservation larger than availability size - concurrency test":
|
|
proc concurrencyTest(): Future[void] {.async.} =
|
|
let availability = createAvailability()
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let one = reservations.createReservation(
|
|
availability.id,
|
|
availability.totalSize - 1,
|
|
RequestId.example,
|
|
uint64.example,
|
|
UInt256.example,
|
|
validUntil,
|
|
)
|
|
|
|
let two = reservations.createReservation(
|
|
availability.id, availability.totalSize, RequestId.example, uint64.example,
|
|
UInt256.example, validUntil,
|
|
)
|
|
|
|
let oneResult = await one
|
|
let twoResult = await two
|
|
|
|
check oneResult.isErr or twoResult.isErr
|
|
|
|
if oneResult.isErr:
|
|
check oneResult.error of BytesOutOfBoundsError
|
|
if twoResult.isErr:
|
|
check twoResult.error of BytesOutOfBoundsError
|
|
|
|
var futures: seq[Future[void]]
|
|
for _ in 1 .. CONCURRENCY_TESTS_COUNT:
|
|
futures.add(concurrencyTest())
|
|
|
|
await allFuturesThrowing(futures)
|
|
|
|
test "creating reservation reduces availability size":
|
|
let availability = createAvailability()
|
|
let orig = availability.freeSize
|
|
let reservation = createReservation(availability)
|
|
let key = availability.id.key.get
|
|
let updated = (await reservations.get(key, Availability)).get
|
|
check updated.freeSize == orig - reservation.size
|
|
|
|
test "can check if reservation exists":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
let key = reservation.key.get
|
|
check await reservations.exists(key)
|
|
|
|
test "non-existant availability does not exist":
|
|
let key = AvailabilityId.example.key.get
|
|
check not (await reservations.exists(key))
|
|
|
|
test "non-existant reservation does not exist":
|
|
let key = key(ReservationId.example, AvailabilityId.example).get
|
|
check not (await reservations.exists(key))
|
|
|
|
test "can check if availability exists":
|
|
let availability = createAvailability()
|
|
let key = availability.key.get
|
|
check await reservations.exists(key)
|
|
|
|
test "can delete reservation":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
check isOk (
|
|
await reservations.deleteReservation(reservation.id, reservation.availabilityId)
|
|
)
|
|
let key = reservation.key.get
|
|
check not (await reservations.exists(key))
|
|
|
|
test "deleting reservation returns bytes back to availability":
|
|
let availability = createAvailability()
|
|
let orig = availability.freeSize
|
|
let reservation = createReservation(availability)
|
|
discard
|
|
await reservations.deleteReservation(reservation.id, reservation.availabilityId)
|
|
let key = availability.key.get
|
|
let updated = !(await reservations.get(key, Availability))
|
|
check updated.freeSize == orig
|
|
|
|
test "calling returnBytesToAvailability returns bytes back to availability":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
let orig = availability.freeSize - reservation.size
|
|
let origQuota = repo.quotaReservedBytes
|
|
let returnedBytes = reservation.size + 200.uint64
|
|
|
|
check isOk await reservations.returnBytesToAvailability(
|
|
reservation.availabilityId, reservation.id, returnedBytes
|
|
)
|
|
|
|
let key = availability.key.get
|
|
let updated = !(await reservations.get(key, Availability))
|
|
|
|
check updated.freeSize > orig
|
|
check (updated.freeSize - orig) == 200.uint64
|
|
check (repo.quotaReservedBytes - origQuota) == 200.NBytes
|
|
|
|
test "update releases quota when lowering size":
|
|
let
|
|
availability = createAvailability()
|
|
origQuota = repo.quotaReservedBytes
|
|
availability.totalSize = availability.totalSize - 100
|
|
|
|
check isOk await reservations.update(availability)
|
|
check (origQuota - repo.quotaReservedBytes) == 100.NBytes
|
|
|
|
test "update reserves quota when growing size":
|
|
let
|
|
availability = createAvailability()
|
|
origQuota = repo.quotaReservedBytes
|
|
availability.totalSize = availability.totalSize + 100
|
|
|
|
check isOk await reservations.update(availability)
|
|
check (repo.quotaReservedBytes - origQuota) == 100.NBytes
|
|
|
|
test "create availability set enabled to true by default":
|
|
let availability = createAvailability()
|
|
check availability.enabled == true
|
|
|
|
test "create availability set until to 0 by default":
|
|
let availability = createAvailability()
|
|
check availability.until == 0.SecondsSince1970
|
|
|
|
test "create availability whith correct values":
|
|
var until = getTime().toUnix()
|
|
|
|
let availability = createAvailability(enabled = false, until = until)
|
|
check availability.enabled == false
|
|
check availability.until == until
|
|
|
|
test "create an availability fails when trying set until with a negative value":
|
|
let totalSize = rand(100000 .. 200000).uint64
|
|
let example = Availability.example(collateralPerByte)
|
|
let totalCollateral = totalSize.u256 * collateralPerByte
|
|
|
|
let result = await reservations.createAvailability(
|
|
totalSize,
|
|
example.duration,
|
|
example.minPricePerBytePerSecond,
|
|
totalCollateral,
|
|
enabled = true,
|
|
until = -1.SecondsSince1970,
|
|
)
|
|
|
|
check result.isErr
|
|
check result.error of UntilOutOfBoundsError
|
|
|
|
test "update an availability fails when trying set until with a negative value":
|
|
let until = getTime().toUnix()
|
|
let availability = createAvailability(until = until)
|
|
|
|
availability.until = -1
|
|
|
|
let result = await reservations.update(availability)
|
|
check result.isErr
|
|
check result.error of UntilOutOfBoundsError
|
|
|
|
test "reservation can be partially released":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
check isOk await reservations.release(reservation.id, reservation.availabilityId, 1)
|
|
let key = reservation.key.get
|
|
let updated = !(await reservations.get(key, Reservation))
|
|
check updated.size == reservation.size - 1
|
|
|
|
test "cannot release more bytes than size of reservation":
|
|
let availability = createAvailability()
|
|
let reservation = createReservation(availability)
|
|
let updated = await reservations.release(
|
|
reservation.id, reservation.availabilityId, reservation.size + 1
|
|
)
|
|
check updated.isErr
|
|
check updated.error of BytesOutOfBoundsError
|
|
|
|
test "cannot release bytes from non-existant reservation":
|
|
let availability = createAvailability()
|
|
discard createReservation(availability)
|
|
let updated = await reservations.release(ReservationId.example, availability.id, 1)
|
|
check updated.isErr
|
|
check updated.error of NotExistsError
|
|
|
|
test "OnAvailabilitySaved called when availability is created":
|
|
var added: Availability
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
added = a
|
|
|
|
let availability = createAvailability()
|
|
|
|
check added == availability
|
|
|
|
test "OnAvailabilitySaved called when availability size is increased":
|
|
var availability = createAvailability()
|
|
var added: Availability
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
added = a
|
|
availability.freeSize += 1
|
|
discard await reservations.update(availability)
|
|
|
|
check added == availability
|
|
|
|
test "OnAvailabilitySaved is not called when availability size is decreased":
|
|
var availability = createAvailability()
|
|
var called = false
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
called = true
|
|
availability.freeSize -= 1.uint64
|
|
discard await reservations.update(availability)
|
|
|
|
check not called
|
|
|
|
test "OnAvailabilitySaved is not called when availability is disabled":
|
|
var availability = createAvailability(enabled = false)
|
|
var called = false
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
called = true
|
|
availability.freeSize -= 1
|
|
discard await reservations.update(availability)
|
|
|
|
check not called
|
|
|
|
test "OnAvailabilitySaved called when availability duration is increased":
|
|
var availability = createAvailability()
|
|
var added: Availability
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
added = a
|
|
availability.duration += 1
|
|
discard await reservations.update(availability)
|
|
|
|
check added == availability
|
|
|
|
test "OnAvailabilitySaved is not called when availability duration is decreased":
|
|
var availability = createAvailability()
|
|
var called = false
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
called = true
|
|
availability.duration -= 1
|
|
discard await reservations.update(availability)
|
|
|
|
check not called
|
|
|
|
test "OnAvailabilitySaved called when availability minPricePerBytePerSecond is increased":
|
|
var availability = createAvailability()
|
|
var added: Availability
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
added = a
|
|
availability.minPricePerBytePerSecond += 1.u256
|
|
discard await reservations.update(availability)
|
|
|
|
check added == availability
|
|
|
|
test "OnAvailabilitySaved is not called when availability minPricePerBytePerSecond is decreased":
|
|
var availability = createAvailability()
|
|
var called = false
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
called = true
|
|
availability.minPricePerBytePerSecond -= 1.u256
|
|
discard await reservations.update(availability)
|
|
|
|
check not called
|
|
|
|
test "OnAvailabilitySaved called when availability totalRemainingCollateral is increased":
|
|
var availability = createAvailability()
|
|
var added: Availability
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
added = a
|
|
availability.totalRemainingCollateral =
|
|
availability.totalRemainingCollateral + 1.u256
|
|
discard await reservations.update(availability)
|
|
|
|
check added == availability
|
|
|
|
test "OnAvailabilitySaved is not called when availability totalRemainingCollateral is decreased":
|
|
var availability = createAvailability()
|
|
var called = false
|
|
reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
|
|
called = true
|
|
availability.totalRemainingCollateral =
|
|
availability.totalRemainingCollateral - 1.u256
|
|
discard await reservations.update(availability)
|
|
|
|
check not called
|
|
|
|
test "availabilities can be found":
|
|
let availability = createAvailability()
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize, availability.duration,
|
|
availability.minPricePerBytePerSecond, collateralPerByte, validUntil,
|
|
)
|
|
|
|
check found.isSome
|
|
check found.get == availability
|
|
|
|
test "does not find an availability when is it disabled":
|
|
let availability = createAvailability(enabled = false)
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize, availability.duration,
|
|
availability.minPricePerBytePerSecond, collateralPerByte, validUntil,
|
|
)
|
|
|
|
check found.isNone
|
|
|
|
test "finds an availability when the until date is after the duration":
|
|
let example = Availability.example(collateralPerByte)
|
|
let until = getTime().toUnix() + example.duration.SecondsSince1970
|
|
let availability = createAvailability(until = until)
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize, availability.duration,
|
|
availability.minPricePerBytePerSecond, collateralPerByte, validUntil,
|
|
)
|
|
|
|
check found.isSome
|
|
check found.get == availability
|
|
|
|
test "does not find an availability when the until date is before the duration":
|
|
let example = Availability.example(collateralPerByte)
|
|
let until = getTime().toUnix() + 1.SecondsSince1970
|
|
let availability = createAvailability(until = until)
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize, availability.duration,
|
|
availability.minPricePerBytePerSecond, collateralPerByte, validUntil,
|
|
)
|
|
|
|
check found.isNone
|
|
|
|
test "non-matching availabilities are not found":
|
|
let availability = createAvailability()
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize + 1,
|
|
availability.duration,
|
|
availability.minPricePerBytePerSecond,
|
|
collateralPerByte,
|
|
validUntil,
|
|
)
|
|
|
|
check found.isNone
|
|
|
|
test "non-existent availability cannot be found":
|
|
let availability = Availability.example
|
|
let validUntil = getTime().toUnix() + 30.SecondsSince1970
|
|
let found = await reservations.findAvailability(
|
|
availability.freeSize, availability.duration,
|
|
availability.minPricePerBytePerSecond, collateralPerByte, validUntil,
|
|
)
|
|
|
|
check found.isNone
|
|
|
|
test "non-existent availability cannot be retrieved":
|
|
let key = AvailabilityId.example.key.get
|
|
let got = await reservations.get(key, Availability)
|
|
check got.error of NotExistsError
|
|
|
|
test "can get available bytes in repo":
|
|
check reservations.available == DefaultQuotaBytes.uint
|
|
|
|
test "reports quota available to be reserved":
|
|
check reservations.hasAvailable(DefaultQuotaBytes.uint - 1)
|
|
|
|
test "reports quota not available to be reserved":
|
|
check not reservations.hasAvailable(DefaultQuotaBytes.uint64 + 1)
|
|
|
|
test "fails to create availability with size that is larger than available quota":
|
|
let created = await reservations.createAvailability(
|
|
DefaultQuotaBytes.uint64 + 1,
|
|
uint64.example,
|
|
UInt256.example,
|
|
UInt256.example,
|
|
enabled = true,
|
|
until = 0.SecondsSince1970,
|
|
)
|
|
check created.isErr
|
|
check created.error of ReserveFailedError
|
|
check created.error.parent of QuotaNotEnoughError
|