fn record_replay_integration()

in below/src/test.rs [26:113]

• 76 lines of code
• 1 McCabe index (conditional complexity)

fn record_replay_integration() {
    let logger = get_logger();
    let dir = TempDir::new("below_record_replay_test").expect("tempdir failed");
    let mut store = store::StoreWriter::new(
        logger.clone(),
        &dir,
        CompressionMode::ZstdDictionary(ChunkSizePo2(2)),
        store::Format::Cbor,
    )
    .expect("Failed to create store");

    // Collect a sample
    let sample = Collector::new(
        logger.clone(),
        /* collector_options */ Default::default(),
    )
    .collect_sample()
    .expect("failed to collect sample");

    // Validate some data in the sample
    sample
        .cgroup
        .pressure
        .as_ref()
        .expect("missing memory.pressure")
        .memory
        .full
        .total
        .as_ref()
        .expect("missing memory.pressure.total");
    let nr_procs = sample.processes.len();
    let hostname = sample.system.hostname.clone();
    let proc0_cgroup = sample
        .processes
        .iter()
        .next()
        .expect("unable to iter")
        .1
        .cgroup
        .clone();
    assert!(nr_procs > 0);
    assert!(!hostname.is_empty());
    assert!(!proc0_cgroup.is_empty());

    // Store two copies of the same sample so the model can generate
    // all the delta fields. Use the same sample twice so we can predict
    // what the deltas will be (0).
    let timestamp = 554433;
    let unix_ts = UNIX_EPOCH + Duration::from_secs(timestamp);
    let df = DataFrame { sample };
    store.put(unix_ts, &df).expect("failed to store sample");
    store
        .put(unix_ts + Duration::from_secs(1), &df)
        .expect("Failed to store second sample");

    // Restore the first sample
    let mut advance = new_advance_local(get_logger(), dir.as_ref().to_path_buf(), unix_ts);
    advance.initialize();
    let restored_sample = advance
        .advance(store::Direction::Forward)
        .expect("failed to get advanced data");

    // Validate some values in restored sample
    restored_sample
        .cgroup
        .data
        .io_total
        .as_ref()
        .expect("missing io.stat")
        .rbytes_per_sec
        .as_ref()
        .expect("missing io stat read bytes per second");
    assert!(restored_sample.process.processes.len() == nr_procs);
    assert!(restored_sample.system.hostname == hostname);
    assert!(
        restored_sample
            .process
            .processes
            .iter()
            .next()
            .expect("unable to iter")
            .1
            .cgroup
            .as_ref()
            .expect("missing process cgroup")
            == &proc0_cgroup
    );
}