Files
breeze/tests/dew_behavior.zi
T
waozi 955fe51d17 Buy Dew through Google Play in the Google Play version
The Google Play edition (the gplay build type) now builds its native code
with GOOGLE_PLAY and adds Kryon's Play Billing (its gplay sources from the
Kryon package and billing 9.1); the direct and F-Droid builds carry no
Google billing. Top up lists Entity's Dew packs at Google Play's price in the
buyer's currency once Play answers. Breeze sends each purchase to the node
with its own signed-in request through entity/dew_play, and Play forgets it
only after the node has credited the Dew. The Play edition's Top up shows no
Monero address or other coins, and running out of Dew no longer names
Monero. The old payment bridge stubs are gone.

Kryon and Entity move to their Play Billing commits; liboqs stays pinned.
2026-10-27 18:06:54 -03:00

472 lines
24 KiB
Ziran

#import "entity/dew_model"
#import "entity/dew_play"
// Real account keys, authentication and persistence; only HTTP is synthetic.
#import, file "../src/storage/dew.zi";
#import, file "../src/storage/practice_unlocks.zi";
#import, file "../src/storage/account_types.zi";
#import, file "../src/storage/sync_account.zi";
#import, file "../src/storage/db.zi";
#import, file "../src/storage/state.zi";
#import, file "../src/apps/package_files.zi";
#import, file "storage_test_support.zi";
#import "keys"
#import "async_client"
#import "net_http"
#import "wire"
#import "transaction"
#import "text_buffer"
#import "byte_text_linux"
#import "json_scan"
#import, file "../src/storage/sync_async.zi";
#import, file "../src/storage/sync_node_storage.zi";
#import, file "../src/storage/sync_state.zi";
#import, file "../src/storage/storage_settings.zi";
#import, file "../src/app/text_buffers.zi";
#import, file "../src/platform/dew_payment.zi";
owner: AccountKeys;
response_status: s32 = 200;
response_balance: s64 = 1234567;
response_size: string = "";
response_plans: bool = true;
requests: s32;
last_body: [256]u8;
address_requests: s32;
unlock_requests: s32;
address_network: string = "mainnet";
address_asset: string = "waozi:token";
address_confirmations: s64 = 10;
address_atomic: s64 = 1000000000000LL;
gift_requests: s32;
gift_balance: s64;
// Answers a gift as if for another request, which settles nothing.
gift_reply_foreign: bool;
last_gift_body: [256]u8;
play_requests: s32;
last_play_body: [512]u8;
TestPlayPurchase :: "{\"ready\":true,\"package\":\"xyz.waozi.inbe\",\"error\":\"\",\"products\":[],\"purchases\":[{\"product\":\"dew_500\",\"token\":\"abcdefghijklmnop.Token-1_2\",\"order\":\"GPA.1\"}]}"
TestFriend :: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
TestAddress :: "8aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
Reply :: (output: []u8) -> bool {
writer := Writer.{output, 0, true}
writer = WriteText(writer, "{\"account_id\":\"")
writer = WriteText(writer, TextUntilNul(owner.public_id[:]))
writer = WriteText(writer, "\",\"asset_id\":\"waozi:token\",\"units_per_dew\":1000000,\"enabled\":true,\"free_bytes\":10485760,")
// A size this app does not know yet sits between the known ones.
if response_plans {
writer = WriteText(writer, "\"plans\":[{\"size\":\"1gb\",\"limit_bytes\":1073741824,\"monthly_units\":200000000,\"yearly_units\":2000000000},")
writer = WriteText(writer, "{\"size\":\"10gb\",\"limit_bytes\":10737418240,\"monthly_units\":900000000,\"yearly_units\":9000000000},")
writer = WriteText(writer, "{\"size\":\"5gb\",\"limit_bytes\":5368709120,\"monthly_units\":600000000,\"yearly_units\":6000000000}],")
}
writer = WriteText(writer, "\"monthly_units\":200000000,\"yearly_units\":2000000000,\"used_bytes\":1024,\"plan\":{\"balance\":")
writer = WriteDecimal(writer, response_balance)
writer = WriteText(writer, ",\"size\":\"")
writer = WriteText(writer, response_size)
writer = WriteText(writer, "\",\"limit_bytes\":10485760,\"expires_at\":0}}\n")
return writer.valid
}
AddressReply :: (output: []u8) -> bool {
writer := Writer.{output, 0, true}
writer = WriteText(writer, "{\"account_id\":\"")
writer = WriteText(writer, TextUntilNul(owner.public_id[:]))
writer = WriteText(writer, "\",\"asset_id\":\"")
writer = WriteText(writer, address_asset)
writer = WriteText(writer, "\",\"network\":\"")
writer = WriteText(writer, address_network)
writer = WriteText(writer, "\",\"address\":\"")
writer = WriteText(writer, TestAddress)
writer = WriteText(writer, "\",\"rate\":{\"xmr_atomic_units\":")
writer = WriteDecimal(writer, address_atomic)
writer = WriteText(writer, ",\"token_units\":5000000},\"confirmations_required\":")
writer = WriteDecimal(writer, address_confirmations)
writer = WriteText(writer, ",\"minimum_atomic_amount\":1000}\n")
return writer.valid
}
// The node echoes the gift it was sent, with the sender's new balance.
GiftReply :: (body: string, output: []u8) -> bool {
request_id: [65]u8
recipient: [65]u8
units: s64
unused ReadStringText(body, FieldAt(body, 0, "request_id"), request_id[:])
unused ReadStringText(body, FieldAt(body, 0, "recipient"), recipient[:])
unused DewInteger(body, FieldAt(body, 0, "units"), *units)
writer := Writer.{output, 0, true}
writer = WriteText(writer, "{\"request_id\":\"")
writer = WriteText(writer, ifx gift_reply_foreign then "another-request-id" else TextUntilNul(request_id[:]))
writer = WriteText(writer, "\",\"recipient\":\"")
writer = WriteText(writer, TextUntilNul(recipient[:]))
writer = WriteText(writer, "\",\"units\":")
writer = WriteDecimal(writer, units)
writer = WriteText(writer, ",\"balance\":")
writer = WriteDecimal(writer, gift_balance)
writer = WriteText(writer, ",\"receipt_id\":\"gift-receipt\"}\n")
return writer.valid
}
FakeStart :: (context: *void, request: HttpRequest, output: []u8) -> bool {
unused context
challenge := "https://api.waozi.xyz/api/v1/sync/challenge?user_id="
if request.url.count == challenge.count + 64 && request.url[:challenge.count] == challenge {
return AppCopyText("{\"nonce\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", output)
}
if request.url == "https://api.waozi.xyz/api/v1/sync/login" {
writer := Writer.{output, 0, true}
writer = WriteText(writer, "{\"auth_token\":\"synthetic-dew-token\",\"expires_in_seconds\":3600,\"server_time\":")
writer = WriteDecimal(writer, DewNow())
writer = WriteText(writer, "}")
return writer.valid
}
if request.url == "https://api.waozi.xyz/api/v1/tokens/purchases/monero/address" {
address_requests += 1
check_true("address lookup uses authenticated GET", request.method == "GET" && request.body.count == 0)
return AddressReply(output)
}
// The account bought Tai Chi on another device.
if request.url == "https://api.waozi.xyz/api/v1/unlocks" {
unlock_requests += 1
check_true("unlocks are read with an authenticated GET", request.method == "GET" && request.body.count == 0)
return AppCopyText("{\"unlocks\":[{\"product\":\"inbe.practice.taichi\",\"receipt_id\":\"r1\",\"created_at\":1}],\"products\":[{\"product\":\"inbe.practice.taichi\",\"price_units\":1000000,\"regular_price_units\":10000000,\"trial_until\":1807801200}]}", output)
}
if request.url == "https://api.waozi.xyz/api/v1/tokens/purchases/google/verify" {
play_requests += 1
check_true("Google Play purchases are sent with an authenticated POST", request.method == "POST")
unused AppCopyText(request.body, last_play_body[:])
return AppCopyText("{\"credited\":true}", output)
}
if request.url == "https://api.waozi.xyz/api/v1/tokens/gifts" {
gift_requests += 1
check_true("gifts are sent with an authenticated POST", request.method == "POST")
unused AppCopyText(request.body, last_gift_body[:])
return GiftReply(request.body, output)
}
check_true("only the storage endpoint is requested", request.url == "https://api.waozi.xyz/api/v1/storage/plan")
requests += 1
unused AppCopyText(request.body, last_body[:])
return Reply(output)
}
FakePoll :: (context: *void, status: *s32) -> s32 {
unused context
status.* = ifx dew_operation.request.stage == 3 then response_status else 200
return 1
}
FakeCancel :: (context: *void) {
unused context
}
#program_export
DewTestTransport :: () -> AsyncTransport {
return AsyncTransport.{null, FakeStart, FakePoll, FakeCancel}
}
Finish :: () {
for step: cast(s32)0..39 {
DewTick(false, 1.0)
if !dew_operation.active {
return
}
}
check_true("Dew request completes", false)
}
#program_export
Check :: () -> s32 {
check_true("fixture transport ready", DewTestTransport().start != null)
guard := support_begin("/tmp/inbe-dew-test/")
if guard != 0 {
return guard
}
check_true("database ready", storage_init("/tmp/inbe-dew-test/data") != 0)
DewTick(true, 1.0)
check_true("offline sends no request", requests == 0 && !dew_account.known)
check_true("owner created", CreateAccountKeys(*owner) != 0)
check_true("owner saved", sync_account_save(*owner,
cast(SyncAccountLocalDataChoice)SyncAccountLocalDataChoice.SYNC_ACCOUNT_LOCAL_DATA_MERGE) ==
cast(SyncAccountSaveResult)SyncAccountSaveResult.SYNC_ACCOUNT_SAVE_OK)
storage_set_setting_text("sync_server_url", DewNode)
storage_set_sync_enabled(1)
check_true("account is connected to Waozi", DewReady())
DewTick(true, 1.0)
check_true("balance request started", dew_operation.active)
Finish()
check_int("one balance request", requests, 1)
check_int("balance request authenticated", dew_operation.result, 0)
check_true("confirmed balance loaded", dew_account.known && dew_account.balance == 1234567)
// A purchase made on another device shows here before anything is
// downloaded: the account's unlocks are read once after it connects.
check_true("Tai Chi not owned before the account is read", !UnlockOwned(UnlockTaiChi))
for step: cast(s32)0..79 {
UnlockSync()
if unlock_requests > 0 && !unlock_operation.active {
break
}
}
check_int("the account's unlocks are read once", unlock_requests, 1)
unlock_context_second = -1
check_true("the account's Tai Chi purchase is recognised", UnlockOwned(UnlockTaiChi))
for step: cast(s32)0..9 {
UnlockSync()
}
check_int("no repeated background reads", unlock_requests, 1)
UnlockReset()
unlock_context_second = -1
check_true("the purchase is remembered for the account offline", UnlockOwned(UnlockTaiChi))
check_true("storage sizes and Dew prices come from the node",
dew_account.free_bytes == 10485760 &&
dew_account.plans[0].limit_bytes == 1073741824 && dew_account.plans[0].monthly_units == 200000000 &&
dew_account.plans[0].yearly_units == 2000000000 &&
dew_account.plans[1].limit_bytes == 5368709120 && dew_account.plans[1].monthly_units == 600000000 &&
dew_account.plans[1].yearly_units == 6000000000)
check_true("free account has no paid size", dew_account.plan_size == 0)
buffer: [48]u8
check_true("fractional Dew preserves precision", DewFormat(dew_account.balance, DewUnits, buffer[:]) && TextUntilNul(buffer[:]) == "1.234567")
check_true("zero is a real balance", DewFormat(0, DewUnits, buffer[:]) && TextUntilNul(buffer[:]) == "0")
check_true("whole Dew has no decimal zeros", DewFormat(10000000, DewUnits, buffer[:]) && TextUntilNul(buffer[:]) == "10")
check_true("XMR uses twelve decimals", DewFormat(1, 1000000000000LL, buffer[:]) && TextUntilNul(buffer[:]) == "0.000000000001")
number: s64
check_true("credit integer overflow rejected", !DewInteger("9223372036854775808", 0, *number))
check_true("fractional ledger units rejected", !DewInteger("1.5", 0, *number))
check_true("negative balance rejected", !DewInteger("-1", 0, *number))
check_true("maximum integer preserved", DewInteger("9223372036854775807", 0, *number) && number == 9223372036854775807)
DewTopUp()
Finish()
check_int("one Monero address lookup", address_requests, 1)
check_true("Monero address belongs to the connected account", TextUntilNul(dew_address[:]) == TestAddress)
check_true("Monero quote preserves atomic units", dew_rate_atomic == 1000000000000LL && dew_rate_units == 5000000 && dew_confirmations == 10)
check_true("foreign Monero account rejected", !DewParseAddress("{\"account_id\":\"another-account\"}"))
check_true("minimum Monero deposit loaded", dew_minimum_atomic == 1000)
invalid: [8192]u8
address_network = "stagenet"
unused AddressReply(invalid[:])
check_true("test network payment rejected", !DewParseAddress(TextUntilNul(invalid[:])))
address_network = "mainnet"
address_asset = "other:token"
unused AddressReply(invalid[:])
check_true("foreign payment asset rejected", !DewParseAddress(TextUntilNul(invalid[:])))
address_asset = "waozi:token"
address_atomic = 99
address_confirmations = 0
unused AddressReply(invalid[:])
check_true("invalid quote rejected atomically", !DewParseAddress(TextUntilNul(invalid[:])) &&
dew_rate_atomic == 1000000000000LL && dew_confirmations == 10 && dew_minimum_atomic == 1000)
address_atomic = 1000000000000LL
address_confirmations = 10
response_status = 503
DewTopUp()
check_true("new address lookup hides the previous quote", dew_address[0] == cast(u8)0)
Finish()
check_true("failed lookup cannot show a stale payment address", dew_address[0] == cast(u8)0)
response_status = 200
DewTopUp()
Finish()
check_true("safe payment lookup recovers", TextUntilNul(dew_address[:]) == TestAddress)
parsed: DewAccount
check_true("extra JSON documents rejected", !DewParseAccount("{}\n{}", TextUntilNul(owner.public_id[:]), *parsed))
response_plans = false
noplans: [8192]u8
unused Reply(noplans[:])
check_true("account without sized plans rejected",
!DewParseAccount(TextUntilNul(noplans[:]), TextUntilNul(owner.public_id[:]), *parsed))
response_plans = true
requests_before := requests
DewBuyStorage("2gb", "monthly")
check_true("unknown size sends nothing", requests == requests_before && dew_attempt[0] == cast(u8)0)
response_balance = 234567
response_size = "5gb"
DewBuyStorage("5gb", "monthly")
check_true("waiting purchase remembers its size", DewAttemptSize() == 2)
Finish()
check_true("upgrade finishes with confirmed balance", dew_account.balance == 234567 && dew_attempt[0] == cast(u8)0)
check_true("account size comes from the node", dew_account.plan_size == 2)
check_true("confirmed upgrade wakes sync once", DewTakeSyncRequest() && !DewTakeSyncRequest())
period: [16]u8
sent_size: [16]u8
body := TextUntilNul(last_body[:])
check_true("period sent", ReadStringText(body, FieldAt(body, 0, "period"), period[:]) == 7 && TextUntilNul(period[:]) == "monthly")
check_true("size sent", ReadStringText(body, FieldAt(body, 0, "size"), sent_size[:]) == 3 && TextUntilNul(sent_size[:]) == "5gb")
response_size = ""
response_status = 503
DewBuyStorage("1gb", "yearly")
Finish()
check_true("uncertain purchase keeps its request", dew_attempt[0] != cast(u8)0)
attempt: [256]u8 = dew_attempt
DewCancel()
DewTick(true, 1.0)
response_status = 200
Finish()
check_true("uncertain request survives restart", TextUntilNul(dew_attempt[:]) == TextUntilNul(attempt[:]))
DewBuyStorage("5gb", "monthly")
Finish()
check_true("retry preserves the original yearly purchase", TextUntilNul(last_body[:]) == TextUntilNul(attempt[:]))
response_status = 402
DewBuyStorage("1gb", "monthly")
Finish()
check_true("insufficient credit is explained", dew_notice == "profile_dew_funds" && dew_attempt[0] == cast(u8)0)
unused DewTakeSyncRequest()
SyncNodeStorageWrite(DewNode, SyncNodeStorage.{.known = true,
.used_bytes = 10485760, .limit_bytes = 10485760, .checked_at = DewNow(), .full = true})
response_status = 200
DewTick(true, 100.0)
Finish()
check_true("allowance refreshed from another device wakes sync once", DewTakeSyncRequest() && !DewTakeSyncRequest())
rates: DewRates
check_true("node rates parse in integer units", DewParseRates(
"{\"xmr_usd_cents\":34512,\"updated_at\":1789000000,\"sources\":[\"coingecko\",\"kraken\"],\"xmr_atomic_units\":1000000000000,\"token_units\":10000000000}",
*rates) && rates.known && rates.usd_cents_per_xmr == 34512)
dew_rates = rates
dew_address = .{}
check_true("100 Dew is 0.01 XMR at 10000 Dew per XMR", DewXmrAtomic(100 * DewUnits) == 10000000000)
check_true("0.01 XMR at 345.12 USD is 3.45 USD", DewUsdCents(10000000000) == 345)
// The public response can predate a changed deposit quote. The balance
// must use the quote that will actually credit this address.
dew_rates.token_units = 1000 * DewUnits
unused AppCopyText(TestAddress, dew_address[:])
dew_rate_atomic = 1000000000000LL
dew_rate_units = 10000 * DewUnits
check_true("98 Dew uses the deposit quote despite an older public ratio",
DewXmrAtomic(98 * DewUnits) == 9800000000LL)
check_true("98 Dew dollar value follows the same deposit quote",
DewUsdCents(DewXmrAtomic(98 * DewUnits)) == 338)
funding := DewFundingRate()
check_true("displayed exchange and balance use one invertible quote",
DewUnitsForXmr(DewXmrAtomic(98 * DewUnits), funding.xmr_atomic_units,
funding.token_units) == 98 * DewUnits)
dew_rates = DewRates.{}
check_true("a deposit quote works without a public rates response",
DewXmrAtomic(98 * DewUnits) == 9800000000LL)
check_true("a deposit quote alone never invents a dollar price",
DewUsdCents(DewXmrAtomic(98 * DewUnits)) == 0)
dew_address = .{}
check_true("a quote without its address is not reused",
DewXmrAtomic(98 * DewUnits) == 0)
stale: DewRates
check_true("a node without a current price still gives the Dew ratio", DewParseRates(
"{\"xmr_usd_cents\":0,\"updated_at\":0,\"sources\":[],\"xmr_atomic_units\":1000000000000,\"token_units\":10000000000}",
*stale) && stale.known)
dew_rates = stale
check_true("no current price shows no USD", DewUsdCents(10000000000) == 0 && DewXmrAtomic(100 * DewUnits) == 10000000000)
broken: DewRates
check_true("fractional cents rejected", !DewParseRates(
"{\"xmr_usd_cents\":1.5,\"updated_at\":0,\"sources\":[],\"xmr_atomic_units\":1,\"token_units\":1}", *broken))
dew_rates = DewRates.{}
check_true("without rates nothing converts", DewXmrAtomic(10 * DewUnits) == 0)
// A gift to a friend moves whole requests: one at a time, never to
// oneself, and an uncertain one is sent again as it was.
response_status = 200
check_true("no gift to oneself", !DewSendGift(TextUntilNul(owner.public_id[:]), DewUnits))
check_true("no empty gift", !DewSendGift(TestFriend, 0))
check_true("no gift to a malformed account", !DewSendGift("bbbb", DewUnits))
check_int("refused gifts send nothing", gift_requests, 0)
response_balance = 11000000
DewTick(true, 200.0)
Finish()
check_true("balance known before gifting", dew_account.known && dew_account.balance == 11000000)
gift_balance = 9000000
check_true("gift accepted", DewSendGift(TestFriend, 2 * DewUnits))
check_true("one gift at a time", !DewSendGift(TestFriend, DewUnits))
check_true("a new gift is sending", dew_gift_state == DewGiftSending && dew_gift_units == 2 * DewUnits)
Finish()
check_int("one gift request", gift_requests, 1)
gift := TextUntilNul(last_gift_body[:])
gift_recipient: [65]u8
gift_request: [65]u8
gift_units: s64
check_true("gift names the friend", ReadStringText(gift, FieldAt(gift, 0, "recipient"), gift_recipient[:]) == 64 &&
TextUntilNul(gift_recipient[:]) == TestFriend)
check_true("gift sends integer units", DewInteger(gift, FieldAt(gift, 0, "units"), *gift_units) && gift_units == 2000000)
check_true("gift carries a request ID", ReadStringText(gift, FieldAt(gift, 0, "request_id"), gift_request[:]) >= 8)
check_true("confirmed gift shows the sender's new balance", dew_gift_state == DewGiftSent &&
dew_account.balance == 9000000 && dew_gift_attempt[0] == cast(u8)0)
saved_gift: [192]u8
unused storage_get_social_cache_json("dew.gift", *saved_gift[0], 192)
check_true("a confirmed gift is forgotten", TextUntilNul(saved_gift[:]) == "{}")
response_status = 503
check_true("second gift accepted", DewSendGift(TestFriend, DewUnits))
Finish()
check_true("uncertain gift is kept to send again", dew_gift_attempt[0] != cast(u8)0 &&
dew_gift_state == DewGiftSending && dew_gift_notice == "dew_gift_waiting")
uncertain: [192]u8 = dew_gift_attempt
DewTick(false, 2.0)
check_true("an uncertain gift waits before repeating", !dew_operation.active)
DewCancel()
DewContext()
check_true("uncertain gift survives restart", TextUntilNul(dew_gift_attempt[:]) == TextUntilNul(uncertain[:]) &&
dew_gift_state == DewGiftSending && dew_gift_units == DewUnits &&
TextUntilNul(dew_gift_recipient[:]) == TestFriend)
response_status = 200
gift_balance = 8000000
Finish()
check_true("the retry repeats the same request", TextUntilNul(last_gift_body[:]) == TextUntilNul(uncertain[:]))
check_true("retried gift confirmed once", dew_gift_state == DewGiftSent && dew_gift_attempt[0] == cast(u8)0)
gift_reply_foreign = true
check_true("third gift accepted", DewSendGift(TestFriend, DewUnits))
Finish()
check_true("an answer for another request settles nothing", dew_gift_attempt[0] != cast(u8)0 &&
dew_gift_notice == "dew_gift_waiting")
gift_reply_foreign = false
DewTick(false, 30.0)
Finish()
check_true("the gift settles when the node answers it", dew_gift_state == DewGiftSent && dew_gift_attempt[0] == cast(u8)0)
response_status = 402
check_true("unaffordable gift accepted for the node to judge", DewSendGift(TestFriend, 50 * DewUnits))
Finish()
check_true("missing Dew is explained", dew_gift_state == DewGiftRefused &&
dew_gift_notice == "dew_gift_funds" && dew_gift_attempt[0] == cast(u8)0)
response_status = 403
unused DewSendGift(TestFriend, DewUnits)
Finish()
check_true("gifts only reach friends", dew_gift_notice == "dew_gift_not_friend" && dew_gift_attempt[0] == cast(u8)0)
response_status = 409
unused DewSendGift(TestFriend, DewUnits)
Finish()
check_true("a refused request is not repeated", dew_gift_notice == "dew_gift_failed" && dew_gift_attempt[0] == cast(u8)0)
response_status = 200
// The Google Play edition sends each purchase Play lists to the node, and
// Play forgets it only once the node has credited its Dew.
check_true("other editions sell no Dew through Google Play", !dew_play.enabled && DewTopUpAvailable())
dew_play.enabled = true
check_true("the Play edition tops up once Google Play answers", !DewTopUpAvailable())
unused AppCopyText(TestPlayPurchase, dew_play.state[:])
response_status = 503
DewTick(false, 200.0)
check_true("a Google Play purchase goes to the node", dew_operation.active && dew_action == DewPlayCredit)
Finish()
check_int("one Google Play verify request", play_requests, 1)
check_true("the verify request names the package, pack and token", TextUntilNul(last_play_body[:]) ==
"{\"app_id\":\"entity\",\"package_name\":\"xyz.waozi.inbe\",\"product_id\":\"dew_500\",\"purchase_token\":\"abcdefghijklmnop.Token-1_2\"}")
check_true("an uncredited purchase stays with Play and waits", TextUntilNul(dew_play.status[:]) == "failed" &&
dew_play.wait > 0 && dew_play.state[0] == #char "{" && !dew_operation.active)
DewTick(false, 201.0)
check_true("the waiting purchase is not sent at once", !dew_operation.active && play_requests == 1)
response_status = 200
dew_play.wait = 1
DewTick(false, 202.0)
Finish()
check_int("the purchase is sent again", play_requests, 2)
check_true("a credited purchase is done", TextUntilNul(dew_play.status[:]) == "credited" &&
dew_play.state[0] == cast(u8)0 && !dew_operation.active)
dew_play = .{}
storage_set_setting_text("sync_public_id", "another-account")
DewContext()
check_true("account change clears the old balance", !dew_account.known && dew_address[0] == cast(u8)0)
storage_set_setting_text("sync_server_url", "https://other.example")
DewTick(true, 100.0)
check_true("other nodes receive no Dew requests", !dew_operation.active && !dew_account.known)
storage_close()
remove_tree("/tmp/inbe-dew-test/")
return failures
}