fake_ftp 0.0.9 → 0.1.0

data/lib/fake_ftp/version.rb

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

data/spec/models/fake_ftp/file_spec.rb

@@ -8,48 +8,63 @@ describe FakeFtp::File do
 
     it "has a name attribute" do
       @file.name = "some name"
-      @file.name.should == "some name"
+      expect(@file.name).to eql("some name")
+    end
+
+    it "has a last_modified_time attribute" do
+      now = Time.now
+      @file.last_modified_time = now
+      expect(@file.last_modified_time).to eql(now)
     end
 
     it "has a bytes attribute" do
       @file.bytes = 87
-      @file.bytes.should == 87
+      expect(@file.bytes).to eql(87)
     end
 
     it "has a data attribute" do
       @file.data = 'some data'
-      @file.data.should == 'some data'
-      @file.bytes.should == 'some data'.length
+      expect(@file.data).to eql('some data')
+      expect(@file.bytes).to eql('some data'.length)
     end
   end
 
   context 'setup' do
     it "can be initialized without attributes" do
       file = FakeFtp::File.new
-      file.name.should be_nil
-      file.bytes.should be_nil
-      file.instance_variable_get(:@type).should be_nil
+      expect(file.name).to be_nil
+      expect(file.bytes).to be_nil
+      expect(file.instance_variable_get(:@type)).to be_nil
     end
 
     it "can be initialized with name" do
       file = FakeFtp::File.new('filename')
-      file.name.should == 'filename'
-      file.bytes.should be_nil
-      file.instance_variable_get(:@type).should be_nil
+      expect(file.name).to eql('filename')
+      expect(file.bytes).to be_nil
+      expect(file.instance_variable_get(:@type)).to be_nil
     end
 
     it "can be initialized with name and bytes" do
       file = FakeFtp::File.new('filename', 104)
-      file.name.should == 'filename'
-      file.bytes.should == 104
-      file.instance_variable_get(:@type).should be_nil
+      expect(file.name).to eql('filename')
+      expect(file.bytes).to eql(104)
+      expect(file.instance_variable_get(:@type)).to be_nil
     end
-    
+
     it "can be initialized with name and bytes and type" do
       file = FakeFtp::File.new('filename', 104, :passive)
-      file.name.should == 'filename'
-      file.bytes.should == 104
-      file.instance_variable_get(:@type).should == :passive
+      expect(file.name).to eql('filename')
+      expect(file.bytes).to eql(104)
+      expect(file.instance_variable_get(:@type)).to eql(:passive)
+    end
+
+    it "can be initialized with name and bytes and type and last_modified_time" do
+      time = Time.now
+      file = FakeFtp::File.new('filename', 104, :passive, time)
+      expect(file.name).to eql('filename')
+      expect(file.bytes).to eql(104)
+      expect(file.instance_variable_get(:@type)).to eql(:passive)
+      expect(file.last_modified_time).to eql(time)
     end
   end
 
@@ -60,12 +75,12 @@ describe FakeFtp::File do
 
     it "should be true if type is :passive" do
       @file.type = :passive
-      @file.passive?.should be_true
+      expect(@file.passive?).to be_true
     end
 
     it "should be false if type is :active" do
       @file.type = :active
-      @file.passive?.should be_false
+      expect(@file.passive?).to be_false
     end
   end
 
@@ -76,12 +91,12 @@ describe FakeFtp::File do
 
     it "should be true if type is :active" do
       @file.type = :active
-      @file.active?.should be_true
+      expect(@file.active?).to be_true
     end
 
     it "should be false if type is :passive" do
       @file.type = :passive
-      @file.active?.should be_false
+      expect(@file.active?).to be_false
     end
   end
 end

data/spec/models/fake_ftp/server_spec.rb

@@ -4,53 +4,53 @@ require 'net/ftp'
 describe FakeFtp::Server, 'setup' do
   it "starts a server on port n" do
     server = FakeFtp::Server.new(21212)
-    server.port.should == 21212
+    expect(server.port).to eql(21212)
   end
 
   it "should defaults to port 21" do
     server = FakeFtp::Server.new
-    server.port.should == 21
+    expect(server.port).to eql(21)
   end
 
   it "starts a passive server on port p" do
     server = FakeFtp::Server.new(21212, 21213)
-    server.passive_port.should == 21213
+    expect(server.passive_port).to eql(21213)
   end
 
   it "should start and stop" do
     server = FakeFtp::Server.new(21212)
-    server.is_running?.should be_false
+    expect(server.is_running?).to be_false
     server.start
-    server.is_running?.should be_true
+    expect(server.is_running?).to be_true
     server.stop
-    server.is_running?.should be_false
+    expect(server.is_running?).to be_false
   end
 
   it "should default :mode to :active" do
     server = FakeFtp::Server.new(21212, 21213)
-    server.mode.should == :active
+    expect(server.mode).to eql(:active)
   end
 
   it "should start and stop passive port" do
     server = FakeFtp::Server.new(21212, 21213)
-    server.is_running?(21213).should be_false
+    expect(server.is_running?(21213)).to be_false
     server.start
-    server.is_running?(21213).should be_true
+    expect(server.is_running?(21213)).to be_true
     server.stop
-    server.is_running?(21213).should be_false
+    expect(server.is_running?(21213)).to be_false
   end
 
   it "should raise if attempting to use a bound port" do
     server = FakeFtp::Server.new(21212)
     server.start
-    proc { FakeFtp::Server.new(21212) }.should raise_error(Errno::EADDRINUSE, "Address already in use - 21212")
+    expect { FakeFtp::Server.new(21212) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21212")
     server.stop
   end
 
   it "should raise if attempting to use a bound passive_port" do
     server = FakeFtp::Server.new(21212, 21213)
     server.start
-    proc { FakeFtp::Server.new(21214, 21213) }.should raise_error(Errno::EADDRINUSE, "Address already in use - 21213")
+    expect { FakeFtp::Server.new(21214, 21213) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21213")
     server.stop
   end
 end
@@ -62,106 +62,96 @@ describe FakeFtp::Server, 'files' do
   before { server.instance_variable_set(:@files, [file]) }
 
   it "returns filenames from :files" do
-    server.files.should include('filename')
+    expect(server.files).to include('filename')
   end
 
   it "can be accessed with :file" do
-    server.file('filename').should == file
+    expect(server.file('filename')).to eql(file)
   end
 
   it "can reset files" do
     server.reset
-    server.files.should == []
+    expect(server.files).to eql([])
   end
 end
 
 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 { server.stop }
+  after {
+    client.close
+    server.stop
+  }
 
   context 'general' do
-    before :each do
-      @client = TCPSocket.open('127.0.0.1', 21212)
-    end
-
-    after :each do
-      @client.close
-    end
 
     it "should accept connections" do
-      @client.gets.should == "220 Can has FTP?\r\n"
+      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
-      @client.gets.should == "500 Unknown command\r\n"
+      client.gets
+      client.puts
+      expect(client.gets).to eql("500 Unknown command\r\n")
     end
 
     it "accepts QUIT" do
-      @client.gets
-      @client.puts "QUIT"
-      @client.gets.should == "221 OMG bye!\r\n"
+      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"
+      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
-    after :each do
-      @client.close
-    end
 
     it "accepts PASV" do
-      server.mode.should == :active
-      @client = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets
-      @client.puts "PASV"
-      @client.gets.should == "227 Entering Passive Mode (127,0,0,1,82,221)\r\n"
-      server.mode.should == :passive
+      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 = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets
-      @client.puts "PASV"
-      @client.gets.should == "227 Entering Passive Mode (127,0,0,1,82,119)\r\n"
+      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 = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets
-      @client.puts "PASV"
-      @client.gets.should == "502 Aww hell no, use Active\r\n"
+      client.gets
+      client.puts "PASV"
+      expect(client.gets).to eql("502 Aww hell no, use Active\r\n")
     end
   end
 
   context 'active' do
     before :each do
-      @client = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets
+      client.gets
 
       @data_server = ::TCPServer.new('127.0.0.1', 21216)
       @data_connection = Thread.new do
         @server_client = @data_server.accept
-        @server_client.should_not be_nil
+        expect(@server_client).to_not be_nil
       end
     end
 
@@ -169,188 +159,252 @@ describe FakeFtp::Server, 'commands' do
       @data_server.close
       @data_server = nil
       @data_connection = nil
-      @client.close
     end
 
     it "accepts PORT and connects to port" do
-      @client.puts "PORT 127,0,0,1,82,224"
-      @client.gets.should == "200 Okay\r\n"
+      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
-      server.mode.should == :active
-      @client.puts 'PASV'
-      @client.gets
-      server.mode.should == :passive
+      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"
-      @client.gets.should == "200 Okay\r\n"
+      client.puts "PORT 127,0,0,1,82,224"
+      expect(client.gets).to eql("200 Okay\r\n")
 
       @data_connection.join
 
-      server.mode.should == :active
+      expect(server.mode).to eql(:active)
     end
   end
 
   context 'authentication commands' do
     before :each do
-      @client = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets ## connection successful response
-    end
-
-    after :each do
-      @client.close
+      client.gets ## connection successful response
     end
 
     it "accepts USER" do
-      @client.puts "USER some_dude"
-      @client.gets.should == "331 send your password\r\n"
+      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"
-      @client.gets.should == "230 logged in\r\n"
+      client.puts "USER anonymous"
+      expect(client.gets).to eql("230 logged in\r\n")
     end
 
     it "accepts PASS" do
-      @client.puts "PASS password"
-      @client.gets.should == "230 logged in\r\n"
+      client.puts "PASS password"
+      expect(client.gets).to eql("230 logged in\r\n")
     end
 
     it "accepts ACCT" do
-      @client.puts "ACCT"
-      @client.gets.should == "230 WHATEVER!\r\n"
+      client.puts "ACCT"
+      expect(client.gets).to eql("230 WHATEVER!\r\n")
     end
   end
 
   context 'directory commands' do
     before :each do
-      @client = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets ## connection successful response
-    end
-
-    after :each do
-      @client.close
+      client.gets ## connection successful response
     end
 
     it "returns directory on PWD" do
-      @client.puts "PWD"
-      @client.gets.should == "257 \"/pub\" is current directory\r\n"
+      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"
-      @client.gets.should == "250 OK!\r\n"
-      @client.puts "CDUP"
-      @client.gets.should == "250 OK!\r\n"
-    end
-
-    it "does not respond to MKD" do
-      @client.puts "MKD some_dir"
-      @client.gets.should == "500 Unknown command\r\n"
+      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 = TCPSocket.open('127.0.0.1', 21212)
-      @client.gets ## connection successful response
-    end
-
-    after :each do
-      @client.close
+      client.gets ## connection successful response
     end
 
     it "accepts TYPE ascii" do
-      @client.puts "TYPE A"
-      @client.gets.should == "200 Type set to A.\r\n"
+      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"
-      @client.gets.should == "200 Type set to I.\r\n"
+      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"
-      @client.gets.should == "504 We don't allow those\r\n"
-      @client.puts "TYPE N"
-      @client.gets.should == "504 We don't allow those\r\n"
-      @client.puts "TYPE T"
-      @client.gets.should == "504 We don't allow those\r\n"
-      @client.puts "TYPE C"
-      @client.gets.should == "504 We don't allow those\r\n"
-      @client.puts "TYPE L"
-      @client.gets.should == "504 We don't allow those\r\n"
+      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'
-        @client.gets.should == "227 Entering Passive Mode (127,0,0,1,82,221)\r\n"
+        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"
-        @client.gets.should == "125 Do it!\r\n"
-        @data_client = TCPSocket.open('127.0.0.1', 21213)
-        @data_client.puts "1234567890"
-        @data_client.close
-        @client.gets.should == "226 Did it!\r\n"
-        server.files.should include('some_file')
-        server.file('some_file').bytes.should == 10
+        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"
-        @client.gets.should == "501 No filename given\r\n"
+        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"
-        @client.gets.should == "550 File not found\r\n"
+        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"
-        @client.gets.should == "150 File status ok, about to open data connection\r\n"
-        @data_client = TCPSocket.open('127.0.0.1', 21213)
-        data = @data_client.read(1024)
-        @data_client.close
-        data.should == '1234567890'
-        @client.gets.should == "226 File transferred\r\n"
+        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"
-        @client.gets.should == "150 Listing status ok, about to open data connection\r\n"
-        @data_client = TCPSocket.open('127.0.0.1', 21213)
-        data = @data_client.read(2048)
-        @data_client.close
-        data.should == [
+        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",
           "-rw-r--r--\t1\towner\tgroup\t10\t#{server.file('another_file').created.strftime('%b %d %H:%M')}\tanother_file",
-        ].join("\n")
-        @client.gets.should == "226 List information transferred\r\n"
+        ].join("\n"))
+        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}"
+        end.join("\n"))
+        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}"
+        end.join("\n"))
+        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"
-        @client.gets.should == "150 Listing status ok, about to open data connection\r\n"
-        @data_client = TCPSocket.open('127.0.0.1', 21213)
-        data = @data_client.read(1024)
-        @data_client.close
-        data.should == "some_file\nanother_file"
-        @client.gets.should == "226 List information transferred\r\n"
+        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
@@ -367,58 +421,123 @@ describe FakeFtp::Server, 'commands' do
         @data_server = 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"
-        @client.gets.should == "425 Ain't no data port!\r\n"
+        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"
-        @client.gets.should == "200 Okay\r\n"
+        client.puts "PORT 127,0,0,1,82,224"
+        expect(client.gets).to eql("200 Okay\r\n")
 
-        @client.puts "STOR some_other_file"
-        @client.gets.should == "125 Do it!\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
 
-        @client.gets.should == "226 Did it!\r\n"
-        server.files.should include('some_other_file')
-        server.file('some_other_file').bytes.should == 5
+        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"
-        @client.gets.should == "200 Okay\r\n"
+        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"
-        @client.gets.should == "150 File status ok, about to open data connection\r\n"
+        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
 
-        data.should == '1234567890'
-        @client.gets.should == "226 File transferred\r\n"
+        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"
-        @client.gets.should == "200 Okay\r\n"
+        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"
-        @client.gets.should == "150 Listing status ok, about to open data connection\r\n"
+        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
 
-        data.should == "some_file\nanother_file"
-        @client.gets.should == "226 List information transferred\r\n"
+        expect(data).to eql("some_file\nanother_file")
+        expect(client.gets).to eql("226 List information transferred\r\n")
       end
     end
   end
@@ -437,54 +556,68 @@ describe FakeFtp::Server, 'with ftp client' do
   end
 
   it 'should accept connections' do
-    proc { client.connect('127.0.0.1', 21212) }.should_not raise_error
+    expect { client.connect('127.0.0.1', 21212) }.to_not raise_error
   end
 
   context "" do
     before { client.connect("127.0.0.1", 21212) }
 
     it "should allow anonymous authentication" do
-      proc { client.login }.should_not raise_error
+      expect { client.login }.to_not raise_error
     end
 
     it "should allow named authentication" do
-      proc { client.login('someone', 'password') }.should_not raise_error
+      expect { client.login('someone', 'password') }.to_not raise_error
     end
 
     it "should allow client to quit" do
-      proc { client.login('someone', 'password') }.should_not raise_error
-      proc { client.quit }.should_not raise_error
+      expect { client.login('someone', 'password') }.to_not raise_error
+      expect { client.quit }.to_not raise_error
+    end
+
+    it "should allow mtime" do
+      filename = 'someone'
+      time = Time.now
+      server.add_file(filename, "some data", time)
+
+      client.passive = false
+      mtime = client.mtime(filename)
+      expect(mtime.to_s).to eql(time.to_s)
+
+      client.passive = true
+      mtime = client.mtime(filename)
+      expect(mtime.to_s).to eql(time.to_s)
     end
 
     it "should put files using PASV" do
-      File.stat(text_filename).size.should == 20
+      expect(File.stat(text_filename).size).to eql(20)
 
       client.passive = true
-      proc { client.put(text_filename) }.should_not raise_error
+      expect { client.put(text_filename) }.to_not raise_error
 
-      server.files.should include('text_file.txt')
-      server.file('text_file.txt').bytes.should == 20
-      server.file('text_file.txt').should be_passive
-      server.file('text_file.txt').should_not be_active
+      expect(server.files).to include('text_file.txt')
+      expect(server.file('text_file.txt').bytes).to eql(20)
+      expect(server.file('text_file.txt')).to be_passive
+      expect(server.file('text_file.txt')).to_not be_active
     end
 
     it "should put files using active" do
-      File.stat(text_filename).size.should == 20
+      expect(File.stat(text_filename).size).to eql(20)
 
       client.passive = false
-      proc { client.put(text_filename) }.should_not raise_error
+      expect { client.put(text_filename) }.to_not raise_error
 
-      server.files.should include('text_file.txt')
-      server.file('text_file.txt').bytes.should == 20
-      server.file('text_file.txt').should_not be_passive
-      server.file('text_file.txt').should be_active
+      expect(server.files).to include('text_file.txt')
+      expect(server.file('text_file.txt').bytes).to eql(20)
+      expect(server.file('text_file.txt')).to_not be_passive
+      expect(server.file('text_file.txt')).to be_active
     end
 
     xit "should disconnect clients on close" do
       # TODO: when this succeeds, we can care less about manually closing clients
       #       otherwise we get a CLOSE_WAIT process hanging around that blocks our port
       server.stop
-      client.closed?.should be_true
+      expect(client.closed?).to be_true
     end
   end
 end