mamiya 0.0.1.alpha2

data/spec/script_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'tmpdir'
+
+require 'mamiya/script'
+require 'mamiya/dsl'
+
+describe Mamiya::Script do
+  it "inherits Mamiya::DSL" do
+    expect(described_class.ancestors).to include(Mamiya::DSL)
+  end
+
+  subject(:script) { described_class.new }
+  let(:log) { [] }
+
+  let(:logger) {
+    double("logger").tap do |_|
+      _.stub(:[]) { _ }
+      %i(info warn debug).each do |severity|
+        _.stub(severity) { |*args| log << [severity, *args]; _ }
+      end
+    end
+  }
+
+  before do
+    script.set :logger, logger
+  end
+
+  describe "#run" do
+    it "runs command" do
+      tmpdir = Dir.mktmpdir('akane-script-spec')
+      testee = File.join(tmpdir, 'test')
+
+      expect {
+        script.run("touch", testee)
+      } \
+        .to change { File.exists?(testee) } \
+        .from(false).to(true)
+    end
+
+    context "when the command failed" do
+      it "raises error" do
+        expect {
+          script.run("false")
+        }.to raise_error(Mamiya::Script::CommandFailed)
+      end
+
+      context "with allow_failure" do
+        it "ignores error" do
+          expect {
+            script.run("false", allow_failure: true)
+          }.not_to raise_error
+        end
+      end
+    end
+
+
+    it "logs command as information" do
+      script.run("echo", "foo", "bar'", " baz")
+      expect(log).to include([:info, "$ echo foo bar\\' \\ baz"])
+    end
+
+    it "logs stdout as debug" do
+      script.run("echo", "foo")
+      expect(log).to include([:debug, "foo"])
+    end
+
+    it "logs stderr as warn" do
+      script.run("ruby", "-e", "warn 'bar'")
+      expect(log).to include([:warn, "bar"])
+    end
+
+    it "returns captured output as String" do
+      out = script.run("ruby", "-e", "puts 'foo'; warn 'bar'")
+      expect(out).to match(/^foo$/)
+      expect(out).to match(/^bar$/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'rack/test'
+require 'mamiya/storages/mock'
+require 'mamiya/logger'
+
+module Rack
+  module Test
+    class Session
+      def envs
+        @envs ||= {}
+      end
+
+      alias_method :default_env_orig, :default_env
+      def default_env
+        default_env_orig.merge(envs)
+      end
+    end
+  end
+end
+
+unless ENV["ENABLE_LOG"]
+  Mamiya::Logger.defaults[:outputs] = []
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.after(:each) do
+    Mamiya::Storages::Mock.clear
+  end
+end

data/spec/steps/build_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+
+require 'mamiya/package'
+
+require 'mamiya/steps/build'
+
+describe Mamiya::Steps::Build do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-build-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  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(:exclude_from_package) { [] }
+  let(:package_under) { nil }
+  let(:dereference_symlinks) { false }
+  let(:skip_prepare_build) { false }
+
+  let(:package_name) { nil }
+  let(:script) do
+    double('script',
+      application: 'app',
+      build_from: build_dir,
+      build_to: package_dir,
+      before_build: proc {},
+      prepare_build: proc {},
+      build: proc {},
+      after_build: proc {},
+      package_name: proc { |_| package_name || _ },
+      package_meta: proc { |_| _ },
+      package_under: package_under,
+      dereference_symlinks: dereference_symlinks,
+      exclude_from_package: exclude_from_package,
+      skip_prepare_build: skip_prepare_build,
+    )
+  end
+  
+  subject(:build_step) { described_class.new(script: script) }
+
+  describe "#run!" do
+    before do
+      Dir.mkdir(build_dir)
+      Dir.mkdir(package_dir)
+      Dir.mkdir(extract_dir)
+
+      File.write(build_dir.join('greeting'), 'hello')
+    end
+
+    it "calls hooks with proper order" do
+      hooks = %i(before_build prepare_build build after_build)
+
+      flags = []
+      hooks.each do |sym|
+        allow(script).to receive(sym).and_return(proc { flags << sym })
+      end
+
+      expect { build_step.run! }.
+        to change { flags }.
+        from([]).
+        to(hooks)
+    end
+
+    it "calls after_build hook even if exception occured" do
+      e = Exception.new("Good bye, the cruel world")
+      allow(script).to receive(:build).and_return(proc { raise e })
+
+      received = nil
+      allow(script).to receive(:after_build).and_return(proc { |_| received = _ })
+
+      expect {
+        begin
+          build_step.run!
+        rescue Exception; end
+      }.
+        to change { received }.
+        from(nil).to(e)
+    end
+
+    it "calls build hook in :build_from (pwd)" do
+      pwd = nil
+      script.stub(build: proc { pwd = Dir.pwd })
+
+      expect {
+        build_step.run!
+      }.not_to change { Dir.pwd }
+
+      expect(File.realpath(pwd)).to eq script.build_from.realpath.to_s
+    end
+
+    it "creates package using Package after :build called" do
+      built = false
+      allow(script).to receive(:build).and_return(proc { built = true })
+      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')
+
+      expect_any_instance_of(Mamiya::Package).to \
+        receive(:build!).with(
+            build_dir,
+            hash_including(
+              exclude_from_package: ['test'],
+              dereference_symlinks: true,
+              package_under: 'foo',
+            )
+          ) {
+        expect(built).to be_true
+      }
+
+      build_step.run!
+    end
+
+    it "creates package with metadata including application" do
+      meta = {}
+      allow_any_instance_of(Mamiya::Package).to receive(:meta).and_return(meta)
+      expect_any_instance_of(Mamiya::Package).to receive(:build!) {
+        expect(meta[:application]).to eq 'app'
+      }
+
+      build_step.run!
+    end
+
+    context "with package name determiner" do
+      it "calls package name determiner with current candidate" do
+        received = nil
+        allow(script).to receive(:package_name).and_return(proc { |arg| received = arg })
+
+        build_step.run!
+
+        expect(received).to be_a_kind_of(Array)
+
+        # Default candidates
+        expect(received.size).to eq 2
+        expect(received[0]).to match(/\A\d{4}-\d{2}-\d{2}_\d{2}\.\d{2}\.\d{2}\z/)
+        expect(received[1]).to eq script.application
+      end
+
+      it "uses result by joining with '-' as package name to be built" do
+        allow(script).to receive(:package_name).and_return(proc { |arg| %w(veni vidi vici) })
+
+        build_step.run!
+
+        expect(package_dir.join('veni-vidi-vici.tar.gz')).to be_exist
+      end
+
+      it "calls the determiner in build dir" do
+        pwd = nil
+        allow(script).to receive(:package_name).and_return(proc { |arg| pwd = Dir.pwd; arg })
+
+        expect {
+          build_step.run!
+        }.not_to change { Dir.pwd }
+
+        expect(File.realpath(pwd)).to eq script.build_from.realpath.to_s
+      end
+
+      context "when the determiner returned non-Array" do
+        it "wraps with Array before calling next determiner"
+      end
+    end
+
+    context "with package meta determiner" do
+      it "calls determiners with current candidate" do
+        received = nil
+        allow(script).to receive(:package_meta).and_return(proc { |arg| received = arg })
+
+        build_step.run!
+
+        expect(received).to be_a_kind_of(Hash)
+      end
+
+      it "uses result as package metadata" do
+        meta = {}
+        allow_any_instance_of(Mamiya::Package).to receive(:meta).and_return(meta)
+        allow_any_instance_of(Mamiya::Package).to receive(:build!) { }
+
+        allow(script).to receive(:package_meta).and_return(proc { |arg| {'test' => 'hello'} })
+
+        build_step.run!
+
+        expect(meta['test']).to eq 'hello'
+      end
+
+      it "calls the determiner in build dir" do
+        pwd = nil
+        allow(script).to receive(:package_meta).and_return(proc { |arg| pwd = Dir.pwd; arg })
+
+        expect {
+          build_step.run!
+        }.not_to change { Dir.pwd }
+
+        expect(File.realpath(pwd)).to eq script.build_from.realpath.to_s
+      end
+    end
+
+    context "when build_from directory exist" do
+      it "calls prepare_build with update=true" do
+        arg = nil
+        allow(script).to receive(:prepare_build).and_return(proc { |update| arg = update })
+
+        expect {
+          build_step.run!
+        }.to change { arg }.
+          from(nil).to(true)
+      end
+    end
+
+    context "when build_from directory doesn't exist" do
+      before do
+        FileUtils.remove_entry_secure(build_dir)
+      end
+
+      it "calls prepare_build with update=false" do
+        arg = nil
+        allow(script).to receive(:prepare_build).and_return(proc { |update| arg = update })
+
+        expect {
+          begin
+            build_step.run!
+          rescue Errno::ENOENT; end
+        }.to change { arg }.
+          from(nil).to(false)
+      end
+
+      it "raises error" do
+        expect {
+          build_step.run!
+        }.to raise_error(Errno::ENOENT)
+      end
+    end
+
+
+    context "with skip_prepare_build option" do
+      context "when the option is false" do
+        let(:skip_prepare_build) { false }
+
+        it "calls prepare_build" do
+          flag = false
+          allow(script).to receive(:prepare_build).and_return(proc { flag = true })
+
+          expect { build_step.run! }.to change { flag }.
+            from(false).to(true)
+        end
+      end
+
+      context "when the option is true" do
+        let(:skip_prepare_build) { true }
+
+        it "doesn't call prepare_build" do
+          flag = false
+          allow(script).to receive(:prepare_build).and_return(proc { flag = true })
+
+          expect { build_step.run! }.not_to change { flag }
+        end
+      end
+    end
+  end
+end

data/spec/steps/extract_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+
+require 'mamiya/package'
+require 'mamiya/steps/extract'
+
+describe Mamiya::Steps::Extract do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-extract-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:package_dir) { Pathname.new(tmpdir).join('pkg').tap(&:mkdir) }
+
+  let(:target_package) { package_dir.join('test-package.tar.gz').to_s }
+  let(:script) do
+    double('script',
+      application: 'myapp',
+    )
+  end
+
+  let(:destination) { Pathname.new(tmpdir).join('dst') }
+
+  let(:options) do
+    {
+      package: target_package,
+      destination: destination.to_s,
+    }
+  end
+
+  subject(:extract_step) { described_class.new(script: script, **options) }
+
+  describe "#run!" do
+    before do
+      FileUtils.cp File.join(__dir__, '..', 'fixtures', 'test-package.tar.gz'), target_package
+      File.write target_package.gsub(/\.tar\.gz$/,'.json'), "{}\n"
+    end
+
+    context "when destination exists" do
+      before do
+        destination.mkdir()
+        allow_any_instance_of(Mamiya::Package).to receive(:name).and_return('package-name')
+      end
+
+      it "extracts package on sub-directory named as same as package name" do
+        extract_step.run!
+        expect(destination.join('package-name')).to be_a_directory
+        expect(destination.join('package-name', 'greeting')).to be_exist
+      end
+    end
+
+    context "when destination not exists" do
+      it "extracts package on destination" do
+        extract_step.run!
+        expect(destination).to be_a_directory
+        expect(destination.join('greeting')).to be_exist
+      end
+    end
+
+    context "with verify option" do
+      it "verifies"
+    end
+
+    context "when package not exists" do
+      it "-"
+    end
+  end
+end