baf 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9311e4cba4d27aee336f9983d97efd78d8296b5672ec1dccc3337056b66ba620
-  data.tar.gz: a9ba3e9ab48e78e71173faaa63eece4addadcc9573e28ea6d3b19adbe6fc41c9
+  metadata.gz: c3dd2c36e21fb8a41d21f0d3ea90c5126274b9f68f19f4b2cb0f09c33aa38605
+  data.tar.gz: 9cf8f0b59d4b8cbb70f174912f2569f204fd27a82236a8e992c6729b366cc574
 SHA512:
-  metadata.gz: 7aeeb1da2a0f359a5a537580ab13384b3cba5501a6c00722c0f025760eb4c31c951ddf0616410138520bd2457972386dd1bf9bd976259aa271d6365187a0d6e7
-  data.tar.gz: 74267eaf156de24338b988e46960565cb1eefc6dc5b241ccb1dba4db022ed6bd313f5932d944833ab010f858b314daeb3145318e01a8a6b52925e730f753f1af
+  metadata.gz: bcc9f8fb5658bb47c75067a09912585878ee73ab227c09628eb4d2742e3f360a8c2f55b3effa1e2acc1329f130046f8ec76caefa66d6c468fbdce46596ba6370
+  data.tar.gz: 8aa8f06dee9cb55a12e560177c80a44f724c4fab30b5a5e9de9764f7fdd4eb12d0e9e76ebdedbad4fdd5fbb7cb58ea101fb3402d68d56fd191a0297b0dd198bb

data/lib/baf/option.rb

@@ -1,11 +1,11 @@
 module Baf
   class Option
-    LONG_PREFIX             = '--'.freeze
-    LONG_NORMALIZE_SEARCH   = ?_.freeze
-    LONG_NORMALIZE_REPLACE  = ?-.freeze
-    LONG_WITH_ARG_GLUE      = ' '.freeze
-    PARSER_MESSAGE          = :on
-    PARSER_MESSAGE_TAIL     = :on_tail
+    LONG_PREFIX = '--'.freeze
+    LONG_NORMALIZE_SEARCH = ?_.freeze
+    LONG_NORMALIZE_REPLACE = ?-.freeze
+    LONG_WITH_ARG_GLUE = ' '.freeze
+    PARSER_MESSAGE = :on
+    PARSER_MESSAGE_TAIL = :on_tail
 
     attr_accessor :short, :long, :arg, :desc, :block, :tail
 

data/lib/baf/options_registrant.rb

@@ -3,8 +3,8 @@ require 'baf/option'
 
 module Baf
   class OptionsRegistrant
-    SUMMARY_HEADER    = "\noptions:".freeze
-    HELP_PARSER_ARGS  = %w[
+    SUMMARY_HEADER = "\noptions:".freeze
+    HELP_PARSER_ARGS = %w[
       -h
       --help
       print\ this\ message

data/lib/baf/testing/cucumber/steps/execution.rb

@@ -1,50 +1,35 @@
-def program_run check: false, opts: nil, args: nil, wait: true
-  cmd = [*@_baf_program ||= %w[ruby baf]]
-  cmd << opts if opts
-  cmd << args.split(' ') if args
-  if wait
-    run_simple cmd.join(' '), fail_on_error: false
-  else
-    run cmd.join ' '
-  end
-  program_run_check if check
-end
-
-def program_run_check status: 0
-  expect(last_command_started).to have_exit_status status
-rescue RSpec::Expectations::ExpectationNotMetError => e
-  if ENV.key? 'BAF_TEST_DEBUG'
-    fail RSpec::Expectations::ExpectationNotMetError, <<-eoh
-#{e.message} Output was:
-  ```\n#{last_command_started.output.lines.map { |l| "  #{l}" }.join}  ```
-    eoh
-  else
-    raise
-  end
+def run state, cmd: nil, wait: true, args: []
+  cmd ||= state[:program]
+  Baf::Testing.run cmd + args,
+    wait: wait,
+    env_allow: state.fetch(:env_allow) { [] },
+    timeout: state[:exec_timeout]
 end
 
 
 When /^I( successfully)? (run|\w+) the program$/ do |check, run|
-  program_run check: !!check, wait: run == 'run'
-end
-
-When /^I( successfully)? (run|\w+) the program with arguments? (.+)$/ do |check, run, args|
-  program_run check: !!check, args: args, wait: run == 'run'
+  $_baf[:process] = run $_baf, wait: run == 'run'
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
-When /^I( successfully)? (run|\w+) the program with command (.+)$/ do |check, run, cmd|
-  program_run check: !!check, args: cmd, wait: run == 'run'
+When(
+  /^I( successfully)? (run|\w+) the program with (?:argument|command|option)s? (.+)$/
+) do |check, run, args|
+  $_baf[:process] = run $_baf, wait: run == 'run', args: args.split(' ')
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
-When /^I( successfully)? (run|\w+) the program with options? (-.+)$/ do |check, run, opts|
-  program_run check: !!check, opts: opts, wait: run == 'run'
+When /^I( successfully)? (run|\w+) `([^`]+)`$/ do |check, run, command|
+  $_baf[:process] = run $_baf, cmd: command.split(' '), wait: run == 'run'
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
 
-Then /^the exit status must be (\d+)$/ do |exit_status|
-  program_run_check status: exit_status.to_i
+Then /^the program must terminate successfully$/ do
+  Baf::Testing.wait $_baf[:process]
+  Baf::Testing.expect_ex $_baf[:process], 0
 end
 
-Then /^the program must terminate successfully$/ do
-  program_run_check status: 0
+Then /^the exit status must be (\d+)$/ do |exit_status|
+  Baf::Testing.expect_ex $_baf[:process], Integer(exit_status)
 end

data/lib/baf/testing/cucumber/steps/filesystem.rb

@@ -0,0 +1,3 @@
+Given /^a file named ([^ ]+) with:$/ do |path, content|
+  Baf::Testing.write_file path, content + $/
+end

data/lib/baf/testing/cucumber/steps/input.rb

@@ -1,3 +1,3 @@
 When /^I input "([^"]+)"$/ do |content|
-  last_command_started.write unescape_text content
+  $_baf[:process].input Baf::Testing.unescape_step_arg content
 end

data/lib/baf/testing/cucumber/steps/output.rb

@@ -1,44 +1,35 @@
-def build_regexp pattern, options
-  Regexp.new(pattern, options.each_char.inject(0) do |m, e|
-    m | case e
-      when ?i then Regexp::IGNORECASE
-      when ?m then Regexp::MULTILINE
-      when ?x then Regexp::EXTENDED
-    end
-  end)
-end
-
-def expect_output content, stream: :output
-  stream = :stderr if stream == :error
-  expect(last_command_started.send stream).to eq unescape_text content
-end
-
-
 Then /^the output must be empty$/ do
-  expect(last_command_started.output).to be_empty
+  expect($_baf[:process].output).to be_empty
 end
 
 Then /^the output must contain:$/ do |content|
-  expect(last_command_started.output).to include unescape_text content
+  expect($_baf[:process].output).to include content
 end
 
 Then /^the output must contain "([^"]+)"$/ do |content|
-  expect(last_command_started.output).to include unescape_text content
+  expect($_baf[:process].output).to include content
 end
 
 Then /^the output must not contain "([^"]+)"$/ do |content|
-  expect(last_command_started.output).not_to include unescape_text content
+  expect($_baf[:process].output).not_to include content
 end
 
 Then /^the output must contain exactly:$/ do |content|
-  expect_output content + $/
+  expect($_baf[:process].output).to eq content + $/
 end
 
 Then /^the( error)? output must contain exactly "([^"]+)"$/ do |stream, content|
   stream = stream ? :error : :output
-  expect_output content, stream: stream
+  expect($_baf[:process].output stream)
+    .to eq Baf::Testing::unescape_step_arg content
+end
+
+Then /^the output must match:/ do |pattern|
+  expect($_baf[:process].output)
+    .to match Baf::Testing.build_regexp(pattern, 'mx')
 end
 
 Then /^the output must match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
-  expect(last_command_started.output).to match build_regexp(pattern, options)
+  expect($_baf[:process].output)
+    .to match Baf::Testing.build_regexp(pattern, options)
 end

data/lib/baf/testing/cucumber/steps/output_wait.rb

@@ -1,57 +1,16 @@
-require 'timeout'
-
-module Baf
-  module Testing
-    class WaitError < ::StandardError
-      attr_reader :timeout
-
-      def initialize message, timeout
-        super message
-        @timeout = timeout
-      end
-    end
-  end
-end
-
-def wait_output! pattern, times: 1, results: nil
-  output = -> { last_command_started.output }
-  wait_until do
-    case pattern
-    when Regexp then (results = output.call.scan(pattern)).size >= times
-    when String then output.call.include? pattern
-    end
-  end
-  results
-rescue Baf::Testing::WaitError => e
-  fail <<-eoh
-expected `#{pattern}' not seen after #{e.timeout} seconds in:
-  ```\n#{output.call.lines.map { |l| "  #{l}" }.join}  ```
-  eoh
-end
-
-def wait_until message: 'condition not met after %d seconds'
-  timeout = ENV.key?('BAF_TEST_TIMEOUT') ?
-    ENV['BAF_TEST_TIMEOUT'].to_i :
-    2
-  Timeout.timeout timeout do
-    loop do
-      break if yield
-      sleep 0.05
-    end
-  end
-rescue Timeout::Error
-  fail Baf::Testing::WaitError.new(message % timeout, timeout)
+def wait_output pattern, output: -> { $_baf[:process].output }, times: 1
+  Baf::Testing.wait_output pattern, stream: output, times: times
 end
 
 
 Then /^the output will match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
-  wait_output! build_regexp pattern, options
+  wait_output Baf::Testing.build_regexp pattern, options
 end
 
 Then /^the output will contain:$/ do |content|
-  wait_output! content + $/
+  wait_output content + $/
 end
 
 Then /^the output will contain "([^"]+)"$/ do |content|
-  wait_output! content
+  wait_output content
 end

data/lib/baf/testing/cucumber.rb

@@ -1,5 +1,11 @@
-require 'aruba/api'
-require 'aruba/cucumber/hooks'
-
+require 'baf/testing'
 require 'baf/testing/cucumber/steps/execution'
+require 'baf/testing/cucumber/steps/filesystem'
 require 'baf/testing/cucumber/steps/output'
+
+$_baf = {}
+
+Around do |_, block|
+  Baf::Testing.exercise_scenario &block
+  $_baf.delete :process
+end

data/lib/baf/testing/process.rb

@@ -0,0 +1,107 @@
+require 'baf'
+
+require 'tempfile'
+
+module Baf
+  module Testing
+    class Process
+      ExecutionFailure = Class.new Error
+
+      TIMEOUT = 4
+      TMP_FILE_PREFIX = 'baf_test_'.freeze
+      WAIT_POLL_DELAY = 0.01
+
+      attr_reader :pid, :exit_status, :timeout
+
+      def initialize command, env_allow: [], timeout: TIMEOUT
+        @command = command
+        @env_allow = env_allow
+        @timeout = timeout
+        @stdout = Tempfile.new TMP_FILE_PREFIX
+        @stderr = Tempfile.new TMP_FILE_PREFIX
+      end
+
+      def start
+        reader, writer = IO.pipe
+
+        @pid = spawn env,
+          *@command,
+          unsetenv_others: true,
+          in: reader,
+          out: @stdout,
+          err: @stderr
+        reader.close
+        @stdin = writer
+      rescue Errno::ENOENT => e
+        fail ExecutionFailure, e.message
+      end
+
+      def wait timeout: @timeout
+        deadline = Time.now + timeout
+        wait_poll
+        until stopped? || Time.now >= deadline
+          sleep WAIT_POLL_DELAY
+          wait_poll
+        end
+        yield unless stopped? if block_given?
+      end
+
+      def stop wait_timeout: 1
+        ::Process.kill :TERM, @pid
+        wait timeout: wait_timeout
+        return if stopped?
+        ::Process.kill :KILL, @pid
+        ::Process.wait2 @pid
+      rescue Errno::ECHILD, Errno::ESRCH
+      end
+
+      def running?
+        started? && !stopped?
+      end
+
+      def input str
+        @stdin.write str
+      end
+
+      def output stream = nil
+        case stream
+          when :output then [@stdout]
+          when :error then [@stderr]
+          else [@stdout, @stderr]
+        end.inject '' do |memo, stream|
+          memo + IO.read(stream.path)
+        end
+      end
+
+    private
+
+      def env
+        ENV.inject({}) do |acc, (k, v)|
+          if env_allow? k then acc.merge k => v else acc end
+        end.merge 'HOME' => File.realpath(?.)
+      end
+
+      def env_allow? var
+        @env_allow.any? do |e|
+          case e
+            when String then var == e
+            when Regexp then var =~ e
+          end
+        end
+      end
+
+      def started?
+        !!@pid
+      end
+
+      def stopped?
+        !!@exit_status
+      end
+
+      def wait_poll
+        pid, status = ::Process.wait2 @pid, ::Process::WNOHANG
+        @exit_status = status.exitstatus if pid
+      end
+    end
+  end
+end

data/lib/baf/testing.rb

@@ -0,0 +1,138 @@
+require 'fileutils'
+
+require 'baf'
+require 'baf/testing/process'
+
+module Baf
+  module Testing
+    ExecutionTimeout = Class.new Error
+    ExitStatusMismatch = Class.new Error
+
+    class WaitError < Error
+      attr_reader :timeout
+
+      def initialize message, timeout
+        super message
+        @timeout = timeout
+      end
+    end
+
+    ENV_WHITELIST = [
+      /\ACHRUBY_/,
+      /\AGEM_/,
+      'PATH',
+      /\ARB_/,
+      'RUBYOPT'
+    ].freeze
+
+    EXEC_TIMEOUT_ERROR_FMT = 'process did not exit after %.03f seconds'.freeze
+
+    EXIT_STATUS_MISMATCH_FMT = <<~eoh.freeze
+      expected %<expected>d exit status got %<actual>d; output was:
+      %{separator}
+      %{output}
+      %{separator}
+    eoh
+
+    OUTPUT_SEPARATOR = (?- * 70).freeze
+
+    WAIT_MESSAGE_FMT = 'condition not met after %.03f seconds'.freeze
+    WAIT_OUTPUT_MESSAGE_FMT = <<~eoh.freeze
+      expected `%{pattern}' not seen after %<timeout>.03f seconds in:
+      %{separator}
+      %{output}
+      %{separator}
+    eoh
+    WAIT_TIMEOUT = ENV.key?('BAF_TEST_TIMEOUT') ?
+      ENV['BAF_TEST_TIMEOUT'].to_i :
+      2
+
+    WORKING_DIR = 'tmp/uat'.freeze
+
+    class << self
+      def build_regexp pattern, options = ''
+        Regexp.new(pattern, options.each_char.inject(0) do |m, e|
+          m | case e
+            when ?i then Regexp::IGNORECASE
+            when ?m then Regexp::MULTILINE
+            when ?x then Regexp::EXTENDED
+          end
+        end)
+      end
+
+      def exercise_scenario dir: WORKING_DIR
+        FileUtils.remove_entry_secure dir, true
+        FileUtils.mkdir_p dir
+        Dir.chdir dir do
+          yield
+        end
+      end
+
+      def expect_ex process, exit_status
+        return if process.exit_status == exit_status
+
+        fail ExitStatusMismatch, EXIT_STATUS_MISMATCH_FMT % {
+          expected: exit_status,
+          actual: process.exit_status,
+          separator: OUTPUT_SEPARATOR,
+          output: process.output.chomp
+        }
+      end
+
+      def run command, wait: true, env_allow: [], timeout: nil
+        Process.new(
+          command,
+          env_allow: ENV_WHITELIST + env_allow,
+          timeout: timeout || Process::TIMEOUT
+        ).tap do |process|
+          process.start
+          wait process if wait
+        end
+      end
+
+      def wait process
+        process.wait do
+          process.stop
+          fail ExecutionTimeout, EXEC_TIMEOUT_ERROR_FMT % process.timeout
+        end
+      end
+
+      def unescape_step_arg str
+        str.gsub '\n', "\n"
+      end
+
+      def wait_until message: WAIT_MESSAGE_FMT, timeout: WAIT_TIMEOUT
+        return if yield
+        deadline = Time.now + timeout
+        until Time.now >= deadline
+          return if yield
+          sleep 0.05
+        end
+        fail WaitError.new message % timeout, timeout
+      end
+
+      def wait_output pattern, stream:, times: 1, timeout: WAIT_TIMEOUT
+        results = nil
+        wait_until timeout: timeout do
+          case pattern
+            when Regexp then (results = stream.call.scan(pattern)).size >= times
+            when String then stream.call.include? pattern
+          end
+        end
+        results
+      rescue Baf::Testing::WaitError => e
+        fail Baf::Testing::WaitError.new(WAIT_OUTPUT_MESSAGE_FMT % {
+          pattern: pattern,
+          timeout: timeout,
+          separator: OUTPUT_SEPARATOR,
+          output: stream.call.chomp
+        }, timeout)
+      end
+
+      def write_file path, content
+        FileUtils.mkdir_p File.dirname path
+        IO.write path, content
+      end
+    end
+  end
+end

metadata

@@ -1,44 +1,117 @@
 --- !ruby/object:Gem::Specification
 name: baf
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Thibault Jouan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2022-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: baf-testing
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Basic Application Framework
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+description: |
+  baf helps writing an user acceptance test suite with a dedicated library
+  and cucumber steps. It can run and wait for programs in a modified
+  environment, verify the exit status, the output streams and other side
+  effects. It also supports interactive programs and writing to their
+  standard input.
+
+  Then, it provides a DSL to write the CLI:
+
+      require 'baf/cli'
+
+      module MyProgram
+        class CLI < Baf::CLI
+          def setup
+            flag_version '0.1.2'.freeze
+
+            option :c, :config, 'config', 'specify config file' do |path|
+              @config_path = path
+            end
+          end
+
+          def run
+            usage! unless arguments.any?
+
+            puts 'arguments: %s' % arguments
+            puts 'config: %s' % @config_path if @config_path
+          end
+        end
+      end
+
+      MyProgram::CLI.run ARGV
+
+  Which behaves this way:
+
+      % ./my_program
+      Usage: my_program [options]
+
+      options:
+          -c, --config config              specify config file
+
+          -h, --help                       print this message
+          -V, --version                    print version
+      zsh: exit 64    ./my_program
+
+      % ./my_program --wrong-arg
+      Usage: my_program [options]
+
+      options:
+          -c, --config config              specify config file
+
+          -h, --help                       print this message
+          -V, --version                    print version
+      zsh: exit 64    ./my_program --wrong-arg
+
+      % ./my_program foo
+      arguments ["foo"]
+
+      % ./my_program -c some_file foo
+      arguments ["foo"]
+      config path some_file
 email: tj@a13.fr
 executables: []
 extensions: []
@@ -50,12 +123,14 @@ files:
 - lib/baf/flag.rb
 - lib/baf/option.rb
 - lib/baf/options_registrant.rb
+- lib/baf/testing.rb
 - lib/baf/testing/cucumber.rb
 - lib/baf/testing/cucumber/steps/execution.rb
+- lib/baf/testing/cucumber/steps/filesystem.rb
 - lib/baf/testing/cucumber/steps/input.rb
 - lib/baf/testing/cucumber/steps/output.rb
 - lib/baf/testing/cucumber/steps/output_wait.rb
-- lib/baf/version.rb
+- lib/baf/testing/process.rb
 homepage: https://rubygems.org/gems/baf
 licenses:
 - BSD-3-Clause
@@ -75,8 +150,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.14
 signing_key:
 specification_version: 4
-summary: Basic Application Framework
+summary: Toolkit for testing and writing CLI programs
 test_files: []

data/lib/baf/version.rb

@@ -1,3 +0,0 @@
-module Baf
-  VERSION = '0.14.1'.freeze
-end