fake_ftp 0.2.0 → 0.3.0

data/spec/integration/server_spec.rb

@@ -1,10 +1,13 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'net/ftp'
 
-describe FakeFtp::Server, 'with ftp client' do
-  let(:server) { FakeFtp::Server.new(21212, 21213) }
-  let(:client) { Net::FTP.new }
-  let(:text_filename) { File.expand_path("../fixtures/text_file.txt", File.dirname(__FILE__)) }
+describe FakeFtp::Server, 'with ftp client', integration: true do
+  let(:server) { FakeFtp::Server.new(21_212, 21_213, absolute: true) }
+  let(:client) { Net::FTP.new(nil, debug_mode: ENV['DEBUG'] == '1') }
+  let(:text_filename) do
+    File.expand_path('../../fixtures/text_file.txt', __FILE__)
+  end
 
   before { server.start }
 
@@ -14,29 +17,29 @@ describe FakeFtp::Server, 'with ftp client' do
   end
 
   it 'should accept connections' do
-    expect { client.connect('127.0.0.1', 21212) }.to_not raise_error
+    expect { client.connect('127.0.0.1', 21_212) }.to_not raise_error
   end
 
-  context "with client" do
-    before { client.connect("127.0.0.1", 21212) }
+  context 'with client' do
+    before { client.connect('127.0.0.1', 21_212) }
 
-    it "should allow anonymous authentication" do
+    it 'should allow anonymous authentication' do
       expect { client.login }.to_not raise_error
     end
 
-    it "should allow named authentication" do
+    it 'should allow named authentication' do
       expect { client.login('someone', 'password') }.to_not raise_error
     end
 
-    it "should allow client to quit" do
+    it 'should allow client to quit' do
       expect { client.login('someone', 'password') }.to_not raise_error
       expect { client.quit }.to_not raise_error
     end
 
-    it "should allow mtime" do
-      filename = 'someone'
+    it 'should allow mtime' do
+      filename = '/pub/someone'
       time = Time.now
-      server.add_file(filename, "some data", time)
+      server.add_file(filename, 'some data', time)
 
       client.passive = false
       mtime = client.mtime(filename)
@@ -47,35 +50,42 @@ describe FakeFtp::Server, 'with ftp client' do
       expect(mtime.to_s).to eql(time.to_s)
     end
 
-    it "should put files using PASV" do
+    it 'should put files using PASV' do
       expect(File.stat(text_filename).size).to eql(20)
 
       client.passive = true
       expect { client.put(text_filename) }.to_not raise_error
 
-      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
+      expect(server.files).to include('/pub/text_file.txt')
+      expect(server.file('/pub/text_file.txt').bytes).to eql(20)
+      expect(server.file('/pub/text_file.txt')).to be_passive
+      expect(server.file('/pub/text_file.txt')).to_not be_active
     end
 
-    it "should put files using active" do
+    it 'should put files using active' do
       expect(File.stat(text_filename).size).to eql(20)
 
       client.passive = false
       expect { client.put(text_filename) }.to_not raise_error
 
-      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
+      expect(server.files).to include('/pub/text_file.txt')
+      expect(server.file('/pub/text_file.txt').bytes).to eql(20)
+      expect(server.file('/pub/text_file.txt')).to_not be_passive
+      expect(server.file('/pub/text_file.txt')).to be_active
+    end
+
+    it 'should allow client to execute SITE command' do
+      expect { client.site('umask') }.to_not raise_error
     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
-      expect(client.closed?).to be_true
+    it 'should be able to delete files added using put' do
+      expect(File.stat(text_filename).size).to eql(20)
+
+      client.passive = false
+      expect { client.put(text_filename) }.to_not raise_error
+      expect(server.files).to include('/pub/text_file.txt')
+      expect { client.delete(text_filename) }.to_not raise_error
+      expect(server.files).to_not include('/pub/text_file.txt')
     end
   end
 end

data/spec/models/fake_ftp/file_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper.rb"
+# frozen_string_literal: true
 
 describe FakeFtp::File do
   context 'attributes' do
@@ -6,59 +6,60 @@ describe FakeFtp::File do
       @file = FakeFtp::File.new
     end
 
-    it "has a name attribute" do
-      @file.name = "some name"
-      expect(@file.name).to eql("some name")
+    it 'has a name attribute' do
+      @file.name = 'some name'
+      expect(@file.name).to eql('some name')
     end
 
-    it "has a last_modified_time attribute" do
+    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
+    it 'has a bytes attribute' do
       @file.bytes = 87
       expect(@file.bytes).to eql(87)
     end
 
-    it "has a data attribute" do
+    it 'has a data attribute' do
       @file.data = 'some data'
       expect(@file.data).to eql('some data')
-      expect(@file.bytes).to eql('some data'.length)
+      expect(@file.bytes).to eql(9)
     end
   end
 
   context 'setup' do
-    it "can be initialized without attributes" do
+    it 'can be initialized without attributes' do
       file = FakeFtp::File.new
       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
+    it 'can be initialized with name' do
       file = FakeFtp::File.new('filename')
       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
+    it 'can be initialized with name and bytes' do
       file = FakeFtp::File.new('filename', 104)
       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
+    it 'can be initialized with name and bytes and type' do
       file = FakeFtp::File.new('filename', 104, :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
+    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')
@@ -73,14 +74,14 @@ describe FakeFtp::File do
       @file = FakeFtp::File.new
     end
 
-    it "should be true if type is :passive" do
+    it 'should be true if type is :passive' do
       @file.type = :passive
-      expect(@file.passive?).to be_true
+      expect(@file.passive?).to be true
     end
 
-    it "should be false if type is :active" do
+    it 'should be false if type is :active' do
       @file.type = :active
-      expect(@file.passive?).to be_false
+      expect(@file.passive?).to be false
     end
   end
 
@@ -89,14 +90,14 @@ describe FakeFtp::File do
       @file = FakeFtp::File.new
     end
 
-    it "should be true if type is :active" do
+    it 'should be true if type is :active' do
       @file.type = :active
-      expect(@file.active?).to be_true
+      expect(@file.active?).to be true
     end
 
-    it "should be false if type is :passive" do
+    it 'should be false if type is :passive' do
       @file.type = :passive
-      expect(@file.active?).to be_false
+      expect(@file.active?).to be false
     end
   end
 end

data/spec/models/fake_ftp/server_spec.rb

@@ -1,76 +1,77 @@
-require "spec_helper.rb"
+# frozen_string_literal: true
 
 describe FakeFtp::Server, 'setup' do
-  it "starts a server on port n" do
-    server = FakeFtp::Server.new(21212)
-    expect(server.port).to eql(21212)
+  it 'starts a server on port n' do
+    server = FakeFtp::Server.new(21_212)
+    expect(server.port).to eql(21_212)
   end
 
-  it "should defaults to port 21" do
+  it 'should defaults to port 21' do
     server = FakeFtp::Server.new
     expect(server.port).to eql(21)
   end
 
-  it "starts a passive server on port p" do
-    server = FakeFtp::Server.new(21212, 21213)
-    expect(server.passive_port).to eql(21213)
+  it 'starts a passive server on port p' do
+    server = FakeFtp::Server.new(21_212, 21_213)
+    expect(server.passive_port).to eql(21_213)
   end
 
-  it "should start and stop" do
-    server = FakeFtp::Server.new(21212)
-    expect(server.is_running?).to be_false
+  it 'should start and stop' do
+    server = FakeFtp::Server.new(21_212)
+    expect(server.running?).to be false
     server.start
-    expect(server.is_running?).to be_true
+    expect(server.running?).to be true
     server.stop
-    expect(server.is_running?).to be_false
+    expect(server.running?).to be false
   end
 
-  it "should default :mode to :active" do
-    server = FakeFtp::Server.new(21212, 21213)
+  it 'should default :mode to :active' do
+    server = FakeFtp::Server.new(21_212, 21_213)
     expect(server.mode).to eql(:active)
   end
 
-  it "should start and stop passive port" do
-    server = FakeFtp::Server.new(21212, 21213)
-    expect(server.is_running?(21213)).to be_false
+  it 'should start and stop passive port' do
+    server = FakeFtp::Server.new(21_212, 21_213)
+    expect(server.running?(21_213)).to be false
     server.start
-    expect(server.is_running?(21213)).to be_true
+    expect(server.running?(21_213)).to be true
     server.stop
-    expect(server.is_running?(21213)).to be_false
+    expect(server.running?(21_213)).to be false
   end
 
-  it "should raise if attempting to use a bound port" do
-    server = FakeFtp::Server.new(21212)
+  it 'should raise if attempting to use a bound port' do
+    server = FakeFtp::Server.new(21_212)
     server.start
-    expect { FakeFtp::Server.new(21212) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21212")
+    expect { FakeFtp::Server.new(21_212) }
+      .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)
+  it 'should raise if attempting to use a bound passive_port' do
+    server = FakeFtp::Server.new(21_212, 21_213)
     server.start
-    expect { FakeFtp::Server.new(21214, 21213) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21213")
+    expect { FakeFtp::Server.new(21_214, 21_213) }
+      .to raise_error(Errno::EADDRINUSE, 'Address already in use - 21213')
     server.stop
   end
 end
 
 describe FakeFtp::Server, 'files' do
   let(:file) { FakeFtp::File.new('filename', 34) }
-  let(:server) { FakeFtp::Server.new(21212) }
+  let(:server) { FakeFtp::Server.new(21_212) }
 
-  before { server.instance_variable_set(:@files, [file]) }
+  before { server.instance_variable_set(:@store, '/pub/filename' => file) }
 
-  it "returns filenames from :files" do
+  it 'returns filenames from :files' do
     expect(server.files).to include('filename')
   end
 
-  it "can be accessed with :file" do
+  it 'can be accessed with :file' do
     expect(server.file('filename')).to eql(file)
   end
 
-  it "can reset files" do
+  it 'can reset files' do
     server.reset
     expect(server.files).to eql([])
   end
 end
-

data/spec/spec_helper.rb

@@ -1,18 +1,102 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.dirname(__FILE__), '**','*')
+# frozen_string_literal: true
 
-require 'rubygems'
-require 'bundler/setup'
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
 
+require 'simplecov'
 require 'rspec'
-require 'fake_ftp' # and any other gems you need
-
-RSpec.configure do |config|
-  
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
+require 'fake_ftp'
+
+RSpec.configure do |c|
+  c.filter_run_excluding(
+    functional: ENV['FUNCTIONAL_SPECS'] != '1',
+    integration: ENV['INTEGRATION_SPECS'] != '1'
+  )
+end
+
+module SpecHelper
+  def gets_with_timeout(client, timeout: 5, endwith: "\r\n", chunk: 1024)
+    outer_caller = caller(0..1).last.to_s
+    start = Time.now
+    buf = ''
+    loop do
+      if Time.now - start >= timeout
+        raise Timeout::Error, "client=#{client} timeout=#{timeout}s " \
+              "buf=#{buf.inspect} caller=#{outer_caller.inspect}"
+      end
+      bytes = client.read_nonblock(chunk, exception: false)
+      return buf if bytes.nil?
+      buf += bytes unless bytes == :wait_readable
+      return buf if buf.end_with?(endwith)
+    end
+    buf
+  end
+
+  module_function :gets_with_timeout
+
+  def local_addr_bits(port)
+    [
+      127, 0, 0, 1,
+      port / 256,
+      port % 256
+    ].map(&:to_s).join(',')
+  end
+
+  module_function :local_addr_bits
+
+  def statline(ftp_file)
+    %W[
+      -rw-r--r--
+      1
+      owner
+      group
+      10
+      #{ftp_file.created.strftime('%b %d %H:%M')}
+      #{ftp_file.name}
+    ].join("\t")
+  end
+
+  module_function :statline
+
+  class FakeDataServer
+    def initialize(port)
+      @port = port
+    end
+
+    attr_reader :port
+
+    def addr_bits
+      ::SpecHelper.local_addr_bits(port)
+    end
+
+    def start
+      server
+    end
+
+    def stop
+      server.close
+    end
+
+    def handler_sock
+      @handler_sock ||= wait_for_handler_sock
+    end
+
+    private
+
+    def wait_for_handler_sock
+      sock = nil
+
+      while sock.nil? || sock == :wait_readable
+        sleep 0.01
+        sock = server.accept_nonblock(exception: false)
+      end
+
+      sock
+    end
+
+    def server
+      @server ||= TCPServer.new('127.0.0.1', port).tap do |srv|
+        srv.sync = true
+      end
+    end
+  end
 end