fn test_configuration_overrides_applied()

in components/search/src/selector.rs [2599:2754]

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

    fn test_configuration_overrides_applied() {
        let selector = Arc::new(SearchEngineSelector::new());

        let config_overrides_result = Arc::clone(&selector).set_config_overrides(
            json!({
              "data": [
                {
                  "identifier": "test",
                  "partnerCode": "overrides-partner-code",
                  "clickUrl": "https://example.com/click-url",
                  "telemetrySuffix": "overrides-telemetry-suffix",
                  "urls": {
                    "search": {
                      "base": "https://example.com/search-overrides",
                      "method": "GET",
                        "params": [{
                          "name": "overrides-name",
                          "value": "overrides-value",
                        }],
                    }
                  },
                },
                { // Test partial override with some missing fields
                  "identifier": "distro-default",
                  "partnerCode": "distro-overrides-partner-code",
                  "clickUrl": "https://example.com/click-url-distro",
                  "urls": {
                    "search": {
                      "base": "https://example.com/search-distro",
                    },
                  },
                }
              ]
            })
            .to_string(),
        );
        let config_result = Arc::clone(&selector).set_search_config(
            json!({
              "data": [
                {
                  "recordType": "engine",
                  "identifier": "test",
                  "base": {
                    "name": "Test",
                    "classification": "general",
                    "urls": {
                      "search": {
                        "base": "https://example.com",
                        "method": "GET",
                      }
                    }
                  },
                  "variants": [{
                    "environment": {
                      "allRegionsAndLocales": true
                    }
                  }],
                },
                {
                  "recordType": "engine",
                  "identifier": "distro-default",
                  "base": {
                    "name": "Distribution Default",
                    "classification": "general",
                    "urls": {
                      "search": {
                        "base": "https://example.com",
                        "method": "GET"
                      }
                    }
                  },
                  "variants": [{
                    "environment": {
                      "allRegionsAndLocales": true
                    },
                    "telemetrySuffix": "distro-telemetry-suffix",
                  }],
                },
              ]
            })
            .to_string(),
        );
        assert!(
            config_result.is_ok(),
            "Should have set the configuration successfully. {:?}",
            config_result
        );
        assert!(
            config_overrides_result.is_ok(),
            "Should have set the configuration overrides successfully. {:?}",
            config_overrides_result
        );

        let test_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "test".to_string(),
            name: "Test".to_string(),
            partner_code: "overrides-partner-code".to_string(),
            telemetry_suffix: "overrides-telemetry-suffix".to_string(),
            click_url: Some("https://example.com/click-url".to_string()),
            urls: SearchEngineUrls {
                search: SearchEngineUrl {
                    base: "https://example.com/search-overrides".to_string(),
                    method: "GET".to_string(),
                    params: vec![SearchUrlParam {
                        name: "overrides-name".to_string(),
                        value: Some("overrides-value".to_string()),
                        enterprise_value: None,
                        experiment_config: None,
                    }],
                    search_term_param_name: None,
                },
                ..Default::default()
            },
            ..Default::default()
        };
        let distro_default_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "distro-default".to_string(),
            name: "Distribution Default".to_string(),
            partner_code: "distro-overrides-partner-code".to_string(),
            telemetry_suffix: "distro-telemetry-suffix".to_string(),
            click_url: Some("https://example.com/click-url-distro".to_string()),
            urls: SearchEngineUrls {
                search: SearchEngineUrl {
                    base: "https://example.com/search-distro".to_string(),
                    method: "GET".to_string(),
                    params: Vec::new(),
                    search_term_param_name: None,
                },
                ..Default::default()
            },
            ..Default::default()
        };

        let result = Arc::clone(&selector).filter_engine_configuration(SearchUserEnvironment {
            ..Default::default()
        });
        assert!(
            result.is_ok(),
            "Should have filtered the configuration without error. {:?}",
            result
        );

        assert_eq!(
            result.unwrap(),
            RefinedSearchConfig {
                engines: vec![distro_default_engine.clone(), test_engine.clone(),],
                app_default_engine_id: None,
                app_private_default_engine_id: None
            },
            "Should have applied the overrides to the matching engine."
        );
    }