mamiya 0.0.1.alpha2

data/spec/master/web_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+require 'mamiya/storages/mock'
+require 'mamiya/package'
+
+require 'mamiya/master/web'
+
+describe Mamiya::Master::Web do
+  include Rack::Test::Methods
+
+  let!(:tmpdir) { Dir.mktmpdir('maimya-master-web-spec') }
+  after { FileUtils.remove_entry_secure(tmpdir) }
+
+  let(:app) { described_class }
+
+  let(:config_source) do
+    {}
+  end
+
+  let(:config) do
+    double('config').tap do |c|
+      allow(c).to receive(:[]) do |k|
+        config_source[k]
+      end
+    end
+  end
+
+  let(:master) do
+    double('master', config: config).tap do |m|
+      allow(m).to receive(:storage) do |app|
+        Mamiya::Storages::Mock.new(application: app)
+      end
+    end
+  end
+
+  let(:package) do
+    File.write File.join(tmpdir, 'mypackage.tar.gz'), "\n"
+    File.write File.join(tmpdir, 'mypackage.json'), "#{{meta: 'data'}.to_json}\n"
+    Mamiya::Package.new(File.join(tmpdir, 'mypackage'))
+  end
+
+  before do
+    described_class.set :environment, :test
+
+    current_session.envs["rack.logger"] = Mamiya::Logger.new
+    current_session.envs["mamiya.master"] = master
+
+    Mamiya::Storages::Mock.new(application: 'myapp').push(package)
+  end
+
+  describe "GET /" do
+    it "returns text" do
+      get '/'
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to match(/^mamiya/)
+    end
+  end
+
+  describe "GET /packages/:application" do
+    it "returns package list" do
+      get '/packages/myapp'
+
+      expect(last_response.status).to eq 200
+      expect(last_response.content_type).to eq 'application/json'
+      json = JSON.parse(last_response.body)
+      expect(json['packages']).to eq ['mypackage']
+    end
+
+    it "returns empty list with 204 for inexistence app" do
+      get '/packages/noapp'
+
+      expect(last_response.status).to eq 404
+      expect(last_response.content_type).to eq 'application/json'
+      json = JSON.parse(last_response.body)
+      expect(json['packages']).to eq []
+    end
+  end
+
+  describe "GET /packages/:application/:package" do
+    it "returns package detail" do
+      get '/packages/myapp/mypackage'
+
+      expect(last_response.status).to eq 200
+      expect(last_response.content_type).to eq 'application/json'
+      json = JSON.parse(last_response.body)
+      expect(json['application']).to eq 'myapp'
+      expect(json['name']).to eq 'mypackage'
+      expect(json['meta']).to eq('meta' => 'data')
+    end
+
+    context "when not exists" do
+      it "returns 404" do
+        get '/packages/myapp/mypkg'
+
+        expect(last_response.status).to eq 404
+        expect(last_response.content_type).to eq 'application/json'
+        expect(JSON.parse(last_response.body)).to eq({})
+      end
+    end
+  end
+
+  describe "POST /packages/:application/:package/distribute" do
+    it "dispatchs distribute request" do
+      expect(master).to receive(:distribute).with('myapp', 'mypackage')
+
+      post '/packages/myapp/mypackage/distribute'
+
+      expect(last_response.status).to eq 204 # no content
+    end
+
+    context "when package not found" do
+      it "returns 404" do
+        post '/packages/myapp/noexist/distribute'
+        expect(last_response.status).to eq 404
+      end
+    end
+  end
+end

data/spec/master_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+require 'json'
+require 'villein/event'
+
+require 'mamiya/agent'
+require 'mamiya/storages/mock'
+
+require 'mamiya/master/agent_monitor'
+require 'mamiya/master'
+
+require_relative './support/dummy_serf.rb'
+
+describe Mamiya::Master do
+  let(:serf) { DummySerf.new }
+  let(:agent_monitor) { double('agent_monitor', start!: nil) }
+
+  let(:config) do
+    {
+      serf: {agent: {rpc_addr: '127.0.0.1:17373', bind: '127.0.0.1:17946'}},
+      web: {port: 0, bind: 'localhost'},
+      storage: {type: :mock},
+    }
+  end
+
+  before do
+    allow(Villein::Agent).to receive(:new).and_return(serf)
+    allow(Mamiya::Master::AgentMonitor).to receive(:new).and_return(agent_monitor)
+  end
+
+  subject(:master) { described_class.new(config) }
+
+  it "inherits Mamiya::Agent" do
+    expect(described_class.superclass).to eq Mamiya::Agent
+  end
+
+  describe "#distribute" do
+    # let!(:tmpdir) { Dir.mktmpdir('maimya-master-spec') }
+    # after { FileUtils.remove_entry_secure(tmpdir) }
+
+    # let(:package) do
+    #   File.write File.join(tmpdir, 'mypackage.tar.gz'), "\n"
+    #   File.write File.join(tmpdir, 'mypackage.json'), "#{{meta: 'data'}.to_json}\n"
+    #   Mamiya::Package.new(File.join(tmpdir, 'mypackage'))
+    # end
+
+    # before do
+    #   Mamiya::Storages::Mock.new(application: 'myapp').push(package)
+    # end
+
+    it "triggers fetch event" do
+      expect(master).to receive(:trigger).with(:fetch, application: 'myapp', package: 'mypackage')
+
+      master.distribute('myapp', 'mypackage')
+    end
+  end
+
+  it "starts agent monitor"
+
+  describe "(member join event)" do
+    it "initiates refresh" do
+      master # initiate
+
+      expect(agent_monitor).to receive(:refresh).with(node: ['the-node', 'another-node'])
+
+      serf.trigger("member_join", Villein::Event.new(
+        {"SERF_EVENT" => "member-join"},
+        payload: "the-node\tX.X.X.X\t\tkey=val,a=b\nanother-node\tY.Y.Y.Y\t\tkey=val,a=b\n"
+      ))
+    end
+  end
+
+  describe "#run!" do
+    it "starts serf and web" do
+      begin
+        flag = false
+
+        expect_any_instance_of(Rack::Server).to receive(:start)
+        expect(serf).to receive(:start!)
+        expect(serf).to receive(:auto_stop) do
+          flag = true
+        end
+
+        th = Thread.new { master.run! }
+        th.abort_on_exception = true
+
+        10.times { break if flag; sleep 0.1 }
+      ensure
+        th.kill if th && th.alive?
+      end
+    end
+  end
+end

data/spec/package_spec.rb

@@ -0,0 +1,394 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+require 'digest/sha2'
+require 'json'
+
+require 'mamiya/package'
+
+describe Mamiya::Package do
+  let!(:tmpdir) { Dir.mktmpdir("mamiya-package-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:build_dir)   { Pathname.new(tmpdir).join('build') }
+  let(:extract_dir) { Pathname.new(tmpdir).join('extract') }
+  before do
+    build_dir.mkdir
+    extract_dir.mkdir
+  end
+
+  let(:package_path) { File.join(tmpdir, 'test.tar.gz') }
+  let(:meta_path)    { package_path.sub(/tar\.gz$/, "json") }
+
+  let(:arg) { package_path }
+
+  subject(:package) {
+    Mamiya::Package.new(arg)
+  }
+
+  describe "#initialize" do
+    context "without file extension" do
+      it "accepts" do
+        expect { described_class.new('foo') }.not_to raise_error
+      end
+    end
+
+    context "with .tar.gz" do
+      it "accepts" do
+        expect { described_class.new('foo.tar.gz') }.not_to raise_error
+      end
+    end
+
+    context "with .json" do
+      it "accepts" do
+        expect { described_class.new('foo.json') }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#path" do
+    subject { package.path }
+    it { should eq Pathname.new(package_path) }
+
+    context "without file extension" do
+      let(:arg) { 'test' }
+      it { should eq Pathname.new('test.tar.gz') }
+    end
+
+    context "with .tar.gz" do
+      let(:arg) { 'test.tar.gz' }
+      it { should eq Pathname.new('test.tar.gz') }
+    end
+
+    context "with .json" do
+      let(:arg) { 'test.json' }
+      it { should eq Pathname.new('test.tar.gz') }
+    end
+
+    context "with filename containing dot" do
+      let(:arg) { 'a.b' }
+      it { should eq Pathname.new('a.b.tar.gz') }
+    end
+  end
+
+  describe "#meta_path" do
+    subject { package.meta_path }
+
+    context "without file extension" do
+      let(:arg) { 'test' }
+      it { should eq Pathname.new('test.json') }
+    end
+
+    context "with .tar.gz" do
+      let(:arg) { 'test.tar.gz' }
+      it { should eq Pathname.new('test.json') }
+    end
+
+    context "with .json" do
+      let(:arg) { 'test.json' }
+      it { should eq Pathname.new('test.json') }
+    end
+
+    context "with filename containing dot" do
+      let(:arg) { 'a.b' }
+      it { should eq Pathname.new('a.b.json') }
+    end
+  end
+
+  describe "#extract_onto!(path)" do
+    subject { package.extract_onto!(extract_dir) }
+
+    context "with package" do
+      before do
+        File.write build_dir.join("greeting"), "hello\n"
+        Dir.chdir(build_dir) {
+          system "tar", "cjf", package_path, '.'
+        }
+      end
+
+      context "when directory exists" do
+        it "extracts onto specified directory" do
+          expect {
+            package.extract_onto!(extract_dir)
+          }.to change {
+            extract_dir.join('greeting').exist?
+          }.from(false).to(true)
+
+          expect(extract_dir.join('greeting').read).to eq "hello\n"
+        end
+      end
+
+      context "when directory not exists" do
+        before do
+          FileUtils.remove_entry_secure extract_dir
+        end
+
+        it "creates directory" do
+          expect {
+            package.extract_onto!(extract_dir)
+          }.to change {
+            extract_dir.exist?
+          }.from(false).to(true)
+
+          expect(extract_dir.join('greeting').read).to eq "hello\n"
+        end
+      end
+    end
+
+    context "without package" do
+      it "raises error" do
+        expect {
+          package.extract_onto!(extract_dir)
+        }.to raise_error(Mamiya::Package::NotExists)
+      end
+    end
+  end
+
+  describe "#valid?" do
+    subject { package.valid? }
+
+    it "verifies signature"
+
+    context "when checksum is correct" do
+      before do
+        File.write(package_path, "test\n")
+        File.write(meta_path, {"checksum" => Digest::SHA2.hexdigest("test\n")}.to_json + "\n")
+      end
+
+      it { should be_true }
+    end
+
+    context "when checksum is incorrect" do
+      before do
+        File.write(package_path, "wrong\n")
+        File.write(meta_path, {"checksum" => Digest::SHA2.hexdigest("text\n")}.to_json + "\n")
+      end
+
+      it { should be_false }
+    end
+
+    context "when package not exists" do
+      it "raises error" do
+        expect { subject }.to raise_error(Mamiya::Package::NotExists)
+      end
+    end
+
+    context "when package meta json not exists" do
+      before do
+        File.write package_path, "\n"
+      end
+
+      it "raises error" do
+        expect { subject }.to raise_error(Mamiya::Package::NotExists)
+      end
+    end
+  end
+
+  describe "#name" do
+    subject { package.name }
+
+    it { should eq 'test' }
+
+    context "when meta['name'] exists" do
+      before do
+        package.meta['name'] = 'pack'
+      end
+
+      it { should eq 'pack' }
+    end
+  end
+
+  describe "#application" do
+    subject { package.application }
+
+    it { should eq nil }
+
+    context "when meta['application'] exists" do
+      before do
+        package.meta['application'] = 'app'
+      end
+
+      it { should eq 'app' }
+    end
+  end
+
+  describe "#checksum" do
+    subject { package.checksum }
+
+    it { should be_nil }
+
+    context "when package exists" do
+      before do
+        File.write package_path, "text\n"
+      end
+
+      it { should eq Digest::SHA2.hexdigest("text\n") }
+    end
+  end
+
+  describe "#exists?" do
+    subject { package.exists? }
+
+    context "when package exists" do
+      before do
+        File.write package_path, ''
+      end
+
+      it { should be_true }
+    end
+
+    context "when package not exists" do
+      before do
+        File.unlink(package_path) if File.exists?(package_path)
+      end
+
+      it { should be_false }
+    end
+  end
+
+  describe "#sign!" do
+    it "signs package"
+  end
+
+  describe "#build!(build_dir)" do
+    let(:dereference_symlinks) { nil }
+    let(:exclude_from_package) { nil }
+    let(:package_under) { nil }
+
+    let(:build) {
+      kwargs = {}
+      kwargs[:dereference_symlinks] = dereference_symlinks unless dereference_symlinks.nil?
+      kwargs[:exclude_from_package] = exclude_from_package unless exclude_from_package.nil?
+      kwargs[:package_under] = package_under unless package_under.nil?
+      package.build!(
+        build_dir,
+        **kwargs
+      )
+    }
+
+    before do
+      File.write(build_dir.join('greeting'), 'hello')
+    end
+
+    def build_then_extract!
+      build
+
+      expect(Pathname.new(package_path)).not_to be_nil
+
+      system "tar", "xf", package_path, "-C", extract_dir.to_s
+    end
+
+    it "creates a package to path" do
+      expect {
+        build
+      }.to change {
+        File.exist? package_path
+      }.from(false).to(true)
+    end
+
+    it "includes file in build_dir" do
+      build_then_extract!
+      expect(extract_dir.join('greeting').read).to eq 'hello'
+    end
+
+    it "excludes SCM directories" do
+      build_dir.join('.git').mkdir
+      File.write build_dir.join('.git', 'test'), "test\n"
+      build_then_extract!
+
+      expect(extract_dir.join('.git')).not_to be_exist
+    end
+
+    it "includes deploy script itself"
+
+    it "saves meta file" do
+      package.meta = {"a" => 1, "b" => {"c" => ["d", "e"]}}
+      packed_meta = package.meta.dup
+
+      build_then_extract!
+
+      expect(package.meta["checksum"]).to eq Digest::SHA2.file(package_path).hexdigest
+
+      meta_path_in_build = extract_dir.join('.mamiya.meta.json')
+      packed_meta['name'] = package.meta['name']
+      json = JSON.parse(File.read(meta_path_in_build))
+      expect(json).to eq JSON.parse(packed_meta.to_json)
+
+      json = JSON.parse(File.read(meta_path))
+      expect(json).to eq JSON.parse(package.meta.to_json)
+    end
+
+    it "doesn't leave meta file in build_dir" do
+      package.meta = {"a" => 1, "b" => {"c" => ["d", "e"]}}
+      build
+
+      expect(build_dir.join('.mamiya.meta.json')).not_to be_exist
+    end
+
+    context "with exclude_from_package option" do
+      let(:exclude_from_package) { ['foo', 'hoge*'] }
+
+      before do
+        File.write build_dir.join('foo'), "test\n"
+        File.write build_dir.join('hogefuga'), "test\n"
+
+        build_then_extract!
+      end
+
+      it "excludes matched files from package" do
+        expect(extract_dir.join('foo')).not_to be_exist
+        expect(extract_dir.join('hogefuga')).not_to be_exist
+
+        expect(extract_dir.join('greeting').read).to eq 'hello'
+      end
+    end
+
+    context "with package_under option" do
+      let(:package_under) { 'dir' }
+
+      before do
+        build_dir.join('dir').mkdir
+
+        File.write build_dir.join('root'), "shouldnt-be-included\n"
+        File.write build_dir.join('dir', 'greeting'), "hola\n"
+
+        build_then_extract!
+      end
+
+      it "packages under specified directory" do
+        expect(extract_dir.join('root')).not_to be_exist
+        expect(extract_dir.join('greeting').read).to eq "hola\n"
+      end
+    end
+
+    context "with dereference_symlinks option" do
+      before do
+        File.write build_dir.join('target'), "I am target\n"
+        build_dir.join('alias').make_symlink('target')
+
+        build_then_extract!
+      end
+
+      context "when the option is true" do
+        let(:dereference_symlinks) { true }
+
+        it "dereferences symlinks for package" do
+          expect(extract_dir.join('alias')).to be_exist
+          expect(extract_dir.join('alias')).not_to be_symlink
+          expect(extract_dir.join('alias').read).to eq "I am target\n"
+        end
+      end
+
+      context "when the option is false" do
+        let(:dereference_symlinks) { false }
+
+        it "doesn't dereference symlinks" do
+          expect(extract_dir.join('alias')).to be_exist
+          expect(extract_dir.join('alias')).to be_symlink
+          realpath = extract_dir.join('alias').realpath.relative_path_from(extract_dir.realpath).to_s
+          expect(realpath).to eq 'target'
+        end
+      end
+    end
+  end
+end