Merge pull request #163 from erickt/2018
Port to rust 2018
diff --git a/Cargo.toml b/Cargo.toml
index 23ee009..fa9cede 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,6 @@
[package]
name = "tuf"
+edition = "2018"
version = "0.3.0-alpha3"
authors = [ "heartsucker <heartsucker@autistici.org>" ]
description = "Library for The Update Framework (TUF)"
diff --git a/src/client.rs b/src/client.rs
index dd8debd..80c83c3 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -47,20 +47,20 @@
//! }
//! ```
+use chrono::offset::Utc;
use std::io::{Read, Write};
-use chrono::offset::Utc;
-use crypto::{self, KeyId};
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::{self, KeyId};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
Metadata, MetadataPath, MetadataVersion, Role, RootMetadata, SignedMetadata, SnapshotMetadata,
TargetDescription, TargetPath, TargetsMetadata, VirtualTargetPath,
};
-use repository::Repository;
-use tuf::Tuf;
-use util::SafeReader;
-use Result;
+use crate::repository::Repository;
+use crate::tuf::Tuf;
+use crate::util::SafeReader;
+use crate::Result;
/// Translates real paths (where a file is stored) into virtual paths (how it is addressed in TUF)
/// and back.
@@ -175,7 +175,8 @@
&config.max_root_size,
config.min_bytes_per_second,
None,
- ).or_else(|_| -> Result<SignedMetadata<_, RootMetadata>> {
+ )
+ .or_else(|_| -> Result<SignedMetadata<_, RootMetadata>> {
// FIXME: should we be fetching the latest version instead of version 1?
let root = remote.fetch_metadata(
&root_path,
@@ -338,7 +339,8 @@
let snapshot_description = match self.tuf.timestamp() {
Some(ts) => Ok(ts.snapshot()),
None => Err(Error::MissingMetadata(Role::Timestamp)),
- }?.clone();
+ }?
+ .clone();
if snapshot_description.version() <= self.tuf.snapshot().map(|s| s.version()).unwrap_or(0) {
return Ok(false);
@@ -383,7 +385,8 @@
)),
},
None => Err(Error::MissingMetadata(Role::Snapshot)),
- }?.clone();
+ }?
+ .clone();
if targets_description.version() <= self.tuf.targets().map(|t| t.version()).unwrap_or(0) {
return Ok(false);
@@ -486,7 +489,7 @@
return (
default_terminate,
Err(Error::MissingMetadata(Role::Targets)),
- )
+ );
}
},
};
@@ -534,7 +537,8 @@
&Some(role_meta.size()),
self.config.min_bytes_per_second(),
Some((alg, value.clone())),
- ).or_else(|_| {
+ )
+ .or_else(|_| {
self.remote.fetch_metadata::<TargetsMetadata>(
delegation.role(),
&version,
@@ -762,14 +766,14 @@
#[cfg(test)]
mod test {
use super::*;
- use chrono::prelude::*;
- use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
- use interchange::Json;
- use metadata::{
+ use crate::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
+ use crate::interchange::Json;
+ use crate::metadata::{
MetadataPath, MetadataVersion, RootMetadataBuilder, SnapshotMetadataBuilder,
TargetsMetadataBuilder, TimestampMetadataBuilder,
};
- use repository::EphemeralRepository;
+ use crate::repository::EphemeralRepository;
+ use chrono::prelude::*;
use std::u32;
lazy_static! {
@@ -863,49 +867,57 @@
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::Number(1),
&root1,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::None,
&root1,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Targets),
&MetadataVersion::Number(1),
&targets,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Targets),
&MetadataVersion::None,
&targets,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Snapshot),
&MetadataVersion::Number(1),
&snapshot,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Snapshot),
&MetadataVersion::None,
&snapshot,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Timestamp),
&MetadataVersion::Number(1),
×tamp,
- ).unwrap();
+ )
+ .unwrap();
repo.store_metadata(
&MetadataPath::from_role(&Role::Timestamp),
&MetadataVersion::None,
×tamp,
- ).unwrap();
+ )
+ .unwrap();
////
// Now, make sure that the local metadata got version 1.
@@ -915,7 +927,8 @@
Config::build().finish().unwrap(),
EphemeralRepository::new(),
repo,
- ).unwrap();
+ )
+ .unwrap();
assert_eq!(client.update(), Ok(true));
assert_eq!(client.tuf.root().version(), 1);
@@ -930,7 +943,8 @@
&None,
u32::MAX,
None
- ).unwrap(),
+ )
+ .unwrap(),
);
////
@@ -942,7 +956,8 @@
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::Number(2),
&root2,
- ).unwrap();
+ )
+ .unwrap();
client
.remote
@@ -950,7 +965,8 @@
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::None,
&root2,
- ).unwrap();
+ )
+ .unwrap();
client
.remote
@@ -958,7 +974,8 @@
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::Number(3),
&root3,
- ).unwrap();
+ )
+ .unwrap();
client
.remote
@@ -966,7 +983,8 @@
&MetadataPath::from_role(&Role::Root),
&MetadataVersion::None,
&root3,
- ).unwrap();
+ )
+ .unwrap();
////
// Finally, check that the update brings us to version 3.
@@ -984,7 +1002,8 @@
&None,
u32::MAX,
None
- ).unwrap(),
+ )
+ .unwrap(),
);
}
}
diff --git a/src/crypto.rs b/src/crypto.rs
index 2c9623d..288ea72 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -21,9 +21,9 @@
use std::sync::Arc;
use untrusted::Input;
-use error::Error;
-use shims;
-use Result;
+use crate::error::Error;
+use crate::shims;
+use crate::Result;
const HASH_ALG_PREFS: &[HashAlgorithm] = &[HashAlgorithm::Sha512, HashAlgorithm::Sha256];
@@ -82,7 +82,7 @@
return Err(Error::IllegalArgument(format!(
"Unknown hash algorithm: {}",
s
- )))
+ )));
}
};
@@ -409,7 +409,7 @@
return Err(Error::IllegalArgument(format!(
"Cannot use signature scheme {:?} with Ed25519 keys",
s
- )))
+ )));
}
};
Ok(k)
@@ -499,7 +499,7 @@
return Err(Error::IllegalArgument(format!(
"Key {:?} can't be used with scheme {:?}",
k, s
- )))
+ )));
}
};
@@ -521,12 +521,14 @@
"rsa_keygen_pubexp:65537",
"-outform",
"der",
- ]).output()?;
+ ])
+ .output()?;
let mut pk8 = Command::new("openssl")
.args(&[
"pkcs8", "-inform", "der", "-topk8", "-nocrypt", "-outform", "der",
- ]).stdin(Stdio::piped())
+ ])
+ .stdin(Stdio::piped())
.stdout(Stdio::piped())
.spawn()?;
@@ -623,7 +625,7 @@
return Err(Error::IllegalArgument(format!(
"Unknown signature scheme: {}",
s
- )))
+ )));
}
};
@@ -632,7 +634,8 @@
Input::from(&self.value.0),
Input::from(msg),
Input::from(&sig.value.0),
- ).map_err(|_| Error::BadSignature)
+ )
+ .map_err(|_| Error::BadSignature)
}
}
@@ -856,7 +859,7 @@
#[cfg(test)]
mod test {
use super::*;
- use json;
+ use serde_json::{self, json};
const RSA_2048_PK8: &'static [u8] = include_bytes!("../tests/rsa/rsa-2048.pk8.der");
const RSA_2048_SPKI: &'static [u8] = include_bytes!("../tests/rsa/rsa-2048.spki.der");
@@ -935,9 +938,9 @@
fn serde_key_id() {
let s = "T5vfRrM1iHpgzGwAHe7MbJH_7r4chkOAphV3OPCCv0I=";
let jsn = json!(s);
- let parsed: KeyId = json::from_str(&format!("\"{}\"", s)).unwrap();
+ let parsed: KeyId = serde_json::from_str(&format!("\"{}\"", s)).unwrap();
assert_eq!(parsed, KeyId::from_string(s).unwrap());
- let encoded = json::to_value(&parsed).unwrap();
+ let encoded = serde_json::to_value(&parsed).unwrap();
assert_eq!(encoded, jsn);
}
@@ -945,9 +948,9 @@
fn serde_signature_value() {
let s = "T5vfRrM1iHpgzGwAHe7MbJH_7r4chkOAphV3OPCCv0I=";
let jsn = json!(s);
- let parsed: SignatureValue = json::from_str(&format!("\"{}\"", s)).unwrap();
+ let parsed: SignatureValue = serde_json::from_str(&format!("\"{}\"", s)).unwrap();
assert_eq!(parsed, SignatureValue::from_string(s).unwrap());
- let encoded = json::to_value(&parsed).unwrap();
+ let encoded = serde_json::to_value(&parsed).unwrap();
assert_eq!(encoded, jsn);
}
@@ -955,14 +958,14 @@
fn serde_rsa_public_key() {
let der = RSA_2048_SPKI;
let pub_key = PublicKey::from_spki(der, SignatureScheme::RsaSsaPssSha256).unwrap();
- let encoded = json::to_value(&pub_key).unwrap();
+ let encoded = serde_json::to_value(&pub_key).unwrap();
let jsn = json!({
"type": "rsa",
"scheme": "rsassa-pss-sha256",
"public_key": BASE64URL.encode(der),
});
assert_eq!(encoded, jsn);
- let decoded: PublicKey = json::from_value(encoded).unwrap();
+ let decoded: PublicKey = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, pub_key);
}
@@ -970,14 +973,14 @@
fn serde_ed25519_public_key() {
let der = ED25519_SPKI;
let pub_key = PublicKey::from_spki(der, SignatureScheme::Ed25519).unwrap();
- let encoded = json::to_value(&pub_key).unwrap();
+ let encoded = serde_json::to_value(&pub_key).unwrap();
let jsn = json!({
"type": "ed25519",
"scheme": "ed25519",
"public_key": BASE64URL.encode(der),
});
assert_eq!(encoded, jsn);
- let decoded: PublicKey = json::from_value(encoded).unwrap();
+ let decoded: PublicKey = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, pub_key);
}
@@ -986,15 +989,15 @@
let key = PrivateKey::from_pkcs8(ED25519_PK8, SignatureScheme::Ed25519).unwrap();
let msg = b"test";
let sig = key.sign(msg).unwrap();
- let encoded = json::to_value(&sig).unwrap();
+ let encoded = serde_json::to_value(&sig).unwrap();
let jsn = json!({
- "key_id": "qfrfBrkB4lBBSDEBlZgaTGS_SrE6UfmON9kP4i3dJFY=",
- "value": "_k0Tsqc8Azod5_UQeyBfx7oOFWbLlbkjScrmqkU4lWATv-D3v5d8sHK7Z\
- eh4K18zoFc_54gWKZoBfKW6VZ45DA==",
+ "key_id": "qfrfBrkB4lBBSDEBlZgaTGS_SrE6UfmON9kP4i3dJFY=",
+ "value": "_k0Tsqc8Azod5_UQeyBfx7oOFWbLlbkjScrmqkU4lWATv-D3v5d8sHK7Z\
+ eh4K18zoFc_54gWKZoBfKW6VZ45DA==",
});
assert_eq!(encoded, jsn);
- let decoded: Signature = json::from_value(encoded).unwrap();
+ let decoded: Signature = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, sig);
}
diff --git a/src/error.rs b/src/error.rs
index 45cc70b..e708598 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -3,13 +3,13 @@
use data_encoding::DecodeError;
use derp;
use hyper;
-use json;
+use serde_json;
use std::fmt;
use std::io;
use std::path::Path;
use tempfile;
-use metadata::Role;
+use crate::metadata::Role;
/// Error type for all TUF related errors.
#[derive(Debug, PartialEq, Eq)]
@@ -70,8 +70,8 @@
}
}
-impl From<json::error::Error> for Error {
- fn from(err: json::error::Error) -> Error {
+impl From<serde_json::error::Error> for Error {
+ fn from(err: serde_json::error::Error) -> Error {
Error::Encoding(format!("JSON: {:?}", err))
}
}
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index f7c23a9..3fea747 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -1,8 +1,8 @@
use itoa;
-use json;
+use serde_json;
use std::collections::BTreeMap;
-pub fn canonicalize(jsn: &json::Value) -> Result<Vec<u8>, String> {
+pub fn canonicalize(jsn: &serde_json::Value) -> Result<Vec<u8>, String> {
let converted = convert(jsn)?;
let mut buf = Vec::new();
let _ = converted.write(&mut buf); // Vec<u8> impl always succeeds (or panics).
@@ -41,8 +41,8 @@
.map_err(|err| format!("Write error: {}", err)),
Value::String(ref s) => {
// this mess is abusing serde_json to get json escaping
- let s = json::Value::String(s.clone());
- let s = json::to_string(&s).map_err(|e| format!("{:?}", e))?;
+ let s = serde_json::Value::String(s.clone());
+ let s = serde_json::to_string(&s).map_err(|e| format!("{:?}", e))?;
buf.extend(s.as_bytes());
Ok(())
}
@@ -69,8 +69,8 @@
first = false;
// this mess is abusing serde_json to get json escaping
- let k = json::Value::String(k.clone());
- let k = json::to_string(&k).map_err(|e| format!("{:?}", e))?;
+ let k = serde_json::Value::String(k.clone());
+ let k = serde_json::to_string(&k).map_err(|e| format!("{:?}", e))?;
buf.extend(k.as_bytes());
buf.push(b':');
@@ -88,31 +88,31 @@
U64(u64),
}
-fn convert(jsn: &json::Value) -> Result<Value, String> {
+fn convert(jsn: &serde_json::Value) -> Result<Value, String> {
match *jsn {
- json::Value::Null => Ok(Value::Null),
- json::Value::Bool(b) => Ok(Value::Bool(b)),
- json::Value::Number(ref n) => n
+ serde_json::Value::Null => Ok(Value::Null),
+ serde_json::Value::Bool(b) => Ok(Value::Bool(b)),
+ serde_json::Value::Number(ref n) => n
.as_i64()
.map(Number::I64)
.or_else(|| n.as_u64().map(Number::U64))
.map(Value::Number)
.ok_or_else(|| String::from("only i64 and u64 are supported")),
- json::Value::Array(ref arr) => {
+ serde_json::Value::Array(ref arr) => {
let mut out = Vec::new();
for res in arr.iter().map(|v| convert(v)) {
out.push(res?)
}
Ok(Value::Array(out))
}
- json::Value::Object(ref obj) => {
+ serde_json::Value::Object(ref obj) => {
let mut out = BTreeMap::new();
for (k, v) in obj.iter() {
let _ = out.insert(k.clone(), convert(v)?);
}
Ok(Value::Object(out))
}
- json::Value::String(ref s) => Ok(Value::String(s.clone())),
+ serde_json::Value::String(ref s) => Ok(Value::String(s.clone())),
}
}
diff --git a/src/interchange/mod.rs b/src/interchange/mod.rs
index 7f6dbd6..8bdcb6f 100644
--- a/src/interchange/mod.rs
+++ b/src/interchange/mod.rs
@@ -2,14 +2,14 @@
mod cjson;
-use json;
use serde::de::DeserializeOwned;
use serde::ser::Serialize;
+use serde_json;
use std::fmt::Debug;
use std::io::{Read, Write};
-use error::Error;
-use Result;
+use crate::error::Error;
+use crate::Result;
/// The format used for data interchange, serialization, and deserialization.
pub trait DataInterchange: Debug + PartialEq + Clone {
@@ -219,7 +219,7 @@
#[derive(Debug, Clone, PartialEq)]
pub struct Json {}
impl DataInterchange for Json {
- type RawData = json::Value;
+ type RawData = serde_json::Value;
/// ```
/// # use tuf::interchange::{DataInterchange, Json};
@@ -267,7 +267,7 @@
where
T: DeserializeOwned,
{
- Ok(json::from_value(raw_data.clone())?)
+ Ok(serde_json::from_value(raw_data.clone())?)
}
/// ```
@@ -296,7 +296,7 @@
where
T: Serialize,
{
- Ok(json::to_value(data)?)
+ Ok(serde_json::to_value(data)?)
}
/// ```
@@ -327,6 +327,6 @@
R: Read,
T: DeserializeOwned,
{
- Ok(json::from_reader(rdr)?)
+ Ok(serde_json::from_reader(rdr)?)
}
}
diff --git a/src/lib.rs b/src/lib.rs
index a93a655..1d6f125 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -130,12 +130,7 @@
extern crate serde;
#[macro_use]
extern crate serde_derive;
-
-#[cfg(not(test))]
-extern crate serde_json as json;
-#[cfg(test)]
-#[macro_use]
-extern crate serde_json as json;
+extern crate serde_json;
extern crate tempfile;
extern crate untrusted;
@@ -154,6 +149,6 @@
pub mod tuf;
mod util;
-pub use error::*;
-pub use tuf::*;
-pub use util::*;
+pub use crate::error::*;
+pub use crate::tuf::*;
+pub use crate::util::*;
diff --git a/src/metadata.rs b/src/metadata.rs
index 0e0fb91..a25db77 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -9,11 +9,11 @@
use std::io::Read;
use std::marker::PhantomData;
-use crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
-use error::Error;
-use interchange::DataInterchange;
-use shims;
-use Result;
+use crate::crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::shims;
+use crate::Result;
#[cfg_attr(rustfmt, rustfmt_skip)]
static PATH_ILLEGAL_COMPONENTS: &'static [&str] = &[
@@ -1377,9 +1377,11 @@
parents[0]
.iter()
.any(|p| parent.is_child(p) || parent == &p)
- }).cloned()
+ })
+ .cloned()
.collect::<HashSet<_>>()
- }).collect::<Vec<_>>();
+ })
+ .collect::<Vec<_>>();
self.matches_chain(&*new)
}
@@ -1684,11 +1686,12 @@
return Err(Error::IllegalArgument("Roles cannot be empty.".into()));
}
- if roles.len() != roles
- .iter()
- .map(|r| &r.role)
- .collect::<HashSet<&MetadataPath>>()
- .len()
+ if roles.len()
+ != roles
+ .iter()
+ .map(|r| &r.role)
+ .collect::<HashSet<&MetadataPath>>()
+ .len()
{
return Err(Error::IllegalArgument(
"Cannot have duplicated roles in delegations.".into(),
@@ -1827,10 +1830,10 @@
#[cfg(test)]
mod test {
use super::*;
+ use crate::crypto::SignatureScheme;
+ use crate::interchange::Json;
use chrono::prelude::*;
- use crypto::SignatureScheme;
- use interchange::Json;
- use json;
+ use serde_json::json;
const ED25519_1_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
const ED25519_2_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-2.pk8.der");
@@ -1895,7 +1898,8 @@
.iter()
.map(|p| VirtualTargetPath::new(p.to_string()).unwrap())
.collect::<HashSet<_>>()
- }).collect::<Vec<_>>();
+ })
+ .collect::<Vec<_>>();
println!(
"CASE: expect: {} path: {:?} parents: {:?}",
expected, target, parents
@@ -1907,32 +1911,32 @@
#[test]
fn serde_target_path() {
let s = "foo/bar";
- let t = json::from_str::<VirtualTargetPath>(&format!("\"{}\"", s)).unwrap();
+ let t = serde_json::from_str::<VirtualTargetPath>(&format!("\"{}\"", s)).unwrap();
assert_eq!(t.to_string().as_str(), s);
- assert_eq!(json::to_value(t).unwrap(), json!("foo/bar"));
+ assert_eq!(serde_json::to_value(t).unwrap(), json!("foo/bar"));
}
#[test]
fn serde_metadata_path() {
let s = "foo/bar";
- let m = json::from_str::<MetadataPath>(&format!("\"{}\"", s)).unwrap();
+ let m = serde_json::from_str::<MetadataPath>(&format!("\"{}\"", s)).unwrap();
assert_eq!(m.to_string().as_str(), s);
- assert_eq!(json::to_value(m).unwrap(), json!("foo/bar"));
+ assert_eq!(serde_json::to_value(m).unwrap(), json!("foo/bar"));
}
#[test]
fn serde_target_description() {
let s: &[u8] = b"from water does all life begin";
let description = TargetDescription::from_reader(s, &[HashAlgorithm::Sha256]).unwrap();
- let jsn_str = json::to_string(&description).unwrap();
+ let jsn_str = serde_json::to_string(&description).unwrap();
let jsn = json!({
"size": 30,
"hashes": {
"sha256": "_F10XHEryG6poxJk2sDJVu61OFf2d-7QWCm7cQE8rhg=",
},
});
- let parsed_str: TargetDescription = json::from_str(&jsn_str).unwrap();
- let parsed_jsn: TargetDescription = json::from_value(jsn).unwrap();
+ let parsed_str: TargetDescription = serde_json::from_str(&jsn_str).unwrap();
+ let parsed_jsn: TargetDescription = serde_json::from_value(jsn).unwrap();
assert_eq!(parsed_str, parsed_jsn);
}
@@ -1941,7 +1945,8 @@
let hashes = hashset!(
"diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
"ar9AgoRsmeEcf6Ponta_1TZu1ds5uXbDemBig30O7ck=",
- ).iter()
+ )
+ .iter()
.map(|k| KeyId::from_string(*k).unwrap())
.collect();
let role_def = RoleDefinition::new(2, hashes).unwrap();
@@ -1953,9 +1958,9 @@
"diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
],
});
- let encoded = json::to_value(&role_def).unwrap();
+ let encoded = serde_json::to_value(&role_def).unwrap();
assert_eq!(encoded, jsn);
- let decoded: RoleDefinition = json::from_value(encoded).unwrap();
+ let decoded: RoleDefinition = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, role_def);
let jsn = json!({
@@ -1964,7 +1969,7 @@
"diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
],
});
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
let jsn = json!({
"threshold": -1,
@@ -1972,7 +1977,7 @@
"diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
],
});
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
}
#[test]
@@ -2041,9 +2046,9 @@
},
});
- let encoded = json::to_value(&root).unwrap();
+ let encoded = serde_json::to_value(&root).unwrap();
assert_eq!(encoded, jsn);
- let decoded: RootMetadata = json::from_value(encoded).unwrap();
+ let decoded: RootMetadata = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, root);
}
@@ -2053,7 +2058,8 @@
1,
100,
hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
- ).unwrap();
+ )
+ .unwrap();
let timestamp = TimestampMetadataBuilder::from_metadata_description(description)
.expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
@@ -2073,9 +2079,9 @@
},
});
- let encoded = json::to_value(×tamp).unwrap();
+ let encoded = serde_json::to_value(×tamp).unwrap();
assert_eq!(encoded, jsn);
- let decoded: TimestampMetadata = json::from_value(encoded).unwrap();
+ let decoded: TimestampMetadata = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, timestamp);
}
@@ -2089,8 +2095,10 @@
1,
100,
hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
- ).unwrap(),
- ).build()
+ )
+ .unwrap(),
+ )
+ .build()
.unwrap();
let jsn = json!({
@@ -2108,9 +2116,9 @@
},
});
- let encoded = json::to_value(&snapshot).unwrap();
+ let encoded = serde_json::to_value(&snapshot).unwrap();
assert_eq!(encoded, jsn);
- let decoded: SnapshotMetadata = json::from_value(encoded).unwrap();
+ let decoded: SnapshotMetadata = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, snapshot);
}
@@ -2121,7 +2129,8 @@
.insert_target_description(
VirtualTargetPath::new("foo".into()).unwrap(),
TargetDescription::from_reader(&b"foo"[..], &[HashAlgorithm::Sha256]).unwrap(),
- ).build()
+ )
+ .build()
.unwrap();
let jsn = json!({
@@ -2138,9 +2147,9 @@
},
});
- let encoded = json::to_value(&targets).unwrap();
+ let encoded = serde_json::to_value(&targets).unwrap();
assert_eq!(encoded, jsn);
- let decoded: TargetsMetadata = json::from_value(encoded).unwrap();
+ let decoded: TargetsMetadata = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, targets);
}
@@ -2149,16 +2158,16 @@
let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
let delegations = Delegations::new(
&hashset![key.public().clone()],
- vec![
- Delegation::new(
- MetadataPath::new("foo/bar".into()).unwrap(),
- false,
- 1,
- hashset!(key.key_id().clone()),
- hashset!(VirtualTargetPath::new("baz/quux".into()).unwrap()),
- ).unwrap(),
- ],
- ).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("foo/bar".into()).unwrap(),
+ false,
+ 1,
+ hashset!(key.key_id().clone()),
+ hashset!(VirtualTargetPath::new("baz/quux".into()).unwrap()),
+ )
+ .unwrap()],
+ )
+ .unwrap();
let targets = TargetsMetadataBuilder::new()
.expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
@@ -2192,9 +2201,9 @@
}
});
- let encoded = json::to_value(&targets).unwrap();
+ let encoded = serde_json::to_value(&targets).unwrap();
assert_eq!(encoded, jsn);
- let decoded: TargetsMetadata = json::from_value(encoded).unwrap();
+ let decoded: TargetsMetadata = serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, targets);
}
@@ -2208,8 +2217,10 @@
1,
100,
hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
- ).unwrap(),
- ).build()
+ )
+ .unwrap(),
+ )
+ .build()
.unwrap();
let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
@@ -2240,9 +2251,10 @@
},
});
- let encoded = json::to_value(&signed).unwrap();
+ let encoded = serde_json::to_value(&signed).unwrap();
assert_eq!(encoded, jsn, "{:#?} != {:#?}", encoded, jsn);
- let decoded: SignedMetadata<Json, SnapshotMetadata> = json::from_value(encoded).unwrap();
+ let decoded: SignedMetadata<Json, SnapshotMetadata> =
+ serde_json::from_value(encoded).unwrap();
assert_eq!(decoded, signed);
}
@@ -2269,7 +2281,7 @@
// TODO test for mismatched ed25519/rsa keys/schemes
- fn make_root() -> json::Value {
+ fn make_root() -> serde_json::Value {
let root_key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
let snapshot_key = PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519).unwrap();
let targets_key = PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519).unwrap();
@@ -2285,19 +2297,19 @@
.build()
.unwrap();
- json::to_value(&root).unwrap()
+ serde_json::to_value(&root).unwrap()
}
- fn make_snapshot() -> json::Value {
+ fn make_snapshot() -> serde_json::Value {
let snapshot = SnapshotMetadataBuilder::new()
.expires(Utc.ymd(2038, 1, 1).and_hms(0, 0, 0))
.build()
.unwrap();
- json::to_value(&snapshot).unwrap()
+ serde_json::to_value(&snapshot).unwrap()
}
- fn make_timestamp() -> json::Value {
+ fn make_timestamp() -> serde_json::Value {
let description =
MetadataDescription::from_reader(&[][..], 1, &[HashAlgorithm::Sha256]).unwrap();
@@ -2306,39 +2318,39 @@
.build()
.unwrap();
- json::to_value(×tamp).unwrap()
+ serde_json::to_value(×tamp).unwrap()
}
- fn make_targets() -> json::Value {
+ fn make_targets() -> serde_json::Value {
let targets =
TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
.unwrap();
- json::to_value(&targets).unwrap()
+ serde_json::to_value(&targets).unwrap()
}
- fn make_delegations() -> json::Value {
+ fn make_delegations() -> serde_json::Value {
let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
.unwrap()
.public()
.clone();
let delegations = Delegations::new(
&hashset![key.clone()],
- vec![
- Delegation::new(
- MetadataPath::new("foo".into()).unwrap(),
- false,
- 1,
- hashset!(key.key_id().clone()),
- hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
- ).unwrap(),
- ],
- ).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("foo".into()).unwrap(),
+ false,
+ 1,
+ hashset!(key.key_id().clone()),
+ hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
+ )
+ .unwrap()],
+ )
+ .unwrap();
- json::to_value(&delegations).unwrap()
+ serde_json::to_value(&delegations).unwrap()
}
- fn make_delegation() -> json::Value {
+ fn make_delegation() -> serde_json::Value {
let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
.unwrap()
.public()
@@ -2349,12 +2361,13 @@
1,
hashset!(key.key_id().clone()),
hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
- ).unwrap();
+ )
+ .unwrap();
- json::to_value(&delegation).unwrap()
+ serde_json::to_value(&delegation).unwrap()
}
- fn set_version(value: &mut json::Value, version: i64) {
+ fn set_version(value: &mut serde_json::Value, version: i64) {
match value.as_object_mut() {
Some(obj) => {
let _ = obj.insert("version".into(), json!(version));
@@ -2368,11 +2381,11 @@
fn deserialize_json_root_illegal_version() {
let mut root_json = make_root();
set_version(&mut root_json, 0);
- assert!(json::from_value::<RootMetadata>(root_json.clone()).is_err());
+ assert!(serde_json::from_value::<RootMetadata>(root_json.clone()).is_err());
let mut root_json = make_root();
set_version(&mut root_json, -1);
- assert!(json::from_value::<RootMetadata>(root_json).is_err());
+ assert!(serde_json::from_value::<RootMetadata>(root_json).is_err());
}
// Refuse to deserialize root metadata if it contains duplicate keys
@@ -2395,10 +2408,10 @@
.as_array_mut()
.unwrap()
.push(dupe);
- assert!(json::from_value::<RootMetadata>(root_json).is_err());
+ assert!(serde_json::from_value::<RootMetadata>(root_json).is_err());
}
- fn set_threshold(value: &mut json::Value, threshold: i32) {
+ fn set_threshold(value: &mut serde_json::Value, threshold: i32) {
match value.as_object_mut() {
Some(obj) => {
let _ = obj.insert("threshold".into(), json!(threshold));
@@ -2418,15 +2431,16 @@
.key_id()
.clone()
),
- ).unwrap();
+ )
+ .unwrap();
- let mut jsn = json::to_value(&role_def).unwrap();
+ let mut jsn = serde_json::to_value(&role_def).unwrap();
set_threshold(&mut jsn, 0);
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
- let mut jsn = json::to_value(&role_def).unwrap();
+ let mut jsn = serde_json::to_value(&role_def).unwrap();
set_threshold(&mut jsn, -1);
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
let role_def = RoleDefinition::new(
2,
@@ -2440,11 +2454,12 @@
.key_id()
.clone(),
),
- ).unwrap();
+ )
+ .unwrap();
- let mut jsn = json::to_value(&role_def).unwrap();
+ let mut jsn = serde_json::to_value(&role_def).unwrap();
set_threshold(&mut jsn, 3);
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
}
// Refuse to deserialilze root metadata with wrong type field
@@ -2455,7 +2470,7 @@
.as_object_mut()
.unwrap()
.insert("type".into(), json!("snapshot"));
- assert!(json::from_value::<RootMetadata>(root).is_err());
+ assert!(serde_json::from_value::<RootMetadata>(root).is_err());
}
// Refuse to deserialize role definitions with duplicated key ids
@@ -2466,7 +2481,7 @@
.key_id()
.clone();
let role_def = RoleDefinition::new(1, hashset!(key_id.clone())).unwrap();
- let mut jsn = json::to_value(&role_def).unwrap();
+ let mut jsn = serde_json::to_value(&role_def).unwrap();
match jsn.as_object_mut() {
Some(obj) => match obj.get_mut("key_ids").unwrap().as_array_mut() {
@@ -2476,7 +2491,7 @@
None => panic!(),
}
- assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+ assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
}
// Refuse to deserialize snapshot metadata with illegal versions
@@ -2484,11 +2499,11 @@
fn deserialize_json_snapshot_illegal_version() {
let mut snapshot = make_snapshot();
set_version(&mut snapshot, 0);
- assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+ assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
let mut snapshot = make_snapshot();
set_version(&mut snapshot, -1);
- assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+ assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
}
// Refuse to deserialilze snapshot metadata with wrong type field
@@ -2499,7 +2514,7 @@
.as_object_mut()
.unwrap()
.insert("type".into(), json!("root"));
- assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+ assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
}
// Refuse to deserialize timestamp metadata with illegal versions
@@ -2507,11 +2522,11 @@
fn deserialize_json_timestamp_illegal_version() {
let mut timestamp = make_timestamp();
set_version(&mut timestamp, 0);
- assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+ assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
let mut timestamp = make_timestamp();
set_version(&mut timestamp, -1);
- assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+ assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
}
// Refuse to deserialilze timestamp metadata with wrong type field
@@ -2522,7 +2537,7 @@
.as_object_mut()
.unwrap()
.insert("type".into(), json!("root"));
- assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+ assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
}
// Refuse to deserialize targets metadata with illegal versions
@@ -2530,11 +2545,11 @@
fn deserialize_json_targets_illegal_version() {
let mut targets = make_targets();
set_version(&mut targets, 0);
- assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+ assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
let mut targets = make_targets();
set_version(&mut targets, -1);
- assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+ assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
}
// Refuse to deserialilze targets metadata with wrong type field
@@ -2545,7 +2560,7 @@
.as_object_mut()
.unwrap()
.insert("type".into(), json!("root"));
- assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+ assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
}
// Refuse to deserialize delegations with no keys
@@ -2560,7 +2575,7 @@
.as_array_mut()
.unwrap()
.clear();
- assert!(json::from_value::<Delegations>(delegations).is_err());
+ assert!(serde_json::from_value::<Delegations>(delegations).is_err());
}
// Refuse to deserialize delegations with no roles
@@ -2575,7 +2590,7 @@
.as_array_mut()
.unwrap()
.clear();
- assert!(json::from_value::<Delegations>(delegations).is_err());
+ assert!(serde_json::from_value::<Delegations>(delegations).is_err());
}
// Refuse to deserialize delegations with duplicated roles
@@ -2598,7 +2613,7 @@
.as_array_mut()
.unwrap()
.push(dupe);
- assert!(json::from_value::<Delegations>(delegations).is_err());
+ assert!(serde_json::from_value::<Delegations>(delegations).is_err());
}
// Refuse to deserialize a delegation with insufficient threshold
@@ -2606,11 +2621,11 @@
fn deserialize_json_delegation_bad_threshold() {
let mut delegation = make_delegation();
set_threshold(&mut delegation, 0);
- assert!(json::from_value::<Delegation>(delegation).is_err());
+ assert!(serde_json::from_value::<Delegation>(delegation).is_err());
let mut delegation = make_delegation();
set_threshold(&mut delegation, 2);
- assert!(json::from_value::<Delegation>(delegation).is_err());
+ assert!(serde_json::from_value::<Delegation>(delegation).is_err());
}
// Refuse to deserialize a delegation with duplicate key IDs
@@ -2633,7 +2648,7 @@
.as_array_mut()
.unwrap()
.push(dupe);
- assert!(json::from_value::<Delegation>(delegation).is_err());
+ assert!(serde_json::from_value::<Delegation>(delegation).is_err());
}
// Refuse to deserialize a delegation with duplicate paths
@@ -2656,7 +2671,7 @@
.as_array_mut()
.unwrap()
.push(dupe);
- assert!(json::from_value::<Delegation>(delegation).is_err());
+ assert!(serde_json::from_value::<Delegation>(delegation).is_err());
}
// Refuse to deserialize a Delegations struct with duplicate keys
@@ -2668,17 +2683,17 @@
.clone();
let delegations = Delegations::new(
&hashset!(key.clone()),
- vec![
- Delegation::new(
- MetadataPath::new("foo".into()).unwrap(),
- false,
- 1,
- hashset!(key.key_id().clone()),
- hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
- ).unwrap(),
- ],
- ).unwrap();
- let mut delegations = json::to_value(delegations).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("foo".into()).unwrap(),
+ false,
+ 1,
+ hashset!(key.key_id().clone()),
+ hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
+ )
+ .unwrap()],
+ )
+ .unwrap();
+ let mut delegations = serde_json::to_value(delegations).unwrap();
let dupe = delegations
.as_object()
@@ -2696,6 +2711,6 @@
.as_array_mut()
.unwrap()
.push(dupe);
- assert!(json::from_value::<Delegations>(delegations).is_err());
+ assert!(serde_json::from_value::<Delegations>(delegations).is_err());
}
}
diff --git a/src/repository.rs b/src/repository.rs
index 7304d79..3d68917 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -12,14 +12,14 @@
use std::sync::{Arc, RwLock};
use tempfile::NamedTempFile;
-use crypto::{self, HashAlgorithm, HashValue};
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::{self, HashAlgorithm, HashValue};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
Metadata, MetadataPath, MetadataVersion, SignedMetadata, TargetDescription, TargetPath,
};
-use util::SafeReader;
-use Result;
+use crate::util::SafeReader;
+use crate::Result;
/// Top-level trait that represents a TUF repository and contains all the ways it can be interacted
/// with.
@@ -504,7 +504,7 @@
#[cfg(test)]
mod test {
use super::*;
- use interchange::Json;
+ use crate::interchange::Json;
use tempfile;
#[test]
@@ -546,15 +546,13 @@
TargetDescription::from_reader(data, &[HashAlgorithm::Sha256]).unwrap();
let path = TargetPath::new("foo/bar/baz".into()).unwrap();
repo.store_target(data, &path).unwrap();
- assert!(
- temp_dir
- .path()
- .join("targets")
- .join("foo")
- .join("bar")
- .join("baz")
- .exists()
- );
+ assert!(temp_dir
+ .path()
+ .join("targets")
+ .join("foo")
+ .join("bar")
+ .join("baz")
+ .exists());
let mut buf = Vec::new();
diff --git a/src/shims.rs b/src/shims.rs
index 294474e..88072a2 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -4,10 +4,10 @@
use std::collections::{HashMap, HashSet};
use std::iter::FromIterator;
-use crypto;
-use error::Error;
-use metadata::{self, Metadata};
-use Result;
+use crate::crypto;
+use crate::error::Error;
+use crate::metadata::{self, Metadata};
+use crate::Result;
fn parse_datetime(ts: &str) -> Result<DateTime<Utc>> {
Utc.datetime_from_str(ts, "%FT%TZ")
diff --git a/src/tuf.rs b/src/tuf.rs
index 1fa84fa..26f2297 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -4,14 +4,14 @@
use std::collections::{HashMap, HashSet};
use std::marker::PhantomData;
-use crypto::KeyId;
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::KeyId;
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
Delegations, Metadata, MetadataPath, Role, RootMetadata, SignedMetadata, SnapshotMetadata,
TargetDescription, TargetsMetadata, TimestampMetadata, VirtualTargetPath,
};
-use Result;
+use crate::Result;
/// Contains trusted TUF metadata and can be used to verify other metadata and targets.
#[derive(Debug)]
@@ -411,7 +411,7 @@
None => {
return Err(Error::VerificationFailure(
"Delegations not authorized".into(),
- ))
+ ));
}
};
@@ -421,7 +421,7 @@
return Err(Error::VerificationFailure(format!(
"The degated role {:?} was not present in the snapshot metadata.",
role
- )))
+ )));
}
};
@@ -622,9 +622,9 @@
#[cfg(test)]
mod test {
use super::*;
- use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
- use interchange::Json;
- use metadata::{
+ use crate::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
+ use crate::interchange::Json;
+ use crate::metadata::{
RootMetadataBuilder, SnapshotMetadataBuilder, TargetsMetadataBuilder,
TimestampMetadataBuilder,
};
diff --git a/src/util.rs b/src/util.rs
index c6ba957..d0deb81 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -3,9 +3,9 @@
use ring::digest::{self, SHA256, SHA512};
use std::io::{self, ErrorKind, Read};
-use crypto::{HashAlgorithm, HashValue};
-use error::Error;
-use Result;
+use crate::crypto::{HashAlgorithm, HashValue};
+use crate::error::Error;
+use crate::Result;
/// Wrapper to verify a byte stream as it is read.
///
@@ -48,7 +48,7 @@
return Err(Error::IllegalArgument(format!(
"Unknown hash algorithm: {}",
s
- )))
+ )));
}
};
Some((ctx, value))
@@ -181,7 +181,8 @@
bytes.len() as u64,
0,
Some((&HashAlgorithm::Sha256, hash_value)),
- ).unwrap();
+ )
+ .unwrap();
let mut buf = Vec::new();
assert!(reader.read_to_end(&mut buf).is_ok());
assert_eq!(buf, bytes);
@@ -199,7 +200,8 @@
bytes.len() as u64,
0,
Some((&HashAlgorithm::Sha256, hash_value)),
- ).unwrap();
+ )
+ .unwrap();
let mut buf = Vec::new();
assert!(reader.read_to_end(&mut buf).is_err());
}
@@ -215,7 +217,8 @@
bytes.len() as u64,
0,
Some((&HashAlgorithm::Sha256, hash_value)),
- ).unwrap();
+ )
+ .unwrap();
let mut buf = Vec::new();
assert!(reader.read_to_end(&mut buf).is_ok());
assert_eq!(buf, bytes);
@@ -233,7 +236,8 @@
bytes.len() as u64,
0,
Some((&HashAlgorithm::Sha256, hash_value)),
- ).unwrap();
+ )
+ .unwrap();
let mut buf = Vec::new();
assert!(reader.read_to_end(&mut buf).is_err());
}
diff --git a/tests/integration.rs b/tests/integration.rs
index ad495f0..ed63c04 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -43,10 +43,12 @@
.insert_metadata_description(
MetadataPath::new("targets".into()).unwrap(),
MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
- ).insert_metadata_description(
+ )
+ .insert_metadata_description(
MetadataPath::new("delegation".into()).unwrap(),
MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
- ).signed::<Json>(&snapshot_key)
+ )
+ .signed::<Json>(&snapshot_key)
.unwrap();
let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
@@ -60,22 +62,22 @@
//// build the targets ////
let delegations = Delegations::new(
&hashset![delegation_key.public().clone()],
- vec![
- Delegation::new(
- MetadataPath::new("delegation".into()).unwrap(),
- false,
- 1,
- vec![delegation_key.key_id().clone()]
- .iter()
- .cloned()
- .collect(),
- vec![VirtualTargetPath::new("foo".into()).unwrap()]
- .iter()
- .cloned()
- .collect(),
- ).unwrap(),
- ],
- ).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("delegation".into()).unwrap(),
+ false,
+ 1,
+ vec![delegation_key.key_id().clone()]
+ .iter()
+ .cloned()
+ .collect(),
+ vec![VirtualTargetPath::new("foo".into()).unwrap()]
+ .iter()
+ .cloned()
+ .collect(),
+ )
+ .unwrap()],
+ )
+ .unwrap();
let targets = TargetsMetadataBuilder::new()
.delegations(delegations)
.signed::<Json>(&targets_key)
@@ -90,17 +92,17 @@
VirtualTargetPath::new("foo".into()).unwrap(),
target_file,
&[HashAlgorithm::Sha256],
- ).unwrap()
+ )
+ .unwrap()
.signed::<Json>(&delegation_key)
.unwrap();
tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), delegation)
.unwrap();
- assert!(
- tuf.target_description(&VirtualTargetPath::new("foo".into()).unwrap())
- .is_ok()
- );
+ assert!(tuf
+ .target_description(&VirtualTargetPath::new("foo".into()).unwrap())
+ .is_ok());
}
#[test]
@@ -130,13 +132,16 @@
.insert_metadata_description(
MetadataPath::new("targets".into()).unwrap(),
MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
- ).insert_metadata_description(
+ )
+ .insert_metadata_description(
MetadataPath::new("delegation-a".into()).unwrap(),
MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
- ).insert_metadata_description(
+ )
+ .insert_metadata_description(
MetadataPath::new("delegation-b".into()).unwrap(),
MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
- ).signed::<Json>(&snapshot_key)
+ )
+ .signed::<Json>(&snapshot_key)
.unwrap();
let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
@@ -151,22 +156,22 @@
let delegations = Delegations::new(
&hashset![delegation_a_key.public().clone()],
- vec![
- Delegation::new(
- MetadataPath::new("delegation-a".into()).unwrap(),
- false,
- 1,
- vec![delegation_a_key.key_id().clone()]
- .iter()
- .cloned()
- .collect(),
- vec![VirtualTargetPath::new("foo".into()).unwrap()]
- .iter()
- .cloned()
- .collect(),
- ).unwrap(),
- ],
- ).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("delegation-a".into()).unwrap(),
+ false,
+ 1,
+ vec![delegation_a_key.key_id().clone()]
+ .iter()
+ .cloned()
+ .collect(),
+ vec![VirtualTargetPath::new("foo".into()).unwrap()]
+ .iter()
+ .cloned()
+ .collect(),
+ )
+ .unwrap()],
+ )
+ .unwrap();
let targets = TargetsMetadataBuilder::new()
.delegations(delegations)
.signed::<Json>(&targets_key)
@@ -178,22 +183,22 @@
let delegations = Delegations::new(
&hashset![delegation_b_key.public().clone()],
- vec![
- Delegation::new(
- MetadataPath::new("delegation-b".into()).unwrap(),
- false,
- 1,
- vec![delegation_b_key.key_id().clone()]
- .iter()
- .cloned()
- .collect(),
- vec![VirtualTargetPath::new("foo".into()).unwrap()]
- .iter()
- .cloned()
- .collect(),
- ).unwrap(),
- ],
- ).unwrap();
+ vec![Delegation::new(
+ MetadataPath::new("delegation-b".into()).unwrap(),
+ false,
+ 1,
+ vec![delegation_b_key.key_id().clone()]
+ .iter()
+ .cloned()
+ .collect(),
+ vec![VirtualTargetPath::new("foo".into()).unwrap()]
+ .iter()
+ .cloned()
+ .collect(),
+ )
+ .unwrap()],
+ )
+ .unwrap();
let delegation = TargetsMetadataBuilder::new()
.delegations(delegations)
@@ -203,7 +208,8 @@
tuf.update_delegation(
&MetadataPath::new("delegation-a".into()).unwrap(),
delegation,
- ).unwrap();
+ )
+ .unwrap();
//// build delegation B ////
@@ -214,17 +220,18 @@
VirtualTargetPath::new("foo".into()).unwrap(),
target_file,
&[HashAlgorithm::Sha256],
- ).unwrap()
+ )
+ .unwrap()
.signed::<Json>(&delegation_b_key)
.unwrap();
tuf.update_delegation(
&MetadataPath::new("delegation-b".into()).unwrap(),
delegation,
- ).unwrap();
+ )
+ .unwrap();
- assert!(
- tuf.target_description(&VirtualTargetPath::new("foo".into()).unwrap())
- .is_ok()
- );
+ assert!(tuf
+ .target_description(&VirtualTargetPath::new("foo".into()).unwrap())
+ .is_ok());
}
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
index 8eaea1c..ff7707c 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -105,7 +105,8 @@
config.path_translator().real_to_virtual(&target_path)?,
target_file,
&[HashAlgorithm::Sha256],
- )?.signed::<Json>(&targets_key)?;
+ )?
+ .signed::<Json>(&targets_key)?;
remote.store_metadata(
&MetadataPath::new("targets".into())?,
