| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use crate::{ |
| common::App, |
| configuration::Config, |
| protocol::{ |
| request::{ |
| Event, InstallSource, Ping, Request, RequestWrapper, UpdateCheck, HEADER_APP_ID, |
| HEADER_INTERACTIVITY, HEADER_UPDATER_NAME, |
| }, |
| Cohort, PROTOCOL_V3, |
| }, |
| }; |
| |
| use http; |
| use log::*; |
| use std::result; |
| |
| type ProtocolApp = crate::protocol::request::App; |
| |
| /// Building a request can fail for multiple reasons, this enum consolidates them into a single |
| /// type that can be used to express those reasons. |
| #[derive(Debug)] |
| pub enum Error { |
| Json(serde_json::Error), |
| Http(http::Error), |
| } |
| |
| impl From<serde_json::Error> for Error { |
| fn from(e: serde_json::Error) -> Self { |
| Error::Json(e) |
| } |
| } |
| |
| impl From<http::Error> for Error { |
| fn from(e: http::Error) -> Self { |
| Error::Http(e) |
| } |
| } |
| |
| /// The builder's own Result type. |
| pub type Result<T> = result::Result<T, Error>; |
| |
| /// These are the parameters that describe how the request should be performed. |
| #[derive(Clone, Debug, PartialEq)] |
| pub struct RequestParams { |
| /// The install source for a request changes a number of properties of the request, including |
| /// the HTTP request headers, and influences how Omaha services the request (e.g. throttling) |
| pub source: InstallSource, |
| |
| /// If true, the request should use any configured proxies. This allows the bypassing of |
| /// proxies if there are difficulties in communicating with the Omaha service. |
| pub use_configured_proxies: bool, |
| } |
| |
| /// The AppEntry holds the data for the app whose request is currently being constructed. An app |
| /// can only have a single cohort, update check, or ping, but may have multiple events. Note that |
| /// while this object allows for no update check, no ping, and no events, that doesn't make sense |
| /// via the protocol. |
| /// |
| /// This struct has ownership over it's members, so that they may later be moved out when the |
| /// request itself is built. |
| struct AppEntry { |
| /// The identifying data for the application. |
| app: App, |
| |
| /// The optionally-present cohort that this application belongs to. |
| cohort: Option<Cohort>, |
| |
| /// Set to true if an update check should be performed. |
| update_check: bool, |
| |
| /// A ping, if that's being performed. |
| ping: Option<Ping>, |
| |
| /// Any events that need to be sent to the Omaha service. |
| events: Vec<Event>, |
| } |
| |
| impl AppEntry { |
| /// Basic constructor for the AppEntry. All AppEntries MUST have an App and a Cohort, |
| /// everything else can be omitted. |
| fn new(app: &App, cohort: &Option<Cohort>) -> AppEntry { |
| AppEntry { |
| app: app.clone(), |
| cohort: cohort.clone(), |
| update_check: false, |
| ping: None, |
| events: Vec::new(), |
| } |
| } |
| } |
| |
| /// Conversion method to construct a ProtocolApp from an AppEntry. This consumes the entry, moving |
| /// it's members into the generated ProtocolApp. |
| impl From<AppEntry> for ProtocolApp { |
| fn from(entry: AppEntry) -> ProtocolApp { |
| if !entry.update_check && entry.events.is_empty() && entry.ping == None { |
| warn!( |
| "Generated protocol::request for {} has no update check, ping, or events", |
| entry.app.id |
| ); |
| } |
| ProtocolApp { |
| id: entry.app.id, |
| version: entry.app.version.to_string(), |
| fingerprint: entry.app.fingerprint, |
| cohort: entry.cohort, |
| update_check: if entry.update_check { Some(UpdateCheck::default()) } else { None }, |
| events: entry.events, |
| ping: entry.ping, |
| } |
| } |
| } |
| |
| /// The RequestBuilder is used to create the protocol requests. Each request is represented by an |
| /// instance of protocol::request::Request. |
| pub struct RequestBuilder<'a> { |
| // The static data identifying the updater binary. |
| config: &'a Config, |
| |
| // The parameters that control how this request is to be made. |
| params: RequestParams, |
| |
| // The applications to include in this request, with their associated update checks, pings, and |
| // events to report. |
| app_entries: Vec<AppEntry>, |
| } |
| |
| /// The RequestBuilder is a stateful builder for protocol::request::Request objects. After being |
| /// instantiated with the base parameters for the current request, it has functions for accumulating |
| /// an update check, a ping, and multiple events for individual App objects. |
| /// |
| /// The 'add_*()' functions are all insensitive to order for a given App and it's Cohort. However, |
| /// if multiple different App entries are used, then order matters. The order in the request is |
| /// the order that the Apps are added to the RequestBuilder. |
| /// |
| /// Further, the cohort is only captured on the _first_ time a given App is added to the request. |
| /// If, for some reason, the same App is added twice, but with a different cohort, the latter cohort |
| /// is ignored. |
| /// |
| /// The operation being added (update check, ping, or event) is added to the existing App. The app |
| /// maintains its existing place in the list of Apps to be added to the request. |
| impl<'a> RequestBuilder<'a> { |
| /// Constructor for creating a new RequestBuilder based on the Updater configuration and the |
| /// parameters for the current request. |
| pub fn new(config: &'a Config, params: &RequestParams) -> Self { |
| RequestBuilder { config, params: params.clone(), app_entries: Vec::new() } |
| } |
| |
| /// Insert the given app (with its cohort), and run the associated closure on it. If the app |
| /// already exists in the request (by app id), just run the closure on the AppEntry. |
| fn insert_and_modify_entry<F>(&mut self, app: &App, cohort: &Option<Cohort>, modify: F) |
| where |
| F: Fn(&mut AppEntry), |
| { |
| for existing_entry in self.app_entries.iter_mut() { |
| if existing_entry.app.id == app.id { |
| // found an existing App in the Vec, so just run the closure on this AppEntry. |
| modify(existing_entry); |
| // and short-circuit out. |
| return; |
| } |
| } |
| |
| // The App wasn't found, so add it to the list, after running the closure on a newly |
| // generated AppEntry for this App. |
| let mut app_entry = AppEntry::new(app, cohort); |
| modify(&mut app_entry); |
| self.app_entries.push(app_entry); |
| } |
| |
| /// This function adds an update check for the given App, in the given Cohort. This function is |
| /// an idempotent accumulator, in that it only once adds the App with it's associated Cohort to |
| /// the request. Afterward, it just marks the App as needing an update check. |
| pub fn add_update_check(mut self, app: &App, cohort: &Option<Cohort>) -> Self { |
| self.insert_and_modify_entry(app, cohort, |entry| { |
| entry.update_check = true; |
| }); |
| self |
| } |
| |
| /// This function adds a Ping for the given App, in the given Cohort. This function is an |
| /// idempotent accumulator, in that it only once adds the App with it's associated Cohort to the |
| /// request. Afterward, it just adds the Ping to the App. |
| pub fn add_ping(mut self, app: &App, cohort: &Option<Cohort>, ping: &Ping) -> Self { |
| self.insert_and_modify_entry(app, cohort, |entry| { |
| entry.ping = Some(ping.clone()); |
| }); |
| self |
| } |
| |
| /// This function adds an Event for the given App, in the given Cohort. This function is an |
| /// idempotent accumulator, in that it only once adds the App with it's associated Cohort to the |
| /// request. Afterward, it just adds the Event to the App. |
| pub fn add_event(mut self, app: &App, cohort: &Option<Cohort>, event: &Event) -> Self { |
| self.insert_and_modify_entry(app, cohort, |entry| { |
| entry.events.push(event.clone()); |
| }); |
| self |
| } |
| |
| /// This function constructs the protocol::request::Request object from this Builder. |
| /// |
| /// Note that the builder is consumed in the process, and cannot be used afterward. |
| pub fn build(self) -> Result<http::Request<hyper::Body>> { |
| self.build_intermediate().into() |
| } |
| |
| /// Helper function that constructs the request body from the builder. |
| fn build_intermediate(self) -> Intermediate { |
| let mut headers = vec![ |
| // Set the content-type to be JSON. |
| (http::header::CONTENT_TYPE.as_str(), "application/json".to_string()), |
| // The updater name header is always set directly from the name in the configuration |
| (HEADER_UPDATER_NAME, self.config.updater.name.clone()), |
| // The interactivity header is set based on the source of the request that's set in |
| // the request params |
| ( |
| HEADER_INTERACTIVITY, |
| match self.params.source { |
| InstallSource::OnDemand => "fg".to_string(), |
| InstallSource::ScheduledTask => "bg".to_string(), |
| }, |
| ), |
| ]; |
| // And the app id header is based on the first app id in the request. |
| // TODO: Send all app ids, or only send the first based on configuration. |
| if let Some(main_app) = self.app_entries.first() { |
| headers.push((HEADER_APP_ID, main_app.app.id.clone())); |
| } |
| |
| let apps = self.app_entries.into_iter().map(|entry| ProtocolApp::from(entry)).collect(); |
| |
| Intermediate { |
| uri: self.config.service_url.clone(), |
| headers, |
| body: RequestWrapper { |
| request: Request { |
| protocol_version: PROTOCOL_V3.to_string(), |
| updater: self.config.updater.name.clone(), |
| updater_version: self.config.updater.version.to_string(), |
| install_source: self.params.source.clone(), |
| is_machine: true, |
| os: self.config.os.clone(), |
| apps, |
| }, |
| }, |
| } |
| } |
| } |
| |
| /// As the name implies, this is an itermediate that can be used to construct an http::Request from |
| /// the data that's in the Builder. It allows for type-aware inspection of the constructed protcol |
| /// request, as well as the full construction of the http request (uri, headers, body). |
| /// |
| /// This struct owns all of it's data, so that they can be moved directly into the constructed http |
| /// request. |
| struct Intermediate { |
| /// The URI for the http request. |
| uri: String, |
| |
| /// The http request headers, in key:&str=value:String pairs |
| headers: Vec<(&'static str, String)>, |
| |
| /// The request body, still in object form as a RequestWrapper |
| body: RequestWrapper, |
| } |
| |
| impl From<Intermediate> for Result<http::Request<hyper::Body>> { |
| fn from(intermediate: Intermediate) -> Self { |
| let mut builder = hyper::Request::get(intermediate.uri); |
| for (key, value) in intermediate.headers { |
| builder.header(key, value); |
| } |
| |
| let body = serde_json::to_string(&intermediate.body)?; |
| let request = builder.body(body.into())?; |
| Ok(request) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use crate::{ |
| common::Version, |
| configuration::test_support::config_generator, |
| protocol::request::{EventResult, EventType}, |
| }; |
| use futures::{compat::Stream01CompatExt, executor::block_on, prelude::*}; |
| use pretty_assertions::assert_eq; |
| use serde_json::json; |
| |
| /// Test that a simple request's fields are all correct: |
| /// |
| /// - All request fields are set properly from the Config |
| /// - That the App is translated to a protocol::request:::App |
| #[test] |
| pub fn test_simple_request() { |
| let config = config_generator(); |
| |
| let intermediate = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::OnDemand, use_configured_proxies: false }, |
| ) |
| .add_update_check( |
| &App { id: "app id".to_string(), version: Version([5, 6, 7, 8]), fingerprint: None }, |
| &Some(Cohort::new("some-channel")), |
| ) |
| .build_intermediate(); |
| |
| // Assert that all the request fields are accurate (this is in their order of declaration) |
| let request = intermediate.body.request; |
| assert_eq!(request.protocol_version, "3.0"); |
| assert_eq!(request.updater, config.updater.name); |
| assert_eq!(request.updater_version, config.updater.version.to_string()); |
| assert_eq!(request.install_source, InstallSource::OnDemand); |
| assert_eq!(request.is_machine, true); |
| |
| // Just test that the config OS object was passed through (as opposed to manually comparing |
| // all the fields) |
| assert_eq!(request.os, config.os); |
| |
| // Validate that the App was added, with it's cohort and all of the other expected |
| // fields for an update check request. |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "app id"); |
| assert_eq!(app.version, "5.6.7.8"); |
| assert_eq!(app.fingerprint, None); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| assert_eq!(app.update_check, Some(UpdateCheck::default())); |
| assert!(app.events.is_empty()); |
| assert_eq!(app.ping, None); |
| |
| // Assert that the headers are set correctly |
| let headers = intermediate.headers; |
| assert_eq!(4, headers.len()); |
| assert!(headers.contains(&("content-type", "application/json".to_string()))); |
| assert!(headers.contains(&(HEADER_UPDATER_NAME, config.updater.name))); |
| assert!(headers.contains(&(HEADER_APP_ID, "app id".to_string()))); |
| assert!(headers.contains(&(HEADER_INTERACTIVITY, "fg".to_string()))); |
| } |
| |
| /// Test that a simple update check results in the correct HTTP request: |
| /// - service url |
| /// - headers |
| /// - request body |
| #[test] |
| pub fn test_single_request() { |
| let config = config_generator(); |
| |
| let (parts, body) = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::OnDemand, use_configured_proxies: false }, |
| ) |
| .add_update_check( |
| &App { id: "app id".to_string(), version: Version([5, 6, 7, 8]), fingerprint: None }, |
| &Some(Cohort::new("some-channel")), |
| ) |
| .build() |
| .unwrap() |
| .into_parts(); |
| |
| // Assert that the HTTP method and uri are accurate |
| assert_eq!(http::Method::GET, parts.method); |
| assert_eq!(config.service_url, parts.uri.to_string()); |
| |
| // Assert that all the request body is correct, by generating an equivalent JSON one and |
| // then comparing the resultant byte bodies |
| let expected = json!({ |
| "request": { |
| "protocol": "3.0", |
| "updater": config.updater.name, |
| "updaterversion": config.updater.version.to_string(), |
| "installsource": "ondemand", |
| "ismachine": true, |
| "os": { |
| "platform": config.os.platform, |
| "version": config.os.version, |
| "sp": config.os.service_pack, |
| "arch": config.os.arch, |
| }, |
| "app": [ |
| { |
| "appid": "app id", |
| "cohort": "some-channel", |
| "version": "5.6.7.8", |
| "updatecheck": {}, |
| }, |
| ], |
| } |
| }); |
| |
| // Extract the request body out into a concatenated stream of Chunks, into a slice, so |
| // that serde can be used to parse the body into a JSON Value object that can be compared |
| // with the expected json constructed above. |
| let actual: serde_json::Value = |
| serde_json::from_slice(&block_on(body.compat().try_concat()).unwrap().to_vec()) |
| .unwrap(); |
| |
| assert_eq!(expected, actual); |
| |
| // Assert that the headers are all correct |
| let headers = parts.headers; |
| assert_eq!(4, headers.len()); |
| assert_eq!("application/json", headers.get("content-type").unwrap().to_str().unwrap()); |
| assert_eq!( |
| config.updater.name, |
| headers.get(HEADER_UPDATER_NAME).unwrap().to_str().unwrap() |
| ); |
| assert_eq!("app id", headers.get(HEADER_APP_ID).unwrap().to_str().unwrap()); |
| assert_eq!("fg", headers.get(HEADER_INTERACTIVITY).unwrap().to_str().unwrap()); |
| } |
| |
| /// Test that a ping is correctly added to an App entry. |
| #[test] |
| pub fn test_simple_ping() { |
| let config = config_generator(); |
| |
| let intermediate = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_ping( |
| &App { |
| id: "ping app id".to_string(), |
| version: Version([6, 7, 8, 9]), |
| fingerprint: None, |
| }, |
| &Some(Cohort::new("ping-channel")), |
| &Ping { date_last_active: Some(34), date_last_roll_call: Some(45) }, |
| ) |
| .build_intermediate(); |
| |
| // Validate that the App was added, with it's cohort |
| let app = &intermediate.body.request.apps[0]; |
| assert_eq!(app.id, "ping app id"); |
| assert_eq!(app.version, "6.7.8.9"); |
| assert_eq!(app.cohort, Some(Cohort::new("ping-channel"))); |
| |
| // And that the App has a Ping entry set, with the same values as was passed to the |
| // Builder. |
| let ping = app.ping.as_ref().unwrap(); |
| assert_eq!(ping.date_last_active, Some(34)); |
| assert_eq!(ping.date_last_roll_call, Some(45)); |
| |
| // Assert that the headers are set correctly |
| let headers = intermediate.headers; |
| assert_eq!(4, headers.len()); |
| assert!(headers.contains(&("content-type", "application/json".to_string()))); |
| assert!(headers.contains(&(HEADER_UPDATER_NAME, config.updater.name))); |
| assert!(headers.contains(&(HEADER_APP_ID, "ping app id".to_string()))); |
| assert!(headers.contains(&(HEADER_INTERACTIVITY, "bg".to_string()))); |
| } |
| |
| /// Test that an event is properly added to an App entry |
| #[test] |
| pub fn test_simple_event() { |
| let config = config_generator(); |
| |
| let request = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_event( |
| &App { |
| id: "event app id".to_string(), |
| version: Version([6, 7, 8, 9]), |
| fingerprint: None, |
| }, |
| &Some(Cohort::new("event-channel")), |
| &Event { |
| event_type: EventType::UpdateDownloadStarted, |
| event_result: EventResult::Success, |
| errorcode: Some(26598), |
| ..Event::default() |
| }, |
| ) |
| .build_intermediate() |
| .body |
| .request; |
| |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "event app id"); |
| assert_eq!(app.version, "6.7.8.9"); |
| assert_eq!(app.cohort, Some(Cohort::new("event-channel"))); |
| |
| let event = &app.events[0]; |
| assert_eq!(event.event_type, EventType::UpdateDownloadStarted); |
| assert_eq!(event.event_result, EventResult::Success); |
| assert_eq!(event.errorcode, Some(26598)); |
| } |
| |
| /// Test that multiple events are properly added to an App entry |
| #[test] |
| pub fn test_multiple_events() { |
| let config = config_generator(); |
| |
| // Setup the first app and its cohort |
| let app_1 = App { |
| id: "event app id".to_string(), |
| version: Version([6, 7, 8, 9]), |
| fingerprint: None, |
| }; |
| let app_1_cohort = Some(Cohort::new("event-channel")); |
| |
| // Make the call to the RequestBuilder that is being tested. |
| let request = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_event( |
| &app_1, |
| &app_1_cohort, |
| &Event { |
| event_type: EventType::UpdateDownloadStarted, |
| event_result: EventResult::Success, |
| errorcode: Some(26598), |
| ..Event::default() |
| }, |
| ) |
| .add_event( |
| &app_1, |
| &app_1_cohort, |
| &Event { |
| event_type: EventType::UpdateDownloadFinished, |
| event_result: EventResult::Error, |
| errorcode: Some(988456), |
| ..Event::default() |
| }, |
| ) |
| .build_intermediate() |
| .body |
| .request; |
| |
| // Validate that the resultant Request has the right fields and events |
| |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "event app id"); |
| assert_eq!(app.version, "6.7.8.9"); |
| assert_eq!(app.cohort, Some(Cohort::new("event-channel"))); |
| |
| let event = &app.events[0]; |
| assert_eq!(event.event_type, EventType::UpdateDownloadStarted); |
| assert_eq!(event.event_result, EventResult::Success); |
| assert_eq!(event.errorcode, Some(26598)); |
| |
| let event = &app.events[1]; |
| assert_eq!(event.event_type, EventType::UpdateDownloadFinished); |
| assert_eq!(event.event_result, EventResult::Error); |
| assert_eq!(event.errorcode, Some(988456)); |
| } |
| |
| /// When adding multiple apps to a request, a ping or an event needs to be attached to the |
| /// correct app entry in the protocol request. The next few tests are centered on validating |
| /// that in various scenarios. |
| |
| /// This test ensures that if the matching app entry is the first one in the request, that the |
| /// ping is attached to it (and not the last that was added). |
| #[test] |
| pub fn test_ping_added_to_first_app_update_entry() { |
| let config = config_generator(); |
| |
| // Setup the first app and its cohort |
| let app_1 = App { |
| id: "first app id".to_string(), |
| version: Version([1, 2, 3, 4]), |
| fingerprint: None, |
| }; |
| let app_1_cohort = Some(Cohort::new("some-channel")); |
| |
| // Setup the second app and its cohort |
| let app_2 = App { |
| id: "second app id".to_string(), |
| version: Version([5, 6, 7, 8]), |
| fingerprint: None, |
| }; |
| let app_2_cohort = Some(Cohort::new("some-channel")); |
| |
| // Now make the call to the RequestBuilder that is being tested. |
| let request = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_update_check(&app_1, &app_1_cohort) |
| .add_update_check(&app_2, &app_2_cohort) |
| .add_ping( |
| &app_1, |
| &app_1_cohort, |
| &Ping { date_last_active: Some(34), date_last_roll_call: Some(45) }, |
| ) |
| .build_intermediate() |
| .body |
| .request; |
| |
| // Validate the resultant Request is correct. |
| |
| // There should only be the two app entries. |
| assert_eq!(request.apps.len(), 2); |
| |
| // The first app should have the ping attached to it. |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "first app id"); |
| assert_eq!(app.version, "1.2.3.4"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| let ping = &app.ping.as_ref().unwrap(); |
| assert_eq!(ping.date_last_active, Some(34)); |
| assert_eq!(ping.date_last_roll_call, Some(45)); |
| |
| // And the second app should not. |
| let app = &request.apps[1]; |
| assert_eq!(app.id, "second app id"); |
| assert_eq!(app.version, "5.6.7.8"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| assert_eq!(app.ping, None); |
| } |
| |
| /// This test ensures that if the matching app entry is the second one in the request, that the |
| /// ping is attached to it (and not to the first app that was added). |
| #[test] |
| pub fn test_ping_added_to_second_app_update_entry() { |
| let config = config_generator(); |
| |
| // Setup the first app and its cohort |
| let app_1 = App { |
| id: "first app id".to_string(), |
| version: Version([1, 2, 3, 4]), |
| fingerprint: None, |
| }; |
| let app_1_cohort = Some(Cohort::new("some-channel")); |
| |
| // Setup the second app and its cohort |
| let app_2 = App { |
| id: "second app id".to_string(), |
| version: Version([5, 6, 7, 8]), |
| fingerprint: None, |
| }; |
| let app_2_cohort = Some(Cohort::new("some-channel")); |
| |
| // Now make the call to the RequestBuilder that is being tested. |
| let builder = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_update_check(&app_1, &app_1_cohort) |
| .add_update_check(&app_2, &app_2_cohort) |
| .add_ping( |
| &app_2, |
| &app_2_cohort, |
| &Ping { date_last_active: Some(34), date_last_roll_call: Some(45) }, |
| ); |
| |
| let request = builder.build_intermediate().body.request; |
| |
| // Validate that the resultant request is correct. |
| |
| // There should only be the two entries. |
| assert_eq!(request.apps.len(), 2); |
| |
| // The first app should not have the ping attached to it. |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "first app id"); |
| assert_eq!(app.version, "1.2.3.4"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| |
| // And the second app should. |
| let app = &request.apps[1]; |
| assert_eq!(app.id, "second app id"); |
| assert_eq!(app.version, "5.6.7.8"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| |
| let ping = app.ping.as_ref().unwrap(); |
| assert_eq!(ping.date_last_active, Some(34)); |
| assert_eq!(ping.date_last_roll_call, Some(45)); |
| } |
| |
| /// This test ensures that if the matching app entry is the first one in the request, that the |
| /// event is attached to it (and not the last that was added). |
| #[test] |
| pub fn test_event_added_to_first_app_update_entry() { |
| let config = config_generator(); |
| |
| // Setup the first app and its cohort |
| let app_1 = App { |
| id: "first app id".to_string(), |
| version: Version([1, 2, 3, 4]), |
| fingerprint: None, |
| }; |
| let app_1_cohort = Some(Cohort::new("some-channel")); |
| |
| // Setup the second app and its cohort |
| let app_2 = App { |
| id: "second app id".to_string(), |
| version: Version([5, 6, 7, 8]), |
| fingerprint: None, |
| }; |
| let app_2_cohort = Some(Cohort::new("some-channel")); |
| |
| // Now make the call to the RequestBuilder that is being tested. |
| let request = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_update_check(&app_1, &app_1_cohort) |
| .add_update_check(&app_2, &app_2_cohort) |
| .add_event( |
| &app_1, |
| &app_1_cohort, |
| &Event { |
| event_type: EventType::UpdateDownloadFinished, |
| event_result: EventResult::Success, |
| errorcode: Some(2456), |
| ..Event::default() |
| }, |
| ) |
| .build_intermediate() |
| .body |
| .request; |
| |
| // There should only be the two entries. |
| assert_eq!(request.apps.len(), 2); |
| |
| // The first app should have the event attached to it. |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "first app id"); |
| assert_eq!(app.version, "1.2.3.4"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| let event = &app.events[0]; |
| assert_eq!(event.event_type, EventType::UpdateDownloadFinished); |
| assert_eq!(event.event_result, EventResult::Success); |
| assert_eq!(event.errorcode, Some(2456)); |
| |
| // And the second app should not. |
| let app = &request.apps[1]; |
| assert_eq!(app.id, "second app id"); |
| assert_eq!(app.version, "5.6.7.8"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| assert!(app.events.is_empty()); |
| } |
| |
| /// This test ensures that if the matching app entry is the second one in the request, that the |
| /// event is attached to it (and not to the first app that was added). |
| #[test] |
| pub fn test_event_added_to_second_app_update_entry() { |
| let config = config_generator(); |
| |
| // Setup the first app and its cohort |
| let app_1 = App { |
| id: "first app id".to_string(), |
| version: Version([1, 2, 3, 4]), |
| fingerprint: None, |
| }; |
| let app_1_cohort = Some(Cohort::new("some-channel")); |
| |
| // Setup the second app and its cohort |
| let app_2 = App { |
| id: "second app id".to_string(), |
| version: Version([5, 6, 7, 8]), |
| fingerprint: None, |
| }; |
| let app_2_cohort = Some(Cohort::new("some-channel")); |
| |
| // Now make the call to the RequestBuilder that is being tested. |
| let builder = RequestBuilder::new( |
| &config, |
| &RequestParams { source: InstallSource::ScheduledTask, use_configured_proxies: false }, |
| ) |
| .add_update_check(&app_1, &app_1_cohort) |
| .add_update_check(&app_2, &app_2_cohort) |
| .add_event( |
| &app_2, |
| &app_2_cohort, |
| &Event { |
| event_type: EventType::UpdateDownloadFinished, |
| event_result: EventResult::Success, |
| errorcode: Some(2456), |
| ..Event::default() |
| }, |
| ); |
| |
| let request = builder.build_intermediate().body.request; |
| |
| // There should only be the two entries. |
| assert_eq!(request.apps.len(), 2); |
| |
| // The first app should not have the event attached. |
| let app = &request.apps[0]; |
| assert_eq!(app.id, "first app id"); |
| assert_eq!(app.version, "1.2.3.4"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| assert!(app.events.is_empty()); |
| |
| // And the second app should. |
| let app = &request.apps[1]; |
| assert_eq!(app.id, "second app id"); |
| assert_eq!(app.version, "5.6.7.8"); |
| assert_eq!(app.cohort, Some(Cohort::new("some-channel"))); |
| |
| assert_eq!(app.events.len(), 1); |
| let event = &app.events[0]; |
| assert_eq!(event.event_type, EventType::UpdateDownloadFinished); |
| assert_eq!(event.event_result, EventResult::Success); |
| assert_eq!(event.errorcode, Some(2456)); |
| } |
| } |
