mamiya 0.0.1.alpha2

data/spec/steps/fetch_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+require 'json'
+
+require 'mamiya/package'
+require 'mamiya/storages/mock'
+
+require 'mamiya/steps/fetch'
+
+describe Mamiya::Steps::Fetch do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-fetch-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:package_dir)     { Pathname.new(tmpdir).join('pkg').tap(&:mkdir) }
+  let(:destination_dir) { Pathname.new(tmpdir).join('dst').tap(&:mkdir) }
+
+  let(:package_name) { 'test' }
+  let(:package_path) { package_dir.join("#{package_name}.tar.gz") }
+
+  let(:package2_name) { 'test2' }
+  let(:package2_path) { package_dir.join("#{package2_name}.tar.gz") }
+
+
+  let(:script) do
+    double('script',
+      application: 'another',
+    )
+  end
+
+  let(:config_source) do
+    { storage: {} }
+  end
+
+  let(:config) do
+    double('config',
+      storage_class: Mamiya::Storages::Mock
+    ).tap do |_|
+      allow(_).to receive(:[]) do |k|
+        config_source[k]
+      end
+    end
+  end
+
+  let(:options) do
+    {package: package_name, application: 'app', destination: destination_dir.to_s}
+  end
+
+  subject(:fetch_step) { described_class.new(script: script, config: config, **options) }
+
+  describe "#run!" do
+    before do
+      File.write package_path, "\n"
+      File.write(package_path.to_s.gsub(/\.tar\.gz$/,'.json'),
+                 {'name' => 'test', 'application' => 'app'}.to_json)
+
+      File.write package2_path, "\n"
+      File.write(package2_path.to_s.gsub(/\.tar\.gz$/,'.json'),
+                 {'name' => 'test2', 'application' => 'another'}.to_json)
+
+
+      Mamiya::Storages::Mock.new(application: 'app').push(
+        Mamiya::Package.new(package_path))
+      Mamiya::Storages::Mock.new(application: 'another').push(
+        Mamiya::Package.new(package2_path))
+    end
+
+    it "fetches package from storage" do
+      fetch_step.run!
+      expect(destination_dir.join("#{package_name}.tar.gz")).to be_exist
+    end
+
+    context "when options[:application] is nil" do
+      let(:options) do
+        {package: package2_name, destination: destination_dir.to_s}
+      end
+
+      it "takes application name from script if available" do
+        fetch_step.run!
+        expect(destination_dir.join("#{package2_name}.tar.gz")).to be_exist
+        expect(destination_dir.join("#{package_name}.tar.gz")).not_to be_exist
+
+        expect(JSON.parse(destination_dir.join("#{package2_name}.json").read)['application']).to eq 'another'
+      end
+    end
+
+    context "with verify option" do
+      it "verifies "
+    end
+
+    context "when package not exists" do
+      it "-"
+    end
+  end
+end

data/spec/steps/push_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'fileutils'
+
+require 'mamiya/package'
+require 'mamiya/storages/mock'
+
+require 'mamiya/steps/push'
+
+describe Mamiya::Steps::Push do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-steps-build-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:package_dir) { Pathname.new(tmpdir).join('pkg').tap(&:mkdir) }
+
+  let(:target_package) { package_dir.join('test.tar.gz').to_s }
+  let(:script) do
+    double('script',
+      application: 'myapp',
+    )
+  end
+
+  let(:config_source) do
+    {
+      storage: {
+      }
+    }
+  end
+  let(:config) do
+    double('config',
+      storage_class: Mamiya::Storages::Mock
+    ).tap do |_|
+      allow(_).to receive(:[]) do |k|
+        config_source[k]
+      end
+    end
+  end
+
+  let(:options) do
+    {package: target_package}
+  end
+
+  subject(:push_step) { described_class.new(script: script, config: config, **options) }
+
+  describe "#run!" do
+    let(:package_application) do
+      # to confirm Push step uses package's application name
+      'app'
+    end
+
+    before do
+      File.write target_package, "\n"
+      File.write target_package.gsub(/\.tar\.gz$/,'.json'), "{}\n"
+
+      allow_any_instance_of(Mamiya::Package).to receive(:application).and_return(package_application)
+    end
+
+    it "pushes package to storage" do
+      push_step.run!
+      expect(Mamiya::Storages::Mock.storage['app']['test']).not_to be_nil
+    end
+
+    context "with application option" do
+      let(:options) { {package: target_package, application: 'newapp'} }
+
+      it "pushes package to storage for given application name" do
+        push_step.run!
+        expect(Mamiya::Storages::Mock.storage['newapp']['test']).not_to be_nil
+      end
+    end
+  end
+end

data/spec/storages/abstract_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require 'mamiya/storages/abstract'
+
+describe Mamiya::Storages::Abstract do
+  subject(:storage) { described_class.new }
+
+  describe "#prune(nums_to_keep)" do
+    before do
+      allow(storage).to receive(:packages).and_return(%w(1 2 3 4 5 6 7))
+    end
+
+    it "discards old releases" do
+      expect(storage).to receive(:remove).with('1')
+      expect(storage).to receive(:remove).with('2')
+      expect(storage).to receive(:remove).with('3')
+      expect(storage).to receive(:remove).with('4')
+
+      storage.prune(3)
+    end
+  end
+end

data/spec/storages/s3_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+require 'aws-sdk-core'
+require 'mamiya/package'
+require 'mamiya/storages/abstract'
+require 'mamiya/storages/s3'
+require 'tmpdir'
+require 'fileutils'
+require 'stringio'
+
+describe Mamiya::Storages::S3 do
+  before(:suite) do
+    %w(AWS_ACCESS_KEY AWS_ACCESS_KEY_ID AMAZON_ACCESS_KEY_ID
+       AWS_SECRET_KEY AWS_SECRET_ACCESS_KEY AMAZON_SECRET_ACCESS_KEY
+       AWS_SESSION_TOKEN AMAZON_SESSION_TOKEN).each do |key|
+      ENV.delete key
+    end
+  end
+
+  let(:bucket) { 'testbucket' }
+  let(:config) do
+    {
+      application: 'myapp',
+      bucket: bucket,
+      foo: :bar,
+      access_key_id: 'AKI',
+      secret_access_key: 'secret',
+      region: 'ap-northeast-1'
+    }
+  end
+  subject(:storage) { described_class.new(config) }
+
+  let(:s3) do
+    double('s3',
+      put_object: nil,
+      head_object: nil,
+      list_objects: nil,
+      delete_objects: nil
+    )
+  end
+
+  before do
+    allow(Aws::S3).to receive(:new).with(foo: :bar, access_key_id: 'AKI', secret_access_key: 'secret', region: 'ap-northeast-1').and_return(s3)
+  end
+
+  describe "#push(package)" do
+    let!(:tmpdir) { Dir.mktmpdir("mamiya-package-spec") }
+    let(:tarball) { File.join(tmpdir, 'test.tar.gz') }
+    let(:metafile) { File.join(tmpdir, 'test.json') }
+    before do
+      File.write tarball, "aaaaa\n"
+      File.write File.join(tmpdir, 'test.json'), "{}\n"
+    end
+    after { FileUtils.remove_entry_secure tmpdir }
+
+    let(:package) { double('package', :kind_of? => true, :exists? => true, path: tarball, meta_path: metafile, name: 'test') }
+
+    it "uploads package to S3" do
+      allow(s3).to receive(:head_object).and_raise(Aws::S3::Errors::NotFound.new(nil, ''))
+
+      expect(s3).to receive(:put_object) do |options|
+        expect(options[:bucket]).to eq 'testbucket'
+        expect(options[:key]).to eq "myapp/test.tar.gz"
+        expect(options[:body]).to be_a_kind_of(File)
+        expect(options[:body].path).to eq tarball
+      end
+
+      expect(s3).to receive(:put_object) do |options|
+        expect(options[:bucket]).to eq 'testbucket'
+        expect(options[:key]).to eq "myapp/test.json"
+        expect(options[:body]).to be_a_kind_of(File)
+        expect(options[:body].path).to eq metafile
+      end
+
+      storage.push package
+    end
+
+    context "when not built" do
+      before do
+        package.stub(:exists? => false)
+      end
+
+      it "raises error" do
+        expect {
+          storage.push(package)
+        }.to raise_error(Mamiya::Storages::Abstract::NotBuilt)
+      end
+    end
+
+    context "when already uploaded" do
+      it "raises error" do
+        allow(s3).to receive(:head_object).with(bucket: 'testbucket', key: 'myapp/test.tar.gz').and_return(double('response'))
+
+        expect {
+          storage.push(package)
+        }.to raise_error(Mamiya::Storages::Abstract::AlreadyExists)
+      end
+    end
+  end
+
+  describe "#fetch(package_name, dir)" do
+    let!(:tmpdir) { Dir.mktmpdir("mamiya-package-spec") }
+    after { FileUtils.remove_entry_secure tmpdir }
+
+    let(:tarball) { File.join(tmpdir, 'test.tar.gz') }
+    let(:metafile) { File.join(tmpdir, 'test.json') }
+
+    let(:package_name) { 'test' }
+    subject(:fetch) { storage.fetch(package_name, tmpdir) }
+
+    it "retrieves package from S3" do
+      requests = []
+      expect(s3).to receive(:get_object).twice do |options, send_options|
+        requests << [options, send_options]
+        if options[:key] && send_options[:target] &&
+           options[:key].end_with?('.json') && send_options[:target].kind_of?(IO)
+          expect(send_options[:target]).to be_binmode
+          send_options[:target].puts "{}"
+        end
+      end
+
+      fetch
+
+      options, send_options = requests.shift
+      expect(options[:bucket]).to eq 'testbucket'
+      expect(options[:key]).to eq "myapp/test.tar.gz"
+      expect(send_options[:target]).to be_a_kind_of(File)
+      expect(send_options[:target].path).to eq tarball
+
+      options, send_options = requests.shift
+      expect(options[:bucket]).to eq 'testbucket'
+      expect(options[:key]).to eq "myapp/test.json"
+      expect(send_options[:target]).to be_a_kind_of(File)
+      expect(send_options[:target].path).to eq metafile
+    end
+
+    it "returns Mamiya::Package" do
+      allow(s3).to receive(:get_object) do
+        File.write metafile, "{}\n"
+      end
+
+      expect(fetch).to be_a_kind_of(Mamiya::Package)
+      expect(File.realpath(fetch.path)).to eq File.realpath(tarball)
+    end
+
+    context "when not found" do
+      before do
+        allow(s3).to receive(:get_object).and_raise(Aws::S3::Errors::NoSuchKey.new(nil, ''))
+      end
+
+      it "raises error" do
+        expect {
+          fetch
+        }.to raise_error(Mamiya::Storages::Abstract::NotFound)
+      end
+    end
+
+    context "when meta already exists" do
+      before do
+        File.write metafile, "\n"
+      end
+
+      it "raises error" do
+        expect {
+          fetch
+        }.to raise_error(Mamiya::Storages::Abstract::AlreadyFetched)
+      end
+    end
+
+    context "when tarball already exists" do
+      before do
+        File.write tarball, "\n"
+      end
+
+      it "raises error" do
+        expect {
+          fetch
+        }.to raise_error(Mamiya::Storages::Abstract::AlreadyFetched)
+      end
+    end
+
+    context "when name has .json" do
+      let(:package_name) { 'test.json' }
+
+      it "retrieves package" do
+        expect(s3).to receive(:get_object).with(
+          hash_including(bucket: 'testbucket', key: 'myapp/test.tar.gz'), hash_including(target: an_instance_of(File)))
+        expect(s3).to receive(:get_object).with(
+          hash_including(bucket: 'testbucket', key: 'myapp/test.json'), hash_including(target: an_instance_of(File))) do
+          File.write metafile, "{}\n"
+        end
+
+        fetch
+      end
+    end
+
+    context "when name has .tar.gz" do
+      let(:package_name) { 'test.tar.gz' }
+
+      it "retrieves package" do
+        expect(s3).to receive(:get_object).with(
+          hash_including(bucket: 'testbucket', key: 'myapp/test.tar.gz'), hash_including(target: an_instance_of(File)))
+        expect(s3).to receive(:get_object).with(
+          hash_including(bucket: 'testbucket', key: 'myapp/test.json'), hash_including(target: an_instance_of(File))) do
+          File.write metafile, "{}\n"
+        end
+
+        fetch
+      end
+    end
+  end
+
+  describe "#meta(package_name)" do
+    let(:package_name) { 'test' }
+    subject(:meta) { storage.meta(package_name) }
+
+    before do
+      allow(s3).to receive(:get_object).with(bucket: 'testbucket', key: 'myapp/test.json').and_return(
+        double("response", body: StringIO.new({"foo" => "bar"}.to_json, "r").tap(&:read))
+      )
+    end
+
+    it "retrieves meta JSON from S3" do
+      expect(meta).to eq("foo" => "bar")
+    end
+
+    context "when not found" do
+      before do
+        allow(s3).to receive(:get_object).and_raise(Aws::S3::Errors::NoSuchKey.new(nil, ''))
+      end
+
+      it "returns nil" do
+        expect(meta).to be_nil
+      end
+    end
+
+    context "when name has .json" do
+      let(:package_name) { 'test.json' }
+
+      it "retrieves meta JSON from S3" do
+        expect(meta).to eq("foo" => "bar")
+      end
+    end
+
+    context "when name has .tar.gz" do
+      let(:package_name) { 'test.tar.gz' }
+
+      it "retrieves meta JSON from S3" do
+        expect(meta).to eq("foo" => "bar")
+      end
+    end
+  end
+
+  describe "#remove(package_name)" do
+    let(:package_name) { 'test' }
+    subject(:remove) { storage.remove(package_name) }
+
+    before do
+      allow(s3).to receive(:head_object).and_return(double('response'))
+    end
+
+    it "removes specified package from S3" do
+      expect(s3).to receive(:delete_objects).with(bucket: 'testbucket', objects: [{key: 'myapp/test.tar.gz'}, {key: 'myapp/test.json'}])
+      remove
+    end
+
+    context "with name has .tar.gz" do
+      let(:package_name) { 'test.tar.gz' }
+
+      it "removes specified package from S3" do
+        expect(s3).to receive(:delete_objects).with(bucket: 'testbucket', objects: [{key: 'myapp/test.tar.gz'}, {key: 'myapp/test.json'}])
+        remove
+      end
+    end
+
+    context "with name has .json" do
+      let(:package_name) { 'test.json' }
+
+      it "removes specified package from S3" do
+        expect(s3).to receive(:delete_objects).with(bucket: 'testbucket', objects: [{key: 'myapp/test.tar.gz'}, {key: 'myapp/test.json'}])
+        remove
+      end
+    end
+
+    context "when not found" do
+      before do
+        allow(s3).to receive(:head_object).and_raise(Aws::S3::Errors::NotFound.new(nil, ''))
+      end
+
+      it "raises error" do
+        expect { storage.remove('test') }.to raise_error(Mamiya::Storages::Abstract::NotFound)
+      end
+    end
+  end
+
+  describe ".find" do
+    before do
+      allow(s3).to receive(:list_objects).with(bucket: 'testbucket', delimiter: '/') \
+        .and_return(
+          double("object list",
+                 common_prefixes: [
+                   double("prefix1", prefix: 'myapp'),
+                   double("prefix2", prefix: 'testapp')
+                 ]
+                )
+        )
+    end
+
+    subject(:applications) { described_class.find(config.dup.tap{|_| _.delete(:application) }) }
+
+    it "lists applications in S3" do
+      expect(applications).to be_a_kind_of(Hash)
+      expect(applications['myapp']).to be_a_kind_of(described_class)
+      expect(applications['myapp'].application).to eq 'myapp'
+      expect(applications['testapp']).to be_a_kind_of(described_class)
+      expect(applications['testapp'].application).to eq 'testapp'
+    end
+  end
+
+  describe "#packages" do
+    before do
+      allow(s3).to receive(:list_objects).with(bucket: 'testbucket', delimiter: '/', prefix: 'myapp/') \
+        .and_return(
+          double("object list",
+                 contents: [
+                   double("obj1.1", key: 'myapp/1.tar.gz'),
+                   double("obj1.2", key: 'myapp/1.json'),
+                   double("obj2.1", key: 'myapp/2.tar.gz'),
+                   double("obj2.2", key: 'myapp/2.json'),
+                   double("obj3.2", key: 'myapp/3.json'),
+                   double("obj4.1", key: 'myapp/4.tar.gz'),
+                 ]
+                )
+        )
+    end
+
+    subject(:packages) { storage.packages }
+
+    it "lists packages in S3" do
+      expect(packages).to eq ['1', '2']
+    end
+  end
+end