convoy 1.0.0

data/spec/integration/basic_options_spec.rb

@@ -0,0 +1,41 @@
+describe "Convoy basic app with options defined", :integration => true do
+    subject { Convoy::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, :default => "option 1"
+            end
+
+            app.action do |options, arguments|
+                Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+            end
+        end
+    end
+
+    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_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_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_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
+        let(:option_string) { "-k" }
+        it("should not exit with code 0") { expect { subject }.not_to exit_with_code(0) }
+    end
+end

data/spec/integration/basic_options_with_multi_spec.rb

@@ -0,0 +1,30 @@
+describe "Convoy basic app with multi option", :integration => true do
+    subject { Convoy::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|
+                Convoy::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

@@ -0,0 +1,38 @@
+describe "Convoy basic app with no options defined", :integration => true do
+    subject { Convoy::App.create(option_string, &app_configuration) }
+
+    let(:app_configuration) do
+        lambda do |app|
+            app.action do |options, arguments|
+                Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+            end
+        end
+    end
+
+    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_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_for_command(result, :global) }
+    end
+
+    context "gets --help option automatically" do
+        let(:option_string) { "--help" }
+        it("exit code should be 0") { expect { subject }.to exit_with_code(0) }
+    end
+
+    context "gets --verbosity option automatically" do
+        let(:option_string) { "--verbosity=DEBUG" }
+        it("exit code should be 0") { expect { subject }.to exit_with_code(0) }
+    end
+
+    context "gets --error-output-format option automatically" do
+        let(:option_string) { "--error-output-format=advanced" }
+        it("exit code should be 0") { expect { subject }.to exit_with_code(0) }
+    end
+end

data/spec/integration/basic_validations_spec.rb

@@ -0,0 +1,77 @@
+describe "Convoy basic app with validations", :integration => true do
+    subject { Convoy::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|
+                    Convoy::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|
+                    Convoy::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|
+                    Convoy::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,35 @@
+require 'readline'
+
+describe "Convoy basic app that requires arguments", :integration => true do
+    subject { Convoy::App.create(option_string, &app_configuration) }
+
+    let(:app_configuration) do
+        lambda do |app|
+            app.requires_arguments
+
+            app.action do |options, arguments|
+                Convoy::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 "Convoy basic app with version, description, and summary", :integration => true do
+    subject { Convoy::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|
+                Convoy::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

data/spec/integration/suite_simple_spec.rb

@@ -0,0 +1,45 @@
+describe "Convoy suite app with one level of commands", :integration => true do
+    subject { Convoy::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, :default => "option 1"
+            end
+
+            app.command :command1, :aliases => [:c1] do |command|
+                command.options do |opts|
+                    opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+                end
+
+                command.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+
+            app.action do |options, arguments|
+                Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+            end
+        end
+    end
+
+    context "when calling command with option and global option" do
+        let(:option_string) { "-o hello command1 --option2 world" }
+
+        before do
+            begin
+                subject
+            rescue SystemExit => e
+            end
+        end
+        it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+        it("should have the right command name") { result[:command_name].should == :command1 }
+        it("should have have global option set") { result[:options][:global][:options][:option1].should == 'hello' }
+        it("should have have command option set") { result[:command_options][:option2].should == 'world' }
+    end
+
+    context "when using command alias" do
+        let(:option_string) { "-o hello c1 --option2 world" }
+        it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+    end
+end

data/spec/integration/suite_sub_command_spec.rb

@@ -0,0 +1,51 @@
+describe "Convoy suite app with sub commands", :integration => true do
+    subject { Convoy::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, :default => "option 1"
+            end
+
+            app.command :command1, :aliases => [:c1] do |command|
+                command.options do |opts|
+                    opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+                end
+
+                command.command :sub_command1 do |command|
+                    command.options do |opts|
+                        opts.opt :option3, "Option3", :short => :none, :long => '--option3', :type => :string
+                    end
+
+                    command.action do |options, arguments|
+                        Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                    end
+                end
+
+                command.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+
+            app.action do |options, arguments|
+                Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+            end
+        end
+    end
+
+    context "when calling sub command with option and command option and global option" do
+        let(:option_string) { "-o hello command1 --option2=world sub_command1 --option3=foo" }
+
+        before do
+            begin
+                subject
+            rescue SystemExit => e
+            end
+        end
+        it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+        it("should have the right command name") { result[:command_name].should == :sub_command1 }
+        it("should have have sub command option set") { result[:command_options][:option3].should == 'foo' }
+        it("should have have global option set") { result[:options][:global][:options][:option1].should == 'hello' }
+        it("should have have command option set") { result[:options][:global][:commands][:command1][:options][:option2].should == 'world' }
+    end
+end

data/spec/lib/convoy/action_command/base_spec.rb

@@ -0,0 +1,200 @@
+describe Convoy::SetupAccessor do
+    let(:command) { Convoy::TestCommand.new(options, arguments, config) }
+    let(:options) { {} }
+    let(:arguments) { [] }
+    let(:config) { {} }
+
+    describe "#command_context" do
+        subject { command.send(:command_context) }
+
+        context "when command context already set" do
+            before do
+                command.instance_variable_set(:"@command_context", [:hello])
+            end
+
+            it { subject.should == [:hello] }
+        end
+
+        context "when command context not yet set" do
+            context "and options hash is empty" do
+                it { subject.should == [] }
+            end
+
+            context "and options hash is of valid structure" do
+                context "and command is global" do
+                    let(:options) { {:global => {:commands => {}}} }
+                    it { subject.should == [] }
+                end
+
+                context "and command is child of global" do
+                    let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}}} }
+                    it { subject.should == [:command1] }
+
+                    context "and no commands hash for sub command in options" do
+                        let(:options) { {:global => {:commands => {:command1 => {}}}} }
+                        it { subject.should == [:command1] }
+                    end
+                end
+
+                context "and command is grandchild of global" do
+                    let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}}} }
+                    it { subject.should == [:command1, :sub_command1] }
+                end
+
+                context "and command is great grandchild of global" do
+                    let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {:sub_sub_command1 => {:commands => {}}}}}}}}} }
+                    it { subject.should == [:command1, :sub_command1, :sub_sub_command1] }
+                end
+            end
+        end
+    end
+
+    describe "#command_name" do
+        subject { command.send(:command_name) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}}} }
+            it { subject.should == :global }
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}}} }
+            it { subject.should == :command1 }
+        end
+
+        context "when context is of size 2" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}}} }
+            it { subject.should == :sub_command1 }
+        end
+    end
+
+    describe "#command_options" do
+        subject { command.send(:command_options) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+            it { subject.should == {:hello => :world} }
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}, :options => {:hello => :world}}}}} }
+            it { subject.should == {:hello => :world} }
+        end
+
+        context "when context is of size 2" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}, :options => {:hello => :world}}}}}}} }
+            it { subject.should == {:hello => :world} }
+        end
+    end
+
+    describe "#global_options" do
+        subject { command.send(:global_options) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+            it { subject.should == {:hello => :world} }
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+            it { subject.should == {:hello => :world} }
+        end
+    end
+
+    describe "#parent_options" do
+        subject { command.send(:parent_options) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+            it { subject.should == {} }
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+            it { subject.should == {:hello => :world} }
+        end
+
+        context "when context is of size 2" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}, :options => {:hello => :world}}}}} }
+            it { subject.should == {:hello => :world} }
+        end
+    end
+
+    describe "#grandparent_options" do
+        subject { command.send(:grandparent_options) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+            it { subject.should == {} }
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+            it { subject.should == {} }
+        end
+
+        context "when context is of size 2" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}, :options => {:hello => :world}}} }
+            it { subject.should == {:hello => :world} }
+        end
+    end
+
+    describe "#ancestor_options" do
+        subject { command.send(:ancestor_options, generation_number) }
+
+        context "when context is global" do
+            let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+
+            context "and generation number is 0" do
+                let(:generation_number) { 0 }
+                it { subject.should == {:hello => :world} }
+            end
+
+            context "and generation number is 1" do
+                let(:generation_number) { 1 }
+                it { subject.should == {} }
+            end
+
+            context "and generation number is 2" do
+                let(:generation_number) { 2 }
+                it { subject.should == {} }
+            end
+
+            context "and generation number is 3" do
+                let(:generation_number) { 3 }
+                it { subject.should == {} }
+            end
+        end
+
+        context "when context is of size 1" do
+            let(:options) { {:global => {:commands => {:command1 => {:commands => {}, :options => {:foo => :bar}}}, :options => {:hello => :world}}} }
+
+            context "and generation number is 0" do
+                let(:generation_number) { 0 }
+                it { subject.should == {:foo => :bar} }
+            end
+
+            context "and generation number is 1" do
+                let(:generation_number) { 1 }
+                it { subject.should == {:hello => :world} }
+            end
+
+            context "and generation number is 2" do
+                let(:generation_number) { 2 }
+                it { subject.should == {} }
+            end
+
+            context "and generation number is 3" do
+                let(:generation_number) { 3 }
+                it { subject.should == {} }
+            end
+        end
+    end
+end
+
+module Convoy
+    class TestCommand < ::Convoy::ActionCommand::Base
+        def execute
+        end
+    end
+end