Update File Symbol, add tests

Cargo.toml

@@ -2,3 +2,6 @@
 name = "schematics"
 version = "0.1.0"
 authors = ["Adrian Heine <mail@adrianheine.de>"]
+
+[dev-dependencies]
+tempdir = "0.3"

src/symbols/file.rs

@@ -1,45 +1,13 @@
-use std::error::Error;
+use std::borrow::Cow;
 use std::fmt;
+use std::fs::File as FsFile;
 use std::io;
+use std::io::{Read, Write};
 use std::ops::Deref;
+use std::path::Path;
 
 use symbols::Symbol;
 
-#[derive(Debug)]
-pub enum FileError<E: Error> {
-  ExecError(E),
-  GenericError
-}
-
-impl From<io::Error> for FileError<io::Error> {
-  fn from(err: io::Error) -> FileError<io::Error> {
-    FileError::ExecError(err)
-  }
-}
-
-impl<E: Error> Error for FileError<E> {
-  fn description(&self) -> &str {
-    match self {
-      &FileError::ExecError(ref e) => e.description(),
-      &FileError::GenericError => "Generic error"
-    }
-  }
-  fn cause(&self) -> Option<&Error> {
-    match self {
-      &FileError::ExecError(ref e) => Some(e),
-      _ => None
-    }
-  }
-}
-
-impl<E: Error> fmt::Display for FileError<E> {
-  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-    write!(f, "{}", self.description())
-  }
-}
-
-use std::convert::AsRef;
-
 pub struct File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
   path: D,
   content: C
@@ -54,11 +22,9 @@ impl<C, D> File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
   }
 }
 
-use std::fs::File as FsFile;
-use std::io::{Read, Write};
-
 impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
-  type Error = FileError<io::Error>;
+  type Error = io::Error;
+
   fn target_reached(&self) -> Result<bool, Self::Error> {
     let file = FsFile::open(self.path.as_ref());
     // Check if file exists
@@ -66,16 +32,20 @@ impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt
       return if e.kind() == io::ErrorKind::NotFound {
         Ok(false)
       } else {
-        Err(e.into())
+        Err(e)
       };
     }
     // Check if content is the same
-    let file_content = file.unwrap().bytes();
+    let mut file_content = file.unwrap().bytes();
-    let content_equal = try!(self.content.bytes().zip(file_content).fold(
+    let mut target_content = self.content.bytes();
-      Ok(true),
+    loop {
-      |state, (target_byte, file_byte_option)| state.and_then(|s| file_byte_option.map(|file_byte| s && file_byte == target_byte))
+      match (file_content.next(), target_content.next()) {
-    ));
+        (None, None) => return Ok(true),
-    return Ok(content_equal)
+        (Some(Ok(a)), Some(b)) if a == b => {},
+        (Some(Err(e)), _) => return Err(e),
+        (_, _) => return Ok(false)
+      }
+    }
   }
 
   fn execute(&self) -> Result<(), Self::Error> {

src/symbols/nginx/server.rs

@@ -6,7 +6,6 @@ use std::ops::Deref;
 use command_runner::CommandRunner;
 use symbols::Symbol;
 use symbols::file::File as FileSymbol;
-use symbols::file::FileError;
 
 #[derive(Debug)]
 pub enum NginxServerError<E: Error> {
@@ -14,18 +13,12 @@ pub enum NginxServerError<E: Error> {
   GenericError
 }
 
-impl<E: Error> From<FileError<E>> for NginxServerError<FileError<E>> {
+impl From<io::Error> for NginxServerError<io::Error> {
-  fn from(err: FileError<E>) -> NginxServerError<FileError<E>> {
+  fn from(err: io::Error) -> NginxServerError<io::Error> {
     NginxServerError::ExecError(err)
   }
 }
 
-impl<E: Error> From<io::Error> for NginxServerError<FileError<E>> {
-  fn from(err: io::Error) -> NginxServerError<FileError<E>> {
-    NginxServerError::GenericError
-  }
-}
-
 impl<E: Error> Error for NginxServerError<E> {
   fn description(&self) -> &str {
     match self {

tests/file.rs

@@ -0,0 +1,103 @@
+extern crate schematics;
+extern crate tempdir;
+
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+use tempdir::TempDir;
+use schematics::symbols::Symbol;
+use schematics::symbols::file::File as FileSymbol;
+
+fn get_dir(content: Option<&str>) -> TempDir {
+  let tmp_dir = TempDir::new("unittest").expect("create temp dir");
+  if content.is_none() {
+    return tmp_dir;
+  }
+  let file_path = tmp_dir.path().join("filename");
+  let mut tmp_file = File::create(file_path).expect("create temp file");
+  tmp_file.write_all(content.unwrap().as_bytes()).expect("write temp file");
+  tmp_dir
+}
+
+fn get_symbol(path: &Path) -> FileSymbol<&str, String> {
+  FileSymbol::new(String::from(path.join("filename").to_str().unwrap()), "target content")
+}
+
+// Normal cases
+
+// Good
+#[test]
+fn already_reached() {
+  let dir = get_dir(Some("target content"));
+  let symbol = get_symbol(dir.path());
+
+  assert_eq!(symbol.target_reached().unwrap(), true);
+}
+
+// Bad
+#[test]
+fn wrong_prefix() {
+  let dir = get_dir(Some("not target content"));
+  let symbol = get_symbol(dir.path());
+
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  symbol.execute().unwrap();
+  assert_eq!(symbol.target_reached().unwrap(), true);
+}
+
+#[test]
+fn wrong_postfix() {
+  let dir = get_dir(Some("target content not"));
+  let symbol = get_symbol(dir.path());
+
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  symbol.execute().unwrap();
+  assert_eq!(symbol.target_reached().unwrap(), true);
+}
+
+#[test]
+fn empty_file() {
+  let dir = get_dir(Some(""));
+  let symbol = get_symbol(dir.path());
+
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  symbol.execute().unwrap();
+  assert_eq!(symbol.target_reached().unwrap(), true);
+}
+
+#[test]
+fn no_file() {
+  let dir = get_dir(None);
+  let symbol = get_symbol(dir.path());
+
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  symbol.execute().unwrap();
+  assert_eq!(symbol.target_reached().unwrap(), true);
+}
+
+// Exceptional cases
+
+#[test]
+fn may_not_read_file() {
+  let symbol = get_symbol(&Path::new("/etc/passwd"));
+
+  assert_eq!(symbol.target_reached().is_err(), true);
+}
+
+#[test]
+fn may_not_create_file() {
+  let symbol = get_symbol(&Path::new("/proc/somefile"));
+
+  // Could also return an error
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  assert!(symbol.execute().is_err());
+}
+
+#[test]
+fn directory_missing() {
+  let symbol = get_symbol(&Path::new("/nonexisting"));
+
+  // Could also return an error
+  assert_eq!(symbol.target_reached().unwrap(), false);
+  assert!(symbol.execute().is_err());
+}