escort 0.1.0 → 0.2.0

data/spec/integration/basic_depends_on_spec.rb

@@ -0,0 +1,275 @@
+describe "Escort basic app with dependent options", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  context "when dependency specification has no 'on' parameter" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+          opts.dependency :option1
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "-f" }
+    it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+  end
+
+  context "when option dependent on presence of flag" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+          opts.dependency :option1, :on => :flag1
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and flag is not present" do
+      let(:option_string) { "-o foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and flag is present" do
+      let(:option_string) { "-f -o foo" }
+      it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+    end
+  end
+
+  context "when flag depends on another flag" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean, :default => true
+          opts.opt :flag3, "Flag 3", :short => :none, :long => '--flag3', :type => :boolean
+          opts.opt :flag4, "Flag 4", :short => :none, :long => '--flag4', :type => :boolean
+
+          opts.dependency :flag3, :on => :flag1
+          opts.dependency :flag4, :on => :flag2
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and other flag has a default value of false" do
+      context "and other flag is present" do
+        let(:option_string) { "--flag1 --flag3" }
+        it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+      end
+
+      context "and other flag is not present" do
+        let(:option_string) { "--flag3" }
+        it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+      end
+    end
+
+    context "and other flag has a default value of true" do
+      context "and other flag is present" do
+        let(:option_string) { "--flag2 --flag4" }
+        it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+      end
+
+      context "and other flag is not present" do
+        let(:option_string) { "--flag4" }
+        it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+      end
+
+      context "and other flag negative option is used" do
+        let(:option_string) { "--no-flag2 --flag4" }
+        it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+      end
+    end
+  end
+
+  context "when option dependent on presence of multiple other options" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+          opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+          opts.dependency :option2, :on => [:flag1, :option1]
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and one of the other options is not present" do
+      let(:option_string) { "-f --option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and none of the other options are present" do
+      let(:option_string) { "--option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and all of the other options are present" do
+      let(:option_string) { "-f -o bar --option2=foo" }
+      it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+    end
+  end
+
+  context "when option dependent on other option value" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+          opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+          opts.dependency :option2, :on => {:option1 => 'bar'}
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and other option is supplied with this value" do
+      let(:option_string) { "-o bar --option2=foo" }
+      it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+    end
+
+    context "and other option is supplied with different value" do
+      let(:option_string) { "-o baz --option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and other option is not supplied" do
+      let(:option_string) { "--option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+  end
+
+  context "when option dependent on other option value and presence of yet another option" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+          opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+          opts.dependency :option2, :on => [:flag1, {:option1 => 'bar'}]
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and yet another option is not present" do
+      let(:option_string) { "-o bar --option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and other option has different value" do
+      let(:option_string) { "-o baz -f --option2=foo" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+
+    context "and other option has the right value and yet another option is present" do
+      let(:option_string) { "-o bar -f --option2=foo" }
+      it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+    end
+  end
+
+  context "when option dependent on itself" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+          opts.dependency :option1, :on => :option1
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "-o bar" }
+    it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+  end
+
+  context "when dependency specified for non-existant option" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+          opts.dependency :option2, :on => :option1
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "-o bar" }
+    it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+  end
+
+  context "when option dependent on non-existant option" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+          opts.dependency :option1, :on => :option2
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "-o bar" }
+    it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+  end
+
+  context "when dependency is specified inline" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :depends_on => :flag1
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    context "and dependency is satisfied" do
+      let(:option_string) { "-f -o bar" }
+      it("it should exit successfully") { expect{subject}.to exit_with_code(0) }
+    end
+
+    context "and dependency is not satisfied" do
+      let(:option_string) { "-o bar" }
+      it("it should not exit successfully") { expect{subject}.to_not exit_with_code(0) }
+    end
+  end
+end

data/spec/integration/basic_options_spec.rb

@@ -1,26 +1,14 @@
-describe "Escort basic app with options defined" do
+describe "Escort basic app with options defined", :integration => true do
   subject { Escort::App.create(option_string, &app_configuration) }
-  let(:result) { [] }
-
-  before do
-    $stderr = StringIO.new
-    $stdout = StringIO.new
-  end
-
-  after do
-    $stderr = STDERR
-    $stdout = STDOUT
-  end
 
   let(:app_configuration) do
-    ->(app) do
+    lambda do |app|
       app.options do |opts|
         opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :default => "option 1"
       end
 
       app.action do |options, arguments|
-        result << :global
-        result << {:option1 => options[:global][:options][:option1]}
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
       end
     end
   end
@@ -28,22 +16,22 @@ describe "Escort basic app with options defined" do
   context "when called with empty option string" do
     let(:option_string) { "" }
     it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
-    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
-    it("option1 have its default value in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'option 1', result) }
+    it("should execute the global action") { expect{subject}.to execute_action_for_command(result, :global) }
+    it("option1 have its default value in action") { expect{subject}.to execute_action_with_options(result, :option1 => 'option 1') }
   end
 
   context "when called with option string with short code option" do
     let(:option_string) { "-o blah" }
     it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
-    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
-    it("option1 have the value 'blah' in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'blah', result) }
+    it("should execute the global action") { expect{subject}.to execute_action_for_command(result, :global) }
+    it("option1 have the value 'blah' in action") { expect{subject}.to execute_action_with_options(result, :option1 => 'blah') }
   end
 
   context "when called with option string with long code option" do
     let(:option_string) { "--option1=blah" }
     it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
-    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
-    it("option1 have the value 'blah' in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'blah', result) }
+    it("should execute the global action") { expect{subject}.to execute_action_for_command(result, :global) }
+    it("option1 have the value 'blah' in action") { expect{subject}.to execute_action_with_options(result, :option1 => 'blah') }
   end
 
   context "when called with option string with unknown option" do

data/spec/integration/basic_options_with_multi_spec.rb

@@ -0,0 +1,30 @@
+describe "Escort basic app with multi option", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.options do |opts|
+        opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :multi => true
+      end
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when called with empty option string" do
+    let(:option_string) { "" }
+    it("option1 should be an empty array") { expect{subject}.to execute_action_with_options(result, :option1 => []) }
+  end
+
+  context "when called with option1 specified once" do
+    let(:option_string) { "-o blah" }
+    it("option1 have the value ['blah'] in action") { expect{subject}.to execute_action_with_options(result, :option1 => ['blah']) }
+  end
+
+  context "when called with option1 specified 3 times" do
+    let(:option_string) { "-o blah --option1=blah2 -o blah3" }
+    it("option1 have the value ['blah', 'blah2', 'blah3'] in action") { expect{subject}.to execute_action_with_options(result, :option1 => ['blah', 'blah2', 'blah3']) }
+  end
+end

data/spec/integration/basic_spec.rb

@@ -1,11 +1,10 @@
-describe "Escort basic app with no options defined" do
+describe "Escort basic app with no options defined", :integration => true do
   subject { Escort::App.create(option_string, &app_configuration) }
-  let(:result) { [] }
 
   let(:app_configuration) do
-    ->(app) do
+    lambda do |app|
       app.action do |options, arguments|
-        result << :global
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
       end
     end
   end
@@ -13,12 +12,12 @@ describe "Escort basic app with no options defined" do
   context "when called with empty option string" do
     let(:option_string) { "" }
     it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
-    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
+    it("should execute the global action") { expect{subject}.to execute_action_for_command(result, :global) }
   end
 
   context "when called with non-empty option string" do
     let(:option_string) { "hello" }
     it("exit code should be 0") { expect{ subject }.to exit_with_code(0) }
-    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
+    it("should execute the global action") { expect{subject}.to execute_action_for_command(result, :global) }
   end
 end

data/spec/integration/basic_validations_spec.rb

@@ -0,0 +1,77 @@
+describe "Escort basic app with validations", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  context "when validation exists for non-existant option" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option1, "Option 1", :short => '-o', :long => '--option1', :type => :string
+          opts.validate(:option2, "must be either 'foo' or 'bar'") { |option| ["foo", "bar"].include?(option) }
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "-o bar" }
+
+    it("should exit with code 2") { expect{ subject }.to exit_with_code(2) }
+  end
+
+  context "when option has a validation" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option1, "Option 1", :short => '-o', :long => '--option1', :type => :string
+          opts.validate(:option1, "must be either 'foo' or 'bar'") { |option| ["foo", "bar"].include?(option) }
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and validation fails" do
+      let(:option_string) { "-o baz" }
+      it("should exit with code 3") { expect{ subject }.to exit_with_code(3) }
+    end
+
+    context "and validation does not fail" do
+      let(:option_string) { "-o foo" }
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    end
+  end
+
+  context "when option has multiple validations" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :option2, "Option 2", :short => :none, :long => '--option2', :type => :string
+          opts.validate(:option2, "must be two words") {|option| option =~ /\w\s\w/}
+          opts.validate(:option2, "must be at least 20 characters long") {|option| option.length >= 20}
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+
+    context "and one validation fails" do
+      let(:option_string) { "--option2='hb'" }
+      it("should exit with code 3") { expect{ subject }.to exit_with_code(3) }
+    end
+
+    context "and the other validation fails" do
+      let(:option_string) { "--option2='h bssfs'" }
+      it("should exit with code 3") { expect{ subject }.to exit_with_code(3) }
+    end
+
+    context "and both validations pass" do
+      let(:option_string) { "--option2='h bssfsfsdfsdfsfsdsf'" }
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    end
+  end
+end

data/spec/integration/basic_with_arguments_spec.rb

@@ -0,0 +1,33 @@
+describe "Escort basic app that requires arguments", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.requires_arguments
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when called with no arguments" do
+    let(:option_string) { "" }
+
+    before do
+      Readline.stub(:readline).and_return('1', nil)
+    end
+
+    it("action should receive ['1'] as arguments") { expect{subject}.to execute_action_with_arguments(result, ['1']) }
+  end
+
+  context "when called with one argument" do
+    let(:option_string) { "1" }
+    it("action should receive ['1'] as arguments") { expect{subject}.to execute_action_with_arguments(result, ['1']) }
+  end
+
+  context "when called with three arguments" do
+    let(:option_string) { "1 2 3" }
+    it("action should receive ['1', '2', '3'] as arguments") { expect{subject}.to execute_action_with_arguments(result, ['1', '2', '3']) }
+  end
+end

data/spec/integration/basic_with_text_fields_spec.rb

@@ -0,0 +1,21 @@
+describe "Escort basic app with version, description, and summary", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.version "0.1.1"
+      app.summary "Sum1"
+      app.description "Desc1"
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when called" do
+    let(:option_string) { "" }
+
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+  end
+end