Function test_response_clone_error

modules/llrt_fetch/src/response.rs:1367–1413

()

    #[tokio::test]
    async fn test_response_clone_error() {
        let mock_server = MockServer::start().await;

        Mock::given(matchers::path("some-path/"))
            .respond_with(ResponseTemplate::new(200).set_body_string("Hello".to_string()))
            .mount(&mock_server)
            .await;

        test_async_with_opts(
            |ctx| {
                llrt_stream_web::init(&ctx).unwrap();
                crate::init(&ctx).unwrap();
                Box::pin(async move {
                    let globals = ctx.globals();
                    let run = async {
                        let fetch: Function = globals.get("fetch")?;
                        let options = Object::new(ctx.clone())?;
                        options.set("method", "GET")?;
                        let url = format!("http://{}/some-path/", mock_server.address().clone());

                        let response_promise: Promise = fetch.call((url, options.clone()))?;
                        let response: Class<Response> = response_promise.into_future().await?;

                        // Cloning a response with unconsumed Incoming body should work via tee
                        let cloned = response.borrow().clone(ctx.clone())?;
                        let cloned = Class::instance(ctx.clone(), cloned)?;
                        let text1: String = Response::text(This(response.clone()), ctx.clone())?
                            .into_future()
                            .await?;
                        let text2: String = Response::text(This(cloned), ctx.clone())?
                            .into_future()
                            .await?;
                        assert_eq!(text1, "Hello");
                        assert_eq!(text2, "Hello");

                        // Cloning after body is consumed should fail
                        let clone_result = response.borrow().clone(ctx.clone());
                        assert!(clone_result.is_err());
                        Ok(())
                    };
                    run.await.catch(&ctx).unwrap();
                })
            },
            TestOptions::new().no_pending_jobs(),
        )
        .await;
    }

    #[tokio::test]
    async fn test_response_compressed_body_stream() {