convoy 1.0.0

data/spec/lib/convoy/formatter/shell_command_executor_spec.rb

@@ -0,0 +1,59 @@
+describe Convoy::Formatter::ShellCommandExecutor do
+    let(:executor) { Convoy::Formatter::ShellCommandExecutor.new(command) }
+    let(:result) { [] }
+    let(:error_callback) { lambda { |command, error| result << 'error'; result << error.class } }
+
+    #describe "#execute_in_new_shell" do
+    #subject {executor.execute_in_new_shell(success_callback, error_callback)}
+
+    #let(:success_callback) {lambda{ |command, stdin, stdout, stderr| result << 'success' }}
+
+    #context "when command is invalid" do
+    #let(:command) { 'lx -z' }
+    #it("error callback should be executed") {subject; result.first.should == 'error'}
+    #it("should return nil") {subject.should be_nil}
+    #end
+
+    #context "when command is valid" do
+    #context "but options passed to it are invalid" do
+    #let(:command) { 'ls --foobar' }
+    #it("error callback should be executed") {subject; result.first.should == 'error'}
+    #it("command should produce an exit status error") {subject; result[1].should == Convoy::InternalError}
+    #it("should return nil") {subject.should be_nil}
+    #end
+
+    #context "and options passed to it are valid" do
+    #let(:command) { 'ls -al' }
+    #it("success callback should be executed") {subject; result.first.should == 'success'}
+    #it("should not return nil") {subject.should_not be_nil}
+    #end
+    #end
+    #end
+
+    describe "#execute_in_current_shell" do
+        subject { executor.execute_in_current_shell(success_callback, error_callback) }
+
+        let(:success_callback) { lambda { |command, final_result| result << 'success' } }
+
+        context "when command is invalid" do
+            let(:command) { 'lx -z' }
+            it("error callback should be executed") { subject; result.first.should == 'error' }
+            it("should return nil") { subject.should be_nil }
+        end
+
+        context "when command is valid" do
+            context "but options passed to it are invalid" do
+                let(:command) { 'ls --foobar' }
+                it("error callback should be executed") { subject; result.first.should == 'error' }
+                it("command should produce an exit status error") { subject; result[1].should == Convoy::InternalError }
+                it("should return nil") { subject.should be_nil }
+            end
+
+            context "and options passed to it are valid" do
+                let(:command) { 'ls -al' }
+                it("success callback should be executed") { subject; result.first.should == 'success' }
+                it("should not return nil") { subject.should_not be_nil }
+            end
+        end
+    end
+end

data/spec/lib/convoy/formatter/stream_output_formatter_spec.rb

@@ -0,0 +1,214 @@
+describe Convoy::Formatter::StreamOutputFormatter do
+    let(:formatter) { Convoy::Formatter::StreamOutputFormatter.new(stream, :max_output_width => output_width) }
+    let(:stream) { StringIO.new }
+    let(:output_width) { 10 }
+    let(:output) { stream.readlines }
+
+    describe "#print" do
+        subject { formatter.print(string) }
+
+        before { subject; stream.rewind }
+
+        context "when string is less than output_width" do
+            let(:string) { '12345' }
+            it("stream should have one line") { output.first.should == string }
+        end
+
+        context "when string is greater than output width" do
+            let(:string) { '123456789abcd' }
+            it("stream should have two lines") { output.should == ["123456789a\n", "bcd"] }
+        end
+
+        context "when string is has newlines in it" do
+            context "and both lines less than output width" do
+                let(:string) { "1234567\n89abcd" }
+                it("stream should have two lines") { output.should == ["1234567\n", "89abcd"] }
+            end
+
+            context "and first line greater than output width" do
+                let(:string) { "123456789abcd\nefg" }
+                it("stream should have three lines") { output.should == ["123456789a\n", "bcd\n", "efg"] }
+            end
+        end
+    end
+
+    describe "#puts" do
+        subject { formatter.puts(string, options) }
+        let(:string) { 'hello' }
+        let(:options) { {:newlines => newlines} }
+        let(:newlines) { 1 }
+
+        before { subject; stream.rewind }
+
+        context "when newlines" do
+            context "is zero" do
+                let(:newlines) { 0 }
+                let(:string) { "123456789abcd\nefg" }
+                it("stream should have three lines") { output.should == ["123456789a\n", "bcd\n", "efg"] }
+            end
+
+            context "not specified" do
+                subject { formatter.puts(string) }
+                let(:string) { "123" }
+                it("stream should have one newline") { output.should == ["123\n"] }
+            end
+
+            context "is two" do
+                let(:string) { "123" }
+                let(:newlines) { 2 }
+                it("stream should have two newlines") { output.should == ["123\n", "\n"] }
+            end
+        end
+    end
+
+    describe "#newline" do
+        subject { formatter.newline(newline_count) }
+        let(:newline_count) { 1 }
+
+        before { subject; stream.rewind }
+
+        context "when newline count not specified" do
+            subject { formatter.newline }
+            it("stream should have one newline") { output.should == ["\n"] }
+        end
+
+        context "when newline count is 2" do
+            let(:newline_count) { 2 }
+            it("stream should have two newlines") { output.should == ["\n", "\n"] }
+        end
+    end
+
+    describe "#indent" do
+        subject { formatter.indent(indent_width, &indented_block) }
+
+        let(:indented_block) do
+            lambda { |f| f.print string }
+        end
+
+        before { subject; stream.rewind }
+
+        context "when indent is 0" do
+            let(:indent_width) { 0 }
+
+            context "and we print a string less than output_width" do
+                let(:string) { '12345' }
+                it("stream should have one line") { output.should == ['12345'] }
+            end
+
+            context "and we print a string greater than output width" do
+                let(:string) { '123456789abcd' }
+                it("stream should have two lines") { output.should == ["123456789a\n", "bcd"] }
+            end
+
+            context "and we print a string that has newlines in it" do
+                context "and both lines are less than output width" do
+                    let(:string) { "1234567\n89abcd" }
+                    it("stream should have two lines") { output.should == ["1234567\n", "89abcd"] }
+                end
+
+                context "and first line is greater than output width" do
+                    let(:string) { "123456789abcd\nefg" }
+                    it("stream should have three lines") { output.should == ["123456789a\n", "bcd\n", "efg"] }
+                end
+            end
+        end
+
+        context "when indent is 1" do
+            let(:indent_width) { 1 }
+
+            context "and we print a string less than output_width" do
+                let(:string) { '12345' }
+                it("stream should have one line") { output.should == [' 12345'] }
+            end
+
+            context "and we print a string greater than output width" do
+                let(:string) { '123456789abcd' }
+                it("stream should have two lines") { output.should == [" 123456789\n", " abcd"] }
+            end
+
+            context "and we print a string that has newlines in it" do
+                context "and both lines are less than output width" do
+                    let(:string) { "1234567\n89abcd" }
+                    it("stream should have two lines") { output.should == [" 1234567\n", " 89abcd"] }
+                end
+
+                context "and first line is greater than output width" do
+                    let(:string) { "123456789abcd\nefg" }
+                    it("stream should have three lines") { output.should == [" 123456789\n", " abcd\n", " efg"] }
+                end
+            end
+        end
+
+        context "when indent is 3" do
+            let(:indent_width) { 3 }
+
+            context "and we print a string less than output_width" do
+                let(:string) { '12345' }
+                it("stream should have one line") { output.should == ['   12345'] }
+            end
+
+            context "and we print a string greater than output width" do
+                let(:string) { '123456789abcd' }
+                it("stream should have two lines") { output.should == ["   1234567\n", "   89abcd"] }
+            end
+
+            context "and we print a string that has newlines in it" do
+                context "and both lines are less than output width" do
+                    let(:string) { "1234567\n89abcd" }
+                    it("stream should have two lines") { output.should == ["   1234567\n", "   89abcd"] }
+                end
+
+                context "and first line is greater than output width" do
+                    let(:string) { "123456789abcd\nefg" }
+                    it("stream should have three lines") { output.should == ["   1234567\n", "   89abcd\n", "   efg"] }
+                end
+            end
+        end
+    end
+
+    context "output combinations" do
+        subject do
+            Convoy::Formatter::StreamOutputFormatter.new(stream, :max_output_width => output_width) do |f|
+                f.print "the quick"
+                f.newline
+                f.print "brown fox"
+                f.print "jumped over the"
+                f.print "lazy dog"
+                f.newline
+                f.puts 'rainbow suspenders'
+                f.indent(3) do |f|
+                    f.puts "blah blah blah blah"
+                    f.newline(2)
+                    f.indent(2) do |f|
+                        f.puts "indent me good"
+                        f.print "foo"
+                        f.print "foo"
+                        f.print "foo"
+                        f.newline
+                        f.puts "exit", :newlines => 4
+                    end
+                end
+            end
+        end
+        let(:stream) { StringIO.new }
+        let(:output_width) { 10 }
+
+        let(:output) { stream.readlines }
+
+        before { subject; stream.rewind }
+
+        context "lines should not be greater than output width" do
+            it do
+                output.each do |line|
+                    line.strip.length.should be <= output_width
+                end
+            end
+        end
+
+        context "stream should contain" do
+            it do
+                output.should == ["the quick\n", "brown foxj\n", "umped over\n", " thelazy d\n", "og\n", "rainbow su\n", "spenders\n", "   blah bl\n", "   ah blah\n", "    blah\n", "\n", "\n", "     inden\n", "     t me \n", "     good\n", "     foofo\n", "     ofoo\n", "     exit\n", "\n", "\n", "\n"]
+            end
+        end
+    end
+end

data/spec/lib/convoy/formatter/string_grid_spec.rb

@@ -0,0 +1,59 @@
+describe Convoy::Formatter::StringGrid do
+    let(:width) { 20 }
+
+    describe "#to_s" do
+        subject { grid.to_s }
+
+        context "when 2 rows and 3 columns" do
+            context "no strings span multiple rows" do
+                let(:grid) do
+                    Convoy::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+                        g.row 'a', 'b', 'c'
+                        g.row 1, 2, 3
+                    end
+                end
+                it("all rows should equal table width") do
+                    subject.split("\n").each do |val|
+                        val.length.should == width
+                    end
+                end
+                it { subject.should == "a b c               \n1 2 3               " }
+            end
+
+            context "first column string spans 4 rows" do
+                let(:grid) do
+                    Convoy::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+                        g.row '123456789abcdefgh', 'b', 'c'
+                        g.row 1, 2, 3
+                    end
+                end
+                it("should have 5 rows") do
+                    subject.split("\n").size.should == 5
+                end
+                it("all rows should equal table width") do
+                    subject.split("\n").each do |val|
+                        val.length.should == width
+                    end
+                end
+                it { subject.should == "12345 b c           \n6789a               \nbcdef               \ngh                  \n1     2 3           " }
+            end
+            context "last column string spans 2 rows" do
+                let(:grid) do
+                    Convoy::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+                        g.row 'a', 'b', 'c'
+                        g.row 1, 2, "123456789abcdefghijk"
+                    end
+                end
+                it("should have 3 rows") do
+                    subject.split("\n").size.should == 3
+                end
+                it("all rows should equal table width") do
+                    subject.split("\n").each do |val|
+                        val.length.should == width
+                    end
+                end
+                it { subject.should == "a b c               \n1 2 123456789abcdef \n    ghijk           " }
+            end
+        end
+    end
+end

data/spec/lib/convoy/formatter/string_splitter_spec.rb

@@ -0,0 +1,50 @@
+describe Convoy::Formatter::StringSplitter do
+    let(:splitter) { Convoy::Formatter::StringSplitter.new(max_segment_width) }
+
+    describe "#split" do
+        subject { splitter.split(string) }
+
+        context "when segment width is 10" do
+            let(:max_segment_width) { 10 }
+
+            context "and string is 'abc123'" do
+                let(:string) { 'abc123' }
+                it("should produce 1 segment") { subject.size.should == 1 }
+                it("first segment should be 'abc123'") { subject[0].should == 'abc123' }
+            end
+
+            context "and string is 'abc1234567'" do
+                let(:string) { 'abc1234567' }
+                it("should produce 1 segment") { subject.size.should == 1 }
+                it("first segment should be 'abc1234567'") { subject[0].should == 'abc1234567' }
+            end
+
+            context "and string is 'abc123abc456'" do
+                let(:string) { 'abc123abc456' }
+                it("should produce 2 segments") { subject.size.should == 2 }
+                it("first segment should be 'abc123abc4'") { subject[0].should == 'abc123abc4' }
+                it("first segment should be '56'") { subject[1].should == '56' }
+            end
+
+            context "and string is 'abc123abc456bbbcccddd'" do
+                let(:string) { 'abc123abc456bbbcccddd' }
+                it("should produce 3 segments") { subject.size.should == 3 }
+                it("first segment should be 'abc123abc4'") { subject[0].should == 'abc123abc4' }
+                it("first segment should be '56bbbcccdd'") { subject[1].should == '56bbbcccdd' }
+                it("first segment should be 'd'") { subject[2].should == 'd' }
+            end
+        end
+
+        context "when segment width is 5" do
+            let(:max_segment_width) { 5 }
+
+            context "and string is 'abc\\n123456'" do
+                let(:string) { "abc\n123456" }
+                it("should produce 3 segments") { subject.size.should == 3 }
+                it("first segment should be 'abc'") { subject[0].should == 'abc' }
+                it("second segment should be '12345'") { subject[1].should == '12345' }
+                it("last segment should be '6'") { subject[2].should == '6' }
+            end
+        end
+    end
+end

data/spec/lib/convoy/formatter/terminal_spec.rb

@@ -0,0 +1,19 @@
+describe Convoy::Formatter::Terminal do
+    let(:terminal) { Convoy::Formatter::Terminal }
+
+    describe "#width" do
+        subject { terminal.width }
+
+        context "when width can be found successfully" do
+            let(:current_width) { `/usr/bin/env tput cols`.to_i }
+            it("should be equal to current width") { subject.should == current_width }
+        end
+
+        context "when width could not be found successfully" do
+            before do
+                Convoy::Formatter::ShellCommandExecutor.any_instance.stub(:execute_in_current_shell).and_return(nil)
+            end
+            it("should be equal to default width") { subject.should == Convoy::Formatter::Terminal::DEFAULT_WIDTH }
+        end
+    end
+end

data/spec/lib/convoy/setup/configuration/generator_spec.rb

@@ -0,0 +1,101 @@
+describe Convoy::Setup::Configuration::Generator do
+
+    let(:generator) { Convoy::Setup::Configuration::Generator.new(setup) }
+    let(:setup) { Convoy::SetupAccessor.new(app_configuration) }
+
+
+    describe "#default_data" do
+        subject { generator.default_data }
+
+        context "when basic configuration" do
+            let(:app_configuration) do
+                Convoy::Setup::Dsl::Global.new do |app|
+                    app.options do |opts|
+                        opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                    end
+
+                    app.action do |options, arguments|
+                    end
+                end
+            end
+            it("should have a user config") { subject[:user].should_not be_nil }
+            it("user config should be empty") { subject[:user].should be_empty }
+            it("shoud have a global config") { subject[:global].should_not be_nil }
+            it("global config should not be empty") { subject[:global].should_not be_empty }
+            it("should have a global commands config") { subject[:global][:commands].should_not be_nil }
+            it("global commands config should be empty") { subject[:global][:commands].should be_empty }
+            it("should have a global options config") { subject[:global][:options].should_not be_nil }
+            it("global options config should not be empty") { subject[:global][:options].should_not be_empty }
+            it("options config should have a key for configured option") { subject[:global][:options].keys.size.should == 1 }
+            it("options config key for configured config should be nil when no default value") { subject[:global][:options][:option1].should be_nil }
+
+            context "and configured option has default value" do
+                let(:app_configuration) do
+                    Convoy::Setup::Dsl::Global.new do |app|
+                        app.options do |opts|
+                            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string, :default => "hello"
+                        end
+
+                        app.action do |options, arguments|
+                        end
+                    end
+                end
+                it("options config key for configured config should equal to default value") { subject[:global][:options][:option1].should == 'hello' }
+            end
+        end
+
+        context "when suite configuration" do
+            let(:app_configuration) do
+                Convoy::Setup::Dsl::Global.new do |app|
+                    app.options do |opts|
+                        opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                    end
+
+                    app.command :command1, :aliases => [:c1, :com1] do |command|
+                        command.options do |opts|
+                            opts.opt :option2, "option2", :short => :none, :long => '--option2', :type => :string, :default => 'blah'
+                        end
+                    end
+                end
+            end
+
+            it("should have a global commands config") { subject[:global][:commands].should_not be_nil }
+            it("global commands config should be empty") { subject[:global][:commands].should_not be_empty }
+            it("command1 commands config should not be nil") { subject[:global][:commands][:command1][:commands].should_not be_nil }
+            it("command1 commands config should be empty") { subject[:global][:commands][:command1][:commands].should be_empty }
+            it("command1 options config should not be nil") { subject[:global][:commands][:command1][:options].should_not be_nil }
+            it("command1 options config should not be empty") { subject[:global][:commands][:command1][:options].should_not be_empty }
+            it("command1 options option value should be the same as default value") { subject[:global][:commands][:command1][:options][:option2].should == 'blah' }
+        end
+
+        context "when suite with sub commands configuration" do
+            let(:app_configuration) do
+                Convoy::Setup::Dsl::Global.new do |app|
+                    app.options do |opts|
+                        opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                    end
+
+                    app.command :command1, :aliases => [:c1, :com1] do |command|
+                        command.options do |opts|
+                            opts.opt :option2, "option2", :short => :none, :long => '--option2', :type => :string, :default => 'blah'
+                        end
+
+                        command.command :sub_command1 do |command|
+                            command.options do |opts|
+                                opts.opt :option3, "option3", :short => :none, :long => '--option3', :type => :string, :default => 'yadda'
+                            end
+                        end
+                    end
+                end
+            end
+
+            it("command1 commands config should not be nil") { subject[:global][:commands][:command1][:commands].should_not be_nil }
+            it("command1 commands config should not be empty") { subject[:global][:commands][:command1][:commands].should_not be_empty }
+            it("sub_command1 command config should not be nil") { subject[:global][:commands][:command1][:commands][:sub_command1][:commands].should_not be_nil }
+            it("sub_command1 command config should be empty") { subject[:global][:commands][:command1][:commands][:sub_command1][:commands].should be_empty }
+            it("sub_command1 options config should not be nil") { subject[:global][:commands][:command1][:commands][:sub_command1][:options].should_not be_nil }
+            it("sub_command1 options config should not be empty") { subject[:global][:commands][:command1][:commands][:sub_command1][:options].should_not be_empty }
+            it("sub_command1 options option value should be the same as default value") { subject[:global][:commands][:command1][:commands][:sub_command1][:options][:option3].should == 'yadda' }
+        end
+    end
+end