#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 }