fn test_test_feature()

in components/support/nimbus-cli/src/main.rs [1160:1362]

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

    fn test_test_feature() -> Result<()> {
        let observed = get_commands_from_cli([
            "nimbus-cli",
            "--app",
            "fenix",
            "--channel",
            "developer",
            "test-feature",
            "my-feature",
            "./my-branch.json",
            "./my-treatment.json",
        ])?;

        let expected = vec![
            AppCommand::ValidateExperiment {
                params: fenix_params(),
                manifest: fenix_manifest(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
            },
            AppCommand::Kill { app: fenix() },
            AppCommand::Enroll {
                app: fenix(),
                params: fenix_params(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
                rollouts: Default::default(),
                branch: "my-branch".to_string(),
                preserve_targeting: false,
                preserve_bucketing: false,
                preserve_nimbus_db: false,
                open: Default::default(),
            },
        ];
        assert_eq!(expected, observed);

        // With a specific version of the manifest.
        let observed = get_commands_from_cli([
            "nimbus-cli",
            "--app",
            "fenix",
            "--channel",
            "developer",
            "test-feature",
            "my-feature",
            "./my-branch.json",
            "./my-treatment.json",
            "--version",
            "114",
        ])?;

        let expected = vec![
            AppCommand::ValidateExperiment {
                params: fenix_params(),
                manifest: fenix_old_manifest_with_ref("releases_v114"),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
            },
            AppCommand::Kill { app: fenix() },
            AppCommand::Enroll {
                app: fenix(),
                params: fenix_params(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
                rollouts: Default::default(),
                branch: "my-branch".to_string(),
                preserve_targeting: false,
                preserve_bucketing: false,
                preserve_nimbus_db: false,
                open: Default::default(),
            },
        ];
        assert_eq!(expected, observed);

        // With a specific version of the manifest, via a ref.
        let observed = get_commands_from_cli([
            "nimbus-cli",
            "--app",
            "fenix",
            "--channel",
            "developer",
            "test-feature",
            "my-feature",
            "./my-branch.json",
            "./my-treatment.json",
            "--ref",
            "my-tag",
        ])?;

        let expected = vec![
            AppCommand::ValidateExperiment {
                params: fenix_params(),
                manifest: fenix_manifest_with_ref("my-tag"),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
            },
            AppCommand::Kill { app: fenix() },
            AppCommand::Enroll {
                app: fenix(),
                params: fenix_params(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
                rollouts: Default::default(),
                branch: "my-branch".to_string(),
                preserve_targeting: false,
                preserve_bucketing: false,
                preserve_nimbus_db: false,
                open: Default::default(),
            },
        ];
        assert_eq!(expected, observed);

        // With a file on disk
        let observed = get_commands_from_cli([
            "nimbus-cli",
            "--app",
            "fenix",
            "--channel",
            "developer",
            "test-feature",
            "my-feature",
            "./my-branch.json",
            "./my-treatment.json",
            "--manifest",
            "./manifest.fml.yaml",
        ])?;

        let expected = vec![
            AppCommand::ValidateExperiment {
                params: fenix_params(),
                manifest: manifest_from_file("./manifest.fml.yaml"),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
            },
            AppCommand::Kill { app: fenix() },
            AppCommand::Enroll {
                app: fenix(),
                params: fenix_params(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
                rollouts: Default::default(),
                branch: "my-branch".to_string(),
                preserve_targeting: false,
                preserve_bucketing: false,
                preserve_nimbus_db: false,
                open: Default::default(),
            },
        ];
        assert_eq!(expected, observed);

        let observed = get_commands_from_cli([
            "nimbus-cli",
            "--app",
            "fenix",
            "--channel",
            "developer",
            "test-feature",
            "my-feature",
            "./my-branch.json",
            "./my-treatment.json",
            "--no-validate",
            "--deeplink",
            "host/path?key=value",
        ])?;

        let expected = vec![
            AppCommand::NoOp,
            AppCommand::Kill { app: fenix() },
            AppCommand::Enroll {
                app: fenix(),
                params: fenix_params(),
                experiment: feature_experiment(
                    "my-feature",
                    &["./my-branch.json", "./my-treatment.json"],
                ),
                rollouts: Default::default(),
                branch: "my-branch".to_string(),
                preserve_targeting: false,
                preserve_bucketing: false,
                preserve_nimbus_db: false,
                open: with_deeplink("host/path?key=value"),
            },
        ];
        assert_eq!(expected, observed);

        Ok(())
    }