diff --git a/src/client.rs b/src/client.rs
index 1f9dca1..5c5ed59 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,7 +1,5 @@
 //! Clients for high level interactions with TUF repositories.
 
-use chrono::offset::Utc;
-
 use Result;
 use crypto;
 use error::Error;
@@ -40,38 +38,66 @@
         }
     }
 
-    /// Update TUF metadata from local and remote repositories.
+    /// Update TUF metadata from the local repository.
     ///
     /// Returns `true` if an update occurred and `false` otherwise.
-    // TODO this might need to be split into `update_local` and `update_remote` to be useful to
-    // implementers.
-    pub fn update(&mut self) -> Result<bool> {
-        if self.update_root()? && self.update_timestamp()? {
-            self.update_snapshot()
-        } else {
-            Ok(false)
-        }
+    pub fn update_local(&mut self) -> Result<bool> {
+        let r = Self::update_root(&mut self.tuf, &mut self.local, &self.config.max_root_size)?;
+        let ts = match Self::update_timestamp(
+            &mut self.tuf,
+            &mut self.local,
+            &self.config.max_timestamp_size,
+        ) {
+            Ok(b) => b,
+            Err(e) => {
+                warn!(
+                    "Error updating timestamp metadata from local sources: {:?}",
+                    e
+                );
+                false
+            }
+        };
+        let sn = match Self::update_snapshot(&mut self.tuf, &mut self.local) {
+            Ok(b) => b,
+            Err(e) => {
+                warn!(
+                    "Error updating snapshot metadata from local sources: {:?}",
+                    e
+                );
+                false
+            }
+        };
+        let ta = match Self::update_targets(&mut self.tuf, &mut self.local) {
+            Ok(b) => b,
+            Err(e) => {
+                warn!(
+                    "Error updating targets metadata from local sources: {:?}",
+                    e
+                );
+                false
+            }
+        };
+
+        Ok(r || ts || sn || ta)
+    }
+
+    /// Update TUF metadata from the remote repository.
+    ///
+    /// Returns `true` if an update occurred and `false` otherwise.
+    pub fn update_remote(&mut self) -> Result<bool> {
+        Ok(
+            Self::update_root(&mut self.tuf, &mut self.remote, &self.config.max_root_size)? ||
+                Self::update_timestamp(
+                    &mut self.tuf,
+                    &mut self.remote,
+                    &self.config.max_timestamp_size,
+                )? || Self::update_snapshot(&mut self.tuf, &mut self.remote)? ||
+                Self::update_targets(&mut self.tuf, &mut self.local)?,
+        )
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
-    fn update_root(&mut self) -> Result<bool> {
-        let local_updated =
-            Self::update_root_chain(&mut self.tuf, &self.config.max_root_size, &mut self.local)?;
-        let remote_updated =
-            Self::update_root_chain(&mut self.tuf, &self.config.max_root_size, &mut self.remote)?;
-
-        if self.tuf.root().expires() <= &Utc::now() {
-            Err(Error::ExpiredMetadata(Role::Root))
-        } else {
-            Ok(local_updated || remote_updated)
-        }
-    }
-
-    fn update_root_chain<T>(
-        tuf: &mut Tuf<D>,
-        max_root_size: &Option<usize>,
-        repo: &mut T,
-    ) -> Result<bool>
+    fn update_root<T>(tuf: &mut Tuf<D>, repo: &mut T, max_root_size: &Option<usize>) -> Result<bool>
     where
         T: Repository<D>,
     {
@@ -118,33 +144,35 @@
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
-    fn update_timestamp(&mut self) -> Result<bool> {
-        let ts = self.local.fetch_metadata(
+    fn update_timestamp<T>(
+        tuf: &mut Tuf<D>,
+        repo: &mut T,
+        max_timestamp_size: &Option<usize>,
+    ) -> Result<bool>
+    where
+        T: Repository<D>,
+    {
+        let ts = repo.fetch_metadata(
             &Role::Timestamp,
             &MetadataVersion::None,
-            &self.config.max_timestamp_size,
+            max_timestamp_size,
             None,
         )?;
-        self.tuf.update_timestamp(ts)?;
-
-        let ts = self.remote.fetch_metadata(
-            &Role::Timestamp,
-            &MetadataVersion::None,
-            &self.config.max_timestamp_size,
-            None,
-        )?;
-        self.tuf.update_timestamp(ts)
+        tuf.update_timestamp(ts)
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
-    fn update_snapshot(&mut self) -> Result<bool> {
-        let snapshot_description = match self.tuf.timestamp() {
+    fn update_snapshot<T>(tuf: &mut Tuf<D>, repo: &mut T) -> Result<bool>
+    where
+        T: Repository<D>,
+    {
+        let snapshot_description = match tuf.timestamp() {
             Some(ts) => {
                 match ts.meta().get(&MetadataPath::from_role(&Role::Timestamp)) {
                     Some(d) => Ok(d),
                     None => Err(Error::VerificationFailure(
                         "Timestamp metadata did not contain a description of the \
-                                current snapshot metadata"
+                                current snapshot metadata."
                             .into(),
                     )),
                 }
@@ -158,25 +186,52 @@
             None => None,
         };
 
-        let snap = self.local.fetch_metadata(
+        let snap = repo.fetch_metadata(
             &Role::Snapshot,
             &MetadataVersion::None,
             &snapshot_description.length(),
             hashes,
         )?;
-        self.tuf.update_snapshot(snap)?;
+        tuf.update_snapshot(snap)
+    }
 
-        let snap = self.remote.fetch_metadata(
-            &Role::Snapshot,
+    /// Returns `true` if an update occurred and `false` otherwise.
+    fn update_targets<T>(tuf: &mut Tuf<D>, repo: &mut T) -> Result<bool>
+    where
+        T: Repository<D>,
+    {
+        let targets_description = match tuf.snapshot() {
+            Some(sn) => {
+                match sn.meta().get(&MetadataPath::from_role(&Role::Targets)) {
+                    Some(d) => Ok(d),
+                    None => Err(Error::VerificationFailure(
+                        "Snapshot metadata did not contain a description of the \
+                                current targets metadata."
+                            .into(),
+                    )),
+                }
+            }
+            None => Err(Error::MissingMetadata(Role::Snapshot)),
+        }?
+            .clone();
+
+        let hashes = match targets_description.hashes() {
+            Some(hashes) => Some(crypto::hash_preference(hashes)?),
+            None => None,
+        };
+
+        let targets = repo.fetch_metadata(
+            &Role::Targets,
             &MetadataVersion::None,
-            &snapshot_description.length(),
+            &targets_description.length(),
             hashes,
         )?;
-        self.tuf.update_snapshot(snap)
+        tuf.update_targets(targets)
     }
 }
 
 /// Configuration for a TUF `Client`.
+#[derive(Debug)]
 pub struct Config {
     max_root_size: Option<usize>,
     max_timestamp_size: Option<usize>,
@@ -190,6 +245,7 @@
 }
 
 /// Helper for building and validating a TUF `Config`.
+#[derive(Debug, PartialEq)]
 pub struct ConfigBuilder {
     max_root_size: Option<usize>,
     max_timestamp_size: Option<usize>,
@@ -218,6 +274,16 @@
 }
 
 impl Default for ConfigBuilder {
+    /// ```
+    /// use tuf::client::ConfigBuilder;
+    ///
+    /// let default = ConfigBuilder::default();
+    /// let config = ConfigBuilder::default()
+    ///     .max_root_size(Some(1024 * 1024))
+    ///     .max_timestamp_size(Some(32 * 1024));
+    /// assert_eq!(config, default);
+    /// assert!(default.finish().is_ok())
+    /// ```
     fn default() -> Self {
         ConfigBuilder {
             max_root_size: Some(1024 * 1024),
diff --git a/src/interchange/mod.rs b/src/interchange/mod.rs
index f202f99..42bbbd2 100644
--- a/src/interchange/mod.rs
+++ b/src/interchange/mod.rs
@@ -49,6 +49,11 @@
 impl DataInterchange for JsonDataInterchange {
     type RawData = json::Value;
 
+    /// ```
+    /// use tuf::interchange::{DataInterchange, JsonDataInterchange};
+    ///
+    /// assert_eq!(JsonDataInterchange::extension(), "json");
+    /// ```
     fn extension() -> &'static str {
         "json"
     }
diff --git a/src/tuf.rs b/src/tuf.rs
index 54e6ab4..54bc41b 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -64,6 +64,11 @@
         &self.root
     }
 
+    /// An immutable reference to the optional snapshot metadata.
+    pub fn snapshot(&self) -> Option<&SnapshotMetadata> {
+        self.snapshot.as_ref()
+    }
+
     /// An immutable reference to the optional targets metadata.
     pub fn targets(&self) -> Option<&TargetsMetadata> {
         self.targets.as_ref()
@@ -202,9 +207,9 @@
                     "Attempted to roll back snapshot metadata at version {} to {}.",
                     current_version,
                     snapshot.version()
-                )))
+                )));
             } else if snapshot.version() == current_version {
-                return Ok(false)
+                return Ok(false);
             } else {
                 snapshot
             }
@@ -261,9 +266,9 @@
                     "Attempted to roll back targets metadata at version {} to {}.",
                     current_version,
                     targets.version()
-                )))
+                )));
             } else if targets.version() == current_version {
-                return Ok(false)
+                return Ok(false);
             } else {
                 targets
             }