fn test_set_config_should_handle_default_engines()

in components/search/src/selector.rs [1335:1543]

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

    fn test_set_config_should_handle_default_engines() {
        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": "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
                    }
                  }],
                },
                {
                  "recordType": "engine",
                  "identifier": "private-default-FR",
                  "base": {
                    "name": "Private default FR",
                    "classification": "general",
                    "urls": {
                      "search": {
                        "base": "https://example.com",
                        "method": "GET"
                      }
                    }
                  },
                  "variants": [{
                    "environment": {
                      "allRegionsAndLocales": true,
                    }
                  }],
                },
                {
                  "recordType": "defaultEngines",
                  "globalDefault": "test",
                  "specificDefaults": [{
                    "environment": {
                      "distributions": ["test-distro"],
                    },
                    "default": "distro-default"
                  }, {
                    "environment": {
                      "regions": ["fr"]
                    },
                    "defaultPrivate": "private-default-FR"
                  }]
                }
              ]
            })
            .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(),
            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 distro_default_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "distro-default".to_string(),
            name: "Distribution Default".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 private_default_fr_engine = SearchEngineDefinition {
            charset: "UTF-8".to_string(),
            classification: SearchEngineClassification::General,
            identifier: "private-default-FR".to_string(),
            name: "Private default FR".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 = Arc::clone(&selector).filter_engine_configuration(SearchUserEnvironment {
            distribution_id: "test-distro".to_string(),
            ..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(),
                    private_default_fr_engine.clone(),
                    test_engine.clone(),
                ],
                app_default_engine_id: Some("distro-default".to_string()),
                app_private_default_engine_id: None
            },
            "Should have selected the default engine for the matching specific default"
        );

        let result = Arc::clone(&selector).filter_engine_configuration(SearchUserEnvironment {
            region: "fr".into(),
            distribution_id: String::new(),
            ..Default::default()
        });
        assert!(
            result.is_ok(),
            "Should have filtered the configuration without error. {:?}",
            result
        );
        assert_eq!(
            result.unwrap(),
            RefinedSearchConfig {
                engines: vec![
                    test_engine,
                    private_default_fr_engine,
                    distro_default_engine,
                ],
                app_default_engine_id: Some("test".to_string()),
                app_private_default_engine_id: Some("private-default-FR".to_string())
            },
            "Should have selected the private default engine for the matching specific default"
        );
    }