convoy 1.0.0

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

@@ -0,0 +1,79 @@
+describe Convoy::Setup::Configuration::Loader do
+    include FakeFS::SpecHelpers
+
+    let(:loader) { Convoy::Setup::Configuration::Loader.new(setup, auto_options) }
+    let(:setup) { Convoy::SetupAccessor.new(app_configuration) }
+    let(:auto_options) { Convoy::AutoOptions.new({}) }
+
+    describe "#default_config_path" do
+        subject { loader.default_config_path }
+
+        context "when setup has config file" do
+            let(:app_configuration) do
+                Convoy::Setup::Dsl::Global.new do |app|
+                    app.config_file '.test1rc'
+                    app.options do |opts|
+                        opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                    end
+                end
+            end
+            it { subject.should == File.join(File.expand_path('~'), '.test1rc') }
+        end
+
+        context "when setup has no config file" 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
+                end
+            end
+            it { subject.should be_nil }
+        end
+    end
+
+    describe "#configuration" do
+        subject { loader.configuration }
+
+
+        context "when setup has config file" do
+            context "and config file is autocreatable" do
+                let(:app_configuration) do
+                    Convoy::Setup::Dsl::Global.new do |app|
+                        app.config_file '.test1rc', :autocreate => true
+                        app.options do |opts|
+                            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                        end
+                    end
+                end
+                it { subject.should_not be_nil }
+                it { subject.should_not be_empty }
+                it { subject; File.should exist File.join(File.expand_path('~'), '.test1rc') }
+            end
+
+            context "and config file is not autocreatable" do
+                let(:app_configuration) do
+                    Convoy::Setup::Dsl::Global.new do |app|
+                        app.config_file '.test1rc'
+                        app.options do |opts|
+                            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+                        end
+                    end
+                end
+                it { subject.should_not be_nil }
+                it { subject.should be_empty }
+            end
+        end
+
+        context "when setup has no config file" 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
+                end
+            end
+            it { subject.should be_empty }
+        end
+    end
+end

data/spec/lib/convoy/setup/configuration/locator/chaining_spec.rb

@@ -0,0 +1,81 @@
+describe Convoy::Setup::Configuration::Locator::Chaining do
+    include FakeFS::SpecHelpers
+
+    let(:locator) { Convoy::Setup::Configuration::Locator::Chaining.new(filename) }
+    let(:filename) { '.blahrc' }
+    let(:home) { File.expand_path('~') }
+    let(:pwd) { File.expand_path(File.join(home, 'blah', 'yadda', 'foo')) }
+    let(:executing_directory) { File.expand_path(File.dirname($0)) }
+
+    let(:descending_locator) { Convoy::Setup::Configuration::Locator::DescendingToHome.new(filename) }
+    let(:executing_script_locator) { Convoy::Setup::Configuration::Locator::ExecutingScriptDirectory.new(filename) }
+
+    before do
+        FileUtils.mkdir_p(executing_directory)
+        FileUtils.mkdir_p(home)
+        FileUtils.mkdir_p(pwd)
+        Dir.chdir(pwd)
+    end
+
+    describe "#add_locator" do
+        subject { locator.add_locator("blah") }
+        it { subject.should == locator }
+        it { subject.locators.size.should == 1 }
+    end
+
+    describe "#locate" do
+        subject { locator.locate }
+
+        context "when no sub-locators specified" do
+            it { subject.should be_nil }
+        end
+
+        context "when executing directory locator specified" do
+            before do
+                locator.add_locator(executing_script_locator)
+            end
+
+            let(:path) { File.join(executing_directory, filename) }
+
+            context "and file should be found by it" do
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+
+                it { subject.should == path }
+            end
+
+            context "and file should not be found by it" do
+                it { subject.should be_nil }
+            end
+        end
+
+        context "when descending and current script locators are specified" do
+            before do
+                locator.
+                    add_locator(descending_locator).
+                    add_locator(executing_script_locator)
+            end
+
+            context "and file should not be found" do
+                it { subject.should be_nil }
+            end
+
+            context "and file should be found by current script locator" do
+                let(:path) { File.join(executing_directory, filename) }
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+                it { subject.should == path }
+            end
+
+            context "and file should be found by descending locator" do
+                let(:path) { File.join(home, filename) }
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+                it { subject.should == path }
+            end
+        end
+    end
+end

data/spec/lib/convoy/setup/configuration/locator/descending_to_home_spec.rb

@@ -0,0 +1,57 @@
+describe Convoy::Setup::Configuration::Locator::DescendingToHome do
+    include FakeFS::SpecHelpers
+
+    let(:locator) { Convoy::Setup::Configuration::Locator::DescendingToHome.new(filename) }
+    let(:filename) { '.blahrc' }
+    let(:home) { File.expand_path('~') }
+    let(:pwd) { File.expand_path(File.join(home, 'blah', 'yadda', 'foo')) }
+
+    before do
+        FileUtils.mkdir_p(home)
+        FileUtils.mkdir_p(pwd)
+        Dir.chdir(pwd)
+    end
+
+    describe "#locate" do
+        subject { locator.locate }
+
+        context "when file does not exist anywhere in the relevant directories" do
+            it { subject.should be_nil }
+        end
+
+        context "when file exists" do
+            context "in the top directory of search" do
+                let(:file_location) { File.expand_path(File.join(home, 'blah', 'yadda', 'foo')) }
+                let(:path) { File.join(file_location, filename) }
+
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+
+                it { subject.should == path }
+            end
+
+            context "in one of the middle directories of search" do
+                let(:file_location) { File.expand_path(File.join(home, 'blah', 'yadda')) }
+                let(:path) { File.join(file_location, filename) }
+
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+
+                it { subject.should == path }
+            end
+
+            context "in the home directory" do
+                let(:file_location) { File.expand_path(home) }
+                let(:path) { File.join(file_location, filename) }
+
+                before do
+                    File.open(path, 'w') { |f| f.write("hello") }
+                end
+
+                it { subject.should == path }
+            end
+        end
+    end
+end

data/spec/lib/convoy/setup/configuration/locator/executing_script_directory_spec.rb

@@ -0,0 +1,29 @@
+describe Convoy::Setup::Configuration::Locator::ExecutingScriptDirectory do
+    include FakeFS::SpecHelpers
+
+    let(:locator) { Convoy::Setup::Configuration::Locator::ExecutingScriptDirectory.new(filename) }
+    let(:filename) { '.blahrc' }
+    let(:directory) { File.expand_path(File.dirname($0)) }
+    let(:path) { File.join(directory, filename) }
+
+    describe "#locate" do
+        subject { locator.locate }
+
+        context "when file does not exist in directory" do
+            before do
+                FileUtils.mkdir_p(directory)
+            end
+
+            it { subject.should be_nil }
+        end
+
+        context "when file exists in directory" do
+            before do
+                FileUtils.mkdir_p(directory)
+                File.open(path, 'w') { |f| f.write("hello") }
+            end
+
+            it { subject.should == path }
+        end
+    end
+end

data/spec/lib/convoy/setup/configuration/locator/specified_directory_spec.rb

@@ -0,0 +1,33 @@
+describe Convoy::Setup::Configuration::Locator::SpecifiedDirectory do
+    include FakeFS::SpecHelpers
+
+    let(:locator) { Convoy::Setup::Configuration::Locator::SpecifiedDirectory.new(filename, directory) }
+    let(:filename) { '.blahrc' }
+    let(:directory) { '/usr/alan/yadda' }
+    let(:path) { File.join(directory, filename) }
+
+    describe "#locate" do
+        subject { locator.locate }
+
+        context "when directory does not exist" do
+            it { subject.should be_nil }
+        end
+
+        context "when file does not exist in directory" do
+            before do
+                FileUtils.mkdir_p(directory)
+            end
+
+            it { subject.should be_nil }
+        end
+
+        context "when file exists in directory" do
+            before do
+                FileUtils.mkdir_p(directory)
+                File.open(path, 'w') { |f| f.write("hello") }
+            end
+
+            it { subject.should == path }
+        end
+    end
+end

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

@@ -0,0 +1,41 @@
+describe Convoy::Setup::Configuration::MergeTool do
+    let(:merge_tool) { Convoy::Setup::Configuration::MergeTool.new(new_config_hash, old_config_hash) }
+
+    describe "#config_hash" do
+        subject { merge_tool.config_hash }
+
+        context "when there is a new command" do
+            let(:old_config_hash) { {:global => {:commands => {}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+            let(:new_config_hash) { {:global => {:commands => {:command1 => {:commands => {}, :options => {}}}, :options => {}}, :user => {}} }
+
+            it("should be part of the config") { subject[:global][:commands][:command1].should_not be_nil }
+        end
+
+        context "when there is a new option for an old command" do
+            let(:old_config_hash) { {:global => {:commands => {}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+            let(:new_config_hash) { {:global => {:commands => {}, :options => {:option1 => nil, :option2 => nil}}, :user => {}} }
+
+            it("should be part of the config") { subject[:global][:options].keys.should include(:option2) }
+        end
+
+        context "when an old option for a command is no longer there" do
+            let(:old_config_hash) { {:global => {:commands => {}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+            let(:new_config_hash) { {:global => {:commands => {}, :options => {:option2 => nil}}, :user => {}} }
+
+            it("should not be part of the config") { subject[:global][:options].keys.should_not include(:option1) }
+        end
+
+        context "when old config hash has user supplied value for option" do
+            let(:old_config_hash) { {:global => {:commands => {}, :options => {:option1 => :hello}}, :user => {:hello => :world}} }
+            let(:new_config_hash) { {:global => {:commands => {}, :options => {:option1 => nil}}, :user => {}} }
+
+            it("should retain the user supplied value for option") { subject[:global][:options][:option1].should == :hello }
+        end
+
+        context "when old user hash has values" do
+            let(:old_config_hash) { {:global => {:commands => {}, :options => {}}, :user => {:hello => :world}} }
+            let(:new_config_hash) { {:global => {:commands => {}, :options => {}}, :user => {}} }
+            it("should retain the user config values") { subject[:user][:hello].should == :world }
+        end
+    end
+end

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

@@ -0,0 +1,41 @@
+describe Convoy::Setup::Configuration::Reader do
+    include FakeFS::SpecHelpers
+
+    let(:reader) { Convoy::Setup::Configuration::Reader.new(path) }
+    let(:path) { '/usr/alan/blah.json' }
+    let(:data) { {:hello => :world} }
+
+    describe "#read" do
+        subject { reader.read }
+
+        context "when path not given" do
+            let(:path) { nil }
+            it { subject.should be_empty }
+        end
+
+        context "when configuration file not present" do
+            before do
+                FileUtils.mkdir_p(File.dirname path)
+            end
+            it { subject.should be_empty }
+        end
+
+        context "when configuration file not JSON" do
+            before do
+                FileUtils.mkdir_p(File.dirname path)
+                File.open(path, 'w') { |f| f.write("hello") }
+            end
+            it { subject.should be_empty }
+        end
+
+        context "when configuration file present" do
+            let(:config_data) { {:hello => :blah} }
+
+            before do
+                FileUtils.mkdir_p(File.dirname path)
+                File.open(path, 'w') { |f| f.write(JSON.pretty_generate(config_data)) }
+            end
+            it { subject.data.should == {:hello => "blah"} }
+        end
+    end
+end

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

@@ -0,0 +1,75 @@
+describe Convoy::Setup::Configuration::Writer do
+    include FakeFS::SpecHelpers
+    let(:writer) { Convoy::Setup::Configuration::Writer.new(path, data) }
+    let(:path) { '/usr/alan/blah.json' }
+    let(:data) { {:hello => :world} }
+
+    describe "#write" do
+        subject { writer.write }
+
+        context "when path is nil" do
+            let(:path) { nil }
+            it { subject.should be_empty }
+        end
+
+        context "when path is not nil" do
+            context "and the file does not exist" do
+                it { subject.should_not be_empty }
+                it { subject.path.should == path }
+                it { subject.data.should == data }
+                it("file should have the right contents") do
+                    subject
+                    json = File.read(path)
+                    hash = ::JSON.parse(json)
+                    actual_data = Convoy::Utils.symbolize_keys(hash)
+                    actual_data.should == {:hello => "world"}
+                end
+            end
+
+            context "and the file already exists" do
+                before do
+                    FileUtils.mkdir_p(File.dirname path)
+                    FileUtils.touch(path)
+                end
+                it { subject.should be_empty }
+            end
+        end
+    end
+
+    describe "#update" do
+        subject { writer.update }
+
+        context "when file does not exist" do
+            it { subject.should_not be_empty }
+            it { subject.path.should == path }
+            it { subject.data.should == data }
+            it("file should have the right contents") do
+                subject
+                json = File.read(path)
+                hash = ::JSON.parse(json)
+                actual_data = Convoy::Utils.symbolize_keys(hash)
+                actual_data.should == {:hello => "world"}
+            end
+        end
+
+        context "when file does exit" do
+            let(:previous_data) { {:hello => :blah} }
+            let(:data) { {:hello => :world, :foo => :bar} }
+            before do
+                FileUtils.mkdir_p(File.dirname path)
+                File.open(path, 'w') { |f| f.write(JSON.pretty_generate(previous_data)) }
+            end
+
+            it { subject.should_not be_empty }
+            it { subject.path.should == path }
+            it { subject.data.should == data }
+            it("file should have the right contents") do
+                subject
+                json = File.read(path)
+                hash = ::JSON.parse(json)
+                actual_data = Convoy::Utils.symbolize_keys(hash)
+                actual_data.should == {:hello => "blah", :foo => "bar"}
+            end
+        end
+    end
+end