| // Copyright 2018 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. |
| |
| pub use crate::errors::ParseError; |
| pub use crate::parse::{check_resource, HASH_RE, NAME_RE}; |
| use serde::{Deserialize, Deserializer, Serialize, Serializer}; |
| use serde_derive::Serialize; |
| use std::convert::TryFrom; |
| use std::fmt; |
| use std::str; |
| use url::percent_encoding::percent_decode; |
| use url::Url; |
| |
| /// Decoded representation of a fuchsia-pkg URI. |
| /// |
| /// Depending on which segments are included, the URI may identify a package |
| /// repository, a package within a repository (with optional variant and hash), |
| /// or a resource within a package. |
| /// |
| /// Repository identifier: |
| /// - fuchsia-pkg://example.com/ |
| /// |
| /// Package identifier: |
| /// - fuchsia-pkg://example.com/some-package |
| /// - fuchsia-pkg://example.com/some-package/some-variant |
| /// - fuchsia-pkg://example.com/some-package/some-variant?hash=<some-hash> |
| /// - fuchsia-pkg://example.com/some-package/some-variant/<some-hash> (obsolete) |
| /// |
| /// Resource identifier: |
| /// - fuchsia-pkg://example.com/some-package#path/to/resource |
| /// - fuchsia-pkg://example.com/some-package/some-variant#path/to/resource |
| /// - fuchsia-pkg://example.com/some-package/some-variant?hash=<some-hash>#path/to/resource |
| /// - fuchsia-pkg://example.com/some-package/some-variant/<some-hash>#path/to/resource (obsolete) |
| #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| pub struct PkgUri { |
| host: String, |
| path: String, |
| hash: Option<String>, |
| resource: Option<String>, |
| } |
| |
| impl PkgUri { |
| pub fn parse(input: &str) -> Result<Self, ParseError> { |
| let uri = Url::parse(input)?; |
| |
| let scheme = uri.scheme(); |
| if scheme != "fuchsia-pkg" { |
| return Err(ParseError::InvalidScheme); |
| } |
| |
| let host = if let Some(host) = uri.host() { |
| host.to_string() |
| } else { |
| return Err(ParseError::InvalidHost); |
| }; |
| if host.is_empty() { |
| return Err(ParseError::InvalidHost); |
| } |
| |
| if uri.port().is_some() { |
| return Err(ParseError::CannotContainPort); |
| } |
| |
| if !uri.username().is_empty() { |
| return Err(ParseError::CannotContainUsername); |
| } |
| |
| if uri.password().is_some() { |
| return Err(ParseError::CannotContainPassword); |
| } |
| |
| parse_path(uri.path())?; |
| |
| let path = uri.path().to_string(); |
| let hash = parse_query_pairs(uri.query_pairs())?; |
| |
| let resource = if let Some(resource) = uri.fragment() { |
| let resource = match percent_decode(resource.as_bytes()).decode_utf8() { |
| Ok(resource) => resource, |
| Err(_) => { |
| return Err(ParseError::InvalidResourcePath); |
| } |
| }; |
| |
| if resource.is_empty() { |
| None |
| } else if check_resource(&resource) { |
| Some(resource.to_string()) |
| } else { |
| return Err(ParseError::InvalidResourcePath); |
| } |
| } else { |
| None |
| }; |
| |
| Ok(PkgUri { host, path, hash, resource }) |
| } |
| |
| pub fn host(&self) -> &str { |
| &self.host |
| } |
| |
| pub fn name(&self) -> Option<&str> { |
| // path is always prefixed by a '/'. |
| self.path[1..].split_terminator('/').nth(0) |
| } |
| |
| pub fn variant(&self) -> Option<&str> { |
| // path is always prefixed by a '/'. |
| self.path[1..].split_terminator('/').nth(1) |
| } |
| |
| /// Produce a string representation of the package referenced by this [PkgUri]. |
| pub fn path(&self) -> &str { |
| &self.path |
| } |
| |
| pub fn package_hash(&self) -> Option<&str> { |
| self.hash.as_ref().map(|s| &**s) |
| } |
| |
| pub fn resource(&self) -> Option<&str> { |
| self.resource.as_ref().map(|s| &**s) |
| } |
| |
| /// Returns true if this URI only contains a hostname, and no other parameters. For example, |
| /// fuchsia-pkg://fuchsia.com. |
| pub fn is_repository(&self) -> bool { |
| self.path == "/" && self.hash.is_none() && self.resource.is_none() |
| } |
| |
| /// Produce a new [PkgUri] with any resource fragment stripped off. |
| pub fn root_uri(&self) -> PkgUri { |
| PkgUri { |
| host: self.host.clone(), |
| path: self.path.clone(), |
| hash: self.hash.clone(), |
| resource: None, |
| } |
| } |
| |
| pub fn new_repository(host: String) -> Result<PkgUri, ParseError> { |
| if host.is_empty() { |
| return Err(ParseError::InvalidHost); |
| } |
| |
| Ok(PkgUri { host: host.to_string(), path: "/".to_string(), hash: None, resource: None }) |
| } |
| |
| pub fn new_package( |
| host: String, |
| path: String, |
| hash: Option<String>, |
| ) -> Result<PkgUri, ParseError> { |
| let mut uri = PkgUri::new_repository(host)?; |
| |
| let (name, variant) = parse_path(path.as_str())?; |
| |
| if name.is_none() { |
| return Err(ParseError::InvalidName); |
| } |
| |
| if let Some(ref h) = hash { |
| if variant.is_none() { |
| return Err(ParseError::InvalidVariant); |
| } |
| if !HASH_RE.is_match(h) { |
| return Err(ParseError::InvalidHash); |
| } |
| } |
| uri.path = path; |
| uri.hash = hash; |
| Ok(uri) |
| } |
| |
| pub fn new_resource( |
| host: String, |
| path: String, |
| hash: Option<String>, |
| resource: String, |
| ) -> Result<PkgUri, ParseError> { |
| let mut uri = PkgUri::new_package(host, path, hash)?; |
| if resource.is_empty() || !check_resource(&resource) { |
| return Err(ParseError::InvalidResourcePath); |
| } |
| uri.resource = Some(resource); |
| Ok(uri) |
| } |
| } |
| |
| impl fmt::Display for PkgUri { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "fuchsia-pkg://{}", self.host)?; |
| if self.path != "/" { |
| write!(f, "{}", self.path)?; |
| } |
| if let Some(ref hash) = self.hash { |
| write!(f, "?hash={}", hash)?; |
| } |
| |
| if let Some(ref resource) = self.resource { |
| write!( |
| f, |
| "#{}", |
| url::percent_encoding::utf8_percent_encode( |
| resource, |
| url::percent_encoding::DEFAULT_ENCODE_SET |
| ) |
| )?; |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl str::FromStr for PkgUri { |
| type Err = ParseError; |
| |
| fn from_str(value: &str) -> Result<Self, Self::Err> { |
| PkgUri::parse(value) |
| } |
| } |
| |
| impl TryFrom<&str> for PkgUri { |
| type Error = ParseError; |
| |
| fn try_from(value: &str) -> Result<Self, Self::Error> { |
| PkgUri::parse(value) |
| } |
| } |
| |
| impl Serialize for PkgUri { |
| fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> { |
| self.to_string().serialize(ser) |
| } |
| } |
| |
| impl<'de> Deserialize<'de> for PkgUri { |
| fn deserialize<D>(de: D) -> Result<Self, D::Error> |
| where |
| D: Deserializer<'de>, |
| { |
| let uri = String::deserialize(de)?; |
| Ok(PkgUri::parse(&uri).map_err(|err| serde::de::Error::custom(err))?) |
| } |
| } |
| |
| #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)] |
| #[serde(transparent)] |
| pub struct RepoUri { |
| uri: PkgUri, |
| } |
| |
| impl RepoUri { |
| pub fn new(host: String) -> Result<Self, ParseError> { |
| Ok(RepoUri { uri: PkgUri::new_repository(host)? }) |
| } |
| |
| pub fn parse(input: &str) -> Result<Self, ParseError> { |
| let uri = PkgUri::parse(input)?; |
| RepoUri::try_from(uri) |
| } |
| |
| pub fn host(&self) -> &str { |
| self.uri.host() |
| } |
| } |
| |
| impl str::FromStr for RepoUri { |
| type Err = ParseError; |
| |
| fn from_str(value: &str) -> Result<Self, Self::Err> { |
| RepoUri::parse(value) |
| } |
| } |
| |
| impl TryFrom<&str> for RepoUri { |
| type Error = ParseError; |
| |
| fn try_from(uri: &str) -> Result<Self, Self::Error> { |
| RepoUri::parse(uri) |
| } |
| } |
| |
| impl TryFrom<PkgUri> for RepoUri { |
| type Error = ParseError; |
| |
| fn try_from(uri: PkgUri) -> Result<Self, Self::Error> { |
| if uri.is_repository() { |
| Ok(RepoUri { uri }) |
| } else { |
| Err(ParseError::InvalidRepository) |
| } |
| } |
| } |
| |
| impl From<RepoUri> for PkgUri { |
| fn from(uri: RepoUri) -> Self { |
| uri.uri |
| } |
| } |
| |
| impl fmt::Display for RepoUri { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| self.uri.fmt(f) |
| } |
| } |
| |
| // Implement a custom deserializer to make sure we restrict RepositoryConfig.repo_url to actually |
| // be a repository URI. |
| impl<'de> Deserialize<'de> for RepoUri { |
| fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error> { |
| let uri = PkgUri::deserialize(de)?; |
| Ok(RepoUri::try_from(uri).map_err(|err| serde::de::Error::custom(err))?) |
| } |
| } |
| |
| fn parse_path(mut path: &str) -> Result<(Option<&str>, Option<&str>), ParseError> { |
| let mut name = None; |
| let mut variant = None; |
| |
| if !path.starts_with('/') { |
| return Err(ParseError::InvalidPath); |
| } |
| |
| path = &path[1..]; |
| if !path.is_empty() { |
| let mut iter = path.split('/').fuse(); |
| |
| if let Some(s) = iter.next() { |
| if NAME_RE.is_match(s) { |
| name = Some(s); |
| } else { |
| return Err(ParseError::InvalidName); |
| } |
| } |
| |
| if let Some(s) = iter.next() { |
| if NAME_RE.is_match(s) { |
| variant = Some(s); |
| } else { |
| return Err(ParseError::InvalidVariant); |
| } |
| } |
| |
| if let Some(_) = iter.next() { |
| return Err(ParseError::ExtraPathSegments); |
| } |
| } |
| |
| Ok((name, variant)) |
| } |
| |
| fn parse_query_pairs(pairs: url::form_urlencoded::Parse) -> Result<Option<String>, ParseError> { |
| let mut query_hash = None; |
| for (key, value) in pairs { |
| if key == "hash" { |
| if query_hash.is_some() { |
| return Err(ParseError::InvalidHash); |
| } |
| if !HASH_RE.is_match(&value) { |
| return Err(ParseError::InvalidHash); |
| } |
| query_hash = Some(value.to_string()); |
| } else { |
| return Err(ParseError::ExtraQueryParameters); |
| } |
| } |
| Ok(query_hash) |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use std::convert::TryInto; |
| |
| macro_rules! test_parse_ok { |
| ( |
| $( |
| $test_name:ident => { |
| uri = $pkg_uri:expr, |
| host = $pkg_host:expr, |
| path = $pkg_path:expr, |
| name = $pkg_name:expr, |
| variant = $pkg_variant:expr, |
| hash = $pkg_hash:expr, |
| resource = $pkg_resource:expr, |
| } |
| )+ |
| ) => { |
| $( |
| mod $test_name { |
| use super::*; |
| #[test] |
| fn test_eq() { |
| let pkg_uri = $pkg_uri.to_string(); |
| let uri = PkgUri::parse(&pkg_uri); |
| assert_eq!( |
| uri, |
| Ok(PkgUri { |
| host: $pkg_host.to_string(), |
| path: $pkg_path.to_string(), |
| hash: $pkg_hash.map(|s: &str| s.to_string()), |
| resource: $pkg_resource.map(|s: &str| s.to_string()), |
| }) |
| ); |
| |
| let uri = uri.unwrap(); |
| assert_eq!(uri.path(), $pkg_path); |
| assert_eq!(uri.name(), $pkg_name); |
| assert_eq!(uri.variant(), $pkg_variant); |
| assert_eq!(uri.package_hash(), $pkg_hash); |
| assert_eq!(uri.resource(), $pkg_resource); |
| } |
| |
| #[test] |
| fn test_roundtrip() { |
| let pkg_uri = $pkg_uri.to_string(); |
| let parsed = PkgUri::parse(&pkg_uri).unwrap(); |
| let format_pkg_uri = parsed.to_string(); |
| assert_eq!( |
| PkgUri::parse(&format_pkg_uri), |
| Ok(parsed) |
| ); |
| } |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_parse_err { |
| ( |
| $( |
| $test_name:ident => { |
| uris = $uris:expr, |
| err = $err:expr, |
| } |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| for uri in &$uris { |
| assert_eq!( |
| PkgUri::parse(uri), |
| Err($err), |
| ); |
| } |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_format { |
| ( |
| $( |
| $test_name:ident => { |
| parsed = $parsed:expr, |
| formatted = $formatted:expr, |
| } |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| assert_eq!( |
| format!("{}", $parsed), |
| $formatted |
| ); |
| } |
| )+ |
| } |
| } |
| |
| test_parse_ok! { |
| test_parse_host => { |
| uri = "fuchsia-pkg://fuchsia.com", |
| host = "fuchsia.com", |
| path = "/", |
| name = None, |
| variant = None, |
| hash = None, |
| resource = None, |
| } |
| test_parse_host_name => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = None, |
| } |
| test_parse_host_name_special_chars => { |
| uri = "fuchsia-pkg://fuchsia.com/abc123-._", |
| host = "fuchsia.com", |
| path = "/abc123-._", |
| name = Some("abc123-._"), |
| variant = None, |
| hash = None, |
| resource = None, |
| } |
| test_parse_host_name_variant => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts/stable", |
| host = "fuchsia.com", |
| path = "/fonts/stable", |
| name = Some("fonts"), |
| variant = Some("stable"), |
| hash = None, |
| resource = None, |
| } |
| test_parse_host_name_variant_hash_query => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts/stable?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| host = "fuchsia.com", |
| path = "/fonts/stable", |
| name = Some("fonts"), |
| variant = Some("stable"), |
| hash = Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a"), |
| resource = None, |
| } |
| test_parse_host_name_hash_query => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a"), |
| resource = None, |
| } |
| test_parse_ignoring_empty_resource => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts#", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = None, |
| } |
| test_parse_resource => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts#foo/bar", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = Some("foo/bar"), |
| } |
| test_parse_resource_decodes_percent_encoding => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts#foo%23bar", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = Some("foo#bar"), |
| } |
| test_parse_resource_ignores_nul_chars => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts#foo\x00bar", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = Some("foobar"), |
| } |
| test_parse_resource_allows_encoded_control_chars => { |
| uri = "fuchsia-pkg://fuchsia.com/fonts#foo%09bar", |
| host = "fuchsia.com", |
| path = "/fonts", |
| name = Some("fonts"), |
| variant = None, |
| hash = None, |
| resource = Some("foo\tbar"), |
| } |
| } |
| |
| test_parse_err! { |
| test_parse_host_cannot_be_absent => { |
| uris = [ |
| "fuchsia-pkg://", |
| ], |
| err = ParseError::InvalidHost, |
| } |
| test_parse_host_cannot_be_empty => { |
| uris = [ |
| "fuchsia-pkg:///", |
| ], |
| err = ParseError::InvalidHost, |
| } |
| test_parse_name_cannot_be_empty => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com//", |
| ], |
| err = ParseError::InvalidName, |
| } |
| test_parse_name_cannot_be_longer_than_100_chars => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901/", |
| ], |
| err = ParseError::InvalidName, |
| } |
| test_parse_name_cannot_have_invalid_characters => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/$", |
| "fuchsia-pkg://fuchsia.com/foo$bar", |
| ], |
| err = ParseError::InvalidName, |
| } |
| test_parse_variant_cannot_have_invalid_characters => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts/$", |
| "fuchsia-pkg://fuchsia.com/fonts/foo$bar", |
| ], |
| err = ParseError::InvalidVariant, |
| } |
| test_parse_hash_cannot_be_empty => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts/stable?hash=", |
| ], |
| err = ParseError::InvalidHash, |
| } |
| test_parse_hash_cannot_have_invalid_characters => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts/stable?hash=8$e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| "fuchsia-pkg://fuchsia.com/fonts/stable?hash=80E8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| ], |
| err = ParseError::InvalidHash, |
| } |
| test_parse_hash_must_be_64_chars => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts/stable?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4", |
| "fuchsia-pkg://fuchsia.com/fonts/stable?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4aa", |
| ], |
| err = ParseError::InvalidHash, |
| } |
| test_parse_path_cannot_have_extra_segments => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts/stable/80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| "fuchsia-pkg://fuchsia.com/fonts/stable/80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a/foo", |
| ], |
| err = ParseError::ExtraPathSegments, |
| } |
| test_parse_resource_cannot_be_slash => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#/", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_cannot_start_with_slash => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#/foo", |
| "fuchsia-pkg://fuchsia.com/fonts#/foo/bar", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_cannot_end_with_slash => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#foo/", |
| "fuchsia-pkg://fuchsia.com/fonts#foo/bar/", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_cannot_contain_dot_dot => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#foo/../bar", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_cannot_contain_empty_segments => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#foo//bar", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_cannot_contain_percent_encoded_nul_chars => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com/fonts#foo%00bar", |
| ], |
| err = ParseError::InvalidResourcePath, |
| } |
| test_parse_resource_rejects_port => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com:1234", |
| ], |
| err = ParseError::CannotContainPort, |
| } |
| test_parse_resource_rejects_username => { |
| uris = [ |
| "fuchsia-pkg://user@fuchsia.com", |
| "fuchsia-pkg://user:password@fuchsia.com", |
| ], |
| err = ParseError::CannotContainUsername, |
| } |
| test_parse_resource_rejects_password => { |
| uris = [ |
| "fuchsia-pkg://:password@fuchsia.com", |
| ], |
| err = ParseError::CannotContainPassword, |
| } |
| test_parse_rejects_unknown_query_params => { |
| uris = [ |
| "fuchsia-pkg://fuchsia.com?foo=bar", |
| ], |
| err = ParseError::ExtraQueryParameters, |
| } |
| } |
| |
| test_format! { |
| test_format_repository_uri => { |
| parsed = PkgUri::new_repository("fuchsia.com".to_string()).unwrap(), |
| formatted = "fuchsia-pkg://fuchsia.com", |
| } |
| test_format_package_uri => { |
| parsed = PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| None, |
| ).unwrap(), |
| formatted = "fuchsia-pkg://fuchsia.com/fonts", |
| } |
| test_format_package_uri_with_variant => { |
| parsed = PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| None, |
| ).unwrap(), |
| formatted = "fuchsia-pkg://fuchsia.com/fonts/stable", |
| } |
| test_format_package_uri_with_hash => { |
| parsed = PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a".to_string()), |
| ).unwrap(), |
| formatted = "fuchsia-pkg://fuchsia.com/fonts/stable?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| } |
| test_format_resource_uri => { |
| parsed = PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| None, |
| "foo#bar".to_string(), |
| ).unwrap(), |
| formatted = "fuchsia-pkg://fuchsia.com/fonts#foo%23bar", |
| } |
| } |
| |
| #[test] |
| fn test_new_repository() { |
| let uri = PkgUri::new_repository("fuchsia.com".to_string()).unwrap(); |
| assert_eq!("fuchsia.com", uri.host()); |
| assert_eq!("/", uri.path()); |
| assert_eq!(None, uri.name()); |
| assert_eq!(None, uri.variant()); |
| assert_eq!(None, uri.package_hash()); |
| assert_eq!(None, uri.resource()); |
| |
| assert_eq!(PkgUri::new_repository("".to_string()), Err(ParseError::InvalidHost)); |
| } |
| |
| #[test] |
| fn test_new_package() { |
| let uri = PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a".to_string()), |
| ) |
| .unwrap(); |
| assert_eq!("fuchsia.com", uri.host()); |
| assert_eq!("/fonts/stable", uri.path()); |
| assert_eq!(Some("fonts"), uri.name()); |
| assert_eq!(Some("stable"), uri.variant()); |
| assert_eq!( |
| Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a"), |
| uri.package_hash() |
| ); |
| assert_eq!(None, uri.resource()); |
| assert_eq!(uri, uri.root_uri()); |
| |
| assert_eq!( |
| PkgUri::new_package("".to_string(), "/fonts".to_string(), None), |
| Err(ParseError::InvalidHost) |
| ); |
| assert_eq!( |
| PkgUri::new_package("fuchsia.com".to_string(), "fonts".to_string(), None), |
| Err(ParseError::InvalidPath) |
| ); |
| assert_eq!( |
| PkgUri::new_package("fuchsia.com".to_string(), "/".to_string(), None), |
| Err(ParseError::InvalidName) |
| ); |
| assert_eq!( |
| PkgUri::new_package("fuchsia.com".to_string(), "/fonts/$".to_string(), None), |
| Err(ParseError::InvalidVariant) |
| ); |
| assert_eq!( |
| PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| Some( |
| "80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a".to_string() |
| ) |
| ), |
| Err(ParseError::InvalidVariant) |
| ); |
| assert_eq!( |
| PkgUri::new_package( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| Some("$".to_string()) |
| ), |
| Err(ParseError::InvalidHash) |
| ); |
| } |
| |
| #[test] |
| fn test_new_resource() { |
| let uri = PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a".to_string()), |
| "foo/bar".to_string(), |
| ) |
| .unwrap(); |
| assert_eq!("fuchsia.com", uri.host()); |
| assert_eq!("/fonts/stable", uri.path()); |
| assert_eq!(Some("fonts"), uri.name()); |
| assert_eq!(Some("stable"), uri.variant()); |
| assert_eq!( |
| Some("80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a"), |
| uri.package_hash() |
| ); |
| assert_eq!(Some("foo/bar"), uri.resource()); |
| let mut uri_no_resource = uri.clone(); |
| uri_no_resource.resource = None; |
| assert_eq!(uri_no_resource, uri.root_uri()); |
| |
| assert_eq!( |
| PkgUri::new_resource("".to_string(), "/fonts".to_string(), None, "foo/bar".to_string()), |
| Err(ParseError::InvalidHost) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/".to_string(), |
| None, |
| "foo/bar".to_string() |
| ), |
| Err(ParseError::InvalidName) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts/$".to_string(), |
| None, |
| "foo/bar".to_string() |
| ), |
| Err(ParseError::InvalidVariant) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| Some( |
| "80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a".to_string() |
| ), |
| "foo/bar".to_string() |
| ), |
| Err(ParseError::InvalidVariant) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts/stable".to_string(), |
| Some("$".to_string()), |
| "foo/bar".to_string() |
| ), |
| Err(ParseError::InvalidHash) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| None, |
| "".to_string() |
| ), |
| Err(ParseError::InvalidResourcePath) |
| ); |
| assert_eq!( |
| PkgUri::new_resource( |
| "fuchsia.com".to_string(), |
| "/fonts".to_string(), |
| None, |
| "a//b".to_string() |
| ), |
| Err(ParseError::InvalidResourcePath) |
| ); |
| } |
| |
| #[test] |
| fn test_repo_uri() { |
| let parsed_pkg_uri = PkgUri::new_repository("fuchsia.com".to_string()).unwrap(); |
| let parsed_repo_uri = RepoUri::new("fuchsia.com".to_string()).unwrap(); |
| |
| let uris = &["fuchsia-pkg://fuchsia.com", "fuchsia-pkg://fuchsia.com/"]; |
| for uri in uris { |
| let uri = RepoUri::parse(uri); |
| assert_eq!(uri.as_ref(), Ok(&parsed_repo_uri)); |
| |
| let uri = uri.unwrap(); |
| assert_eq!(uri.host(), "fuchsia.com"); |
| |
| assert_eq!(uri.try_into().as_ref(), Ok(&parsed_pkg_uri)); |
| } |
| |
| let uris = &[ |
| "fuchsia-pkg://fuchsia.com/foo", |
| "fuchsia-pkg://fuchsia.com/foo/0", |
| "fuchsia-pkg://fuchsia.com#bar", |
| "fuchsia-pkg://fuchsia.com?hash=80e8721f4eba5437c8b6e1604f6ee384f42aed2b6dfbfd0b616a864839cd7b4a", |
| ]; |
| for uri in uris { |
| assert_eq!(RepoUri::parse(uri), Err(ParseError::InvalidRepository)); |
| } |
| } |
| } |
