Additional tests for SSE (client side)

[touilleMan]

Basic tests for SSE already exists:

parsec-cloud/oxidation/libparsec/crates/client_connection/tests/cmds.rs

Lines 66 to 161 in 76f06a1

	#[parsec_test(testbed = "coolorg", with_server)]
	async fn authenticated_sse(env: &TestbedEnv) {
	let alice = env.local_device("alice@dev1".parse().unwrap());
	let bob = env.local_device("bob@dev1".parse().unwrap());
	let cmds_alice =
	AuthenticatedCmds::new(&env.discriminant_dir, alice.clone(), ProxyConfig::default())
	.unwrap();
	let cmds_bob =
	AuthenticatedCmds::new(&env.discriminant_dir, bob.clone(), ProxyConfig::default()).unwrap();
	let send_ping = |msg: &str| {
	let msg = msg.to_owned();
	async {
	let rep = cmds_bob
	.send(authenticated_cmds::ping::Req { ping: msg })
	.await;
	assert!(matches!(
	rep.unwrap(),
	authenticated_cmds::ping::Rep::Ok { .. }
	));
	}
	};
	// Request sent before sse started, will be ignored
	send_ping("too soon").await;
	// Start the sse...
	let mut sse = cmds_alice
	.start_sse_and_wait_for_connection::<authenticated_cmds::events_listen::Req>()
	.await
	.unwrap();
	// Now event are received !
	send_ping("good 1").await;
	p_assert_eq!(
	sse.next().await.unwrap(),
	SSEResponseOrMissedEvents::Response(authenticated_cmds::events_listen::Rep::Ok(
	authenticated_cmds::events_listen::APIEvent::Pinged {
	ping: "good 1".to_owned()
	}
	))
	);
	// Also try to enqueue multiple events
	send_ping("good 2").await;
	send_ping("good 3").await;
	send_ping("good 4").await;
	p_assert_eq!(
	sse.next().await.unwrap(),
	SSEResponseOrMissedEvents::Response(authenticated_cmds::events_listen::Rep::Ok(
	authenticated_cmds::events_listen::APIEvent::Pinged {
	ping: "good 2".to_owned()
	}
	))
	);
	p_assert_eq!(
	sse.next().await.unwrap(),
	SSEResponseOrMissedEvents::Response(authenticated_cmds::events_listen::Rep::Ok(
	authenticated_cmds::events_listen::APIEvent::Pinged {
	ping: "good 3".to_owned()
	}
	))
	);
	p_assert_eq!(
	sse.next().await.unwrap(),
	SSEResponseOrMissedEvents::Response(authenticated_cmds::events_listen::Rep::Ok(
	authenticated_cmds::events_listen::APIEvent::Pinged {
	ping: "good 4".to_owned()
	}
	))
	);
	sse.close();
	// Bad request: invalid signature
	let bad_alice = {
	let mut bad_alice = (*alice).clone();
	bad_alice.signing_key = SigningKey::generate();
	Arc::new(bad_alice)
	};
	let cmds_bad_alice =
	AuthenticatedCmds::new(&env.discriminant_dir, bad_alice, ProxyConfig::default()).unwrap();
	let mut sse = cmds_bad_alice.start_sse::<authenticated_cmds::events_listen::Req>();
	let rep = sse.next().await;
	assert!(
	matches!(
	rep,
	Err(ConnectionError::InvalidResponseStatus(
	reqwest::StatusCode::UNAUTHORIZED
	))
	),
	r#"expected `InvalidResponseStatus` with code 401, but got {rep:?}"#
	);
	}

Additional tests we want:

• SSE Client: Test the missed_events mechanism

  The server can send a special SSE message missed_events that should trigger a special SSE response type in the client.

• SSE Client: Test the last-event-id mechanism works when connection disconnects #5511

  The client is connected with the client, if it loses connection it should send a last-event-id header when reconnecting.
  If events has occurred since then, the server push the events the client has missed.

However those tests are a bit tedious to write:

• We want to test errors behavior, so the testbed server cannot be used.
• We want to test the whole SSE machinery, including the 3rd party libs that implement SSE protocol.
  So we cannot use the testbed mock system.

So there is two solutions to implemented those tests:

1. Modify the testbed server to be able to notify it when it should voluntarily close the client connection to simulate loss of connection.

2. Start our own dummy HTTP server and serve SSE payloads

   We used to have an implementation of such code,
   but it got replaced by the use of the testbed server. Guess it's time for it to return \o/.

Solution 2 seems the cleaner and less painful way to go (given for testing the last-event-id system, we want).