vagrant-unbundled 1.9.7.1 → 1.9.8.1

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/fake_ftp.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fake_ftp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fake_ftp"
+  s.version     = FakeFtp::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Colin Shield", "Eric Saxby"]
+  s.email       = ["sax+github@livinginthepast.org"]
+  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"
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/lib/fake_ftp.rb

@@ -0,0 +1,5 @@
+require 'fake_ftp/server'
+require 'fake_ftp/file'
+
+module FakeFtp
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/lib/fake_ftp/file.rb

@@ -0,0 +1,34 @@
+module FakeFtp
+  class File
+    attr_accessor :bytes, :name, :last_modified_time
+    attr_writer :type
+    attr_accessor :data
+    attr_reader :created
+
+    def initialize(name = nil, data = nil, type = nil, last_modified_time = Time.now)
+      @created = Time.now
+      @name = name
+      @data = data
+      # FIXME this is far too ambiguous. args should not mean different
+      # things in different contexts.
+      data_is_bytes = (data.nil? || Integer === data)
+      @bytes = data_is_bytes ? data : data.to_s.length
+      @data = data_is_bytes ? nil : data
+      @type = type
+      @last_modified_time = last_modified_time.utc
+    end
+
+    def data=(data)
+      @data = data
+      @bytes = @data.nil? ? nil : data.length
+    end
+
+    def passive?
+      @type == :passive
+    end
+
+    def active?
+      @type == :active
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/lib/fake_ftp/server.rb

@@ -0,0 +1,340 @@
+require 'socket'
+require 'thread'
+require 'timeout'
+
+module FakeFtp
+  class Server
+
+    attr_accessor :port, :passive_port
+    attr_reader :mode, :path
+
+    CMDS = %w(
+      acct
+      cwd
+      cdup
+      dele
+      list
+      mdtm
+      mkd
+      nlst
+      pass
+      pasv
+      port
+      pwd
+      quit
+      stor
+      retr
+      rnfr
+      rnto
+      type
+      user
+    )
+    LNBK = "\r\n"
+
+    def initialize(control_port = 21, data_port = nil, options = {})
+      self.port = control_port
+      self.passive_port = data_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 = []
+      @mode = :active
+      @path = "/pub"
+    end
+
+    def files
+      @files.map(&:name)
+    end
+
+    def file(name)
+      @files.detect { |file| file.name == name }
+    end
+
+    def reset
+      @files.clear
+    end
+
+    def add_file(filename, data, last_modified_time = Time.now)
+      @files << FakeFtp::File.new(::File.basename(filename.to_s), data, @mode, last_modified_time)
+    end
+
+    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
+          if @client
+            respond_with('220 Can has FTP?')
+            @connection = Thread.new(@client) do |socket|
+              while @started && !socket.nil? && !socket.closed?
+                input = socket.gets rescue nil
+                respond_with parse(input) if input
+              end
+              unless @client.nil?
+                @client.close unless @client.closed?
+                @client = nil
+              end
+            end
+          end
+        end
+        unless @server.nil?
+          @server.close unless @server.closed?
+          @server = nil
+        end
+      end
+
+      if passive_port
+        @data_server = ::TCPServer.new('127.0.0.1', passive_port)
+        @passive_port = @data_server.addr[1]
+      end
+    end
+
+    def stop
+      @started = false
+      @client.close if @client
+      @server.close if @server
+      @server = nil
+      @data_server.close if @data_server
+      @data_server = nil
+    end
+
+    def is_running?(tcp_port = nil)
+      tcp_port.nil? ? port_is_open?(port) : port_is_open?(tcp_port)
+    end
+
+    private
+
+    def respond_with(stuff)
+      @client.print stuff << LNBK unless stuff.nil? or @client.nil? or @client.closed?
+    end
+
+    def parse(request)
+      return if request.nil?
+      puts request if @options[:debug]
+      command = request[0, 4].downcase.strip
+      contents = request.split
+      message = contents[1..contents.length]
+      case command
+      when *CMDS
+        __send__ "_#{command}", *message
+      else
+        '500 Unknown command'
+      end
+    end
+
+
+    ## FTP commands
+    #
+    #  Methods are prefixed with an underscore to avoid conflicts with internal server
+    #  methods. Methods map 1:1 to FTP command words.
+    #
+    def _acct(*args)
+      '230 WHATEVER!'
+    end
+
+    def _cwd(*args)
+      @path = args[0]
+      @path = "/#{path}" if path[0].chr != "/"
+      '250 OK!'
+    end
+
+    def _cdup(*args)
+      '250 OK!'
+    end
+
+    def _list(*args)
+      wildcards = []
+      args.each do |arg|
+        next unless arg.include? '*'
+        wildcards << arg.gsub('*', '.*')
+      end
+
+      respond_with('425 Ain\'t no data port!') && return if active? && @active_connection.nil?
+
+      respond_with('150 Listing status ok, about to open data connection')
+      data_client = active? ? @active_connection : @data_server.accept
+
+      files = @files
+      if not wildcards.empty?
+        files = files.select do |f|
+          wildcards.any? { |wildcard| f.name =~ /#{wildcard}/ }
+        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}\n"
+      end
+      data_client.write(files.join)
+      data_client.close
+      @active_connection = nil
+
+      '226 List information transferred'
+    end
+
+    def _mdtm(filename = '', local = false)
+      respond_with('501 No filename given') && return if filename.empty?
+      server_file = file(filename)
+      respond_with('550 File not found') && return if server_file.nil?
+
+      respond_with("213 #{server_file.last_modified_time.strftime("%Y%m%d%H%M%S")}")
+    end
+
+    def _nlst(*args)
+      respond_with('425 Ain\'t no data port!') && return if active? && @active_connection.nil?
+
+      respond_with('150 Listing status ok, about to open data connection')
+      data_client = active? ? @active_connection : @data_server.accept
+
+      data_client.write(files.join("\n"))
+      data_client.close
+      @active_connection = nil
+
+      '226 List information transferred'
+    end
+
+    def _pass(*args)
+      '230 logged in'
+    end
+
+    def _pasv(*args)
+      if passive_port
+        @mode = :passive
+        p1 = (passive_port / 256).to_i
+        p2 = passive_port % 256
+        "227 Entering Passive Mode (127,0,0,1,#{p1},#{p2})"
+      else
+        '502 Aww hell no, use Active'
+      end
+    end
+
+    def _port(remote = '')
+      remote = remote.split(',')
+      remote_port = remote[4].to_i * 256 + remote[5].to_i
+      unless @active_connection.nil?
+        @active_connection.close
+        @active_connection = nil
+      end
+      @mode = :active
+      @active_connection = ::TCPSocket.open('127.0.0.1', remote_port)
+      '200 Okay'
+    end
+
+    def _pwd(*args)
+      "257 \"#{path}\" is current directory"
+    end
+
+    def _quit(*args)
+      respond_with '221 OMG bye!'
+      @client.close if @client
+      @client = nil
+    end
+
+    def _retr(filename = '')
+      respond_with('501 No filename given') if filename.empty?
+
+      file = file(::File.basename(filename.to_s))
+      return respond_with('550 File not found') if file.nil?
+
+      respond_with('425 Ain\'t no data port!') && return if active? && @active_connection.nil?
+
+      respond_with('150 File status ok, about to open data connection')
+      data_client = active? ? @active_connection : @data_server.accept
+
+      data_client.write(file.data)
+
+      data_client.close
+      @active_connection = nil
+      '226 File transferred'
+    end
+
+    def _rnfr(rename_from='')
+      return '501 Send path name.' if rename_from.nil? || rename_from.size < 1
+
+      @rename_from = rename_from
+      '350 Send RNTO to complete rename.'
+    end
+
+    def _rnto(rename_to='')
+      return '501 Send path name.' if rename_to.nil? || rename_to.size < 1
+
+      return '503 Send RNFR first.' unless @rename_from
+
+      if file = file(@rename_from)
+        file.name = rename_to
+        @rename_from = nil
+        '250 Path renamed.'
+      else
+        @rename_from = nil
+        '550 File not found.'
+      end
+    end
+
+    def _stor(filename = '')
+      respond_with('425 Ain\'t no data port!') && return if active? && @active_connection.nil?
+
+      respond_with('125 Do it!')
+      data_client = active? ? @active_connection : @data_server.accept
+
+      data = data_client.read(nil).chomp
+      file = FakeFtp::File.new(::File.basename(filename.to_s), data, @mode)
+      @files << file
+
+      data_client.close
+      @active_connection = nil
+      '226 Did it!'
+    end
+
+    def _dele(filename = '')
+      files_to_delete = @files.select{ |file| file.name == filename }
+      return '550 Delete operation failed.' if files_to_delete.count == 0
+
+      @files = @files - files_to_delete
+
+      '250 Delete operation successful.'
+    end
+
+    def _type(type = 'A')
+      case type.to_s
+      when 'A'
+        '200 Type set to A.'
+      when 'I'
+        '200 Type set to I.'
+      else
+        '504 We don\'t allow those'
+      end
+    end
+
+    def _user(name = '')
+      (name.to_s == 'anonymous') ? '230 logged in' : '331 send your password'
+    end
+
+    def _mkd(directory)
+      "257 OK!"
+    end
+
+    def active?
+      @mode == :active
+    end
+
+    private
+
+    def port_is_open?(port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new("127.0.0.1", port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+      end
+
+      return false
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/lib/fake_ftp/version.rb

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

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/spec/fixtures/text_file.txt

@@ -0,0 +1 @@
+Hello im a text file

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/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
+