Function test_get_header

tests/tests/pbs_get_header.rs:24–65

()

#[tokio::test]
async fn test_get_header() -> Result<()> {
    setup_test_env();
    let signer = random_secret();
    let pubkey = signer.public_key();

    let chain = Chain::Holesky;
    let pbs_port = 3200;
    let relay_port = pbs_port + 1;

    // Run a mock relay
    let mock_state = Arc::new(MockRelayState::new(chain, signer));
    let mock_relay = generate_mock_relay(relay_port, pubkey)?;
    tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port));

    // Run the PBS service
    let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), vec![mock_relay.clone()]);
    let state = PbsState::new(config);
    tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state));

    // leave some time to start servers
    tokio::time::sleep(Duration::from_millis(100)).await;

    let mock_validator = MockValidator::new(pbs_port)?;
    info!("Sending get header");
    let res = mock_validator.do_get_header(None).await?;
    assert_eq!(res.status(), StatusCode::OK);

    let res = serde_json::from_slice::<GetHeaderResponse>(&res.bytes().await?)?;

    assert_eq!(mock_state.received_get_header(), 1);
    assert_eq!(res.version, ForkName::Electra);
    assert_eq!(res.data.message.header().block_hash().0[0], 1);
    assert_eq!(res.data.message.header().parent_hash().0, B256::ZERO);
    assert_eq!(*res.data.message.value(), U256::from(10));
    assert_eq!(*res.data.message.pubkey(), BlsPublicKeyBytes::from(mock_state.signer.public_key()));
    assert_eq!(res.data.message.header().timestamp(), timestamp_of_slot_start_sec(0, chain));
    assert_eq!(
        res.data.signature,
        sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root())
    );
    Ok(())
}

#[tokio::test]
async fn test_get_header_returns_204_if_relay_down() -> Result<()> {