vx-builder 0.2.2 → 0.3.0

data/spec/lib/builder/build_configuration/deploy/shell_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Vx::Builder::BuildConfiguration::Deploy::Shell do
+  let(:params) { {
+    "shell"  => "echo true",
+    "branch" => "master"
+  } }
+  subject { described_class.new params }
+
+  context "#branch" do
+    it "should be empty if key 'branch' is not exists" do
+      expect(shell nil).to eq []
+    end
+
+    it "should be if string" do
+      expect(shell "master").to eq ['master']
+    end
+
+    it "should be if array" do
+      expect(shell [:master, :staging]).to eq %w{ master staging }
+    end
+
+    def shell(branch)
+      described_class.new(params.merge("branch" => branch)).branch
+    end
+  end
+
+  context "#to_commands" do
+
+    it "should be empty if nil" do
+      expect(shell nil).to eq []
+    end
+
+    it "should be if string" do
+      expect(shell "command").to eq %w{ command }
+    end
+
+    it "should be if array" do
+      expect(shell [:cmd1, :cmd2]).to eq %w{ cmd1 cmd2 }
+    end
+
+    def shell(command)
+      described_class.new(params.merge("shell" => command)).to_commands
+    end
+  end
+
+  context ".detect" do
+
+    it "should be true if key shell exists" do
+      expect(shell "shell" => "value").to be
+    end
+
+    it "should be false if key shell does not exists" do
+      expect(shell "not_shell" => "value").to_not be
+    end
+
+    def shell(params)
+      described_class.detect(params)
+    end
+  end
+end

data/spec/lib/builder/build_configuration/deploy_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Vx::Builder::BuildConfiguration::Deploy do
+  let(:params) { { "shell" => '/bin/true' } }
+  let(:deploy) { described_class.new params }
+  subject { deploy }
+
+  context "attributes" do
+    subject { deploy.attributes }
+
+    context "when is hash" do
+      let(:params) { { "shell" => '/bin/true' } }
+      it { should eq [{"shell" => "/bin/true"}] }
+    end
+
+    context "when is array" do
+      let(:params) { [{"shell" => '/bin/true'}] }
+      it { should eq [{"shell" => "/bin/true"}] }
+    end
+
+    context "when is nil" do
+      let(:params) { nil }
+      it { should eq [] }
+    end
+  end
+
+  context "find_modules" do
+    let(:branch) { 'master' }
+    subject { deploy.find_modules branch }
+
+    context "when deploy branch is empty array" do
+      let(:params) { {'shell' => 'true'} }
+      it { should_not be_empty }
+    end
+
+    context "when deploy branch is array" do
+      let(:params) { {'shell' => 'true', 'branch' => ['master', 'production']} }
+
+      it "should be true if branch found" do
+        expect(deploy.find_modules 'master').to_not be_empty
+        expect(deploy.find_modules 'production').to_not be_empty
+      end
+
+      it "should be false if branch not found" do
+        expect(deploy.find_modules 'staging').to eq []
+      end
+    end
+  end
+
+end

data/spec/lib/builder/build_configuration/env_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Vx::Builder::BuildConfiguration::Env do
+  let(:params) { { 'matrix' => ['a', 'b'], 'global' => ['c', 'd'] } }
+  let(:env)    { described_class.new params }
+  subject { env }
+
+  its(:attributes) { should eq("matrix" => ['a', 'b'], "global" => ['c', 'd']) }
+
+  context "attributes" do
+
+    context "when env is string" do
+      let(:params) { 'foo' }
+      its(:matrix)     { should eq [] }
+      its(:global)     { should eq ["foo"] }
+    end
+
+    context "when env is array" do
+      let(:params) { [:foo, :bar] }
+      its(:matrix)     { should eq ['foo', 'bar'] }
+      its(:global)     { should eq [] }
+    end
+
+    context "when env is array of one element" do
+      let(:params) { [:foo] }
+      its(:matrix)     { should eq [] }
+      its(:global)     { should eq ['foo'] }
+    end
+
+    context "when env is valid hash" do
+      let(:params) { { "global" => "foo", "matrix" => 'bar' } }
+      its(:matrix)     { should eq ['bar'] }
+      its(:global)     { should eq ['foo'] }
+    end
+
+    context "when env is invalid hash" do
+      let(:params) { { "key" => "foo" } }
+      its(:matrix)     { should eq [] }
+      its(:global)     { should eq [] }
+    end
+
+  end
+end

data/spec/lib/builder/build_configuration_spec.rb

@@ -43,8 +43,7 @@ describe Vx::Builder::BuildConfiguration do
        "scala"          => ['2.10.3'],
        "script"         => ["RAILS_ENV=test ls -1 && echo DONE!"],
        "services"       => ['rabbitmq'],
-       "artifacts"      => ["app/foo.txt", "app/*.txt", "app/", {"prefix"=>"$CI_JOB_ID/"}],
-       "deploy"         => [{"command"=>"cap deploy production", "provider"=>"shell"}],
+       "deploy"         => [{"shell"=>"cap deploy production"}],
        "bundler_args"   => ["--without development"],
        "before_deploy"  => ["echo before deploy"],
        "after_deploy"   => ["echo after deploy"]
@@ -54,135 +53,16 @@ describe Vx::Builder::BuildConfiguration do
 
   context "env" do
     subject { config.env }
-
-    context "when is array" do
-      let(:content) { { 'env' => %w{ 1 2 3 } } }
-      its(:matrix) { should eq %w{1 2 3} }
-      its(:global) { should eq [] }
-    end
-
-    context "when is hash" do
-      let(:content) { { 'env' => {
-        'global' => "global",
-        "matrix" => "matrix"
-      } } }
-      its(:matrix) { should eq %w{matrix} }
-      its(:global) { should eq %w{global} }
-    end
-
-    context "when is empty" do
-      let(:content) { {} }
-      its(:matrix) { should eq [] }
-      its(:global) { should eq [] }
-    end
+    it { should be }
   end
 
   context "cache" do
     subject { config.cache }
-
-    context "when directories present" do
-      let(:content) { { "cache" => {
-        "directories" => ["~/.cache"]
-      } } }
-      its(:directories) { should eq ["~/.cache"] }
-      its(:enabled?)    { should be_true }
-    end
-
-    context "when directories is not exists" do
-      let(:content) { {} }
-      its(:directories) { should eq [] }
-      its(:enabled?)    { should be_true }
-    end
-
-    context "when disabled" do
-      let(:content) { { "cache" => false } }
-      its(:directories) { should eq [] }
-      its(:enabled?)    { should be_false }
-    end
-  end
-
-  context "artifacts" do
-    subject { config.artifacts }
-
-    its(:prefix) { should eq "$CI_JOB_ID/" }
-    its(:files)  { should eq ["app/foo.txt", "app/*.txt", "app/"] }
-
-    context "when is empty" do
-      let(:content) { {} }
-      its(:files)      { should eq [] }
-      its(:prefix)     { should be_nil }
-      its(:attributes) { should eq [] }
-    end
+    it { should be }
   end
 
   context "deploy" do
     subject { config.deploy }
-
-    context "when is empty" do
-      let(:content) { {} }
-      its(:attributes) { should eq [] }
-
-      it "build_configuration#deploy? should be false" do
-        expect(config).to_not be_deploy
-      end
-    end
-
-    context "when is array" do
-      let(:content) { {
-        "deploy" => [
-          {
-            "provider" => "some"
-          }
-        ]
-      } }
-      its(:attributes){ should eq [{"provider" => "some"}] }
-
-      it "build_configuration#deploy? should be true" do
-        expect(config).to be_deploy
-      end
-    end
-
-    context "when is hash" do
-      let(:content) { {
-        "deploy" => {
-            "provider" => "some"
-          }
-      } }
-      its(:attributes){ should eq [{"provider" => "some"}] }
-
-      it "build_configuration#deploy? should be true" do
-        expect(config).to be_deploy
-      end
-    end
-
-    context "with on:" do
-      subject { config.deploy.providers.first.on }
-
-      context "when is string" do
-        let(:content) { {
-          "deploy" => {
-              "provider" => "some",
-              "branch"   => "production"
-            }
-        } }
-
-        it "should be branch" do
-          expect(subject).to eq(["production"])
-        end
-      end
-
-      context "when is array" do
-        let(:content) { {
-          "deploy" => {
-              "provider" => "some",
-              "branch"   => %w{ production master }
-            }
-        } }
-
-        it { should eq %w{ production master } }
-      end
-
-    end
+    it { should be }
   end
-
 end

data/spec/lib/builder/deploy_builder_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Vx::Builder::DeployBuilder do
+  let(:params) { {
+    "env"           => {
+      'global' => "1",
+      "matrix" => "2",
+    },
+    "image"         => "image",
+    "before_script" => "before",
+    "after_success" => "after",
+    "script"        => "script",
+    "deploy" => {
+      "shell"         => "/bin/true",
+      "branch"        => "master"
+    }
+  } }
+  let(:matrix) { create(:matrix_builder, params) }
+  let(:branch) { 'master' }
+  let(:deploy) { described_class.new matrix, branch: branch }
+  subject { deploy }
+
+
+  context "just created" do
+    it { should be }
+    its(:base_build_configuration)    { should eq matrix.build_configuration }
+    its(:matrix_build_configuration)  { should eq matrix.build.first }
+    its(:matrix_build_configuration)  { should be }
+    its(:branch)                      { should eq 'master' }
+  end
+
+  context "valid?" do
+    it "should be true if deploy key exists and found deploy modules" do
+      expect(deploy).to be_valid
+      expect(deploy).to have(1).deploy_modules
+      expect(deploy).to be_deploy
+    end
+
+    it "should be false if cannot found modules for deploy" do
+      deploy = described_class.new matrix, branch: "production"
+      expect(deploy).to_not be_valid
+      expect(deploy).to have(0).deploy_modules
+      expect(deploy).to be_deploy
+    end
+
+    it "should be false if deploy key does not exists" do
+      matrix = create(:matrix_builder)
+      deploy = described_class.new matrix, branch: "master"
+      expect(deploy).to_not be_valid
+      expect(deploy).to have(0).deploy_modules
+      expect(deploy).to_not be_deploy
+    end
+  end
+
+  context "build" do
+
+    it "should create build_configuration with deploy_modules and without deploy" do
+      expect(deploy.build).to be
+      expect(deploy.build).to_not be_deploy
+      expect(deploy.build).to be_deploy_modules
+    end
+
+    it "should be false if not valid" do
+      deploy = described_class.new matrix, branch: "production"
+      expect(deploy.build).to be_false
+    end
+
+    it "should remove attributes from BLACK_LIST" do
+      config = deploy.build
+      expect(config.image).to be_empty
+      expect(config.before_script).to be_empty
+      expect(config.script).to be_empty
+      expect(config.after_success).to be_empty
+    end
+
+    it "should remove matrix env" do
+      config = deploy.build
+      expect(config.env.global).to eq(['1'])
+      expect(config.env.matrix).to eq([])
+    end
+  end
+end

data/spec/lib/builder/{matrix_spec.rb → matrix_builder_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'yaml'
 
-describe Vx::Builder::Matrix do
+describe Vx::Builder::MatrixBuilder do
   let(:attributes) { {
     "env"            => %w{ FOO=1 BAR=2 },
     "rvm"            => %w{ 1.8.7 1.9.3 2.0.0 },
@@ -30,68 +30,9 @@ describe Vx::Builder::Matrix do
     end
   end
 
-  context "deploy_configuration" do
-    let(:branch) { 'master' }
-    subject { matrix.deploy_configuration branch }
+  context 'build' do
 
-    it "should be nil without :deploy key" do
-      expect(subject).to be_nil
-    end
-
-    context "with single deploy without condifitions" do
-      let(:attributes) { {
-        "deploy" => "cap deploy production"
-      } }
-
-      it { should be }
-      its("deploy.attributes"){ should eq(
-        [{"command"=>"cap deploy production", "provider"=>"shell", "branch"=>[]}]
-      ) }
-    end
-
-    context "with single deploy and condititions" do
-      let(:attributes) { {
-        "deploy" => {
-          "command" => "cap deploy production",
-          "branch" => ["master"]
-        }
-      } }
-
-      it { should be }
-      its("deploy.attributes"){ should eq(
-        [{"command"=>"cap deploy production", "provider"=>"shell", "branch"=>["master"]}]
-      ) }
-    end
-
-    context "with multiple deploys and condititions" do
-      let(:attributes) { {
-        "deploy" => [
-          {
-            "command" => "cap deploy staging",
-            "branch" => ["master"]
-          },
-          {
-            "command" => "cap deploy production",
-            "branch" => ["production"]
-          }
-         ]
-      } }
-
-      it { should be }
-      its("deploy.attributes"){ should eq(
-        [{"command"=>"cap deploy staging", "provider"=>"shell", "branch"=>["master"]}]
-      ) }
-
-      context "when no one matched" do
-        let(:branch) { 'staging' }
-        it { should be_nil }
-      end
-    end
-  end
-
-  context 'build_configurations' do
-
-    subject { matrix.build_configurations }
+    subject { matrix.build }
 
     it { should have(12).items }
 
@@ -115,7 +56,7 @@ describe Vx::Builder::Matrix do
       it { should have(1).item }
 
       context "attributes" do
-        subject { matrix.build_configurations.first.to_hash.select{|k,v| !v.empty? } }
+        subject { matrix.build.first.to_hash.select{|k,v| !v.empty? } }
 
         it { should eq(
           "env" => {
@@ -140,7 +81,7 @@ describe Vx::Builder::Matrix do
 
         expect(keys.first["rvm"]).to eq ['2.0.0']
         expect(keys.first['env']).to eq(
-          "matrix" => ["DB=postgresql"],
+          "matrix" => [],
           "global" => ["DB=postgresql"]
         )
       end
@@ -156,7 +97,7 @@ describe Vx::Builder::Matrix do
     end
 
     context "attributes" do
-      subject { matrix.build_configurations.map(&:matrix_id) }
+      subject { matrix.build.map(&:matrix_id) }
 
       it "should have true values" do
         expect(subject).to eq [
@@ -199,8 +140,9 @@ describe Vx::Builder::Matrix do
 
     it { should have(12).items }
 
-    it "should merge matrix env to global env" do
-      expect(subject.map{|i| i["env"]["global"] }.uniq.sort).to eq([["BAR=1", "FOO=1"], ["BAR=2", "FOO=1"]])
+    it "should create environments" do
+      expect(subject.map{|i| i["env"]["matrix"] }.uniq.sort).to eq([["BAR=1"], ["BAR=2"]])
+      expect(subject.map{|i| i["env"]["global"] }.uniq.sort).to eq([["FOO=1"]])
     end
   end