Function test_folder

avro/tests/shared.rs:99–155

(folder: &Path)

}

fn test_folder(folder: &Path) -> Result<(), ErrorsDesc> {
    let file_name = folder.join("schema.json");
    let content = std::fs::read_to_string(file_name).expect("Unable to find schema.json file");

    let schema: Schema = Schema::parse_str(content.as_str()).expect("Can't read schema");

    let data_path = folder.join("data.avro");
    let mut result = Ok(());
    if !data_path.exists() {
        log::error!("folder {folder:?} does not exist");
        return Err(ErrorsDesc::new(
            format!("folder {folder:?} does not exist").as_str(),
        ));
    } else {
        let file: File = File::open(data_path).expect("Can't open data.avro");
        let reader = Reader::builder(BufReader::new(&file))
            .reader_schema(&schema)
            .build()
            .expect("Can't read data.avro");

        let mut writer = Writer::with_codec(&schema, Vec::new(), Codec::Null).unwrap();

        let mut records: Vec<Value> = vec![];

        for r in reader {
            let record: Value = r.expect("Error on reading");
            writer
                .append_value(record.clone())
                .expect("Error on write item");
            records.push(record);
        }

        writer.flush().expect("Error on flush");
        let bytes: Vec<u8> = writer.into_inner().unwrap();
        let reader_bis = Reader::builder(&bytes[..])
            .reader_schema(&schema)
            .build()
            .expect("Can't read flushed vector");

        let mut records_iter: Iter<Value> = records.iter();
        for r2 in reader_bis {
            let record: Value = r2.expect("Error on reading");
            let original = records_iter.next().expect("Error, no next");
            if original != &record {
                result = match result {
                    Ok(_) => Result::Err(ErrorsDesc::new(
                        format!("Records are not equals for folder : {folder:?}").as_str(),
                    )),
                    Err(e) => Err(
                        e.add(format!("Records are not equals for folder : {folder:?}").as_str())
                    ),
                }
            }
        }
    }
    result
}