optparse-plus 3.0.0

data/test/integration/test_cli.rb

@@ -0,0 +1,21 @@
+require_relative "base_integration_test"
+
+include FileUtils
+
+class TestCli < BaseIntegrationTest
+  test_that "optparse_plus CLI is properly documented" do
+    When { @stdout, _, __ = optparse_plus "--help" }
+    Then {
+      assert_banner(@stdout, "optparse_plus", takes_options: true, takes_arguments: { app_name: :required })
+    }
+    And {
+      assert_option(@stdout, "--force")
+      assert_option(@stdout, "--[no-]readme")
+      assert_option(@stdout, "-l", "--license")
+      assert_option(@stdout, "--log-level")
+    }
+    And {
+      assert_oneline_summary(@stdout)
+    }
+  end
+end

data/test/integration/test_license.rb

@@ -0,0 +1,56 @@
+require_relative "base_integration_test"
+
+include FileUtils
+
+class TestLicense < BaseIntegrationTest
+  test_that "omitting a license generates a warning" do
+    When { _, @stderr, __ = optparse_plus "newgem" }
+    Then {
+      assert_match(/warning: your app has no license/,@stderr)
+    }
+  end
+
+  test_that "explicitly omitting a license does not generate a warning" do
+    When { _, @stderr, __ = optparse_plus "newgem -l NONE" }
+    Then {
+      refute_match(/warning: your app has no license/,@stderr)
+    }
+  end
+
+  [
+    "apache",
+    "mit",
+    "gplv2",
+    "gplv3",
+  ].each do |license|
+    test_that "the #{license} license can be included" do
+      When { optparse_plus "newgem -l #{license}" }
+      Then {
+        assert File.exist?("newgem/LICENSE.txt")
+      }
+      And {
+        assert_file("newgem/newgem.gemspec", contains: /#{license.upcase}/)
+      }
+    end
+  end
+
+  test_that "a custom license can be included" do
+    When { optparse_plus "newgem -l custom" }
+    Then {
+      assert File.exist?("newgem/LICENSE.txt")
+    }
+    And {
+      assert_equal "", File.read("newgem/LICENSE.txt").strip
+    }
+  end
+
+  test_that "a non-custom non-supported license causes an error" do
+    When { _, @stderr, @result = optparse_plus "newgem -l foobar", allow_failure: true }
+    Then {
+      refute @result.success?
+    }
+    And {
+      assert_match(/invalid argument: -l foobar/,@stderr)
+    }
+  end
+end

data/test/integration/test_readme.rb

@@ -0,0 +1,53 @@
+require_relative "base_integration_test"
+class TestReadme < BaseIntegrationTest
+  test_that "a reasonable README is created" do
+    When {
+      optparse_plus "newgem --readme"
+    }
+    Then {
+      assert File.exist?("newgem/README.rdoc")
+    }
+    And {
+      readmes = Dir["newgem/README*"].to_a
+      assert_equal 1, readmes.size,"Found more than one README: #{readmes.inspect}"
+    }
+    And {
+      rakefile_contents = File.read("newgem/Rakefile")
+      assert_match(/README.rdoc/,rakefile_contents)
+      assert_match(/rd.main = ["']README.rdoc["']/,rakefile_contents)
+    }
+    And {
+      assert_file("newgem/README.rdoc",
+                  contains: [
+                    /newgem/,
+                    /Author::  YOUR NAME \(YOUR EMAIL\)/,
+                    /\* \{Source on Github\}\[LINK TO GITHUB\]/,
+                    /RDoc\[LINK TO RDOC.INFO\]/,
+                    /^== Install/,
+                    /^== Examples/,
+                    /^== Contributing/,
+      ])
+    }
+  end
+
+  test_that "a readme is created by default" do
+    When {
+      optparse_plus "newgem"
+    }
+    Then {
+      assert File.exist?("newgem/README.rdoc")
+    }
+  end
+
+  test_that "we can omit a README" do
+    When {
+      optparse_plus "--no-readme newgem"
+    }
+    Then {
+      refute File.exist?("newgem/README.rdoc")
+    }
+    And {
+      refute_match(/README/,File.read("newgem/Rakefile"))
+    }
+  end
+end

data/test/integration/test_rspec.rb

@@ -0,0 +1,28 @@
+require_relative "base_integration_test"
+
+include FileUtils
+
+class TestRSpec < BaseIntegrationTest
+  test_that "we can generate an app using RSpec instead of Test::Unit" do
+    When { optparse_plus "--rspec newgem" }
+    Then {
+      refute Dir.exist?("newgem/test")
+      assert Dir.exist?("newgem/spec")
+      assert File.exist?("newgem/spec/something_spec.rb")
+    }
+    And {
+      assert_file("newgem/newgem.gemspec", contains: /add_development_dependency\(["']rspec["']/)
+    }
+    And {
+      stdout,_ = rake("newgem", "-T")
+      assert_match(/rake spec/,stdout)
+      refute_match(/rake testa/,stdout)
+    }
+    When {
+      @stdout, _ = rake("newgem","spec")
+    }
+    Then {
+      assert_match(/1 example,.*0 failures/,@stdout)
+    }
+  end
+end

data/test/integration/test_version.rb

@@ -0,0 +1,21 @@
+require_relative "base_integration_test"
+
+include FileUtils
+
+class TestVersion < BaseIntegrationTest
+  test_that "--help shows the gem version" do
+    Given { optparse_plus "newgem" }
+    When { @stdout, _, = run_app "newgem", "--help" }
+    Then {
+      assert_match(/v\d+\.\d+\.\d+/, @stdout)
+    }
+  end
+
+  test_that "--version shows the gem version" do
+    Given { optparse_plus "newgem" }
+    When { @stdout, _, = run_app "newgem", "--version" }
+    Then {
+      assert_match(/v\d+\.\d+\.\d+/, @stdout)
+    }
+  end
+end

data/test/unit/base_test.rb

@@ -0,0 +1,19 @@
+if RUBY_PLATFORM == 'java'
+  puts "Simplecov seems to cause JRuby to barf, so use another ruby if you want to check coverage"
+else
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test"
+  end
+end
+
+require 'test/unit'
+require 'rspec/expectations'
+require 'clean_test/test_case'
+require 'ostruct'
+
+RSpec::Matchers.configuration.syntax = :should
+
+class BaseTest < Clean::Test::TestCase
+  include RSpec::Matchers
+end

data/test/unit/command_for_tests.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+echo "standard output"
+if [ $# -gt 0 ]; then
+  echo "standard error" 1>&2
+fi
+exit $#

data/test/unit/execution_strategy/test_base.rb

@@ -0,0 +1,24 @@
+require 'base_test'
+
+module ExecutionStrategy
+  class TestBase < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    [
+      [:run_command,["ls"]],
+      [:exception_meaning_command_not_found,[]],
+    ].each do |(method,args)|
+      test_that "#{method} isn't implemented" do
+        Given {
+          @strategy = Base.new
+        }
+        When {
+          @code = lambda { @strategy.send(method,*args) }
+        }
+        Then {
+          assert_raises(RuntimeError,&@code)
+        }
+      end
+    end
+  end
+end

data/test/unit/execution_strategy/test_jvm.rb

@@ -0,0 +1,77 @@
+require 'base_test'
+require 'mocha/test_unit'
+
+# Defined by JRuby, but this test must pass on any Ruby
+class NativeException
+end
+
+module ExecutionStrategy
+  class TestJVM < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    test_that "run_command proxies to Open3.capture3" do
+      Given {
+        @process = mock('java.lang.Process')
+        @runtime = mock('java.lang.Runtime')
+        @command = "ls"
+        @stdout = any_string
+        @stderr = any_string
+        @exitstatus = any_int :min => 1, :max => 127
+      }
+      When the_test_runs
+      Then {
+        expects_lang = mock()
+        JVM.any_instance.expects(:java).returns(expects_lang)
+        expects_Runtime = mock()
+        expects_lang.expects(:lang).returns(expects_Runtime)
+        runtime_klass = mock()
+        expects_Runtime.expects(:Runtime).returns(runtime_klass)
+        runtime_klass.expects(:get_runtime).returns(@runtime)
+        @runtime.expects(:exec).with(@command).returns(@process)
+
+        stdin = mock()
+        @process.expects(:get_output_stream).returns(stdin)
+        stdin.expects(:close)
+
+        stdout_input_stream = mock('InputStream')
+        @process.expects(:get_input_stream).returns(stdout_input_stream)
+        stdout_input_stream.expects(:read).times(2).returns(
+          @stdout,
+          -1)
+
+        stderr_input_stream = mock('InputStream')
+        @process.expects(:get_error_stream).returns(stderr_input_stream)
+        stderr_input_stream.expects(:read).times(2).returns(
+          @stderr,
+          -1)
+
+        @process.expects(:wait_for).returns(@exitstatus)
+      }
+
+      Given new_jvm_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should be == @stdout
+        @results[1].should be == @stderr
+        @results[2].exitstatus.should be == @exitstatus
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns NativeException" do
+      Given new_jvm_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should be == NativeException
+      }
+    end
+
+  private
+    def new_jvm_strategy
+      lambda { @strategy = JVM.new }
+    end
+  end
+end

data/test/unit/execution_strategy/test_mri.rb

@@ -0,0 +1,32 @@
+require 'base_test'
+
+module ExecutionStrategy
+  class TestMRI < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    test_that "run_command isn't implemented" do
+      Given new_mri_strategy
+      When {
+        @code = lambda { @strategy.run_command("ls") }
+      }
+      Then {
+        assert_raises(RuntimeError,&@code)
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_mri_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_mri_strategy
+      lambda { @strategy = MRI.new }
+    end
+  end
+end

data/test/unit/execution_strategy/test_open_3.rb

@@ -0,0 +1,70 @@
+require 'base_test'
+require 'mocha/test_unit'
+require 'open3'
+
+module ExecutionStrategy
+  class TestOpen_3 < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    test_that "run_command proxies to Open3.capture3" do
+      Given {
+        @command = any_string
+        @stdout = any_string
+        @stderr = any_string
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open3.expects(:capture3).with(@command).returns([@stdout,@stderr,@status])
+      }
+
+      Given new_open_3_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should be == @stdout
+        @results[1].should be == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "run_command handles array arguments properly" do
+      Given {
+        @command = [any_string, any_string, any_string]
+        @stdout = any_string
+        @stderr = any_string
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open3.expects(:capture3).with(*@command).returns([@stdout,@stderr,@status])
+      }
+
+      Given new_open_3_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should be == @stdout
+        @results[1].should be == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_open_3_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should be == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_open_3_strategy
+      lambda { @strategy = Open_3.new }
+    end
+  end
+end

data/test/unit/execution_strategy/test_open_4.rb

@@ -0,0 +1,86 @@
+require 'base_test'
+require 'mocha/test_unit'
+
+# Define this symbol without requiring the library;
+# all we're goingn to do is mock calls to it
+module Open4
+end
+
+module ExecutionStrategy
+  class TestOpen_4 < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    test_that "run_command proxies to Open4.capture4" do
+      Given {
+        @command = any_string
+        @stdin_io = mock("IO")
+        @stdout = any_string
+        @stdout_io = StringIO.new(@stdout)
+        @stderr = any_string
+        @stderr_io = StringIO.new(@stderr)
+        @pid = any_int :min => 2, :max => 65536
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open4.expects(:popen4).with(@command).returns([@pid,@stdin_io,@stdout_io,@stderr_io])
+        @stdin_io.expects(:close)
+        Process.expects(:waitpid2).with(@pid).returns([any_string,@status])
+      }
+
+      Given new_open_4_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should be == @stdout
+        @results[1].should be == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "run_command handles array arguments properly" do
+      Given {
+        @command = [any_string, any_string, any_string]
+        @stdin_io = mock("IO")
+        @stdout = any_string
+        @stdout_io = StringIO.new(@stdout)
+        @stderr = any_string
+        @stderr_io = StringIO.new(@stderr)
+        @pid = any_int :min => 2, :max => 65536
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open4.expects(:popen4).with(*@command).returns([@pid,@stdin_io,@stdout_io,@stderr_io])
+        @stdin_io.expects(:close)
+        Process.expects(:waitpid2).with(@pid).returns([any_string,@status])
+      }
+
+      Given new_open_4_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should be == @stdout
+        @results[1].should be == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_open_4_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should be == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_open_4_strategy
+      lambda { @strategy = Open_4.new }
+    end
+  end
+end