upleb.uk

Public git repos — served from a NIP-34 GRASP relay at git.upleb.uk

summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
authorDanConwayDev <DanConwayDev@protonmail.com>2023-11-01 00:00:00 +0000
committerDanConwayDev <DanConwayDev@protonmail.com>2023-11-01 00:00:00 +0000
commit497bf71910f0f224ce66b154d58a228095a40c0a (patch)
treea3d55f0581a27465ea9ab2fd03956881ee13193a /tests
parente237328ec611a5891586530c1d3cb26c16c1093b (diff)
feat(login) fetch from discovered write relays
immediately request metadata and relay list from any newly discovered user write relays
Diffstat (limited to 'tests')
-rw-r--r--tests/login.rs831
1 files changed, 460 insertions, 371 deletions
diff --git a/tests/login.rs b/tests/login.rs
index d565620..e6ead6b 100644
--- a/tests/login.rs
+++ b/tests/login.rs
@@ -27,220 +27,343 @@ mod with_relays {
27 27
28 use super::*; 28 use super::*;
29 29
30 mod when_first_time_login { 30 mod when_user_relay_list_aligns_with_fallback_relays {
31 // this simplifies testing
31 use super::*; 32 use super::*;
32 33
33 // falls_back_to_fallback_relays - this is implict in the tests 34 mod when_first_time_login {
35 use super::*;
34 36
35 mod dislays_logged_in_with_correct_name { 37 // falls_back_to_fallback_relays - this is implict in the tests
36 38
37 use super::*; 39 mod dislays_logged_in_with_correct_name {
38 40
39 async fn run_test_displays_correct_name( 41 use super::*;
40 relay_listener1: Option<ListenerReqFunc<'_>>,
41 relay_listener2: Option<ListenerReqFunc<'_>>,
42 ) -> Result<()> {
43 let (mut r51, mut r52) = (
44 Relay::new(8051, None, relay_listener1),
45 Relay::new(8052, None, relay_listener2),
46 );
47 42
48 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 43 async fn run_test_displays_correct_name(
49 with_fresh_config(|| { 44 relay_listener1: Option<ListenerReqFunc<'_>>,
50 let mut p = CliTester::new(["login"]); 45 relay_listener2: Option<ListenerReqFunc<'_>>,
46 ) -> Result<()> {
47 let (mut r51, mut r52) = (
48 Relay::new(8051, None, relay_listener1),
49 Relay::new(8052, None, relay_listener2),
50 );
51 51
52 p.expect_input(EXPECTED_NSEC_PROMPT)? 52 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
53 .succeeds_with(TEST_KEY_1_NSEC)?; 53 with_fresh_config(|| {
54 let mut p = CliTester::new(["login"]);
54 55
55 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)? 56 p.expect_input(EXPECTED_NSEC_PROMPT)?
56 .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)? 57 .succeeds_with(TEST_KEY_1_NSEC)?;
57 .succeeds_with(TEST_PASSWORD)?;
58 58
59 p.expect("searching for your details...\r\n")?; 59 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
60 p.expect("\r")?; 60 .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
61 .succeeds_with(TEST_PASSWORD)?;
61 62
62 p.expect_end_with("logged in as fred\r\n")?; 63 p.expect("searching for your details...\r\n")?;
63 for p in [51, 52] { 64 p.expect("\r")?;
64 shutdown_relay(8000 + p)?;
65 }
66 Ok(())
67 })
68 });
69 65
70 // launch relay 66 p.expect_end_with("logged in as fred\r\n")?;
71 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),); 67 for p in [51, 52] {
68 shutdown_relay(8000 + p)?;
69 }
70 Ok(())
71 })
72 });
72 73
73 cli_tester_handle.join().unwrap()?; 74 // launch relay
74 Ok(()) 75 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
75 }
76 76
77 #[test] 77 cli_tester_handle.join().unwrap()?;
78 #[serial] 78 Ok(())
79 fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> { 79 }
80 futures::executor::block_on(run_test_displays_correct_name(
81 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
82 relay.respond_events(
83 client_id,
84 &subscription_id,
85 &vec![
86 generate_test_key_1_metadata_event("fred"),
87 generate_test_key_1_relay_list_event(),
88 ],
89 )?;
90 Ok(())
91 }),
92 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
93 relay.respond_events(
94 client_id,
95 &subscription_id,
96 &vec![
97 generate_test_key_1_metadata_event("fred"),
98 generate_test_key_1_relay_list_event(),
99 ],
100 )?;
101 Ok(())
102 }),
103 ))
104 }
105 80
106 #[test] 81 #[test]
107 #[serial] 82 #[serial]
108 fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none() 83 fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> {
109 -> Result<()> { 84 futures::executor::block_on(run_test_displays_correct_name(
110 futures::executor::block_on(run_test_displays_correct_name( 85 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
111 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 86 relay.respond_events(
112 relay.respond_events( 87 client_id,
113 client_id, 88 &subscription_id,
114 &subscription_id, 89 &vec![
115 &vec![ 90 generate_test_key_1_metadata_event("fred"),
116 generate_test_key_1_metadata_event("fred"), 91 generate_test_key_1_relay_list_event_same_as_fallback(),
117 generate_test_key_1_relay_list_event(), 92 ],
118 ], 93 )?;
119 )?; 94 Ok(())
120 Ok(()) 95 }),
121 }), 96 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
122 None, 97 relay.respond_events(
123 )) 98 client_id,
124 } 99 &subscription_id,
100 &vec![
101 generate_test_key_1_metadata_event("fred"),
102 generate_test_key_1_relay_list_event_same_as_fallback(),
103 ],
104 )?;
105 Ok(())
106 }),
107 ))
108 }
125 109
126 #[test] 110 #[test]
127 #[serial] 111 #[serial]
128 fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()> { 112 fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none()
129 futures::executor::block_on(run_test_displays_correct_name( 113 -> Result<()> {
130 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 114 futures::executor::block_on(run_test_displays_correct_name(
131 relay.respond_events( 115 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
132 client_id, 116 relay.respond_events(
133 &subscription_id, 117 client_id,
134 &vec![generate_test_key_1_metadata_event("fred")], 118 &subscription_id,
135 )?; 119 &vec![
136 Ok(()) 120 generate_test_key_1_metadata_event("fred"),
137 }), 121 generate_test_key_1_relay_list_event_same_as_fallback(),
138 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 122 ],
139 relay.respond_events( 123 )?;
140 client_id, 124 Ok(())
141 &subscription_id, 125 }),
142 &vec![generate_test_key_1_relay_list_event()], 126 None,
143 )?; 127 ))
144 Ok(()) 128 }
145 }),
146 ))
147 }
148 129
149 #[test] 130 #[test]
150 #[serial] 131 #[serial]
151 fn when_some_relays_return_old_metadata_event() -> Result<()> { 132 fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()> {
152 futures::executor::block_on(run_test_displays_correct_name( 133 futures::executor::block_on(run_test_displays_correct_name(
153 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 134 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
154 relay.respond_events( 135 relay.respond_events(
155 client_id, 136 client_id,
156 &subscription_id, 137 &subscription_id,
157 &vec![ 138 &vec![generate_test_key_1_metadata_event("fred")],
158 generate_test_key_1_metadata_event("fred"), 139 )?;
159 generate_test_key_1_relay_list_event(), 140 Ok(())
160 ], 141 }),
161 )?; 142 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
162 Ok(()) 143 relay.respond_events(
163 }), 144 client_id,
164 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 145 &subscription_id,
165 relay.respond_events( 146 &vec![generate_test_key_1_relay_list_event_same_as_fallback()],
166 client_id, 147 )?;
167 &subscription_id, 148 Ok(())
168 &vec![generate_test_key_1_metadata_event_old("fred old")], 149 }),
169 )?; 150 ))
170 Ok(()) 151 }
171 }),
172 ))
173 }
174 152
175 #[test] 153 #[test]
176 #[serial] 154 #[serial]
177 fn when_some_relays_return_other_users_metadata() -> Result<()> { 155 fn when_some_relays_return_old_metadata_event() -> Result<()> {
178 futures::executor::block_on(run_test_displays_correct_name( 156 futures::executor::block_on(run_test_displays_correct_name(
179 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 157 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
180 relay.respond_events( 158 relay.respond_events(
181 client_id, 159 client_id,
182 &subscription_id, 160 &subscription_id,
183 &vec![generate_test_key_2_metadata_event("carole")], 161 &vec![
184 )?; 162 generate_test_key_1_metadata_event("fred"),
185 Ok(()) 163 generate_test_key_1_relay_list_event_same_as_fallback(),
186 }), 164 ],
187 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 165 )?;
188 relay.respond_events( 166 Ok(())
189 client_id, 167 }),
190 &subscription_id, 168 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
191 &vec![ 169 relay.respond_events(
192 generate_test_key_1_metadata_event_old("fred"), 170 client_id,
193 generate_test_key_1_relay_list_event(), 171 &subscription_id,
194 ], 172 &vec![generate_test_key_1_metadata_event_old("fred old")],
195 )?; 173 )?;
196 Ok(()) 174 Ok(())
197 }), 175 }),
198 )) 176 ))
199 } 177 }
200 178
201 #[test] 179 #[test]
202 #[serial] 180 #[serial]
203 fn when_some_relays_return_other_event_kinds() -> Result<()> { 181 fn when_some_relays_return_other_users_metadata() -> Result<()> {
204 futures::executor::block_on(run_test_displays_correct_name( 182 futures::executor::block_on(run_test_displays_correct_name(
205 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 183 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
206 let mut event = generate_test_key_1_metadata_event("Fred"); 184 relay.respond_events(
207 event.kind = nostr::Kind::TextNote; 185 client_id,
208 relay.respond_events( 186 &subscription_id,
209 client_id, 187 &vec![generate_test_key_2_metadata_event("carole")],
210 &subscription_id, 188 )?;
211 &vec![make_event_old_or_change_user(event, &TEST_KEY_1_KEYS, 0)], 189 Ok(())
212 )?; 190 }),
191 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
192 relay.respond_events(
193 client_id,
194 &subscription_id,
195 &vec![
196 generate_test_key_1_metadata_event_old("fred"),
197 generate_test_key_1_relay_list_event_same_as_fallback(),
198 ],
199 )?;
200 Ok(())
201 }),
202 ))
203 }
204
205 #[test]
206 #[serial]
207 fn when_some_relays_return_other_event_kinds() -> Result<()> {
208 futures::executor::block_on(run_test_displays_correct_name(
209 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
210 let mut event = generate_test_key_1_metadata_event("Fred");
211 event.kind = nostr::Kind::TextNote;
212 relay.respond_events(
213 client_id,
214 &subscription_id,
215 &vec![make_event_old_or_change_user(event, &TEST_KEY_1_KEYS, 0)],
216 )?;
217 Ok(())
218 }),
219 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
220 relay.respond_events(
221 client_id,
222 &subscription_id,
223 &vec![
224 generate_test_key_1_metadata_event_old("fred"),
225 generate_test_key_1_relay_list_event_same_as_fallback(),
226 ],
227 )?;
228 Ok(())
229 }),
230 ))
231 }
232
233 mod when_specifying_command_line_nsec_only {
234 use super::*;
235
236 #[test]
237 #[serial]
238 fn displays_correct_name() -> Result<()> {
239 futures::executor::block_on(
240 run_test_when_specifying_command_line_nsec_only_displays_correct_name(
241 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
242 relay.respond_events(
243 client_id,
244 &subscription_id,
245 &vec![
246 generate_test_key_1_metadata_event("fred"),
247 generate_test_key_1_relay_list_event_same_as_fallback(),
248 ],
249 )?;
250 Ok(())
251 }),
252 None,
253 ),
254 )
255 }
256 async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name(
257 relay_listener1: Option<ListenerReqFunc<'_>>,
258 relay_listener2: Option<ListenerReqFunc<'_>>,
259 ) -> Result<()> {
260 let (mut r51, mut r52) = (
261 Relay::new(8051, None, relay_listener1),
262 Relay::new(8052, None, relay_listener2),
263 );
264
265 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
266 with_fresh_config(|| {
267 let mut p = CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC]);
268
269 p.expect("searching for your details...\r\n")?;
270 p.expect("\r")?;
271
272 p.expect_end_with("logged in as fred\r\n")?;
273 for p in [51, 52] {
274 shutdown_relay(8000 + p)?;
275 }
276 Ok(())
277 })
278 });
279
280 // launch relay
281 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
282
283 cli_tester_handle.join().unwrap()?;
213 Ok(()) 284 Ok(())
214 }), 285 }
215 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 286 }
216 relay.respond_events( 287 mod when_specifying_command_line_password_only {
217 client_id, 288 use super::*;
218 &subscription_id, 289
219 &vec![ 290 #[test]
220 generate_test_key_1_metadata_event_old("fred"), 291 #[serial]
221 generate_test_key_1_relay_list_event(), 292 fn displays_correct_name() -> Result<()> {
222 ], 293 futures::executor::block_on(
223 )?; 294 run_test_when_specifying_command_line_password_only_displays_correct_name(
295 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
296 relay.respond_events(
297 client_id,
298 &subscription_id,
299 &vec![
300 generate_test_key_1_metadata_event("fred"),
301 generate_test_key_1_relay_list_event_same_as_fallback(),
302 ],
303 )?;
304 Ok(())
305 }),
306 None,
307 ),
308 )
309 }
310 async fn run_test_when_specifying_command_line_password_only_displays_correct_name(
311 relay_listener1: Option<ListenerReqFunc<'_>>,
312 relay_listener2: Option<ListenerReqFunc<'_>>,
313 ) -> Result<()> {
314 let (mut r51, mut r52) = (
315 Relay::new(8051, None, relay_listener1),
316 Relay::new(8052, None, relay_listener2),
317 );
318
319 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
320 with_fresh_config(|| {
321 CliTester::new([
322 "login",
323 "--offline",
324 "--nsec",
325 TEST_KEY_1_NSEC,
326 "--password",
327 TEST_PASSWORD,
328 ])
329 .expect_end_eventually()?;
330
331 let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
332
333 p.expect("searching for your details...\r\n")?;
334 p.expect("\r")?;
335
336 p.expect_end_with("logged in as fred\r\n")?;
337 for p in [51, 52] {
338 shutdown_relay(8000 + p)?;
339 }
340 Ok(())
341 })
342 });
343
344 // launch relay
345 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
346
347 cli_tester_handle.join().unwrap()?;
224 Ok(()) 348 Ok(())
225 }), 349 }
226 )) 350 }
227 }
228 351
229 mod when_specifying_command_line_nsec_only { 352 mod when_specifying_command_line_nsec_and_password {
230 use super::*; 353 use super::*;
231 354
232 #[test] 355 #[test]
233 #[serial] 356 #[serial]
234 fn displays_correct_name() -> Result<()> { 357 fn displays_correct_name() -> Result<()> {
235 futures::executor::block_on( 358 futures::executor::block_on(
236 run_test_when_specifying_command_line_nsec_only_displays_correct_name( 359 run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
237 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 360 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
238 relay.respond_events( 361 relay.respond_events(
239 client_id, 362 client_id,
240 &subscription_id, 363 &subscription_id,
241 &vec![ 364 &vec![
242 generate_test_key_1_metadata_event("fred"), 365 generate_test_key_1_metadata_event("fred"),
243 generate_test_key_1_relay_list_event(), 366 generate_test_key_1_relay_list_event_same_as_fallback(),
244 ], 367 ],
245 )?; 368 )?;
246 Ok(()) 369 Ok(())
@@ -248,8 +371,58 @@ mod with_relays {
248 None, 371 None,
249 ), 372 ),
250 ) 373 )
374 }
375 async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
376 relay_listener1: Option<ListenerReqFunc<'_>>,
377 relay_listener2: Option<ListenerReqFunc<'_>>,
378 ) -> Result<()> {
379 let (mut r51, mut r52) = (
380 Relay::new(8051, None, relay_listener1),
381 Relay::new(8052, None, relay_listener2),
382 );
383
384 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
385 with_fresh_config(|| {
386 let mut p = CliTester::new([
387 "login",
388 "--nsec",
389 TEST_KEY_1_NSEC,
390 "--password",
391 TEST_PASSWORD,
392 ]);
393
394 p.expect("searching for your details...\r\n")?;
395 p.expect("\r")?;
396
397 p.expect_end_with("logged in as fred\r\n")?;
398 for p in [51, 52] {
399 shutdown_relay(8000 + p)?;
400 }
401 Ok(())
402 })
403 });
404
405 // launch relay
406 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
407
408 cli_tester_handle.join().unwrap()?;
409 Ok(())
410 }
411 }
412 }
413
414 mod when_no_metadata_found {
415 use super::*;
416
417 #[test]
418 #[serial]
419 fn warm_user_and_displays_npub() -> Result<()> {
420 futures::executor::block_on(
421 run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None),
422 )
251 } 423 }
252 async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name( 424
425 async fn run_test_when_no_metadata_found_warns_user_and_uses_npub(
253 relay_listener1: Option<ListenerReqFunc<'_>>, 426 relay_listener1: Option<ListenerReqFunc<'_>>,
254 relay_listener2: Option<ListenerReqFunc<'_>>, 427 relay_listener2: Option<ListenerReqFunc<'_>>,
255 ) -> Result<()> { 428 ) -> Result<()> {
@@ -260,12 +433,24 @@ mod with_relays {
260 433
261 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 434 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
262 with_fresh_config(|| { 435 with_fresh_config(|| {
263 let mut p = CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC]); 436 let mut p = CliTester::new(["login"]);
437
438 p.expect_input(EXPECTED_NSEC_PROMPT)?
439 .succeeds_with(TEST_KEY_1_NSEC)?;
440
441 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
442 .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
443 .succeeds_with(TEST_PASSWORD)?;
264 444
265 p.expect("searching for your details...\r\n")?; 445 p.expect("searching for your details...\r\n")?;
266 p.expect("\r")?; 446 p.expect("\r")?;
447 p.expect(
448 "cannot find your account metadata (name, etc) on relays\r\n",
449 )?;
267 450
268 p.expect_end_with("logged in as fred\r\n")?; 451 p.expect_end_with(
452 format!("logged in as {TEST_KEY_1_NPUB}\r\n").as_str(),
453 )?;
269 for p in [51, 52] { 454 for p in [51, 52] {
270 shutdown_relay(8000 + p)?; 455 shutdown_relay(8000 + p)?;
271 } 456 }
@@ -280,22 +465,20 @@ mod with_relays {
280 Ok(()) 465 Ok(())
281 } 466 }
282 } 467 }
283 mod when_specifying_command_line_password_only { 468
469 mod when_metadata_but_no_relay_list_found {
284 use super::*; 470 use super::*;
285 471
286 #[test] 472 #[test]
287 #[serial] 473 #[serial]
288 fn displays_correct_name() -> Result<()> { 474 fn warm_user_and_displays_name() -> Result<()> {
289 futures::executor::block_on( 475 futures::executor::block_on(
290 run_test_when_specifying_command_line_password_only_displays_correct_name( 476 run_test_when_no_relay_list_found_warns_user_and_uses_npub(
291 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 477 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
292 relay.respond_events( 478 relay.respond_events(
293 client_id, 479 client_id,
294 &subscription_id, 480 &subscription_id,
295 &vec![ 481 &vec![generate_test_key_1_metadata_event("fred")],
296 generate_test_key_1_metadata_event("fred"),
297 generate_test_key_1_relay_list_event(),
298 ],
299 )?; 482 )?;
300 Ok(()) 483 Ok(())
301 }), 484 }),
@@ -303,7 +486,8 @@ mod with_relays {
303 ), 486 ),
304 ) 487 )
305 } 488 }
306 async fn run_test_when_specifying_command_line_password_only_displays_correct_name( 489
490 async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub(
307 relay_listener1: Option<ListenerReqFunc<'_>>, 491 relay_listener1: Option<ListenerReqFunc<'_>>,
308 relay_listener2: Option<ListenerReqFunc<'_>>, 492 relay_listener2: Option<ListenerReqFunc<'_>>,
309 ) -> Result<()> { 493 ) -> Result<()> {
@@ -314,20 +498,18 @@ mod with_relays {
314 498
315 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 499 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
316 with_fresh_config(|| { 500 with_fresh_config(|| {
317 CliTester::new([ 501 let mut p = CliTester::new(["login"]);
318 "login",
319 "--offline",
320 "--nsec",
321 TEST_KEY_1_NSEC,
322 "--password",
323 TEST_PASSWORD,
324 ])
325 .expect_end_eventually()?;
326 502
327 let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]); 503 p.expect_input(EXPECTED_NSEC_PROMPT)?
504 .succeeds_with(TEST_KEY_1_NSEC)?;
505
506 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
507 .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
508 .succeeds_with(TEST_PASSWORD)?;
328 509
329 p.expect("searching for your details...\r\n")?; 510 p.expect("searching for your details...\r\n")?;
330 p.expect("\r")?; 511 p.expect("\r")?;
512 p.expect("cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience.\r\n")?;
331 513
332 p.expect_end_with("logged in as fred\r\n")?; 514 p.expect_end_with("logged in as fred\r\n")?;
333 for p in [51, 52] { 515 for p in [51, 52] {
@@ -344,37 +526,42 @@ mod with_relays {
344 Ok(()) 526 Ok(())
345 } 527 }
346 } 528 }
529 }
530
531 mod when_second_time_login_and_details_already_fetched {
532 use super::*;
533
534 // TODO: the following two tests would require a fake config file or
535 // fake time
536 // - uses_relays_from_user_relay_list
537 // - dislays_correct_name - when_local_metadata_is_the_most_recent
347 538
348 mod when_specifying_command_line_nsec_and_password { 539 mod uses_cache {
349 use super::*; 540 use super::*;
350 541
351 #[test] 542 #[test]
352 #[serial] 543 #[serial]
353 fn displays_correct_name() -> Result<()> { 544 fn dislays_logged_in_with_correct_name() -> Result<()> {
354 futures::executor::block_on( 545 futures::executor::block_on(run_test_dislays_logged_in_with_correct_name(Some(
355 run_test_when_specifying_command_line_nsec_and_password_displays_correct_name( 546 &|relay, client_id, subscription_id, _| -> Result<()> {
356 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 547 relay.respond_events(
357 relay.respond_events( 548 client_id,
358 client_id, 549 &subscription_id,
359 &subscription_id, 550 &vec![
360 &vec![ 551 generate_test_key_1_metadata_event("fred"),
361 generate_test_key_1_metadata_event("fred"), 552 generate_test_key_1_relay_list_event_same_as_fallback(),
362 generate_test_key_1_relay_list_event(), 553 ],
363 ], 554 )?;
364 )?; 555 Ok(())
365 Ok(()) 556 },
366 }), 557 )))
367 None,
368 ),
369 )
370 } 558 }
371 async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name( 559 async fn run_test_dislays_logged_in_with_correct_name(
372 relay_listener1: Option<ListenerReqFunc<'_>>, 560 relay_listener: Option<ListenerReqFunc<'_>>,
373 relay_listener2: Option<ListenerReqFunc<'_>>,
374 ) -> Result<()> { 561 ) -> Result<()> {
375 let (mut r51, mut r52) = ( 562 let (mut r51, mut r52) = (
376 Relay::new(8051, None, relay_listener1), 563 Relay::new(8051, None, relay_listener),
377 Relay::new(8052, None, relay_listener2), 564 Relay::new(8052, None, None),
378 ); 565 );
379 566
380 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 567 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
@@ -387,13 +574,19 @@ mod with_relays {
387 TEST_PASSWORD, 574 TEST_PASSWORD,
388 ]); 575 ]);
389 576
390 p.expect("searching for your details...\r\n")?; 577 p.expect_end_eventually_with("logged in as fred\r\n")?;
391 p.expect("\r")?;
392 578
393 p.expect_end_with("logged in as fred\r\n")?;
394 for p in [51, 52] { 579 for p in [51, 52] {
395 shutdown_relay(8000 + p)?; 580 shutdown_relay(8000 + p)?;
396 } 581 }
582
583 let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
584
585 p.expect("searching for your details...\r\n")?;
586 p.expect("\r")?;
587
588 p.expect_end_eventually_with("logged in as fred\r\n")?;
589
397 Ok(()) 590 Ok(())
398 }) 591 })
399 }); 592 });
@@ -402,90 +595,25 @@ mod with_relays {
402 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),); 595 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
403 596
404 cli_tester_handle.join().unwrap()?; 597 cli_tester_handle.join().unwrap()?;
598
405 Ok(()) 599 Ok(())
406 } 600 }
407 } 601 }
408 } 602 }
409 603 }
410 mod when_no_metadata_found { 604 mod when_user_relay_list_contains_write_relays_not_in_fallback_list {
411 use super::*; 605 use super::*;
412 606 mod when_latest_metadata_not_on_fallback_relays_only_on_relays_in_user_list {
413 #[test]
414 #[serial]
415 fn warm_user_and_displays_npub() -> Result<()> {
416 futures::executor::block_on(
417 run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None),
418 )
419 }
420
421 async fn run_test_when_no_metadata_found_warns_user_and_uses_npub(
422 relay_listener1: Option<ListenerReqFunc<'_>>,
423 relay_listener2: Option<ListenerReqFunc<'_>>,
424 ) -> Result<()> {
425 let (mut r51, mut r52) = (
426 Relay::new(8051, None, relay_listener1),
427 Relay::new(8052, None, relay_listener2),
428 );
429
430 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
431 with_fresh_config(|| {
432 let mut p = CliTester::new(["login"]);
433
434 p.expect_input(EXPECTED_NSEC_PROMPT)?
435 .succeeds_with(TEST_KEY_1_NSEC)?;
436
437 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
438 .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
439 .succeeds_with(TEST_PASSWORD)?;
440
441 p.expect("searching for your details...\r\n")?;
442 p.expect("\r")?;
443 p.expect("cannot find your account metadata (name, etc) on relays\r\n")?;
444
445 p.expect_end_with(format!("logged in as {TEST_KEY_1_NPUB}\r\n").as_str())?;
446 for p in [51, 52] {
447 shutdown_relay(8000 + p)?;
448 }
449 Ok(())
450 })
451 });
452
453 // launch relay
454 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
455
456 cli_tester_handle.join().unwrap()?;
457 Ok(())
458 }
459 }
460
461 mod when_metadata_but_no_relay_list_found {
462 use super::*; 607 use super::*;
463 608 async fn run_test_displays_correct_name(
464 #[test]
465 #[serial]
466 fn warm_user_and_displays_name() -> Result<()> {
467 futures::executor::block_on(
468 run_test_when_no_relay_list_found_warns_user_and_uses_npub(
469 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
470 relay.respond_events(
471 client_id,
472 &subscription_id,
473 &vec![generate_test_key_1_metadata_event("fred")],
474 )?;
475 Ok(())
476 }),
477 None,
478 ),
479 )
480 }
481
482 async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub(
483 relay_listener1: Option<ListenerReqFunc<'_>>, 609 relay_listener1: Option<ListenerReqFunc<'_>>,
484 relay_listener2: Option<ListenerReqFunc<'_>>, 610 relay_listener2: Option<ListenerReqFunc<'_>>,
485 ) -> Result<()> { 611 ) -> Result<()> {
486 let (mut r51, mut r52) = ( 612 let (mut r51, mut r52, mut r53, mut r55) = (
487 Relay::new(8051, None, relay_listener1), 613 Relay::new(8051, None, relay_listener1),
488 Relay::new(8052, None, relay_listener2), 614 Relay::new(8052, None, None),
615 Relay::new(8053, None, relay_listener2),
616 Relay::new(8055, None, None),
489 ); 617 );
490 618
491 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 619 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
@@ -501,10 +629,9 @@ mod with_relays {
501 629
502 p.expect("searching for your details...\r\n")?; 630 p.expect("searching for your details...\r\n")?;
503 p.expect("\r")?; 631 p.expect("\r")?;
504 p.expect("cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience.\r\n")?;
505 632
506 p.expect_end_with("logged in as fred\r\n")?; 633 p.expect_end_with("logged in as fred\r\n")?;
507 for p in [51, 52] { 634 for p in [51, 52, 53, 55] {
508 shutdown_relay(8000 + p)?; 635 shutdown_relay(8000 + p)?;
509 } 636 }
510 Ok(()) 637 Ok(())
@@ -512,83 +639,45 @@ mod with_relays {
512 }); 639 });
513 640
514 // launch relay 641 // launch relay
515 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),); 642 let _ = join!(
643 r51.listen_until_close(),
644 r52.listen_until_close(),
645 r53.listen_until_close(),
646 r55.listen_until_close(),
647 );
516 648
517 cli_tester_handle.join().unwrap()?; 649 cli_tester_handle.join().unwrap()?;
518 Ok(()) 650 Ok(())
519 } 651 }
520 }
521 }
522
523 mod when_second_time_login_and_details_already_fetched {
524 use super::*;
525
526 // TODO: the following two tests would require a fake config file or
527 // fake time
528 // - uses_relays_from_user_relay_list
529 // - dislays_correct_name - when_local_metadata_is_the_most_recent
530
531 mod uses_cache {
532 use super::*;
533 652
653 /// this also tests that additional relays are queried
534 #[test] 654 #[test]
535 #[serial] 655 #[serial]
536 fn dislays_logged_in_with_correct_name() -> Result<()> { 656 fn displays_correct_name() -> Result<()> {
537 futures::executor::block_on(run_test_dislays_logged_in_with_correct_name(Some( 657 futures::executor::block_on(run_test_displays_correct_name(
538 &|relay, client_id, subscription_id, _| -> Result<()> { 658 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
539 relay.respond_events( 659 relay.respond_events(
540 client_id, 660 client_id,
541 &subscription_id, 661 &subscription_id,
542 &vec![ 662 &vec![
543 generate_test_key_1_metadata_event("fred"), 663 generate_test_key_1_metadata_event_old("Fred"),
544 generate_test_key_1_relay_list_event(), 664 generate_test_key_1_relay_list_event(),
545 ], 665 ],
546 )?; 666 )?;
547 Ok(()) 667 Ok(())
548 }, 668 }),
549 ))) 669 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
550 } 670 relay.respond_events(
551 async fn run_test_dislays_logged_in_with_correct_name( 671 client_id,
552 relay_listener: Option<ListenerReqFunc<'_>>, 672 &subscription_id,
553 ) -> Result<()> { 673 &vec![
554 let (mut r51, mut r52) = ( 674 generate_test_key_1_metadata_event("fred"),
555 Relay::new(8051, None, relay_listener), 675 generate_test_key_1_relay_list_event(),
556 Relay::new(8052, None, None), 676 ],
557 ); 677 )?;
558
559 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
560 with_fresh_config(|| {
561 let mut p = CliTester::new([
562 "login",
563 "--nsec",
564 TEST_KEY_1_NSEC,
565 "--password",
566 TEST_PASSWORD,
567 ]);
568
569 p.expect_end_eventually_with("logged in as fred\r\n")?;
570
571 for p in [51, 52] {
572 shutdown_relay(8000 + p)?;
573 }
574
575 let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
576
577 p.expect("searching for your details...\r\n")?;
578 p.expect("\r")?;
579
580 p.expect_end_eventually_with("logged in as fred\r\n")?;
581
582 Ok(()) 678 Ok(())
583 }) 679 }),
584 }); 680 ))
585
586 // launch relay
587 let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
588
589 cli_tester_handle.join().unwrap()?;
590
591 Ok(())
592 } 681 }
593 } 682 }
594 } 683 }
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 06:42:34 +0000