fn test()

in aziotctl/aziotctl-common/src/config/apply.rs [682:765]
72 lines of code
4 McCabe index (conditional complexity)

    fn test() {
        let files_directory =
            std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/test-files/apply"));
        for entry in std::fs::read_dir(files_directory).unwrap() {
            let entry = entry.unwrap();
            if !entry.file_type().unwrap().is_dir() {
                continue;
            }

            let case_directory = entry.path();

            let test_name = case_directory.file_name().unwrap().to_str().unwrap();

            println!(".\n.\n=========\n.\nRunning test {test_name}");

            let config = std::fs::read(case_directory.join("config.toml")).unwrap();
            let config = std::str::from_utf8(&config).unwrap();
            let config: super_config::Config =
                toml::from_str(config).expect("could not parse config file");

            let expected_keyd_config = std::fs::read(case_directory.join("keyd.toml"))
                .expect("could not deserialize expected aziot-keyd config");
            let expected_certd_config = std::fs::read(case_directory.join("certd.toml"))
                .expect("could not deserialize expected aziot-certd config");
            let expected_identityd_config = std::fs::read(case_directory.join("identityd.toml"))
                .expect("could not deserialize expected aziot-identityd config");
            let expected_tpmd_config = std::fs::read(case_directory.join("tpmd.toml"))
                .expect("could not deserialize expected aziot-tpmd config");

            let expected_preloaded_device_id_pk_bytes =
                match std::fs::read(case_directory.join("device-id")) {
                    Ok(contents) => Some(contents),
                    Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
                    Err(err) => panic!("could not read device-id file: {err}"),
                };

            let aziotcs_uid = nix::unistd::Uid::from_raw(5555);
            let aziotid_uid = nix::unistd::Uid::from_raw(5556);

            let super::RunOutput {
                keyd_config: actual_keyd_config,
                certd_config: actual_certd_config,
                identityd_config: actual_identityd_config,
                tpmd_config: actual_tpmd_config,
                preloaded_device_id_pk_bytes: actual_preloaded_device_id_pk_bytes,
            } = super::run(config, aziotcs_uid, aziotid_uid).unwrap();

            let actual_keyd_config = toml::to_string(&actual_keyd_config)
                .expect("could not serialize actual aziot-keyd config");
            let actual_certd_config = toml::to_string(&actual_certd_config)
                .expect("could not serialize actual aziot-certd config");
            let actual_identityd_config = toml::to_string(&actual_identityd_config)
                .expect("could not serialize actual aziot-identityd config");
            let actual_tpmd_config = toml::to_string(&actual_tpmd_config)
                .expect("could not serialize actual aziot-tpmd config");

            // Convert the four configs to bytes::Bytes before asserting, because bytes::Bytes's Debug format prints strings.
            // It doesn't matter for the device ID file since it's binary anyway.
            assert_eq!(
                bytes::Bytes::from(expected_keyd_config),
                bytes::Bytes::from(actual_keyd_config),
                "keyd config does not match"
            );
            assert_eq!(
                bytes::Bytes::from(expected_certd_config),
                bytes::Bytes::from(actual_certd_config),
                "certd config does not match"
            );
            assert_eq!(
                bytes::Bytes::from(expected_identityd_config),
                bytes::Bytes::from(actual_identityd_config),
                "identityd config does not match"
            );
            assert_eq!(
                bytes::Bytes::from(expected_tpmd_config),
                bytes::Bytes::from(actual_tpmd_config),
                "tpmd config does not match"
            );
            assert_eq!(
                expected_preloaded_device_id_pk_bytes, actual_preloaded_device_id_pk_bytes,
                "device ID key bytes do not match"
            );
        }
    }