-
-
Notifications
You must be signed in to change notification settings - Fork 104
/
Copy pathtest_mint_db.py
291 lines (235 loc) · 9.16 KB
/
test_mint_db.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
import asyncio
from unittest.mock import AsyncMock
import pytest
import pytest_asyncio
from fastapi import WebSocket
from cashu.core.base import MeltQuoteState, MintQuoteState
from cashu.core.json_rpc.base import (
JSONRPCMethods,
JSONRPCNotficationParams,
JSONRPCNotification,
JSONRPCSubscriptionKinds,
)
from cashu.core.models import PostMeltQuoteRequest
from cashu.mint.ledger import Ledger
from cashu.wallet.wallet import Wallet
from tests.conftest import SERVER_ENDPOINT
from tests.helpers import (
assert_err,
is_github_actions,
pay_if_regtest,
)
@pytest_asyncio.fixture(scope="function")
async def wallet(ledger: Ledger):
wallet = await Wallet.with_db(
url=SERVER_ENDPOINT,
db="test_data/wallet",
name="wallet",
)
await wallet.load_mint()
yield wallet
@pytest.mark.asyncio
@pytest.mark.skipif(is_github_actions, reason="GITHUB_ACTIONS")
async def test_mint_proofs_pending(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(64)
await pay_if_regtest(mint_quote.request)
await wallet.mint(64, quote_id=mint_quote.quote)
proofs = wallet.proofs.copy()
proofs_states_before_split = await wallet.check_proof_state(proofs)
assert all([s.unspent for s in proofs_states_before_split.states])
await ledger.db_write._verify_spent_proofs_and_set_pending(proofs)
proof_states = await wallet.check_proof_state(proofs)
assert all([s.pending for s in proof_states.states])
await assert_err(wallet.split(wallet.proofs, 20), "proofs are pending.")
await ledger.db_write._unset_proofs_pending(proofs)
await wallet.split(proofs, 20)
proofs_states_after_split = await wallet.check_proof_state(proofs)
assert all([s.spent for s in proofs_states_after_split.states])
@pytest.mark.asyncio
async def test_mint_quote(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.amount == 128
assert quote.unit == "sat"
assert not quote.paid
# assert quote.paid_time is None
assert quote.created_time
@pytest.mark.asyncio
async def test_mint_quote_state_transitions(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.unpaid
# set pending again
async def set_state(quote, state):
quote.state = state
# set pending
await assert_err(
set_state(quote, MintQuoteState.pending),
"Cannot change state of an unpaid mint quote",
)
# set unpaid
await assert_err(
set_state(quote, MintQuoteState.unpaid),
"Cannot change state of an unpaid mint quote",
)
# set paid
quote.state = MintQuoteState.paid
# set unpaid
await assert_err(
set_state(quote, MintQuoteState.unpaid),
"Cannot change state of a paid mint quote to unpaid.",
)
# set pending
quote.state = MintQuoteState.pending
# set paid again
quote.state = MintQuoteState.paid
# set pending again
quote.state = MintQuoteState.pending
# set issued
quote.state = MintQuoteState.issued
# set pending again
await assert_err(
set_state(quote, MintQuoteState.pending),
"Cannot change state of an issued mint quote.",
)
@pytest.mark.asyncio
async def test_get_mint_quote_by_request(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
quote = await ledger.crud.get_mint_quote(request=mint_quote.request, db=ledger.db)
assert quote is not None
assert quote.amount == 128
assert quote.unit == "sat"
assert not quote.paid
# assert quote.paid_time is None
assert quote.created_time
@pytest.mark.asyncio
async def test_melt_quote(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
melt_quote = await ledger.melt_quote(
PostMeltQuoteRequest(request=mint_quote.request, unit="sat")
)
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.quote == melt_quote.quote
assert quote.amount == 128
assert quote.unit == "sat"
assert not quote.paid
# assert quote.paid_time is None
assert quote.created_time
@pytest.mark.asyncio
async def test_melt_quote_set_pending(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
melt_quote = await ledger.melt_quote(
PostMeltQuoteRequest(request=mint_quote.request, unit="sat")
)
assert melt_quote is not None
assert melt_quote.state == MeltQuoteState.unpaid.value
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.quote == melt_quote.quote
assert quote.unpaid
previous_state = quote.state
await ledger.db_write._set_melt_quote_pending(quote)
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.pending
# set unpending
await ledger.db_write._unset_melt_quote_pending(quote, previous_state)
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.state == previous_state
@pytest.mark.asyncio
async def test_melt_quote_state_transitions(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
melt_quote = await ledger.melt_quote(
PostMeltQuoteRequest(request=mint_quote.request, unit="sat")
)
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.quote == melt_quote.quote
assert quote.unpaid
# set pending
quote.state = MeltQuoteState.pending
# set unpaid
quote.state = MeltQuoteState.unpaid
# set paid
quote.state = MeltQuoteState.paid
# set pending again
async def set_state(quote, state):
quote.state = state
await assert_err(
set_state(quote, MeltQuoteState.pending),
"Cannot change state of a paid melt quote.",
)
@pytest.mark.asyncio
async def test_mint_quote_set_pending(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
mint_quote = await ledger.crud.get_mint_quote(
quote_id=mint_quote.quote, db=ledger.db
)
assert mint_quote is not None
assert mint_quote.unpaid
# pay_if_regtest pays on regtest, get_mint_quote pays on FakeWallet
await pay_if_regtest(mint_quote.request)
_ = await ledger.get_mint_quote(mint_quote.quote)
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.paid
previous_state = MintQuoteState.paid
await ledger.db_write._set_mint_quote_pending(quote.quote)
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.pending
# try to mint while pending
await assert_err(
wallet.mint(128, quote_id=mint_quote.quote), "Mint quote already pending."
)
# set unpending
await ledger.db_write._unset_mint_quote_pending(quote.quote, previous_state)
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.state == previous_state
assert quote.paid
# # set paid and mint again
# quote.state = MintQuoteState.paid
# await ledger.crud.update_mint_quote(quote=quote, db=ledger.db)
await wallet.mint(quote.amount, quote_id=quote.quote)
# check if quote is issued
quote = await ledger.crud.get_mint_quote(quote_id=mint_quote.quote, db=ledger.db)
assert quote is not None
assert quote.issued
@pytest.mark.asyncio
async def test_db_events_add_client(wallet: Wallet, ledger: Ledger):
mint_quote = await wallet.request_mint(128)
melt_quote = await ledger.melt_quote(
PostMeltQuoteRequest(request=mint_quote.request, unit="sat")
)
assert melt_quote is not None
assert melt_quote.state == MeltQuoteState.unpaid.value
quote = await ledger.crud.get_melt_quote(quote_id=melt_quote.quote, db=ledger.db)
assert quote is not None
assert quote.quote == melt_quote.quote
assert quote.unpaid
# add event client
websocket_mock = AsyncMock(spec=WebSocket)
client = ledger.events.add_client(websocket_mock, ledger.db, ledger.crud)
asyncio.create_task(client.start())
await asyncio.sleep(0.1)
websocket_mock.accept.assert_called_once()
# add subscription
client.add_subscription(
JSONRPCSubscriptionKinds.BOLT11_MELT_QUOTE, [quote.quote], "subId"
)
quote_pending = await ledger.db_write._set_melt_quote_pending(quote)
await asyncio.sleep(0.1)
notification = JSONRPCNotification(
method=JSONRPCMethods.SUBSCRIBE.value,
params=JSONRPCNotficationParams(
subId="subId", payload=quote_pending.dict()
).dict(),
)
websocket_mock.send_text.assert_called_with(notification.json())
# remove subscription
client.remove_subscription("subId")