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.
472 lines
24 KiB
Ziran
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
|
|
}
|