Revision control
Copy as Markdown
use crate::{
JSONEngineBase, JSONEngineMethod, JSONEngineUrl, JSONEngineUrls, JSONEngineVariant,
JSONVariantEnvironment, SearchEngineClassification, SearchEngineDefinition, SearchEngineUrl,
SearchEngineUrls, SearchUrlParam,
};
use serde_json::{json, Value};
#[cfg(test)]
pub struct EngineRecord {
record_type: String,
identifier: String,
name: String,
classification: String,
urls: Value,
variants: Vec<Value>,
partner_code: String,
// Remote Settings metadata
id: Option<String>,
schema: Option<i64>,
last_modified: Option<i64>,
}
#[cfg(test)]
impl EngineRecord {
pub fn full(identifier: &str, name: &str) -> Self {
Self {
record_type: "engine".to_string(),
identifier: identifier.to_string(),
name: name.to_string(),
classification: "general".to_string(),
partner_code: "partner-code".to_string(),
urls: json!({
"search": {
"method": "GET",
"params": [{
"name": "search-name",
"enterpriseValue": "enterprise-value",
}],
"searchTermParamName": "q",
},
"suggestions": {
"method": "POST",
"params": [{
"name": "suggestion-name",
"value": "suggestion-value",
}],
"searchTermParamName": "suggest",
},
"trending": {
"method": "GET",
"params": [{
"name": "trending-name",
"experimentConfig": "trending-experiment-value",
}],
},
"searchForm": {
"method": "GET",
"params": [{
"name": "search-form-name",
"value": "search-form-value",
}],
},
"visualSearch": {
"method": "GET",
"params": [{
"name": "visual-search-name",
"value": "visual-search-value",
}],
"searchTermParamName": "url",
},
}),
variants: vec![json!({
"environment": {
"allRegionsAndLocales": true,
}
})],
// Remote Settings metadata
id: None,
schema: None,
last_modified: None,
}
}
pub fn minimal(identifier: &str, name: &str) -> Self {
Self {
record_type: "engine".to_string(),
identifier: identifier.to_string(),
name: name.to_string(),
classification: "general".to_string(),
partner_code: "partner-code".to_string(),
urls: json!({
"search": {
"method": "GET",
"searchTermParamName": "search",
},
}),
variants: vec![json!({
"environment": {
"allRegionsAndLocales": true,
}
})],
// Remote Settings metadata
id: None,
schema: None,
last_modified: None,
}
}
pub fn build(self) -> Value {
let mut record = json!({
"recordType": self.record_type,
"identifier": self.identifier,
"base": {
"name": self.name,
"classification": self.classification,
"partnerCode": self.partner_code,
"urls": self.urls,
},
"variants": self.variants,
});
if let Some(id) = self.id {
record["id"] = json!(id);
}
if let Some(schema) = self.schema {
record["schema"] = json!(schema);
}
if let Some(last_modified) = self.last_modified {
record["last_modified"] = json!(last_modified);
}
record
}
pub fn add_variant(mut self, vb: Variant) -> Self {
self.variants.push(vb.build());
self
}
pub fn override_variants(mut self, vb: Variant) -> Self {
self.variants = vec![vb.build()];
self
}
// Remote Settings metadata
pub fn id(mut self, id: &str) -> Self {
self.id = Some(id.to_string());
self
}
pub fn schema(mut self, schema: i64) -> Self {
self.schema = Some(schema);
self
}
pub fn last_modified(mut self, last_modified: i64) -> Self {
self.last_modified = Some(last_modified);
self
}
}
#[cfg(test)]
pub struct Variant {
env: Value,
urls: Option<Value>,
partner_code: Option<String>,
telemetry_suffix: Option<String>,
optional: Option<bool>,
subvariants: Vec<Value>,
}
#[cfg(test)]
impl Variant {
pub fn new() -> Self {
Self {
env: json!({}),
urls: None,
partner_code: None,
telemetry_suffix: None,
optional: None,
subvariants: vec![],
}
}
pub fn all_regions_and_locales(mut self) -> Self {
self.env["allRegionsAndLocales"] = serde_json::Value::Bool(true);
self
}
pub fn regions(mut self, regions: &[&str]) -> Self {
self.env["regions"] = json!(regions);
self
}
pub fn locales(mut self, locales: &[&str]) -> Self {
self.env["locales"] = json!(locales);
self
}
pub fn applications(mut self, applications: &[&str]) -> Self {
self.env["applications"] = json!(applications);
self
}
pub fn distributions(mut self, distributions: &[&str]) -> Self {
self.env["distributions"] = json!(distributions);
self
}
pub fn partner_code(mut self, code: &str) -> Self {
self.partner_code = Some(code.to_string());
self
}
pub fn telemetry_suffix(mut self, suffix: &str) -> Self {
self.telemetry_suffix = Some(suffix.to_string());
self
}
pub fn optional(mut self, value: bool) -> Self {
self.optional = Some(value);
self
}
pub fn urls(mut self, urls: Value) -> Self {
self.urls = Some(urls);
self
}
pub fn add_subvariant(mut self, sv: SubVariant) -> Self {
self.subvariants.push(sv.build());
self
}
pub fn build(self) -> Value {
let mut variant = json!({ "environment": self.env });
if let Some(urls) = self.urls {
variant["urls"] = urls;
}
if let Some(partner_code) = self.partner_code {
variant["partnerCode"] = json!(partner_code);
}
if let Some(telemetry_suffix) = self.telemetry_suffix {
variant["telemetrySuffix"] = json!(telemetry_suffix);
}
if let Some(optional) = self.optional {
variant["optional"] = json!(optional);
}
if !self.subvariants.is_empty() {
variant["subVariants"] = json!(self.subvariants);
}
variant
}
}
#[cfg(test)]
pub struct SubVariant {
env: Value,
urls: Option<Value>,
partner_code: Option<String>,
telemetry_suffix: Option<String>,
optional: Option<bool>,
}
#[cfg(test)]
impl SubVariant {
pub fn new() -> Self {
Self {
env: json!({}),
urls: None,
partner_code: None,
telemetry_suffix: None,
optional: None,
}
}
pub fn locales(mut self, locales: &[&str]) -> Self {
self.env["locales"] = json!(locales);
self
}
pub fn partner_code(mut self, code: &str) -> Self {
self.partner_code = Some(code.to_string());
self
}
pub fn telemetry_suffix(mut self, suffix: &str) -> Self {
self.telemetry_suffix = Some(suffix.to_string());
self
}
pub fn urls(mut self, urls: Value) -> Self {
self.urls = Some(urls);
self
}
pub fn build(self) -> Value {
let mut subvariant = json!({ "environment": self.env });
if let Some(urls) = self.urls {
subvariant["urls"] = urls;
}
if let Some(partner_code) = self.partner_code {
subvariant["partnerCode"] = json!(partner_code);
}
if let Some(telemetry_suffix) = self.telemetry_suffix {
subvariant["telemetrySuffix"] = json!(telemetry_suffix);
}
if let Some(optional) = self.optional {
subvariant["optional"] = json!(optional);
}
subvariant
}
}
#[cfg(test)]
pub fn overrides_engine() -> Value {
json!({
"identifier": "overrides-engine",
"name": "Overrides Engine",
"partnerCode": "overrides-partner-code",
"telemetrySuffix": "overrides-telemetry-suffix",
"urls": {
"search": {
"method": "GET",
"params": [{
"name": "overrides-name",
"value": "overrides-value",
}],
}
}
})
}
#[cfg(test)]
pub struct ExpectedEngine {
engine: SearchEngineDefinition,
}
#[cfg(test)]
impl ExpectedEngine {
pub fn full(identifier: &str, name: &str) -> Self {
Self {
engine: Self::expected_full_engine(identifier, name),
}
}
pub fn minimal(identifier: &str, name: &str) -> Self {
Self {
engine: Self::expected_minimal_engine(identifier, name),
}
}
pub fn partner_code(mut self, code: &str) -> Self {
self.engine.partner_code = code.to_string();
self
}
pub fn telemetry_suffix(mut self, suffix: &str) -> Self {
self.engine.telemetry_suffix = suffix.to_string();
self
}
pub fn click_url(mut self, url: &str) -> Self {
self.engine.click_url = Some(url.to_string());
self
}
pub fn optional(mut self, value: bool) -> Self {
self.engine.optional = value;
self
}
pub fn search_method(mut self, method: &str) -> Self {
self.engine.urls.search.method = method.to_string();
self
}
pub fn search_base(mut self, base: &str) -> Self {
self.engine.urls.search.base = base.to_string();
self
}
pub fn search_term_param_name(mut self, param: &str) -> Self {
self.engine.urls.search.search_term_param_name = Some(param.to_string());
self
}
pub fn search_params(mut self, params: Vec<SearchUrlParam>) -> Self {
self.engine.urls.search.params = params;
self
}
pub fn build(self) -> SearchEngineDefinition {
self.engine
}
fn expected_full_engine(identifier: &str, name: &str) -> SearchEngineDefinition {
SearchEngineDefinition {
charset: "UTF-8".to_string(),
classification: SearchEngineClassification::General,
identifier: identifier.to_string(),
name: name.to_string(),
partner_code: "partner-code".to_string(),
urls: SearchEngineUrls {
search: SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "search-name".to_string(),
value: None,
enterprise_value: Some("enterprise-value".to_string()),
experiment_config: None,
}],
search_term_param_name: Some("q".to_string()),
..Default::default()
},
suggestions: Some(SearchEngineUrl {
method: "POST".to_string(),
params: vec![SearchUrlParam {
name: "suggestion-name".to_string(),
value: Some("suggestion-value".to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some("suggest".to_string()),
..Default::default()
}),
trending: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "trending-name".to_string(),
value: None,
enterprise_value: None,
experiment_config: Some("trending-experiment-value".to_string()),
}],
..Default::default()
}),
search_form: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "search-form-name".to_string(),
value: Some("search-form-value".to_string()),
experiment_config: None,
enterprise_value: None,
}],
..Default::default()
}),
visual_search: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "visual-search-name".to_string(),
value: Some("visual-search-value".to_string()),
experiment_config: None,
enterprise_value: None,
}],
search_term_param_name: Some("url".to_string()),
..Default::default()
}),
},
..Default::default()
}
}
fn expected_minimal_engine(identifier: &str, name: &str) -> SearchEngineDefinition {
SearchEngineDefinition {
aliases: Vec::new(),
charset: "UTF-8".to_string(),
classification: SearchEngineClassification::General,
identifier: identifier.to_string(),
is_new_until: None,
name: name.to_string(),
optional: false,
order_hint: None,
partner_code: "partner-code".to_string(),
telemetry_suffix: String::new(),
urls: SearchEngineUrls {
search: SearchEngineUrl {
search_term_param_name: Some("search".to_string()),
..Default::default()
},
suggestions: None,
trending: None,
search_form: None,
visual_search: None,
},
click_url: None,
}
}
}
#[cfg(test)]
use once_cell::sync::Lazy;
#[cfg(test)]
use std::collections::HashMap;
pub static JSON_ENGINE_BASE: Lazy<JSONEngineBase> = Lazy::new(|| JSONEngineBase {
aliases: Some(vec!["foo".to_string(), "bar".to_string()]),
charset: Some("ISO-8859-15".to_string()),
classification: SearchEngineClassification::Unknown,
name: "Test".to_string(),
partner_code: Some("firefox".to_string()),
urls: JSONEngineUrls {
search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Post),
params: Some(vec![
SearchUrlParam {
name: "param".to_string(),
value: Some("test param".to_string()),
enterprise_value: None,
experiment_config: None,
},
SearchUrlParam {
name: "enterprise-name".to_string(),
value: None,
enterprise_value: Some("enterprise-value".to_string()),
experiment_config: None,
},
]),
search_term_param_name: Some("baz".to_string()),
..Default::default()
}),
suggestions: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "suggest-name".to_string(),
value: None,
enterprise_value: None,
experiment_config: Some("suggest-experiment-value".to_string()),
}]),
search_term_param_name: Some("suggest".to_string()),
..Default::default()
}),
trending: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "trend-name".to_string(),
value: Some("trend-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
..Default::default()
}),
search_form: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "search-form-name".to_string(),
value: Some("search-form-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
..Default::default()
}),
visual_search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "visual-search-name".to_string(),
value: Some("visual-search-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("url".to_string()),
display_name_map: Some(HashMap::from([
// Default display name
("default".to_string(), "Visual Search".to_string()),
// en-GB locale with unique display name
("en-GB".to_string(), "Visual Search en-GB".to_string()),
])),
is_new_until: Some("2095-01-01".to_string()),
exclude_partner_code_from_telemetry: true,
accepted_content_types: Some(vec!["image/gif".to_string(), "image/jpeg".to_string()]),
}),
},
});
#[cfg(test)]
pub static JSON_ENGINE_VARIANT: Lazy<JSONEngineVariant> = Lazy::new(|| JSONEngineVariant {
environment: JSONVariantEnvironment {
all_regions_and_locales: true,
..Default::default()
},
is_new_until: Some("2063-04-05".to_string()),
optional: true,
partner_code: Some("trek".to_string()),
telemetry_suffix: Some("star".to_string()),
urls: Some(JSONEngineUrls {
search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "variant".to_string(),
value: Some("test variant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("ship".to_string()),
..Default::default()
}),
suggestions: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "suggest-variant".to_string(),
value: Some("sugg test variant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("variant".to_string()),
..Default::default()
}),
trending: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "trend-variant".to_string(),
value: Some("trend test variant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("trend".to_string()),
exclude_partner_code_from_telemetry: true,
..Default::default()
}),
search_form: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "search-form-name".to_string(),
value: Some("search-form-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
..Default::default()
}),
visual_search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "visual-search-variant-name".to_string(),
value: Some("visual-search-variant-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("url_variant".to_string()),
display_name_map: Some(HashMap::from([
("default".to_string(), "Visual Search Variant".to_string()),
(
"en-GB".to_string(),
"Visual Search Variant en-GB".to_string(),
),
])),
is_new_until: Some("2096-02-02".to_string()),
accepted_content_types: Some(vec!["image/png".to_string(), "image/jpeg".to_string()]),
..Default::default()
}),
}),
sub_variants: vec![],
});
#[cfg(test)]
pub static JSON_ENGINE_SUBVARIANT: Lazy<JSONEngineVariant> = Lazy::new(|| JSONEngineVariant {
environment: JSONVariantEnvironment {
all_regions_and_locales: true,
..Default::default()
},
is_new_until: Some("2063-04-05".to_string()),
optional: true,
partner_code: Some("trek2".to_string()),
telemetry_suffix: Some("star2".to_string()),
urls: Some(JSONEngineUrls {
search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "subvariant".to_string(),
value: Some("test subvariant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("shuttle".to_string()),
..Default::default()
}),
suggestions: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "suggest-subvariant".to_string(),
value: Some("sugg test subvariant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("subvariant".to_string()),
exclude_partner_code_from_telemetry: true,
..Default::default()
}),
trending: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "trend-subvariant".to_string(),
value: Some("trend test subvariant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("subtrend".to_string()),
..Default::default()
}),
search_form: Some(JSONEngineUrl {
method: Some(crate::JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "search-form-subvariant".to_string(),
value: Some("search form subvariant".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
..Default::default()
}),
visual_search: Some(JSONEngineUrl {
method: Some(JSONEngineMethod::Get),
params: Some(vec![SearchUrlParam {
name: "visual-search-subvariant-name".to_string(),
value: Some("visual-search-subvariant-value".to_string()),
enterprise_value: None,
experiment_config: None,
}]),
search_term_param_name: Some("url_subvariant".to_string()),
display_name_map: Some(HashMap::from([
(
"default".to_string(),
"Visual Search Subvariant".to_string(),
),
// en-GB locale with unique display name
(
"en-GB".to_string(),
"Visual Search Subvariant en-GB".to_string(),
),
])),
is_new_until: Some("2097-03-03".to_string()),
accepted_content_types: Some(vec!["image/jpeg".to_string(), "image/webp".to_string()]),
..Default::default()
}),
}),
sub_variants: vec![],
});
#[cfg(test)]
pub struct ExpectedEngineFromJSONBase {
engine: SearchEngineDefinition,
}
#[cfg(test)]
impl ExpectedEngineFromJSONBase {
pub fn new(identifier: &str, name: &str) -> Self {
Self {
engine: SearchEngineDefinition {
aliases: vec!["foo".to_string(), "bar".to_string()],
charset: "ISO-8859-15".to_string(),
classification: SearchEngineClassification::Unknown,
identifier: identifier.to_string(),
is_new_until: None,
partner_code: "firefox".to_string(),
name: name.to_string(),
optional: false,
order_hint: None,
telemetry_suffix: String::new(),
urls: SearchEngineUrls {
search: SearchEngineUrl {
method: "POST".to_string(),
params: vec![
SearchUrlParam {
name: "param".to_string(),
value: Some("test param".to_string()),
enterprise_value: None,
experiment_config: None,
},
SearchUrlParam {
name: "enterprise-name".to_string(),
value: None,
enterprise_value: Some("enterprise-value".to_string()),
experiment_config: None,
},
],
search_term_param_name: Some("baz".to_string()),
..Default::default()
},
suggestions: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "suggest-name".to_string(),
value: None,
enterprise_value: None,
experiment_config: Some("suggest-experiment-value".to_string()),
}],
search_term_param_name: Some("suggest".to_string()),
..Default::default()
}),
trending: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "trend-name".to_string(),
value: Some("trend-value".to_string()),
enterprise_value: None,
experiment_config: None,
}],
..Default::default()
}),
search_form: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "search-form-name".to_string(),
value: Some("search-form-value".to_string()),
enterprise_value: None,
experiment_config: None,
}],
..Default::default()
}),
visual_search: Some(SearchEngineUrl {
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: "visual-search-name".to_string(),
value: Some("visual-search-value".to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some("url".to_string()),
display_name: Some("Visual Search".to_string()),
is_new_until: Some("2095-01-01".to_string()),
exclude_partner_code_from_telemetry: true,
accepted_content_types: Some(vec![
"image/gif".to_string(),
"image/jpeg".to_string(),
]),
}),
},
click_url: None,
},
}
}
pub fn variant_is_new_until(mut self, date: &str) -> Self {
self.engine.is_new_until = Some(date.to_string());
self
}
pub fn variant_optional(mut self, optional: bool) -> Self {
self.engine.optional = optional;
self
}
pub fn variant_partner_code(mut self, partner_code: &str) -> Self {
self.engine.partner_code = partner_code.to_string();
self
}
pub fn variant_telemetry_suffix(mut self, suffix: &str) -> Self {
self.engine.telemetry_suffix = suffix.to_string();
self
}
pub fn visual_search_display_name(mut self, display_name: &str) -> Self {
let visual = self
.engine
.urls
.visual_search
.as_mut()
.expect("Expected base engine to include visual_search");
visual.display_name = Some(display_name.to_string());
self
}
pub fn variant_search_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
) -> Self {
self.engine.urls.search = SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
..Default::default()
};
self
}
pub fn variant_suggestions_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
) -> Self {
self.engine.urls.suggestions = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
..Default::default()
});
self
}
pub fn variant_trending_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
exclude_partner_code_from_telemetry: bool,
) -> Self {
self.engine.urls.trending = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
exclude_partner_code_from_telemetry,
..Default::default()
});
self
}
pub fn variant_search_form_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
) -> Self {
self.engine.urls.search_form = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
..Default::default()
});
self
}
pub fn variant_visual_search_url(
mut self,
base: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
display_name: &str,
is_new_until: &str,
) -> Self {
self.engine.urls.visual_search = Some(SearchEngineUrl {
base: base.to_string(),
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
display_name: Some(display_name.to_string()),
is_new_until: Some(is_new_until.to_string()),
accepted_content_types: Some(vec!["image/png".to_string(), "image/jpeg".to_string()]),
exclude_partner_code_from_telemetry: false,
});
self
}
pub fn subvariant_partner_code(mut self, partner_code: &str) -> Self {
self.engine.partner_code = partner_code.to_string();
self
}
pub fn subvariant_telemetry_suffix(mut self, suffix: &str) -> Self {
self.engine.telemetry_suffix = suffix.to_string();
self
}
pub fn subvariant_search_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
) -> Self {
self.engine.urls.search = SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
..Default::default()
};
self
}
pub fn subvariant_suggestions_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
exclude_partner_code_from_telemetry: bool,
) -> Self {
self.engine.urls.suggestions = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
exclude_partner_code_from_telemetry,
..Default::default()
});
self
}
pub fn subvariant_trending_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
) -> Self {
self.engine.urls.trending = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
..Default::default()
});
self
}
pub fn subvariant_search_form_url(
mut self,
base: &str,
method: &str,
param_name: &str,
param_value: &str,
) -> Self {
self.engine.urls.search_form = Some(SearchEngineUrl {
base: base.to_string(),
method: method.to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
..Default::default()
});
self
}
pub fn subvariant_visual_search_url(
mut self,
base: &str,
param_name: &str,
param_value: &str,
search_term_param_name: &str,
display_name: &str,
is_new_until: &str,
) -> Self {
self.engine.urls.visual_search = Some(SearchEngineUrl {
base: base.to_string(),
method: "GET".to_string(),
params: vec![SearchUrlParam {
name: param_name.to_string(),
value: Some(param_value.to_string()),
enterprise_value: None,
experiment_config: None,
}],
search_term_param_name: Some(search_term_param_name.to_string()),
display_name: Some(display_name.to_string()),
is_new_until: Some(is_new_until.to_string()),
exclude_partner_code_from_telemetry: false,
accepted_content_types: Some(vec!["image/jpeg".to_string(), "image/webp".to_string()]),
});
self
}
pub fn build(self) -> SearchEngineDefinition {
self.engine
}
}