Add more tests (#60)

* add docker with configuration of vsftpd to test more easily

* update README

* porting script from docker to travis

* must run vsftpd inside the docker

* improved Dockerfile and README

* added & fixed tests

* trying to make .travis.yml prettier

Author: matt2xu

.travis.yml

@@ -1,27 +1,39 @@
 language: rust
+
 rust:
-# check it compiles on the latest stable compiler
-- stable
+  # check it compiles on the latest stable compiler
+  - stable
+
 before_install:
-- sudo apt-get update -qq
-- sudo apt-get install -yqq bc pure-ftpd
-- sudo groupadd ftp
-- sudo useradd -s /bin/false -d /home/ftp -m -c "anonymous ftp" -g ftp ftp
-- echo "no" | sudo tee /etc/pure-ftpd/conf/NoAnonymous
-- echo "yes" | sudo tee /etc/pure-ftpd/conf/AnonymousCanCreateDirs
-- sudo /etc/init.d/pure-ftpd restart
-- |
-    pip install 'travis-cargo<0.2' --user &&
+  |
+    sudo apt-get update -qq &&
+    sudo apt-get install -yqq vsftpd &&
+    sudo useradd -s /bin/bash -d /home/ftp -m -c "Doe ftp user" -g ftp Doe &&
+    echo "Doe:mumble" | sudo chpasswd &&
+    echo "listen=yes
+      anon_root=/home/ftp
+      local_enable=yes
+      local_umask=022
+      pasv_enable=yes
+      pasv_min_port=65000
+      pasv_max_port=65010
+      write_enable=yes
+      log_ftp_protocol=yes" | sed -e "s/\s\+\(.*\)/\1/" | sudo tee /etc/vsftpd.conf &&
+    sudo service vsftpd restart &&
+    pip install "travis-cargo<0.2" --user &&
     export PATH=$HOME/.local/bin:$PATH
+
 script:
-- |
+  |
     travis-cargo build &&
-    travis-cargo test &&
+    travis-cargo test -- --features secure &&
     travis-cargo --only stable doc
+
 after_success:
-# upload the documentation from the build with stable (automatically only actually
-# runs on the master branch, not individual PRs)
-- travis-cargo --only stable doc-upload
+  # upload the documentation from the build with stable (automatically only actually
+  # runs on the master branch, not individual PRs)
+  - travis-cargo --only stable doc-upload
+
 env:
   global:
     secure: E/K+u8fhwLNKDvjG6kiuDumrXY/RMZOMa7SS88qhsPKStdHjNmaCwUFUe76RJDzMCqeN31u2mUwvMfMK3xDShABQjoD/tze/KbV5v6VTeL4vplHwZh6TzwaYKKBtNxL1q47A8FSTNK9PUbT+gEIAEY9Nadho7wKrYfT+CQxcb2A=

README.md

@@ -8,7 +8,7 @@ FTP client for Rust
 
 [Documentation](http://mattnenterprise.github.io/rust-ftp)
 
-### Installation
+## Installation
 
 Add ftp via your `Cargo.toml`
 ```toml
@@ -22,7 +22,7 @@ FTPS support is disabled by default. To enable it `secure` should be activated i
 ftp = { version = "*", features = ["secure"] }
 ```
 
-### Usage
+## Usage
 ```rust
 extern crate ftp;
 
@@ -71,3 +71,43 @@ Unless you explicitly state otherwise, any contribution intentionally
 submitted for inclusion in the work by you, as defined in the Apache-2.0
 license, shall be dual licensed as above, without any additional terms or
 conditions.
+
+## Development environment
+
+All you need to develop rust-ftp and run the tests is Rust and Docker.
+The `tests` folder contains a `Dockerfile` that installs and configures
+the vsftpd server.
+
+To create the Docker image:
+
+```bash
+docker build -t ftp-server tests
+```
+
+To start the FTP server that is tested against:
+
+```bash
+tests/ftp-server.sh
+```
+
+This script runs the `ftp-server` image in detached mode and starts the `vsftpd` daemon. It binds ports 21 (FTP) as well as the range 65000-65010 for passive connections.
+
+Once you have an instance running, to run tests type:
+
+```bash
+cargo test
+```
+
+The following commands can be useful:
+```bash
+# List running containers of ftp-server image
+# (to include stopped containers use -a option)
+docker ps --filter ancestor=ftp-server
+
+# To stop and remove a container
+docker stop container_name
+docker rm container_name
+
+# To remove the image
+docker rmi ftp-server
+```

src/ftp.rs

@@ -73,15 +73,15 @@ impl FtpStream {
     ///
     /// ## Example
     ///
-    /// ```
+    /// ```rust,no_run
     /// use ftp::FtpStream;
-    /// use openssl::ssl::*;
+    /// use ftp::openssl::ssl::*;
     ///
     /// // Create an SslContext with a custom cert.
     /// let mut ctx = SslContext::new(SslMethod::Sslv23).unwrap();
     /// let _ = ctx.set_CA_file("/path/to/a/cert.pem").unwrap();
     /// let mut ftp_stream = FtpStream::connect("127.0.0.1:21").unwrap();
-    /// let mut ftp_stream = ftp_stream.into_secure(ctx).unwrap();
+    /// let mut ftp_stream = ftp_stream.into_secure(&ctx).unwrap();
     /// ```
     #[cfg(feature = "secure")]
     pub fn into_secure<T: IntoSsl + Clone>(mut self, ssl: T) -> Result<FtpStream> {
@@ -112,14 +112,18 @@ impl FtpStream {
     ///
     /// ## Example
     ///
-    /// ```
+    /// ```rust,no_run
     /// use ftp::FtpStream;
+    /// use ftp::openssl::ssl::*;
+    ///
+    /// // Create an SslContext with a custom cert.
+    /// let mut ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+    /// let _ = ctx.set_CA_file("/path/to/a/cert.pem").unwrap();
     /// let mut ftp_stream = FtpStream::connect("127.0.0.1:21").unwrap();
-    /// // Switch to the secure mode
-    /// let (mut ftp_stream, _) = ftp_stream.secure();
+    /// let mut ftp_stream = ftp_stream.into_secure(&ctx).unwrap();
     /// // Do all secret things
     /// // Switch back to the insecure mode
-    /// let (mut ftp_stream, _) = ftp_stream.insecure();
+    /// let mut ftp_stream = ftp_stream.into_insecure().unwrap();
     /// // Do all public things
     /// let _ = ftp_stream.quit();
     /// ```
@@ -306,21 +310,21 @@ impl FtpStream {
     /// to download from FTP and `reader` is the function which operates with the
     /// data stream opened.
     ///
-    /// ```ignore
-    /// let result = conn.retr("take_this.txt", |stream| {
-    ///   let mut file = File::create("store_here.txt").unwrap();
-    ///   let mut buf = [0; 2048];
-    ///
-    ///   loop {
-    ///     match stream.read(&mut buf) {
-    ///       Ok(0) => break,
-    ///       Ok(n) => file.write_all(&buf[0..n]).unwrap(),
-    ///       Err(err) => return Err(err)
-    ///     };
-    ///   }
-    ///
-    ///   Ok(())
-    /// });
+    /// ```
+    /// # use ftp::{FtpStream, FtpError};
+    /// # use std::io::Cursor;
+    /// # let mut conn = FtpStream::connect("127.0.0.1:21").unwrap();
+    /// # conn.login("Doe", "mumble").and_then(|_| {
+    /// #     let mut reader = Cursor::new("hello, world!".as_bytes());
+    /// #     conn.put("retr.txt", &mut reader)
+    /// # }).unwrap();
+    /// assert!(conn.retr("retr.txt", |stream| {
+    ///     let mut buf = Vec::new();
+    ///     stream.read_to_end(&mut buf).map(|_|
+    ///         assert_eq!(buf, "hello, world!".as_bytes())
+    ///     ).map_err(|e| FtpError::ConnectionError(e))
+    /// }).is_ok());
+    /// # assert!(conn.rm("retr.txt").is_ok());
     /// ```
     pub fn retr<F>(&mut self, filename: &str, reader: F) -> Result<()>
     where F: Fn(&mut Read) -> Result<()> {
@@ -351,6 +355,20 @@ impl FtpStream {
     }
 
     /// Simple way to retr a file from the server. This stores the file in memory.
+    ///
+    /// ```
+    /// # use ftp::{FtpStream, FtpError};
+    /// # use std::io::Cursor;
+    /// # let mut conn = FtpStream::connect("127.0.0.1:21").unwrap();
+    /// # conn.login("Doe", "mumble").and_then(|_| {
+    /// #     let mut reader = Cursor::new("hello, world!".as_bytes());
+    /// #     conn.put("simple_retr.txt", &mut reader)
+    /// # }).unwrap();
+    /// let cursor = conn.simple_retr("simple_retr.txt").unwrap();
+    /// // do something with bytes
+    /// assert_eq!(cursor.into_inner(), "hello, world!".as_bytes());
+    /// # assert!(conn.rm("simple_retr.txt").is_ok());
+    /// ```
     pub fn simple_retr(&mut self, file_name: &str) -> Result<Cursor<Vec<u8>>> {
         let r = try!(self.simple_retr_(file_name));
         self.read_response(status::CLOSING_DATA_CONNECTION).map(|_| r)

src/lib.rs

@@ -28,13 +28,13 @@
 //!
 //! ### FTPS Usage
 //!
-//! ```ignore
+//! ```rust,no_run
 //! use ftp::FtpStream;
-//! use openssl::ssl::*;
+//! use ftp::openssl::ssl::*;
 //!
-//! let mut ftp_stream = FtpStream::connect("127.0.0.1:21").unwrap();
-//! let mut ctx = SslContext::new(SslMethod::Sslv23).unwrap();
-//! let mut ssl = Ssl::new(&ctx).unwrap();
+//! let ftp_stream = FtpStream::connect("127.0.0.1:21").unwrap();
+//! let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+//! let ssl = Ssl::new(&ctx).unwrap();
 //! // Switch to the secure mode
 //! let mut ftp_stream = ftp_stream.into_secure(ssl).unwrap();
 //! ftp_stream.login("anonymous", "anonymous").unwrap();
@@ -50,8 +50,9 @@
 #[macro_use] extern crate lazy_static;
 extern crate regex;
 extern crate chrono;
+
 #[cfg(feature = "secure")]
-extern crate openssl;
+pub extern crate openssl;
 
 mod ftp;
 mod data_stream;

tests/Dockerfile

@@ -0,0 +1,20 @@
+FROM i386/ubuntu:latest
+
+RUN apt-get update -qq &&\
+    apt-get install -yqq vsftpd
+
+RUN mkdir -p /var/run/vsftpd/empty &&\
+    useradd -s /bin/bash -d /home/ftp -m -c "Doe ftp user" -g ftp Doe &&\
+    echo "Doe:mumble"| chpasswd &&\
+    echo "listen=yes\n\
+anon_root=/home/ftp\n\
+local_enable=yes\n\
+local_umask=022\n\
+pasv_enable=YES\n\
+pasv_min_port=65000\n\
+pasv_max_port=65010\n\
+write_enable=yes\n\
+log_ftp_protocol=yes" > /etc/vsftpd.conf &&\
+    echo "/etc/init.d/vsftpd start" | tee -a /etc/bash.bashrc
+
+CMD ["/bin/bash"]

tests/ftp-server.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+# run the ftp server instance in detached mode (in the background)
+# but also with TTY and interactive mode, so we can attach to it if we want to
+docker run -dti --privileged -p 21:21 -p 65000-65010:65000-65010 ftp-server

tests/lib.rs

@@ -8,16 +8,26 @@ use ftp::FtpStream;
 #[test]
 fn test_ftp() {
     let mut ftp_stream = FtpStream::connect("127.0.0.1:21").unwrap();
-    let _ = ftp_stream.login("anonymous", "[email protected]").unwrap();
+    let _ = ftp_stream.login("Doe", "mumble").unwrap();
 
     ftp_stream.mkdir("test_dir").unwrap();
     ftp_stream.cwd("test_dir").unwrap();
     assert!(ftp_stream.pwd().unwrap().ends_with("/test_dir"));
 
-    // Store a file
-    let file_data = format!("Some awesome file data man!!\n");
-    let mut reader = Cursor::new(file_data.into_bytes());
+    // store a file
+    let file_data = "test data\n";
+    let mut reader = Cursor::new(file_data.as_bytes());
     assert!(ftp_stream.put("test_file.txt", &mut reader).is_ok());
 
-    assert!(ftp_stream.quit().is_ok());
+    // retrieve file
+    assert!(ftp_stream.simple_retr("test_file.txt").map(|bytes|
+        assert_eq!(bytes.into_inner(), file_data.as_bytes())).is_ok());
+
+    // remove file
+    assert!(ftp_stream.rm("test_file.txt").is_ok());
+
+    // cleanup: go up, remove folder, and quit
+    assert!(ftp_stream.cdup().and_then(|_|
+        ftp_stream.rmdir("test_dir")).and_then(|_|
+        ftp_stream.quit()).is_ok());
 }