mamiya 0.0.1.alpha21 → 0.0.1.alpha22

data/spec/master/web_spec.rb

@@ -112,13 +112,25 @@ describe Mamiya::Master::Web do
 
   describe "POST /packages/:application/:package/distribute" do
     it "dispatchs distribute request" do
-      expect(master).to receive(:distribute).with('myapp', 'mypackage')
+      expect(master).to receive(:distribute).with('myapp', 'mypackage', labels: nil)
 
       post '/packages/myapp/mypackage/distribute'
 
       expect(last_response.status).to eq 204 # no content
     end
 
+    context "with labels" do
+      it "dispatchs prepare request with labels" do
+        expect(master).to receive(:distribute).with('myapp', 'mypackage', labels: ['foo'])
+
+        post '/packages/myapp/mypackage/distribute',
+          {'labels' =>  ["foo"]}.to_json,
+          'CONTENT_TYPE' => 'application/json'
+
+        expect(last_response.status).to eq 204 # no content
+      end
+    end
+
     context "when package not found" do
       it "returns 404" do
         post '/packages/myapp/noexist/distribute'
@@ -127,6 +139,36 @@ describe Mamiya::Master::Web do
     end
   end
 
+  describe "POST /packages/:application/:package/prepare" do
+    it "dispatchs prepare request" do
+      expect(master).to receive(:prepare).with('myapp', 'mypackage', labels: nil)
+
+      post '/packages/myapp/mypackage/prepare'
+
+      expect(last_response.status).to eq 204 # no content
+    end
+
+    context "with labels" do
+      it "dispatchs prepare request with labels" do
+        expect(master).to receive(:prepare).with('myapp', 'mypackage', labels: ['foo'])
+
+        post '/packages/myapp/mypackage/prepare',
+          {'labels' =>  ["foo"]}.to_json,
+          'CONTENT_TYPE' => 'application/json'
+
+        expect(last_response.status).to eq 204 # no content
+      end
+    end
+
+    context "when package not found" do
+      it "returns 404" do
+        post '/packages/myapp/noexist/prepare'
+        expect(last_response.status).to eq 404
+      end
+    end
+  end
+
+
   describe "GET /package/:application/:package/distribution" do
     subject(:distribution) do
       res = get('/packages/myapp/mypackage/distribution')

data/spec/steps/build_spec.rb

@@ -14,6 +14,9 @@ describe Mamiya::Steps::Build do
   let(:build_dir)   { Pathname.new(tmpdir).join('build') }
   let(:package_dir) { Pathname.new(tmpdir).join('pkg') }
   let(:extract_dir) { Pathname.new(tmpdir).join('extract') }
+  let(:script_dir)  { Pathname.new(tmpdir).join('script').tap(&:mkdir) }
+
+  let(:script_file)  { script_dir.join('deploy.rb').tap { |_| File.write _, "p :script\n" } }
 
   let(:exclude_from_package) { [] }
   let(:package_under) { nil }
@@ -36,6 +39,9 @@ describe Mamiya::Steps::Build do
       dereference_symlinks: dereference_symlinks,
       exclude_from_package: exclude_from_package,
       skip_prepare_build: skip_prepare_build,
+      script_file: script_file,
+      script_additionals: [],
+      _file: nil,
     )
   end
   
@@ -97,6 +103,7 @@ describe Mamiya::Steps::Build do
       allow(script).to receive(:exclude_from_package).and_return(['test'])
       allow(script).to receive(:dereference_symlinks).and_return(true)
       allow(script).to receive(:package_under).and_return('foo')
+      build_dir.join('foo').mkdir
 
       expect_any_instance_of(Mamiya::Package).to \
         receive(:build!).with(
@@ -123,6 +130,100 @@ describe Mamiya::Steps::Build do
       build_step.run!
     end
 
+    it "packs script_file into .mamiya.script" do
+      expect_any_instance_of(Mamiya::Package).to receive(:build!) do
+        expect(build_dir.join('.mamiya.script')).to be_a_directory
+        expect(build_dir.join('.mamiya.script', 'deploy.rb').read).to match(/:script/)
+      end
+
+      build_step.run!
+
+      expect(build_dir.join('.mamiya.script')).not_to be_exist
+    end
+
+    it "writes script_file in meta" do
+      meta = {}
+      allow_any_instance_of(Mamiya::Package).to receive(:meta).and_return(meta)
+      expect_any_instance_of(Mamiya::Package).to receive(:build!) do
+        expect(meta[:script]).to eq 'deploy.rb'
+      end
+
+      build_step.run!
+
+      expect(build_dir.join('.mamiya.script')).not_to be_exist
+    end
+
+    context "when package_under is specified" do
+      let(:package_under) { 'hoge' }
+
+      before do
+        build_dir.join('hoge').mkdir
+        File.write build_dir.join('hoge', 'test'), "hello\n"
+      end
+
+      it "places .mamiya.script under :package_under" do
+        expect_any_instance_of(Mamiya::Package).to receive(:build!) do
+          expect(build_dir.join('hoge', '.mamiya.script')).to be_a_directory
+          expect(build_dir.join('hoge', '.mamiya.script', 'deploy.rb').read).to match(/:script/)
+        end
+
+        build_step.run!
+
+        expect(build_dir.join('.mamiya.script')).not_to be_exist
+      end
+    end
+
+    context "with :script_additionals" do
+      before do
+        allow(script).to receive(:script_additionals).and_return(%w(test))
+      end
+
+      it "packs them into .mamiya.script" do
+        File.write script_dir.join('test'), "this is test\n"
+
+        expect_any_instance_of(Mamiya::Package).to receive(:build!) do
+          expect(build_dir.join('.mamiya.script')).to be_a_directory
+          expect(build_dir.join('.mamiya.script', 'deploy.rb').read).to match(/:script/)
+          expect(build_dir.join('.mamiya.script', 'test').read).to match(/this is test/)
+        end
+
+        build_step.run!
+
+        expect(build_dir.join('.mamiya.script')).not_to be_exist
+      end
+    end
+
+    context "without script_file and when script is loaded from a file" do
+      before do
+        allow(script).to receive(:_file).and_return(script_file)
+        allow(script).to receive(:script_file).and_return(nil)
+      end
+
+      it "assumes loaded file's directory as script_dir and loaded file as script_file" do
+        expect_any_instance_of(Mamiya::Package).to receive(:build!) do
+          expect(build_dir.join('.mamiya.script')).to be_a_directory
+          expect(build_dir.join('.mamiya.script', 'deploy.rb').read).to match(/:script/)
+        end
+
+        build_step.run!
+
+        expect(build_dir.join('.mamiya.script')).not_to be_exist
+      end
+    end
+
+    context "without script_file and when script is not loaded from a file" do
+      before do
+        allow(script).to receive(:_file).and_return(nil)
+        allow(script).to receive(:script_file).and_return(nil)
+      end
+
+      it "raises an error" do
+        expect {
+          build_step.run!
+        }.to raise_error Mamiya::Steps::Build::ScriptFileNotSpecified
+      end
+    end
+
     context "with package name determiner" do
       it "calls package name determiner with current candidate" do
         received = nil

data/spec/steps/prepare_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+require 'json'
+
+require 'mamiya/script'
+
+require 'mamiya/package'
+require 'mamiya/steps/prepare'
+
+describe Mamiya::Steps::Prepare do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-prepare-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:target_dir) { Pathname.new(tmpdir).join('release').tap(&:mkdir) }
+
+  let(:target_meta) do
+    {
+      script: 'script.rb',
+    }
+  end
+
+  let(:script) do
+    double('script',
+      before_prepare: proc {},
+      prepare: proc {},
+      after_prepare: proc {},
+    )
+  end
+
+  let(:config) do
+    double('config')
+  end
+
+  let(:options) do
+    {target: target_dir, labels: [:foo, :bar]}
+  end
+
+  subject(:step) { described_class.new(script: nil, config: config, **options) }
+
+  before do
+    File.write target_dir.join('.mamiya.meta.json'), target_meta.to_json
+    allow(Mamiya::Script).to receive(:new).and_return(script)
+    allow(script).to receive(:load!).with(target_dir.realpath.join('.mamiya.script', 'script.rb')).and_return(script)
+    allow(script).to receive(:set).and_return(script)
+  end
+
+  describe "#run!" do
+    it "calls hooks with proper order" do
+      hooks = %i(before_prepare prepare after_prepare)
+
+      flags = []
+      hooks.each do |sym|
+        allow(script).to receive(sym).and_return(proc { flags << sym })
+      end
+
+      expect { step.run! }.
+        to change { flags }.
+        from([]).
+        to(hooks)
+    end
+
+    context "if exception occured" do
+      let(:error) { Exception.new("Good bye, the cruel world") }
+      before do
+        e = error
+        allow(script).to receive(:prepare).and_return(proc { raise e })
+      end
+
+      it "calls after hook with error" do
+        received = nil
+        allow(script).to receive(:after_prepare).and_return(proc { |_| received = _ })
+
+        expect {
+          begin
+            step.run!
+          rescue Exception; end
+        }.
+          to change { received }.
+          from(nil).to(error)
+      end
+
+      it "does not create .mamiya.prepared" do
+        expect {
+          step.run!
+        }.to raise_error(error)
+        expect(target_dir.join('.mamiya.prepared')).not_to be_exist
+      end
+    end
+
+    it "creates .mamiya.prepared" do
+      expect {
+        step.run!
+      }.to change {
+        target_dir.join('.mamiya.prepared').exist?
+      }.from(false).to(true)
+    end
+
+    it "calls hook in :target (pwd)" do
+      pwd = nil
+      script.stub(prepare: proc { pwd = Dir.pwd })
+
+      expect {
+        step.run!
+      }.not_to change { Dir.pwd }
+
+      expect(File.realpath(pwd)).to eq target_dir.realpath.to_s
+    end
+
+    it "sets release_path" do
+      expect(script).to receive(:set).with(:release_path, target_dir.realpath)
+      expect(script).to receive(:set).with(:logger, step.logger)
+      step.run!
+    end
+
+    it "calls hooks using labels" do
+      allow(script).to receive(:before_prepare).with(%i(foo bar)).and_return(proc {})
+      allow(script).to receive(:prepare).with(%i(foo bar)).and_return(proc {})
+      allow(script).to receive(:after_prepare).with(%i(foo bar)).and_return(proc {})
+
+      step.run!
+    end
+  end
+end

data/spec/steps/switch_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+require 'json'
+
+require 'mamiya/script'
+
+require 'mamiya/package'
+require 'mamiya/steps/switch'
+
+describe Mamiya::Steps::Switch do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-switch-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:deploy_to) { Pathname.new(tmpdir) }
+  let(:releases_dir) { deploy_to.join('releases').tap(&:mkdir) }
+
+  let(:release_path) { releases_dir.join('20140907030907').tap(&:mkdir) }
+  let(:current_path) { deploy_to.join('current') }
+
+  let(:target_meta) do
+    {script: 'script.rb'}
+  end
+
+  let(:script) do
+    double('script',
+      deploy_to: deploy_to,
+      before_switch: proc {},
+      release: proc {},
+      after_switch: proc {},
+      current_path: current_path,
+    )
+  end
+
+  let(:config) do
+    double('config')
+  end
+
+  let(:options) do
+    {target: release_path, labels: [:foo, :bar]}
+  end
+
+  subject(:step) { described_class.new(script: nil, config: config, **options) }
+
+  before do
+    File.write release_path.join('.mamiya.meta.json'), target_meta.to_json
+    allow(Mamiya::Script).to receive(:new).and_return(script)
+
+    allow(script).to receive(:load!).with(release_path.realpath.join('.mamiya.script', 'script.rb')).and_return(script)
+    allow(script).to receive(:set).and_return(script)
+  end
+
+  describe "#run!" do
+    it "calls hooks with proper order" do
+      hooks = %i(before_switch release after_switch)
+
+      flags = []
+      hooks.each do |sym|
+        allow(script).to receive(sym).and_return(proc { flags << sym })
+      end
+
+      expect { step.run! }.
+        to change { flags }.
+        from([]).
+        to(hooks)
+    end
+
+    it "calls after hook even if exception occured" do
+      e = Exception.new("Good bye, the cruel world")
+      allow(script).to receive(:release).and_return(proc { raise e })
+
+      received = nil
+      allow(script).to receive(:after_switch).and_return(proc { |_| received = _ })
+
+      expect {
+        begin
+          step.run!
+        rescue Exception; end
+      }.
+        to change { received }.
+        from(nil).to(e)
+    end
+
+    it "calls hook in :target (pwd)" do
+      pwd = nil
+      script.stub(release: proc { pwd = Dir.pwd })
+
+      expect {
+        step.run!
+      }.not_to change { Dir.pwd }
+
+      expect(File.realpath(pwd)).to eq release_path.realpath.to_s
+    end
+
+    it "sets release_path" do
+      expect(script).to receive(:set).with(:release_path, release_path.realpath)
+      expect(script).to receive(:set).with(:logger, step.logger)
+      step.run!
+    end
+
+    it "calls hooks using labels" do
+      allow(script).to receive(:before_switch).with(%i(foo bar)).and_return(proc {})
+      allow(script).to receive(:release).with(%i(foo bar)).and_return(proc {})
+      allow(script).to receive(:after_switch).with(%i(foo bar)).and_return(proc {})
+
+      step.run!
+    end
+
+    it "links current to release_path" do
+      expect {
+        step.run!
+      }.to change {
+        current_path.exist? ? current_path.realpath : nil
+      }.from(nil).to(release_path.realpath)
+    end
+
+    context "when current already exists" do
+      before do
+          current_path.make_symlink('releases/20140515000707')
+      end
+
+      it "links current to release_path" do
+        expect {
+          step.run!
+        }.to change {
+          current_path.exist? ? current_path.realpath : nil
+        }.to(release_path.realpath)
+      end
+    end
+
+    context "with no_release" do
+      let(:options) do
+        {target: release_path, no_release: true}
+      end
+
+      it "doesn't call release" do
+        called = false
+        allow(script).to receive(:release).and_return(proc { called = true })
+        step.run!
+
+        expect(called).to be_false
+      end
+    end
+  end
+end