investtools-ftpd 1.0.1

data/features/step_definitions/line_endings.rb

@@ -0,0 +1,7 @@
+def line_ending_type(s)
+  if s =~ /\r\n/
+    :windows
+  else
+    :unix
+  end
+end

data/features/step_definitions/list.rb

@@ -0,0 +1,73 @@
+class FileList
+
+  def initialize(lines)
+    @lines = lines
+  end
+
+  def filenames
+    @lines.map(&:split).map(&:last)
+  end
+
+  def long_form?
+    @lines.all? do |line|
+      line =~ /^[rwxSst-]{10}/
+    end
+  end
+
+  def short_form?
+    !long_form?
+  end
+
+  def eplf_format?
+    @lines.all? do |line|
+      line =~ /^\+.*\t.*$/
+    end
+  end
+
+  def empty?
+    @lines.empty?
+  end
+
+end
+
+When /^the client successfully lists the directory(?: "(.*?)")?$/ do |directory|
+  @list = FileList.new(client.ls(*[directory].compact))
+end
+
+When /^the client lists the directory( "(?:.*?)")?$/ do |directory|
+  capture_error do
+    step "the client successfully lists the directory#{directory}"
+  end
+end
+
+When /^the client successfully name-lists the directory(?: "(.*?)")?$/ do
+|directory|
+  @list = FileList.new(client.nlst(*[directory].compact))
+end
+
+When /^the client name-lists the directory( "(?:.*?)")?$/ do |directory|
+  capture_error do
+    step "the client successfully name-lists the directory#{directory}"
+  end
+end
+
+Then /^the file list should( not)? contain "(.*?)"$/ do |neg, filename|
+  verb = if neg
+           :to_not
+         else
+           :to
+         end
+  expect(@list.filenames).send(verb, include(filename))
+end
+
+Then /^the file list should be in (long|short) form$/ do |form|
+  expect(@list).to send("be_#{form}_form")
+end
+
+Then /^the file list should be empty$/ do
+  expect(@list).to be_empty
+end
+
+Then /^the list should be in EPLF format$/ do
+  expect(@list).to be_eplf_format
+end

data/features/step_definitions/login.rb

@@ -0,0 +1,82 @@
+def logged_in?
+  step "the client lists the directory"
+  @error.nil?
+end
+
+def login(tokens, client_name = nil)
+  capture_error do
+    client(client_name).login *tokens
+  end
+end
+
+Given /^a successful connection( with \w+ TLS)?$/ do |with_tls|
+  step "the client connects#{with_tls}"
+end
+
+Given /^a successful login( with \w+ TLS)?$/ do |with_tls|
+  step "a successful connection#{with_tls}"
+  step 'the client logs in'
+end
+
+Given /^a failed login$/ do
+  step 'the client connects'
+  step 'the client logs in with bad user'
+end
+
+When /^the(?: (\w+))? client logs in(?: with bad (\w+))?$/ do
+|client_name, bad|
+  tokens = [
+    if bad == 'user'
+      'bad_user'
+    else
+      @server.user
+    end,
+    if bad == 'password'
+      'bad_password'
+    else
+      @server.password
+    end,
+    if bad == 'account'
+      'bad_account'
+    else
+      @server.account
+    end,
+  ][0..server.auth_level]
+  @error = login(tokens, client_name)
+end
+
+Then /^the client should( not)? be logged in$/ do |neg|
+  matcher_method = if neg
+                     :be_falsey
+                   else
+                     :be_truthy
+                   end
+  expect(logged_in?).to send(matcher_method)
+end
+
+When /^the client sends a password( with no parameter)?$/ do |no_param|
+  capture_error do
+    args = if no_param
+             []
+           else
+             [server.password]
+           end
+    client.raw 'PASS', *args
+  end
+end
+
+When /^the client sends a user( with no parameter)?$/ do |no_param|
+  capture_error do
+    args = if no_param
+             []
+           else
+             [server.user]
+           end
+    client.raw 'USER', *args
+  end
+end
+
+Given /^the (\w+) client connects and logs in$/ do |client_name|
+  step "the #{client_name} client connects"
+  step "the #{client_name} client logs in"
+end

data/features/step_definitions/mkdir.rb

@@ -0,0 +1,9 @@
+When /^the client makes directory "(.*?)"$/ do |path|
+  capture_error do
+    step %Q(the client successfully makes directory "#{path}")
+  end
+end
+
+When /^the client successfully makes directory "(.*?)"$/ do |path|
+  mkdir_response = client.mkdir path
+end

data/features/step_definitions/mode.rb

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

data/features/step_definitions/mtime.rb

@@ -0,0 +1,23 @@
+require 'date'
+
+When /^the client successfully gets mtime of "(.*?)"$/ \
+do |remote_path|
+  @mtime = client.get_mtime remote_path
+end
+
+When /^the client gets mtime of "(.*?)"$/ do |path|
+  capture_error do
+    step %Q(the client successfully gets mtime of "#{path}")
+  end
+end
+
+When /^the client gets mtime with no path$/ do
+  capture_error do
+    client.raw 'MDTM'
+  end
+end
+
+Then(/^the reported mtime should be "(.*?)"$/) do |mtime|
+  expected_time = DateTime.parse(mtime).to_time.utc
+  expect(@mtime).to eq expected_time
+end

data/features/step_definitions/noop.rb

@@ -0,0 +1,15 @@
+When /^the( \w+)? client successfully does nothing( with a parameter)?$/ do
+|client_name, with_param|
+  if with_param
+    client(client_name).raw 'NOOP', 'foo'
+  else
+    client(client_name).noop
+  end
+end
+
+When /^the( \w+)? client does nothing( with a parameter)?$/ do
+|client_name, with_param|
+  capture_error do
+    step "the#{client_name} client successfully does nothing#{with_param}"
+  end
+end

data/features/step_definitions/options.rb

@@ -0,0 +1,9 @@
+When /^the client successfully sets option "(.*?)"$/ do |option|
+  client.set_option option
+end
+
+When /^the client sets option "(.*?)"$/ do |option|
+  capture_error do
+    step %q'the client successfully sets option "#{option}"'
+  end
+end

data/features/step_definitions/passive.rb

@@ -0,0 +1,3 @@
+Given /^the client is in (passive|active) mode$/ do |mode|
+  client.passive = mode == 'passive'
+end

data/features/step_definitions/pending.rb

@@ -0,0 +1,3 @@
+Given /^PENDING/ do
+  pending
+end

data/features/step_definitions/port.rb

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

data/features/step_definitions/put.rb

@@ -0,0 +1,29 @@
+When /^the client successfully puts (text|binary) "(.*?)"$/ do
+|mode, local_path|
+  client.put mode, local_path
+end
+
+When /^the client puts (\S+) "(.*?)"$/ do |mode, path|
+  capture_error do
+    step %Q(the client successfully puts #{mode} "#{path}")
+  end
+end
+
+When /^the client puts with no path$/ do
+  capture_error do
+    client.raw 'STOR'
+  end
+end
+
+When /^the client successfully stores unique "(.*?)"(?: to "(.*?)")?$/ do
+|local_path, remote_path|
+  client.store_unique local_path, remote_path
+end
+
+When /^the client stores unique "(.*?)"( to ".*?")?$/ do
+|local_path, remote_path|
+  capture_error do
+    step(%Q'the client successfully stores unique ' +
+         %Q'"#{local_path}"#{remote_path}')
+  end
+end

data/features/step_definitions/quit.rb

@@ -0,0 +1,15 @@
+When /^the client successfully quits$/ do
+  client.quit
+end
+
+When /^the client quits$/ do
+  capture_error do
+    step 'the client successfully quits'
+  end
+end
+
+When /^the client quits with a parameter$/ do
+  capture_error do
+    client.raw 'QUIT', 'foo'
+  end
+end

data/features/step_definitions/rename.rb

@@ -0,0 +1,11 @@
+When /^the client renames "(.*?)" to "(.*?)"$/ do
+|from_path, to_path|
+  capture_error do
+    step %Q'the client successfully renames "#{from_path}" to "#{to_path}"'
+  end
+end
+
+When /^the client successfully renames "(.*?)" to "(.*?)"$/ do
+|from_path, to_path|
+  client.rename(from_path, to_path)
+end

data/features/step_definitions/rmdir.rb

@@ -0,0 +1,9 @@
+When /^the client removes directory "(.*?)"$/ do |path|
+  capture_error do
+    step %Q(the client successfully removes directory "#{path}")
+  end
+end
+
+When /^the client successfully removes directory "(.*?)"$/ do |path|
+  mkdir_response = client.rmdir path
+end

data/features/step_definitions/server_files.rb

@@ -0,0 +1,61 @@
+require 'date'
+
+Given /^the server has directory "(.*?)"$/ do |remote_path|
+  server.add_directory remote_path
+end
+
+Given /^the server has file "(.*?)"$/ do |remote_path|
+  server.add_file remote_path
+end
+
+Given(/^the file "(.*?)" has mtime "(.*?)"$/) do |remote_path, mtime|
+  mtime = DateTime.parse(mtime).to_time.utc
+  server.set_mtime remote_path, mtime
+end
+
+Then /^the server should( not)? have file "(.*?)"$/ do |neg, path|
+  matcher = if neg
+              :be_falsey
+            else
+              :be_truthy
+            end
+  expect(server.has_file?(path)).to send(matcher)
+end
+
+Then /^the server should( not)? have directory "(.*?)"$/ do |neg, path|
+  matcher = if neg
+              :be_falsey
+            else
+              :be_truthy
+            end
+  expect(server.has_directory?(path)).to send(matcher)
+end
+
+Then /^the remote file "(.*?)" should have (unix|windows) line endings$/ do
+|remote_path, line_ending_type|
+  expect(line_ending_type(server.file_contents(remote_path))).to eq \
+    line_ending_type.to_sym
+end
+
+Then /^the server should have a file with the contents of "(.*?)"$/ do
+|path|
+  expect(server.has_file_with_contents_of?(path)).to be_truthy
+end
+
+Then /^the server should have (\d+) files? with "(.*?)" in the name$/ do
+|count, name|
+  expect(server.files_named_like(name).size).to eq count.to_i
+end
+
+Then /^the remote file "(.*?)" should match "(\w+)" \+ "(\w+)"$/ do
+|remote_path, template1, template2|
+  expected = @server.template(template1) + @server.template(template2)
+  actual = @server.file_contents(remote_path)
+  expect(actual).to eq expected
+end
+
+Then /^the remote file "(.*?)" should match "(\w+)"$/ do |remote_path, template|
+  expected = @server.template(template)
+  actual = @server.file_contents(remote_path)
+  expect(actual).to eq expected
+end

data/features/step_definitions/server_title.rb

@@ -0,0 +1,12 @@
+Then /^the server returns its title$/ do
+  step 'the server returns its name'
+  step 'the server returns its version'
+end
+
+Then /^the server returns its name$/ do
+  expect(@response).to include @server.server_name
+end
+
+Then /^the server returns its version$/ do
+  expect(@response).to match /\b\d+\.\d+\.\d+\b/
+end

data/features/step_definitions/size.rb

@@ -0,0 +1,20 @@
+When /^the client successfully gets size of (text|binary) "(.*?)"$/ \
+do |mode, remote_path|
+  @size = client.get_size mode, remote_path
+end
+
+When /^the client gets size of (\S+) "(.*?)"$/ do |mode, path|
+  capture_error do
+    step %Q(the client successfully gets size of #{mode} "#{path}")
+  end
+end
+
+When /^the client gets size with no path$/ do
+  capture_error do
+    client.raw 'SIZE'
+  end
+end
+
+Then(/^the reported size should be "(.*?)"$/) do |size|
+  expect(@size).to eq size.to_i
+end

data/features/step_definitions/status.rb

@@ -0,0 +1,9 @@
+When /^the client successfully requests status$/ do
+  @response = client.status
+end
+
+When /^the client requests status$/ do
+  capture_error do
+    step 'the client successfully requests status'
+  end
+end

data/features/step_definitions/success_replies.rb

@@ -0,0 +1,7 @@
+Then /^the server returns a "(.*?)" reply$/ do |reply|
+  expect(@reply).to eq reply + "\n"
+end
+
+Then /^the server returns a not necessary reply$/ do
+  step 'the server returns a "202 Command not needed at this site" reply'
+end