borg-rb 0.0.5 → 0.1.0

data/spec/lib/borg/cli/applications_spec.rb

@@ -2,87 +2,123 @@ require 'spec_helper'
 require 'borg/cli/applications'
 
 describe Borg::CLI::Applications do
-  before :each do
-    @config = double("config1")
-    @files = %w{cap/applications/app1.rb cap/applications/app1/stg1.rb cap/applications/app1/stg2.rb}
-    Dir.stub("[]").and_return(@files)
-    @cli = Capistrano::CLI.new([])
+  before :all do
+    class MockCLI < Capistrano::CLI
+      include Borg::CLI::Applications
+    end
+  end
+
+  after :all do
+    Object.send(:remove_const, :MockCLI)
+  end
+
+  let(:app_config) { <<-RUBY.gsub(/^ {4}/, '')
+    application :app1 do
+      puts 'application = app1'
+    end
+
+    stage :app1, :prd do
+      puts 'stage = prd'
+    end
+
+    stage :app1, :stg do
+      puts 'stage = stg'
+    end
+
+    stage :app1, :alf do
+      puts 'stage = alf'
+    end
+  RUBY
+  }
+
+  before :all do
+    @env = Support::IsolatedEnvironment.new
+    @env.create_file('cap/applications/app.rb', app_config)
+    @app_config_path = @env.workdir_path.join('cap/applications/app.rb')
+    @files = [@app_config_path]
+  end
+
+  after :all do
+    @env.close
   end
 
-  context "#load_applications when called" do
+  before do
+    Dir.stub('[]').and_return(@files)
+    @cli = MockCLI.new([])
+    @config = double('config1')
+  end
+
+  describe '#load_applications' do
     before do
       @files.each { |f| @config.should_receive(:load).with(f) }
     end
 
-    it "should load all files in ./cap/applications/**/*.rb" do
+    it 'loads files in ./cap/applications/**/*.rb' do
       @cli.send :load_applications, @config
     end
 
-    context "with a second call" do
+    context 'when already invoked in the past' do
       before do
         @cli.send :load_applications, @config
-        @config2 = double("config2")
-        @files.each { |f| @config2.should_not_receive(:load).with(f) }
       end
 
-      it "should not load all files in ./cap/applications/**/*.rb for further calls" do
+      it 'does not load files in ./cap/applications/**/*.rb anymore' do
+        @config2 = double('config2')
         @cli.send :load_applications, @config2
+        @files.each { |f| @config2.should_not_receive(:load).with(f) }
       end
     end
   end
 
-  context "#separate_actions_and_applications when called" do
+  describe '#separate_actions_and_applications' do
     before do
       @cli.instance_eval do
         @options = {}
         @options[:actions] = %w{app1 app2:stg1 app2:stg3 test test2}
       end
-      @config.stub(:applications).and_return({
-                                                 app1: double("app1"),
-                                                 app2: double("app2")
-                                             })
+      @config.stub(:applications).
+          and_return({app1: double('app1'), app2: double('app2')})
       @config.applications[:app1].stub(:stages).and_return({})
-      @config.applications[:app2].stub(:stages).and_return({
-                                                              stg1: double("stg1"),
-                                                              stg2: double("stg2")
-                                                          })
+      @config.applications[:app2].stub(:stages).
+          and_return({stg1: double('stg1'),stg2: double('stg2')})
     end
-    it "should remove all applications from actions" do
+    it 'removes all applications from actions' do
       @cli.send :separate_actions_and_applications, @config
-      @cli.options[:actions].should == %w{app2:stg3 test test2}
-      @cli.options[:applications].should == [
-          @config.applications[:app1],
-          @config.applications[:app2].stages[:stg1]
-      ]
+      expect(@cli.options[:actions]).to eq %w{app2:stg3 test test2}
+      expect(@cli.options[:applications]).to eq [
+                                                    @config.applications[:app1],
+                                                    @config.applications[:app2].stages[:stg1]
+                                                ]
     end
 
-    it "should queue both stages if app2" do
+    it 'queues both stages if app2' do
       @cli.instance_eval do
         @options[:actions] = %w{app1 app2 test test2}
       end
 
       @cli.send :separate_actions_and_applications, @config
 
-      @cli.options[:actions].should == %w{test test2}
-      @cli.options[:applications].should == [
-          @config.applications[:app1],
-          @config.applications[:app2].stages[:stg1],
-          @config.applications[:app2].stages[:stg2]
-      ]
+      expect(@cli.options[:actions]).to eq %w{test test2}
+      expect(@cli.options[:applications]).to eq [
+                                                    @config.applications[:app1],
+                                                    @config.applications[:app2].stages[:stg1],
+                                                    @config.applications[:app2].stages[:stg2]
+                                                ]
     end
 
-    it "should raise exception if configs are not isolated to start of the actions list" do
+    it 'raises an exception when configs are not isolated to start of the actions list' do
       @cli.instance_eval do
-        @options[:actions] << "app2:stg2"
+        @options[:actions] << 'app2:stg2'
       end
-      expect{ @cli.send(:separate_actions_and_applications, @config)}.to raise_error(ArgumentError, "Can not have non application configs between application configs")
+      expect{
+        @cli.send(:separate_actions_and_applications, @config)
+      }.to raise_error(ArgumentError, 'Can not have non application configs between application configs')
     end
 
   end
 
-  context "#execute_requested_actions_with_applications when called" do
+  describe '#execute_requested_actions_with_applications' do
     before do
-
       @cli.instance_eval do
         @apps_loaded = true
         @options = {}
@@ -90,27 +126,25 @@ describe Borg::CLI::Applications do
         @options[:applications] = []
       end
       @config.stub(:applications).and_return({})
-
       @cli.stub(:execute_requested_actions_without_applications)
-
     end
 
-    it "should load applications" do
+    it 'loads applications' do
       @cli.should_receive(:load_applications).with(@config)
       @cli.execute_requested_actions_with_applications @config
     end
 
-    it "should separate actions and applications" do
+    it 'separates actions and applications' do
       @cli.should_receive(:separate_actions_and_applications).with(@config)
       @cli.execute_requested_actions_with_applications @config
     end
 
-    it "should call #execute_requested_actions_without_applications when there is an empty applications list" do
+    it 'calls #execute_requested_actions_without_applications when there is an empty applications list' do
       @cli.should_receive(:execute_requested_actions_without_applications).with(@config)
       @cli.execute_requested_actions_with_applications @config
     end
 
-    context "when applications exist" do
+    context 'when applications exist' do
       before do
         apps = [double(:app1), double(:app2)]
         apps[0].stub(:name).and_return(:app1)
@@ -125,23 +159,23 @@ describe Borg::CLI::Applications do
         Thread.current[:borg_application] = nil
       end
 
-      it "should call call execute! for each application" do
+      it 'calls execute! for each application' do
         @cli.stub(:load_applications)
         @cli.stub(:separate_actions_and_applications)
         @cli.should_receive(:execute!).with().twice
         @cli.execute_requested_actions_with_applications @config
       end
 
-      it "should set Thread's borg_application" do
+      it 'sets Thread.current[:borg_application]' do
         @cli.stub(:load_applications)
         @cli.stub(:separate_actions_and_applications)
         @cli.stub(:execute!) do
-          @cli.options[:applications].should include Thread.current[:borg_application]
+          expect(@cli.options[:applications]).to include Thread.current[:borg_application]
         end
         @cli.execute_requested_actions_with_applications @config
       end
 
-      it "should call #execute_requested_actions_without_applications when Thread's borg_application is set" do
+      it 'calls #execute_requested_actions_without_applications when Thread.current[:borg_application] is set' do
         Thread.current[:borg_application] = @cli.options[:applications][0]
         @cli.stub(:load_applications)
         @cli.stub(:separate_actions_and_applications)
@@ -150,7 +184,7 @@ describe Borg::CLI::Applications do
         @cli.execute_requested_actions_with_applications @config
       end
 
-      it "should load the application's config when Thread's borg_application is set" do
+      it 'loads the application config when Thread.current[:borg_application] is set' do
         Thread.current[:borg_application] = @cli.options[:applications][0]
         @cli.stub(:load_applications)
         @cli.stub(:separate_actions_and_applications)
@@ -158,7 +192,6 @@ describe Borg::CLI::Applications do
         @cli.options[:applications][0].should_receive(:load_into)
         @cli.execute_requested_actions_with_applications @config
       end
-
     end
   end
 end

data/spec/lib/borg/cli_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+require 'borg/cli'
+
+describe Borg::CLI do
+  let(:app_config) { <<-RUBY.gsub(/^ {4}/, '')
+    application :app1 do
+      puts 'application = app1'
+    end
+
+    stage :app1, :prd do
+      puts 'stage = prd'
+    end
+
+    stage :app1, :stg do
+      puts 'stage = stg'
+    end
+
+    stage :app1, :alf do
+      puts 'stage = alf'
+    end
+  RUBY
+  }
+
+  before :all do
+    @env = Support::IsolatedEnvironment.new
+    @env.create_file('cap/applications/app.rb', app_config)
+    @app_config_path = @env.workdir_path.join('cap/applications/app.rb')
+    @files = [@app_config_path]
+  end
+
+  after :all do
+    @env.close
+  end
+
+  before do
+    Dir.stub('[]').and_return(@files)
+    @cli = Borg::CLI.new([])
+    @config = double('config1')
+  end
+
+  describe '#load_applications' do
+    before do
+      @files.each { |f| @config.should_receive(:load).with(f) }
+    end
+
+    it 'loads files in ./cap/applications/**/*.rb' do
+      @cli.send :load_applications, @config
+    end
+
+    context 'when already invoked in the past' do
+      before do
+        @cli.send :load_applications, @config
+      end
+
+      it 'does not load files in ./cap/applications/**/*.rb anymore' do
+        @config2 = double('config2')
+        @cli.send :load_applications, @config2
+        @files.each { |f| @config2.should_not_receive(:load).with(f) }
+      end
+    end
+  end
+
+  describe '#separate_actions_and_applications' do
+    before do
+      @cli.instance_eval do
+        @options = {}
+        @options[:actions] = %w{app1 app2:stg1 app2:stg3 test test2}
+      end
+      @config.stub(:applications).
+          and_return({app1: double('app1'), app2: double('app2')})
+      @config.applications[:app1].stub(:stages).and_return({})
+      @config.applications[:app2].stub(:stages).
+          and_return({stg1: double('stg1'),stg2: double('stg2')})
+    end
+    it 'removes all applications from actions' do
+      @cli.send :separate_actions_and_applications, @config
+      expect(@cli.options[:actions]).to eq %w{app2:stg3 test test2}
+      expect(@cli.options[:applications]).to eq [
+          @config.applications[:app1],
+          @config.applications[:app2].stages[:stg1]
+      ]
+    end
+
+    it 'queues both stages if app2' do
+      @cli.instance_eval do
+        @options[:actions] = %w{app1 app2 test test2}
+      end
+
+      @cli.send :separate_actions_and_applications, @config
+
+      expect(@cli.options[:actions]).to eq %w{test test2}
+      expect(@cli.options[:applications]).to eq [
+          @config.applications[:app1],
+          @config.applications[:app2].stages[:stg1],
+          @config.applications[:app2].stages[:stg2]
+      ]
+    end
+
+    it 'raises an exception when configs are not isolated to start of the actions list' do
+      @cli.instance_eval do
+        @options[:actions] << 'app2:stg2'
+      end
+      expect{
+        @cli.send(:separate_actions_and_applications, @config)
+      }.to raise_error(ArgumentError, 'Can not have non application configs between application configs')
+    end
+
+  end
+
+  describe '#execute_requested_actions_with_applications' do
+    before do
+      @cli.instance_eval do
+        @apps_loaded = true
+        @options = {}
+        @options[:actions] = %w{app1 app2:stg1 app2:stg3 test test2}
+        @options[:applications] = []
+      end
+      @config.stub(:applications).and_return({})
+      @cli.stub(:execute_requested_actions_without_applications)
+    end
+
+    it 'loads applications' do
+      @cli.should_receive(:load_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    it 'separates actions and applications' do
+      @cli.should_receive(:separate_actions_and_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    it 'calls #execute_requested_actions_without_applications when there is an empty applications list' do
+      @cli.should_receive(:execute_requested_actions_without_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    context 'when applications exist' do
+      before do
+        apps = [double(:app1), double(:app2)]
+        apps[0].stub(:name).and_return(:app1)
+        apps[1].stub(:name).and_return(:app2)
+        @cli.instance_eval do
+          @options[:applications] = apps
+        end
+        @cli.stub(:puts)
+      end
+
+      after do
+        Thread.current[:borg_application] = nil
+      end
+
+      it 'calls execute! for each application' do
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.should_receive(:execute!).with().twice
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it 'sets Thread.current[:borg_application]' do
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.stub(:execute!) do
+          expect(@cli.options[:applications]).to include Thread.current[:borg_application]
+        end
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it 'calls #execute_requested_actions_without_applications when Thread.current[:borg_application] is set' do
+        Thread.current[:borg_application] = @cli.options[:applications][0]
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.should_receive(:execute_requested_actions_without_applications).with(@config)
+        @cli.options[:applications][0].stub(:load_into)
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it 'loads the application config when Thread.current[:borg_application] is set' do
+        Thread.current[:borg_application] = @cli.options[:applications][0]
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.stub(:execute_requested_actions_without_applications)
+        @cli.options[:applications][0].should_receive(:load_into)
+        @cli.execute_requested_actions_with_applications @config
+      end
+    end
+  end
+end

data/spec/lib/borg/configuration/applications_spec.rb

@@ -2,66 +2,63 @@ require 'spec_helper'
 require 'borg/configuration/applications'
 
 describe Borg::Configuration::Applications do
-  it "should be included into Capistrano::Configuration" do
-    Capistrano::Configuration.ancestors.should include Borg::Configuration::Applications
+  before :all do
+    class MockConfiguration < Capistrano::Configuration
+      include Borg::Configuration::Applications
+    end
   end
 
-  context "when a new Capistrano::Configuration is initialized" do
-    subject { Capistrano::Configuration.new }
-    it "should initialize the applications hash" do
-      expect(subject.applications).to eq({})
-    end
+  after :all do
+    Object.send(:remove_const, :MockConfiguration)
+  end
+
+  let(:config) { MockConfiguration.new }
+
+  it 'initializes the applications hash' do
+    expect(config.applications.class).to eq Hash
   end
 
-  context "when an applications is defined" do
+  context 'when applications are defined' do
     before do
-      @config = Capistrano::Configuration.new
-      @config.load do
-        application "app1" do
-          test_notice "You have called app1"
+      config.load do
+        application 'app1' do
+          test_notice 'You have called app1'
+
         end
       end
     end
-    subject { @config }
 
-    it "should symobolize the name" do
-      expect(subject.applications[:app1].name).to eq :app1
-    end
-
-    it "should create a namespace app1 with task default and a description" do
-      expect(subject.namespaces[:app1]).to be_true
-      expect(subject.namespaces[:app1].tasks[:default]).to be_true
-      expect(subject.namespaces[:app1].tasks[:default].desc).to be_true
-    end
+    it_behaves_like 'an application configuration'
 
-    it "should add it to applications hash and have a block" do
-      expect(subject.applications[:app1].class).to eq Borg::Configuration::Applications::Application
-      expect(subject.applications[:app1].execution_blocks.count).to eq 1
+    it 'creates an execution block for the application' do
+      expect(config.applications[:app1].execution_blocks.count).to eq 1
     end
   end
+
 end
 
 describe Borg::Configuration::Applications::Application do
-  it "should be initialize all variables" do
-    app1 = Borg::Configuration::Applications::Application.new(:app1, double("namespace app1"))
+  it 'initializes: stage, name, and execution_blocks' do
+    app1 = Borg::Configuration::Applications::Application.new(:app1, double('namespace app1'))
     expect(app1.stages).to eq({})
     expect(app1.name).to eq(:app1)
     expect(app1.execution_blocks).to eq([])
   end
 
-  context "an applications with 2 blocks" do
+  context 'an applications with 2 blocks' do
     before do
-      @app1 = Borg::Configuration::Applications::Application.new(:app1, double("namespace app1"))
+      @app1 = Borg::Configuration::Applications::Application.new(:app1, double('namespace app1'))
       @app1.execution_blocks << -> {
-        raise "block 1 called"
+        raise 'block 1 called'
       }
       @app1.execution_blocks << -> {
-        raise "block 2 called"
+        raise 'block 2 called'
       }
     end
-    context "when #load_into is called" do
-      it "should all blocks into the provided config" do
-        config  = double("test config")
+
+    context 'when #load_into is called' do
+      it 'loads all blocks into the provided config' do
+        config  = double('test config')
         config.should_receive(:load).twice
         @app1.load_into config
       end