investtools-ftpd 1.0.1

data/features/ftp_server/type.feature

@@ -0,0 +1,59 @@
+Feature: Representation Type
+
+  As a client
+  I want to set the representation type
+  So that I can interoperate with foreign operating systems
+
+  Background:
+    Given the test server is started
+
+  Scenario: ASCII/default
+    Given a successful login
+    Then the client successfully sets type "A"
+
+  Scenario: ASCII/Non-print
+    Given a successful login
+    Then the client successfully sets type "A N"
+
+  Scenario: ASCII/Telnet
+    Given a successful login
+    When the client successfully sets type "A T"
+
+  Scenario: Type IMAGE
+    Given a successful login
+    Then the client successfully sets type "I"
+
+  Scenario: Type EBCDIC
+    Given a successful login
+    When the client sets type "E"
+    Then the server returns a type not implemented error
+
+  Scenario: Type Local
+    Given a successful login
+    When the client sets type "L 7"
+    Then the server returns a type not implemented error
+
+  Scenario: Invalid Type
+    Given a successful login
+    When the client sets type "*"
+    Then the server returns an invalid type error
+
+  Scenario: Format Carriage Control
+    Given a successful login
+    When the client sets type "A C"
+    Then the server returns a type not implemented error
+
+  Scenario: Invalid Format
+    Given a successful login
+    When the client sets type "A *"
+    Then the server returns an invalid type error
+
+  Scenario: Not logged in
+    Given a successful connection
+    When the client sets type "S"
+    Then the server returns a not logged in error
+
+  Scenario: Missing parameter
+    Given a successful login
+    When the client sets type with no parameter
+    Then the server returns a syntax error

data/features/step_definitions/append.rb

@@ -0,0 +1,15 @@
+When /^the client appends (.*)$/ do |args|
+  capture_error do
+    step "the client successfully appends #{args}"
+  end
+end
+
+When /^the client successfully appends text "(.*?)" onto "(.*?)"$/ do
+|local_path, remote_path|
+  client.append_text local_path, remote_path
+end
+
+When /^the client successfully appends binary "(.*?)" onto "(.*?)"$/ do
+|local_path, remote_path|
+  client.append_binary local_path, remote_path
+end

data/features/step_definitions/client.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+class Clients
+
+  include Singleton
+
+  def initialize
+    @clients = {}
+  end
+
+  def [](client_name)
+    @clients[client_name] ||= TestClient.new
+  end
+
+  def close
+    @clients.values.each(&:close)
+  end
+
+end
+
+def client(client_name = nil)
+  client_name ||= 'client'
+  Clients.instance[client_name]
+end

data/features/step_definitions/client_and_server_files.rb

@@ -0,0 +1,24 @@
+def unix_line_endings(exactly, s)
+  return s if exactly
+  s.gsub(/\r\n/, "\n")
+end
+
+Then /^the remote file "(.*?)" should( exactly)? match the local file$/ do
+|remote_path, exactly|
+  local_path = File.basename(remote_path)
+  remote_contents = server.file_contents(remote_path)
+  local_contents = client.file_contents(local_path)
+  remote_contents = unix_line_endings(exactly, remote_contents)
+  local_contents = unix_line_endings(exactly, local_contents)
+  expect(remote_contents).to eq local_contents
+end
+
+Then /^the local file "(.*?)" should( exactly)? match the remote file$/ do
+|local_path, exactly|
+  remote_path = local_path
+  remote_contents = server.file_contents(remote_path)
+  local_contents = client.file_contents(local_path)
+  remote_contents = unix_line_endings(exactly, remote_contents)
+  local_contents = unix_line_endings(exactly, local_contents)
+  expect(local_contents).to eq remote_contents
+end

data/features/step_definitions/client_files.rb

@@ -0,0 +1,14 @@
+Given /^the client has file "(.*?)"$/ do |local_path|
+  client.add_file local_path
+end
+
+Then /^the local file "(.*?)" should have (unix|windows) line endings$/ do
+|local_path, line_ending_type|
+  expect(line_ending_type(client.file_contents(local_path))).to eq \
+  line_ending_type.to_sym
+end
+
+Then /^the local file "(.*?)" should match its template$/ do |local_path|
+  expect(client.template(local_path)).to eq \
+  client.file_contents(local_path)
+end

data/features/step_definitions/command.rb

@@ -0,0 +1,5 @@
+When /^the client sends command "(.*?)"$/ do |command|
+  capture_error do
+    client.raw command
+  end
+end

data/features/step_definitions/connect.rb

@@ -0,0 +1,37 @@
+require 'double_bag_ftps'
+require 'net/ftp'
+
+When /^the( \w+)? client connects(?: with (\w+) TLS)?$/ do
+|client_name, tls_mode|
+  tls_mode ||= 'off'
+  client(client_name).tls_mode = tls_mode.to_sym
+  client(client_name).start
+  client(client_name).connect(server.host, server.port)
+end
+
+When /^the (\d+)rd client tries to connect$/ do |client_name|
+  client(client_name).start
+  capture_error do
+    client(client_name).connect(server.host, server.port)
+  end
+end
+
+When /^the (\S+) client connects from (\S+)$/ do
+|client_name, source_ip|
+  client(client_name).connect_from(source_ip, server.host, server.port)
+end
+
+When /^the (\S+) client tries to connect from (\S+)$/ do
+|client_name, source_ip|
+  capture_error do
+    step "the #{client_name} client connects from #{source_ip}"
+  end
+end
+
+Then /^the client should be connected$/ do
+  expect(client).to be_connected
+end
+
+Then /^the client should not be connected$/ do
+  expect(client).to_not be_connected
+end

data/features/step_definitions/delete.rb

@@ -0,0 +1,15 @@
+When /^the client deletes "(.*?)"$/ do |path|
+  capture_error do
+    step %Q(the client successfully deletes "#{path}")
+  end
+end
+
+When /^the client successfully deletes "(.*?)"$/ do |path|
+  client.delete path
+end
+
+When /^the client deletes with no path$/ do
+  capture_error do
+    client.raw 'DELE'
+  end
+end

data/features/step_definitions/directory_navigation.rb

@@ -0,0 +1,26 @@
+When /^the client cd's to "(.*?)"$/ do |path|
+  capture_error do
+    step %Q(the client successfully cd's to "#{path}")
+  end
+end
+
+# As of Ruby 1.9.3-p125, Net::FTP#chdir('..') will send a CDUP.
+# However, that could conceivably change: The use of CDUP not
+# required by the FTP protocol.  Therefore we use this step to
+# ensure that CDUP is sent and therefore tested.
+
+When /^the client successfully cd's up$/ do
+  client.raw 'CDUP'
+end
+
+When /^the client successfully cd's to "(.*?)"$/ do |path|
+  client.chdir path
+end
+
+Then /^the current directory should be "(.*?)"$/ do |path|
+  expect(client.pwd).to eq path
+end
+
+Then /^the XPWD directory should be "(.*?)"$/ do |path|
+  expect(client.xpwd).to eq path
+end

data/features/step_definitions/error_replies.rb

@@ -0,0 +1,115 @@
+def capture_error
+  yield
+  @error = nil
+rescue Net::FTPError => e
+  @error = e.message
+end
+
+Then /^the server returns no error$/ do
+  expect(@error).to be_nil
+end
+
+Then /^the server returns a "(.*?)" error$/ do |error_message|
+  expect(@error || '').to include error_message
+end
+
+Then /^the server returns a too many connections error$/ do
+  step 'the server returns a "421 Too many connections" error'
+end
+
+Then /^the server returns a server unavailable error$/ do
+  step 'the server returns a "421 server unavailable" error'
+end
+
+Then /^the server returns a not a directory error$/ do
+  step 'the server returns a "550 Not a directory" error'
+end
+
+Then /^the server returns a login incorrect error$/ do
+  step 'the server returns a "530 Login incorrect" error'
+end
+
+Then /^the server returns a not logged in error$/ do
+  step 'the server returns a "530 Not logged in" error'
+end
+
+Then /^the server returns an access denied error$/ do
+  step 'the server returns a "550 Access denied" error'
+end
+
+Then /^the server returns a path required error$/ do
+  step 'the server returns a "501 Path required" error'
+end
+
+Then /^the server returns a not found error$/ do
+  step 'the server returns a "550 No such file or directory" error'
+end
+
+Then /^the server returns a syntax error$/ do
+  step 'the server returns a "501 Syntax error" error'
+end
+
+Then /^the server returns a bad option error$/ do
+  step 'the server returns a "501 Unsupported option" error'
+end
+
+Then /^the server returns a mode not implemented error$/ do
+  step 'the server returns a "504 Mode not implemented" error'
+end
+
+Then /^the server returns an invalid mode error$/ do
+  step 'the server returns a "504 Invalid mode code" error'
+end
+
+Then /^the server returns a file structure not implemented error$/ do
+  step 'the server returns a "504 Structure not implemented" error'
+end
+
+Then /^the server returns an invalid file structure error$/ do
+  step 'the server returns a "504 Invalid structure code" error'
+end
+
+Then /^the server returns a bad sequence error$/ do
+  step 'the server returns a "503 Bad sequence of commands" error'
+end
+
+Then /^the server returns a type not implemented error$/ do
+  step 'the server returns a "504 Type not implemented" error'
+end
+
+Then /^the server returns an invalid type error$/ do
+  step 'the server returns a "504 Invalid type code" error'
+end
+
+Then /^the server returns a format not implemented error$/ do
+  step 'the server returns a "504 Format not implemented" error'
+end
+
+Then /^the server returns an unimplemented parameter error$/ do
+  step('the server returns a "504 Command not '\
+       'implemented for that parameter" error')
+end
+
+Then /^the server returns a command unrecognized error$/ do
+  step 'the server returns a "500 Syntax error, command unrecognized" error'
+end
+
+Then /^the server returns an unimplemented command error$/ do
+  step 'the server returns a "502 Command not implemented" error'
+end
+
+Then /^the server returns an action not taken error$/ do
+  step 'the server returns a "550 Unable to do it" error'
+end
+
+Then /^the server returns an already exists error$/ do
+  step 'the server returns a "550 Already exists" error'
+end
+
+Then /^the server returns a network protocol not supported error$/ do
+  step 'the server returns a "522 Network protocol" error'
+end
+
+Then /^the server sends a not allowed after epsv all error$/ do
+  step 'the server returns a "501 Not allowed after EPSV ALL" error'
+end

data/features/step_definitions/features.rb

@@ -0,0 +1,21 @@
+When /^the client successfully requests features$/ do
+  @feature_reply = client.raw "FEAT"
+end
+
+def feature_regexp(feature)
+  /^ #{feature}$/
+end
+
+Then /^the response should include feature "(.*?)"$/ do |feature|
+  expect(@feature_reply).to match feature_regexp(feature)
+end
+
+Then /^the response should not include feature "(.*?)"$/ do |feature|
+  expect(@feature_reply).to_not match feature_regexp(feature)
+end
+
+Then /^the response should( not)? include TLS features$/ do |neg|
+  step %Q'the response should#{neg} include feature "AUTH TLS"'
+  step %Q'the response should#{neg} include feature "PBSZ"'
+  step %Q'the response should#{neg} include feature "PROT"'
+end

data/features/step_definitions/file_structure.rb

@@ -0,0 +1,16 @@
+When /^the client successfully sets file structure "(.*?)"$/ do
+|file_structure|
+  client.raw 'STRU', file_structure
+end
+
+When /^the client sets file structure "(.*?)"$/ do |file_structure|
+  capture_error do
+    step %Q'the client successfully sets file structure "#{file_structure}"'
+  end
+end
+
+When /^the client sets file structure with no parameter$/ do
+  capture_error do
+    client.raw 'STRU'
+  end
+end

data/features/step_definitions/generic_send.rb

@@ -0,0 +1,9 @@
+When /^the client successfully sends "(.*?)"$/ do |command|
+  @reply = client.raw command
+end
+
+When /^the client sends "(.*?)"$/ do |command|
+  capture_error do
+    step %Q'the client successfully sends "#{command}"'
+  end
+end

data/features/step_definitions/get.rb

@@ -0,0 +1,16 @@
+When /^the client successfully gets (text|binary) "(.*?)"$/ \
+do |mode, remote_path|
+  client.get mode, remote_path
+end
+
+When /^the client gets (\S+) "(.*?)"$/ do |mode, path|
+  capture_error do
+    step %Q(the client successfully gets #{mode} "#{path}")
+  end
+end
+
+When /^the client gets with no path$/ do
+  capture_error do
+    client.raw 'RETR'
+  end
+end

data/features/step_definitions/help.rb

@@ -0,0 +1,18 @@
+When /^the client successfully asks for help(?: for "(.*?)")?$/ do
+|command|
+  @help_reply = client.help(command)
+end
+
+Then /^the server should return a list of commands$/ do
+  commands = @help_reply.scan(/\b([A-Z][A-Z]+)\b/).flatten
+  expect(commands).to include 'NOOP'
+  expect(commands).to include 'USER'
+end
+
+Then /^the server should return help for "(.*?)"$/ do |command|
+  expect(@help_reply).to match /Command #{command} is recognized/
+end
+
+Then /^the server should return no help for "(.*?)"$/ do |command|
+  expect(@help_reply).to match /Command #{command} is not recognized/
+end

data/features/step_definitions/invalid_commands.rb

@@ -0,0 +1,11 @@
+When /^the client sends an empty command$/ do
+  capture_error do
+    client.raw ''
+  end
+end
+
+When /^the client sends a non-word command$/ do
+  capture_error do
+    client.raw '*'
+  end
+end