fake_ftp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef1324d66ffeb222bc35a3d1fe172bf649fefa9e
-  data.tar.gz: 285616254bf9b2f5ad441bfc41d17943a1609681
+  metadata.gz: 50a4678ec926f8b3ac68aa2db5670987c7c19558
+  data.tar.gz: caf6eef42de1e306f19860b56265b8e64ced3040
 SHA512:
-  metadata.gz: b20a024c9e598db59fac9751517b08cc70c5325f0ba55b96352d719a0227827a18a956ef2e30e85f9c544009c4214f7285bf3d69a0139e66bdd3e0bed207c711
-  data.tar.gz: ecd74f559bf7d48318846671268c5b3d96468c93a3ad6fff487f310014b47e413244e55f700e8881c54565c4dd066d2d0c0573322aba70eb57d75d33f3dc1d16
+  metadata.gz: 70a2926c93a0aff84dc95d52ea0312809bac104dd5d885eeac968932c5b82336d98115d0770ff20db0ad58efce8df62c55bc55376c2991bd9db12ff7680b4018
+  data.tar.gz: d7b0cd6eb3d31c651aab69cca842bbb6f6da82e7487184e2dea56d75c4aa80e5cb641e31146776873ad0d1b574e0c0960ed84750755dcd8e68f172439aea623d

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
+  - 2.0.0
+  - 1.9.3
   - 1.8.7
-gemfile:
-  - Gemfile.travis

data/CONTRIBUTORS.md

@@ -0,0 +1,19 @@
+Contributors
+============
+
+* Eric Saxby - @sax
+
+* Ben Ashford
+* Colin Shield
+* Eirik Lied
+* Eric Oestrich
+* Jacob Maine
+* John Maxwell
+* Kevin Thompson
+* liehann
+* mdalton
+* Nick Rowe
+* Pranas Kiziela
+* Puneet Goyal
+* Steve Thompson
+* Thomas Sonntag

data/{README.markdown → README.md}

@@ -3,17 +3,23 @@ FakeFtp
 
 [![Build status](https://secure.travis-ci.org/livinginthepast/fake_ftp.png)](http://travis-ci.org/livinginthepast/fake_ftp)
 
-This is a gem that allows you to test FTP implementations in ruby. It is a minimal single-client FTP server
-that can be bound to any arbitrary port on localhost.
+This is a gem that allows you to test FTP implementations in ruby. It is 
+a minimal single-client FTP server that can be bound to any arbitrary 
+port on localhost.
+
 
 ## Why?
 
-We want to ensure that our code works, in a way that is agnostic to the implementation used (unlike with stubs or mocks).
+We want to ensure that our code works, in a way that is agnostic to the 
+implementation used (unlike with stubs or mocks).
+
 
 ## How
 
-FakeFtp is a simple FTP server that fakes out enough of the protocol to get us by, allowing us to test that files get to
-their intended destination rather than testing how our code does so.
+FakeFtp is a simple FTP server that fakes out enough of the protocol to 
+get us by, allowing us to test that files get to their intended destination 
+rather than testing how our code does so.
+
 
 ## Usage
 
@@ -66,17 +72,43 @@ server.stop
 
 Note that many FTP clients default to active, unless specified otherwise.
 
+
+## Caveats
+
+This is *not* a real FTP server and should not be treated as one. The goal 
+of this gem is not to create a thread-safe multi-client implementation.
+It is best used to unit test models that generate files and transfer
+them to an FTP server.
+
+As such, there are some things that won't be accepted upstream from pull
+requests:
+* simultaneous multi-client code
+* support for long term file persistence
+* binding to arbitrary IPs
+* global state beyond that required to pass the minimum required to
+  generate passing tests
+
+
+## Recommendations for testing patterns
+
+*Separate configuration from code.* Do not hard code the IP address,
+FQDN or port of an FTP server in your classes. It introduces fragility
+into your tests. Also, the default FTP port of 21 is a privileged port,
+and should be avoided.
+
+*Separate the code that generates files from the code that uploads
+files.* You tests will run much more quickly if you only try to upload
+small files. If you have tests showing that you generate correct files
+from your data, then you can trust that. Why do you need to upload a 20M
+file in your tests if you can stub out your file generation method and
+test file upload against 10 bytes? Fast fast fast.
+
+
 ## References
 
 * http://rubyforge.org/projects/ftpd/ - a simple ftp daemon written by Chris Wanstrath
 * http://ruby-doc.org/stdlib/libdoc/gserver/rdoc/index.html - a generic server in the Ruby standard library, by John W Small
 
-## Contributors
-
-* Eric Saxby
-* Colin Shield
-* liehann (https://github.com/liehann)
-
 ## License
 
 The MIT License

data/fake_ftp.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://rubygems.org/gems/fake_ftp"
   s.summary     = %q{Creates a fake FTP server for use in testing}
   s.description = %q{Testing FTP? Use this!}
+  s.license     = 'MIT'
 
   s.required_rubygems_version = ">= 1.3.6"
   

data/lib/fake_ftp/server.rb

@@ -34,8 +34,8 @@ module FakeFtp
     def initialize(control_port = 21, data_port = nil, options = {})
       self.port = control_port
       self.passive_port = data_port
-      raise(Errno::EADDRINUSE, "#{port}") if is_running?
-      raise(Errno::EADDRINUSE, "#{passive_port}") if passive_port && is_running?(passive_port)
+      raise(Errno::EADDRINUSE, "#{port}") if !control_port.zero? && is_running?
+      raise(Errno::EADDRINUSE, "#{passive_port}") if passive_port && !passive_port.zero? && is_running?(passive_port)
       @connection = nil
       @options = options
       @files = []
@@ -62,6 +62,7 @@ module FakeFtp
     def start
       @started = true
       @server = ::TCPServer.new('127.0.0.1', port)
+      @port = @server.addr[1]
       @thread = Thread.new do
         while @started
           @client = @server.accept rescue nil
@@ -87,6 +88,7 @@ module FakeFtp
 
       if passive_port
         @data_server = ::TCPServer.new('127.0.0.1', passive_port)
+        @passive_port = @data_server.addr[1]
       end
     end
 
@@ -162,9 +164,9 @@ module FakeFtp
         end
       end
       files = files.map do |f|
-        "-rw-r--r--\t1\towner\tgroup\t#{f.bytes}\t#{f.created.strftime('%b %d %H:%M')}\t#{f.name}"
+        "-rw-r--r--\t1\towner\tgroup\t#{f.bytes}\t#{f.created.strftime('%b %d %H:%M')}\t#{f.name}\n"
       end
-      data_client.write(files.join("\n"))
+      data_client.write(files.join)
       data_client.close
       @active_connection = nil
 

data/lib/fake_ftp/version.rb

@@ -1,3 +1,3 @@
 module FakeFtp
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/functional/server_spec.rb

@@ -0,0 +1,468 @@
+require "spec_helper.rb"
+
+describe FakeFtp::Server, 'commands' do
+  let(:server) { FakeFtp::Server.new(21212, 21213) }
+  let(:client) { TCPSocket.open('127.0.0.1', 21212) }
+
+  before { server.start }
+
+  after {
+    client.close
+    server.stop
+  }
+
+  context 'general' do
+    it "should accept connections" do
+      expect(client.gets).to eql("220 Can has FTP?\r\n")
+    end
+
+    it "should get unknown command response when nothing is sent" do
+      client.gets
+      client.puts
+      expect(client.gets).to eql("500 Unknown command\r\n")
+    end
+
+    it "accepts QUIT" do
+      client.gets
+      client.puts "QUIT"
+      expect(client.gets).to eql("221 OMG bye!\r\n")
+    end
+
+    it "should accept multiple commands in one session" do
+      client.gets
+      client.puts "USER thing"
+      client.gets
+      client.puts "PASS thing"
+      client.gets
+      client.puts "ACCT thing"
+      client.gets
+      client.puts "USER thing"
+    end
+  end
+
+  context 'passive' do
+    it "accepts PASV" do
+      expect(server.mode).to eql(:active)
+      client.gets
+      client.puts "PASV"
+      expect(client.gets).to eql("227 Entering Passive Mode (127,0,0,1,82,221)\r\n")
+      expect(server.mode).to eql(:passive)
+    end
+
+    it "responds with correct PASV port" do
+      server.stop
+      server.passive_port = 21111
+      server.start
+      client.gets
+      client.puts "PASV"
+      expect(client.gets).to eql("227 Entering Passive Mode (127,0,0,1,82,119)\r\n")
+    end
+
+    it "does not accept PASV if no port set" do
+      server.stop
+      server.passive_port = nil
+      server.start
+      client.gets
+      client.puts "PASV"
+      expect(client.gets).to eql("502 Aww hell no, use Active\r\n")
+    end
+  end
+
+  context 'active' do
+    let!(:data_server) { ::TCPServer.new('127.0.0.1', 21216) }
+
+    before :each do
+      client.gets
+
+      @data_connection = Thread.new do
+        @server_client = data_server.accept
+        expect(@server_client).to_not be_nil
+      end
+    end
+
+    after :each do
+      data_server.close
+    end
+
+    it "accepts PORT and connects to port" do
+      client.puts "PORT 127,0,0,1,82,224"
+      expect(client.gets).to eql("200 Okay\r\n")
+
+      @data_connection.join
+    end
+
+    it "should switch to :active on port command" do
+      expect(server.mode).to eql(:active)
+      client.puts 'PASV'
+      client.gets
+      expect(server.mode).to eql(:passive)
+
+      client.puts "PORT 127,0,0,1,82,224"
+      expect(client.gets).to eql("200 Okay\r\n")
+
+      @data_connection.join
+
+      expect(server.mode).to eql(:active)
+    end
+  end
+
+  context 'authentication commands' do
+    before :each do
+      client.gets ## connection successful response
+    end
+
+    it "accepts USER" do
+      client.puts "USER some_dude"
+      expect(client.gets).to eql("331 send your password\r\n")
+    end
+
+    it "accepts anonymous USER" do
+      client.puts "USER anonymous"
+      expect(client.gets).to eql("230 logged in\r\n")
+    end
+
+    it "accepts PASS" do
+      client.puts "PASS password"
+      expect(client.gets).to eql("230 logged in\r\n")
+    end
+
+    it "accepts ACCT" do
+      client.puts "ACCT"
+      expect(client.gets).to eql("230 WHATEVER!\r\n")
+    end
+  end
+
+  context 'directory commands' do
+    before :each do
+      client.gets ## connection successful response
+    end
+
+    it "returns directory on PWD" do
+      client.puts "PWD"
+      expect(client.gets).to eql("257 \"/pub\" is current directory\r\n")
+    end
+
+    it "says OK to any CWD, CDUP, without doing anything" do
+      client.puts "CWD somewhere/else"
+      expect(client.gets).to eql("250 OK!\r\n")
+      client.puts "CDUP"
+      expect(client.gets).to eql("250 OK!\r\n")
+    end
+  end
+
+  context 'file commands' do
+    before :each do
+      client.gets ## connection successful response
+    end
+
+    it "accepts TYPE ascii" do
+      client.puts "TYPE A"
+      expect(client.gets).to eql("200 Type set to A.\r\n")
+    end
+
+    it "accepts TYPE image" do
+      client.puts "TYPE I"
+      expect(client.gets).to eql("200 Type set to I.\r\n")
+    end
+
+    it "does not accept TYPEs other than ascii or image" do
+      client.puts "TYPE E"
+      expect(client.gets).to eql("504 We don't allow those\r\n")
+      client.puts "TYPE N"
+      expect(client.gets).to eql("504 We don't allow those\r\n")
+      client.puts "TYPE T"
+      expect(client.gets).to eql("504 We don't allow those\r\n")
+      client.puts "TYPE C"
+      expect(client.gets).to eql("504 We don't allow those\r\n")
+      client.puts "TYPE L"
+      expect(client.gets).to eql("504 We don't allow those\r\n")
+    end
+
+    context 'passive' do
+      let(:data_client) { TCPSocket.open('127.0.0.1', 21213) }
+
+      before :each do
+        client.puts 'PASV'
+        expect(client.gets).to eql("227 Entering Passive Mode (127,0,0,1,82,221)\r\n")
+      end
+
+      it "accepts STOR with filename" do
+        client.puts "STOR some_file"
+        expect(client.gets).to eql("125 Do it!\r\n")
+        data_client.puts "1234567890"
+        data_client.close
+        expect(client.gets).to eql("226 Did it!\r\n")
+        expect(server.files).to include('some_file')
+        expect(server.file('some_file').bytes).to eql(10)
+        expect(server.file('some_file').data).to eql("1234567890")
+      end
+
+      it "accepts STOR with filename and trailing newline" do
+        client.puts "STOR some_file"
+        client.gets
+        # puts tries to be smart and only write a single \n
+        data_client.puts "1234567890\n\n"
+        data_client.close
+        expect(client.gets).to eql("226 Did it!\r\n")
+        expect(server.files).to include('some_file')
+        expect(server.file('some_file').bytes).to eql(11)
+        expect(server.file('some_file').data).to eql("1234567890\n")
+      end
+
+      it "accepts STOR with filename and long file" do
+        client.puts "STOR some_file"
+        expect(client.gets).to eql("125 Do it!\r\n")
+        data_client.puts("1234567890" * 10_000)
+        data_client.close
+        expect(client.gets).to eql("226 Did it!\r\n")
+        expect(server.files).to include('some_file')
+      end
+
+      it "accepts STOR with streams" do
+        client.puts "STOR some_file"
+        expect(client.gets).to eql("125 Do it!\r\n")
+        data_client.write "1234567890"
+        data_client.flush
+        data_client.write "1234567890"
+        data_client.flush
+        data_client.close
+        expect(client.gets).to eql("226 Did it!\r\n")
+        expect(server.file('some_file').data).to eql("12345678901234567890")
+      end
+
+      it "does not accept RETR without a filename" do
+        client.puts "RETR"
+        expect(client.gets).to eql("501 No filename given\r\n")
+      end
+
+      it "does not serve files that do not exist" do
+        client.puts "RETR some_file"
+        expect(client.gets).to eql("550 File not found\r\n")
+      end
+
+      it "accepts RETR with a filename" do
+        server.add_file('some_file', '1234567890')
+        client.puts "RETR some_file"
+        expect(client.gets).to eql("150 File status ok, about to open data connection\r\n")
+        data = data_client.read(1024)
+        data_client.close
+        expect(data).to eql('1234567890')
+        expect(client.gets).to eql("226 File transferred\r\n")
+      end
+
+      it "accepts DELE with a filename" do
+        server.add_file('some_file', '1234567890')
+        client.puts "DELE some_file"
+        expect(client.gets).to eql("250 Delete operation successful.\r\n")
+        expect(server.files).to_not include('some_file')
+      end
+
+      it "gives error message when trying to delete a file that does not exist" do
+        client.puts "DELE non_existing_file"
+        expect(client.gets).to eql("550 Delete operation failed.\r\n")
+      end
+
+      it "accepts a LIST command" do
+        server.add_file('some_file', '1234567890')
+        server.add_file('another_file', '1234567890')
+        client.puts "LIST"
+        expect(client.gets).to eql("150 Listing status ok, about to open data connection\r\n")
+        data = data_client.read(2048)
+        data_client.close
+        expect(data).to eql([
+          "-rw-r--r--\t1\towner\tgroup\t10\t#{server.file('some_file').created.strftime('%b %d %H:%M')}\tsome_file\n",
+          "-rw-r--r--\t1\towner\tgroup\t10\t#{server.file('another_file').created.strftime('%b %d %H:%M')}\tanother_file\n",
+        ].join)
+        expect(client.gets).to eql("226 List information transferred\r\n")
+      end
+
+      it "accepts a LIST command with a wildcard argument" do
+        files = ['test.jpg', 'test-2.jpg', 'test.txt']
+        files.each do |file|
+          server.add_file(file, '1234567890')
+        end
+
+        client.puts "LIST *.jpg"
+        expect(client.gets).to eql("150 Listing status ok, about to open data connection\r\n")
+
+        data = data_client.read(2048)
+        data_client.close
+        expect(data).to eql(files[0,2].map do |file|
+          "-rw-r--r--\t1\towner\tgroup\t10\t#{server.file(file).created.strftime('%b %d %H:%M')}\t#{file}\n"
+        end.join)
+        expect(client.gets).to eql("226 List information transferred\r\n")
+      end
+
+      it "accepts a LIST command with multiple wildcard arguments" do
+        files = ['test.jpg', 'test.gif', 'test.txt']
+        files.each do |file|
+          server.add_file(file, '1234567890')
+        end
+
+        client.puts "LIST *.jpg *.gif"
+        expect(client.gets).to eql("150 Listing status ok, about to open data connection\r\n")
+
+        data = data_client.read(2048)
+        data_client.close
+        expect(data).to eql(files[0,2].map do |file|
+          "-rw-r--r--\t1\towner\tgroup\t10\t#{server.file(file).created.strftime('%b %d %H:%M')}\t#{file}\n"
+        end.join)
+        expect(client.gets).to eql("226 List information transferred\r\n")
+      end
+
+      it "accepts an NLST command" do
+        server.add_file('some_file', '1234567890')
+        server.add_file('another_file', '1234567890')
+        client.puts "NLST"
+        expect(client.gets).to eql("150 Listing status ok, about to open data connection\r\n")
+        data = data_client.read(1024)
+        data_client.close
+        expect(data).to eql("some_file\nanother_file")
+        expect(client.gets).to eql("226 List information transferred\r\n")
+      end
+
+      it "should allow mdtm" do
+        filename = "file.txt"
+        now = Time.now
+        server.add_file(filename, "some dummy content", now)
+        client.puts "MDTM #{filename}"
+        expect(client.gets).to eql("213 #{now.strftime("%Y%m%d%H%M%S")}\r\n")
+      end
+    end
+
+    context 'active' do
+      let!(:data_server) { ::TCPServer.new('127.0.0.1', 21216) }
+
+      before :each do
+        @data_connection = Thread.new do
+          @server_client = data_server.accept
+        end
+      end
+
+      after :each do
+        data_server.close
+        @data_connection = nil
+      end
+
+      it 'creates a directory on MKD' do
+        client.puts "MKD some_dir"
+        expect(client.gets).to eql("257 OK!\r\n")
+      end
+
+      it 'should save the directory after you CWD' do
+        client.puts "CWD /somewhere/else"
+        expect(client.gets).to eql("250 OK!\r\n")
+        client.puts "PWD"
+        expect(client.gets).to eql("257 \"/somewhere/else\" is current directory\r\n")
+      end
+
+      it 'CWD should add a / to the beginning of the directory' do
+        client.puts "CWD somewhere/else"
+        expect(client.gets).to eql("250 OK!\r\n")
+        client.puts "PWD"
+        expect(client.gets).to eql("257 \"/somewhere/else\" is current directory\r\n")
+      end
+
+      it 'should not change the directory on CDUP' do
+        client.puts "CDUP"
+        expect(client.gets).to eql("250 OK!\r\n")
+        client.puts "PWD"
+        expect(client.gets).to eql("257 \"/pub\" is current directory\r\n")
+      end
+
+      it "sends error message if no PORT received" do
+        client.puts "STOR some_file"
+        expect(client.gets).to eql("425 Ain't no data port!\r\n")
+      end
+
+      it "accepts STOR with filename" do
+        client.puts "PORT 127,0,0,1,82,224"
+        expect(client.gets).to eql("200 Okay\r\n")
+
+        client.puts "STOR some_other_file"
+        expect(client.gets).to eql("125 Do it!\r\n")
+
+        @data_connection.join
+        @server_client.print "12345"
+        @server_client.close
+
+        expect(client.gets).to eql("226 Did it!\r\n")
+        expect(server.files).to include('some_other_file')
+        expect(server.file('some_other_file').bytes).to eql(5)
+      end
+
+      it "accepts RETR with a filename" do
+        client.puts "PORT 127,0,0,1,82,224"
+        expect(client.gets).to eql("200 Okay\r\n")
+
+        server.add_file('some_file', '1234567890')
+        client.puts "RETR some_file"
+        expect(client.gets).to eql("150 File status ok, about to open data connection\r\n")
+
+        @data_connection.join
+        data = @server_client.read(1024)
+        @server_client.close
+
+        expect(data).to eql('1234567890')
+        expect(client.gets).to eql("226 File transferred\r\n")
+      end
+
+      it "accepts RNFR without filename" do
+        client.puts "RNFR"
+        expect(client.gets).to eql("501 Send path name.\r\n")
+      end
+
+      it "accepts RNTO without RNFR" do
+        client.puts "RNTO some_other_file"
+        expect(client.gets).to eql("503 Send RNFR first.\r\n")
+      end
+
+      it "accepts RNTO and RNFR without filename" do
+        client.puts "RNFR from_file"
+        expect(client.gets).to eql("350 Send RNTO to complete rename.\r\n")
+
+        client.puts "RNTO"
+        expect(client.gets).to eql("501 Send path name.\r\n")
+      end
+
+      it "accepts RNTO and RNFR for not existing file" do
+        client.puts "RNFR from_file"
+        expect(client.gets).to eql("350 Send RNTO to complete rename.\r\n")
+
+        client.puts "RNTO to_file"
+        expect(client.gets).to eql("550 File not found.\r\n")
+      end
+
+      it "accepts RNTO and RNFR" do
+        server.add_file('from_file', '1234567890')
+
+        client.puts "RNFR from_file"
+        expect(client.gets).to eql("350 Send RNTO to complete rename.\r\n")
+
+        client.puts "RNTO to_file"
+        expect(client.gets).to eql("250 Path renamed.\r\n")
+
+        expect(server.files).to include('to_file')
+        expect(server.files).to_not include('from_file')
+      end
+
+      it "accepts an NLST command" do
+        client.puts "PORT 127,0,0,1,82,224"
+        expect(client.gets).to eql("200 Okay\r\n")
+
+        server.add_file('some_file', '1234567890')
+        server.add_file('another_file', '1234567890')
+        client.puts "NLST"
+        expect(client.gets).to eql("150 Listing status ok, about to open data connection\r\n")
+
+        @data_connection.join
+        data = @server_client.read(1024)
+        @server_client.close
+
+        expect(data).to eql("some_file\nanother_file")
+        expect(client.gets).to eql("226 List information transferred\r\n")
+      end
+    end
+  end
+end
+