fn test_filter_engine_configuration_negotiate_locales()

in components/search/src/selector.rs [2757:2906]

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

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

        let config_overrides_result = Arc::clone(&selector).set_config_overrides(
            json!({
              "data": [
                {
                  "identifier": "overrides-engine",
                  "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": []
                    }
                  }
                }
              ]
            })
            .to_string(),
        );
        let config_result = Arc::clone(&selector).set_search_config(
            json!({
              "data": [
                {
                    "recordType": "availableLocales",
                    "locales": ["de", "en-US"]
                },
                {
                  "recordType": "engine",
                  "identifier": "engine-de",
                  "base": {
                    "name": "German Engine",
                    "classification": "general",
                    "urls": {
                      "search": {
                        "base": "https://example.com",
                        "method": "GET",
                      }
                    }
                  },
                  "variants": [{
                    "environment": {
                      "locales": ["de"]
                    }
                  }],
                },
                {
                  "recordType": "engine",
                  "identifier": "engine-en-us",
                  "base": {
                    "name": "English US Engine",
                    "classification": "general",
                    "urls": {
                      "search": {
                        "base": "https://example.com",
                        "method": "GET"
                      }
                    }
                  },
                  "variants": [{
                    "environment": {
                      "locales": ["en-US"]
                    }
                  }],
                },
              ]
            })
            .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 de_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "engine-de".to_string(),
            name: "German Engine".to_string(),
            urls: SearchEngineUrls {
                search: SearchEngineUrl {
                    base: "https://example.com".to_string(),
                    method: "GET".to_string(),
                    params: Vec::new(),
                    search_term_param_name: None,
                },
                ..Default::default()
            },
            ..Default::default()
        };
        let en_us_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "engine-en-us".to_string(),
            name: "English US Engine".to_string(),
            urls: SearchEngineUrls {
                search: SearchEngineUrl {
                    base: "https://example.com".to_string(),
                    method: "GET".to_string(),
                    params: Vec::new(),
                    search_term_param_name: None,
                },
                ..Default::default()
            },
            ..Default::default()
        };

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

        assert_eq!(
            result_de.unwrap(),
            RefinedSearchConfig {
                engines: vec![de_engine,],
                app_default_engine_id: None,
                app_private_default_engine_id: None,
            },
            "Should have selected the de engine when given de-AT which is not an available locale"
        );

        let result_en = Arc::clone(&selector).filter_engine_configuration(SearchUserEnvironment {
            locale: "en-AU".to_string(),
            ..Default::default()
        });
        assert_eq!(
            result_en.unwrap(),
            RefinedSearchConfig {
                engines: vec![en_us_engine,],
                app_default_engine_id: None,
                app_private_default_engine_id: None,
            },
            "Should have selected the en-us engine when given another english locale we don't support"
        );
    }