mamiya 0.0.1.alpha2

data/spec/config_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'mamiya/storages'
+
+require 'mamiya/config'
+
+describe Mamiya::Config do
+  let(:source) do
+    {
+      "test" => {
+        "a" => ["b" => {"c" => {"d" => "e"}}]
+      },
+      :test2 => :hello
+    }
+  end
+  subject(:config) { described_class.new(source) }
+
+  describe ".load" do
+    let(:fixture_path) { File.join(__dir__, 'fixtures', 'test.yml') }
+
+    subject(:config) { described_class.load(fixture_path) }
+
+    it { should be_a(described_class) }
+
+    it "loads configuration from file" do
+      expect(config[:a][:e]).to eq "f"
+    end
+  end
+
+  it "symbolizes keys" do
+    expect(config[:test][:a][0][:b][:c][:d]).to eq "e"
+    expect(config[:test2]).to eq :hello
+  end
+
+  describe "#storage_class" do
+    let(:source) do
+      {storage: {type: :foobar, conf: :iguration}}
+    end
+    let(:klass) { Class.new }
+
+    before do
+      allow(Mamiya::Storages).to receive(:find).with(:foobar).and_return(klass)
+    end
+
+    subject(:storage_class) { config.storage_class }
+
+    it "finds class using Storages.find" do
+      expect(storage_class).to eq klass
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+require 'mamiya/dsl'
+require 'mamiya/util/label_matcher'
+
+describe Mamiya::DSL do
+  let(:klass) { Class.new(Mamiya::DSL) }
+  subject(:dsl) { klass.new }
+
+  describe ".set_default" do
+    it "sets default" do
+      expect { dsl.testvar }.to raise_error
+      klass.set_default :testvar, 1
+      expect(dsl.testvar).to eq 1
+    end
+  end
+
+  describe ".add_hook" do
+    it "adds hook" do
+      expect { dsl.testhook }.to raise_error
+      klass.add_hook :testhook
+      expect(dsl.testhook).to be_a(Proc)
+    end
+  end
+
+  describe "#evaluate!" do
+    context "with block" do
+      it "evaluates block within its object" do
+        flag = false
+        expect {
+          dsl.evaluate! { flag = true }
+        }.to change { flag }.from(false).to(true)
+      end
+    end
+
+    context "with string" do
+      it "evaluates string within its object" do
+        expect(dsl).to receive(:flag!)
+        dsl.evaluate! "flag!"
+      end
+    end
+  end
+
+  describe "#load!" do
+    before do
+      dsl.set :foo, 42
+    end
+
+    it "loads file" do
+      expect {
+        dsl.load! "#{__dir__}/fixtures/dsl_test_load.rb"
+      }.to change { dsl.foo }.from(42).to(72)
+    end
+  end
+
+  describe "#use" do
+    before do
+      dsl.set :foo, 42
+    end
+
+    it "loads file" do
+      dsl.set :load_path, ["#{__dir__}/fixtures/helpers"]
+      expect {
+        dsl.use :foo
+      }.to change { dsl.foo }.from(42).to(72)
+    end
+
+    context "when file not exists" do
+      it "raises error" do
+        expect {
+          dsl.use :blahblahblah
+        }.to raise_error(Mamiya::DSL::HelperNotFound)
+      end
+    end
+
+    context "with options" do
+      it "passes to file" do
+        dsl.set :load_path, ["#{__dir__}/fixtures/helpers"]
+        expect {
+          dsl.use :foo, value: 100
+        }.to change { dsl.foo }.from(42).to(100)
+      end
+    end
+    
+    context "when loading file" do
+      it "loads file with suitable load path" do
+        expect {
+          dsl.load! "#{__dir__}/fixtures/dsl_test_use.rb"
+        }.to change { dsl.foo }.from(42).to(72)
+      end
+    end
+  end
+
+  describe "#set" do
+    it "sets variable" do
+      expect{ dsl.foo }.to raise_error
+      dsl.set :foo, 100
+      expect(dsl.foo).to eq 100
+      dsl.set :foo, 200
+      expect(dsl.foo).to eq 200
+    end
+  end
+
+  describe "#set_default" do
+    it "sets variable" do
+      dsl.set_default :foo, 100
+      expect(dsl.foo).to eq 100
+    end
+
+    context "when already assigned" do
+      it "doesn't nothing" do
+        dsl.set :foo, 100
+        dsl.set_default :foo, 200
+        expect(dsl.foo).to eq 100
+      end
+    end
+  end
+
+  describe "tasks" do
+    it "defines callable tasks" do
+      flag = false
+      dsl.task :test do
+        flag = true
+      end
+
+      expect {
+        dsl.invoke :test
+      }.to change { flag }.from(false).to(true)
+    end
+
+    it "can be called from another tasks" do
+      flag = false
+
+      dsl.task :a do
+        invoke :b
+      end
+
+      dsl.task :b do
+        flag = true
+      end
+
+      expect {
+        dsl.invoke :a
+      }.to change { flag }.from(false).to(true)
+    end
+
+    context "when task doesn't exist" do
+      it "raises error" do
+        expect {
+          dsl.invoke :nul
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "hook method" do
+    before do
+      klass.add_hook(:testhook)
+    end
+
+    context "without block" do
+      it "returns Proc to run hooks" do
+        expect(dsl.testhook).to be_a_kind_of(Proc)
+      end
+    end
+
+    context "with block" do
+      it "appends given block to hooks" do
+        flag = false
+        dsl.testhook { flag = true }
+        expect { dsl.testhook.call }.to \
+          change { flag }.from(false).to(true)
+      end
+
+      it "appends given block to hooks (multiple)" do
+        flags = []
+        dsl.testhook { flags << :a }
+        dsl.testhook { flags << :b }
+
+        expect { dsl.testhook.call }.to \
+          change { flags }.from([]).to([:a,:b])
+      end
+
+      it "can call hooks with argument" do
+        flag = nil
+        dsl.testhook { |a| flag = a }
+
+        expect { dsl.testhook.call(42) }.to \
+          change { flag }.from(nil).to(42)
+      end
+
+      context "with :prepend" do
+        it "prepends given block to hooks" do
+          flag = nil
+          dsl.testhook { |a| flag = 1 }
+          dsl.testhook(:prepend) { flag = 0 }
+
+          expect { dsl.testhook.call }.to \
+            change { flag }.from(nil).to(1)
+        end
+      end
+
+      context "with :overwrite" do
+        it "overwrites all existing hooks with given block" do
+          flags = []
+          dsl.testhook { |a| flags << :a }
+          dsl.testhook { |a| flags << :b }
+          dsl.testhook(:overwrite) { |a| flags << :c }
+
+          expect { dsl.testhook.call }.to \
+            change { flags }.from([]).to([:c])
+        end
+      end
+    end
+
+    describe "limiting by label" do
+      context "using kwarg :only" do
+        it "runs only for specified label" do
+          matcher = double('matcher')
+          expect(Mamiya::Util::LabelMatcher::Simple).to receive(:new).with([:a,:b,:d]).and_return(matcher)
+          expect(matcher).to receive(:match?).with(:a).and_return(true)
+          expect(matcher).to receive(:match?).with([:a]).and_return(true)
+          expect(matcher).to receive(:match?).with([:b, :c]).and_return(false)
+
+          flags = []
+          dsl.testhook(only: [:a]) { flags << 1 }
+          dsl.testhook { flags << 2 }
+          dsl.testhook(only: [[:b, :c]]) { flags << 3 }
+          dsl.testhook(:prepend, only: [[:a]]) { flags << 4 }
+
+          expect { dsl.testhook(:a, :b, :d).call }.to \
+            change { flags }.from([]).to([4,1,2])
+        end
+      end
+
+      context "using kwarg :except" do
+        it "doesn't run for specified label" do
+          matcher = double('matcher')
+          expect(Mamiya::Util::LabelMatcher::Simple).to receive(:new).with([:a,:b,:d]).and_return(matcher)
+          expect(matcher).to receive(:match?).with(:a).and_return(true)
+          expect(matcher).to receive(:match?).with([:a]).and_return(true)
+          expect(matcher).to receive(:match?).with([:b, :c]).and_return(false)
+
+          flags = []
+          dsl.testhook(except: [:a]) { flags << 1 }
+          dsl.testhook { flags << 2 }
+          dsl.testhook(except: [[:b, :c]]) { flags << 3 }
+          dsl.testhook(:prepend, except: [[:a]]) { flags << 4 }
+
+          expect { dsl.testhook(:a, :b, :d).call }.to \
+            change { flags }.from([]).to([2,3])
+        end
+      end
+    end
+
+    describe "chain hooks" do
+      before do
+        klass.add_hook(:testchain, chain: true)
+      end
+
+      it "injects the result of blocks" do
+        dsl.testchain { |result, arg| result += arg * 3 }
+        dsl.testchain { |result, arg| result -= arg }
+
+        expect(dsl.testchain[2, 5]).to eq 12
+      end
+    end
+
+    describe "naming" do
+      it "ables to name defined hooks" do
+        dsl.testhook('the-name') { }
+        expect(dsl.hooks[:testhook].first[:name]).to eq 'the-name'
+      end
+
+      context "with other option" do
+        it "ables to name defined hooks" do
+          dsl.testhook('the-name2', :prepend) { }
+          dsl.testhook('the-name', :prepend) { }
+          expect(dsl.hooks[:testhook].first[:name]).to eq 'the-name'
+        end
+      end
+    end
+  end
+
+  describe "#servers" do
+    pending "Hey!"
+  end
+
+  describe "#use_servers" do
+    pending "Hey!"
+  end
+end

data/spec/fixtures/dsl_test_load.rb

@@ -0,0 +1 @@
+set :foo, 72

data/spec/fixtures/dsl_test_use.rb

@@ -0,0 +1 @@
+use :foo

data/spec/fixtures/helpers/foo.rb

@@ -0,0 +1 @@
+set :foo, options[:value] || 72

data/spec/fixtures/test-package-source/.mamiya.meta.json

@@ -0,0 +1 @@
+{}

data/spec/fixtures/test-package-source/greeting

@@ -0,0 +1 @@
+hello

data/spec/fixtures/test.yml

@@ -0,0 +1,4 @@
+a:
+  b:
+    - c: d
+  e: f

data/spec/logger_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'stringio'
+require 'tmpdir'
+require 'fileutils'
+
+require 'mamiya/logger'
+
+describe Mamiya::Logger do
+  it "can log" do
+    sio = StringIO.new('', 'w')
+    logger = described_class.new(outputs: [sio])
+    logger.info 'hello'
+    logger.close
+
+    expect(sio.string).to match(/hello/)
+  end
+
+  context "with multiple outputs" do
+    let!(:tmpdir) { Dir.mktmpdir('mamiya-logger-spec') }
+    after { FileUtils.remove_entry_secure tmpdir }
+
+    it "can log" do
+      sio = StringIO.new('', 'w')
+      i,o = IO.pipe
+      path = File.join(tmpdir, 'test.log')
+
+      logger = described_class.new(outputs: [sio, o, path])
+      logger.info 'hello'
+      logger.close
+
+      io_out = i.read; i.close
+
+      expect(sio.string).to match(/hello/)
+      expect(io_out).to match(/hello/)
+      expect(File.read(path)).to match(/hello/)
+    end
+  end
+
+  describe "#[]" do
+    it "can log" do
+      sio = StringIO.new('', 'w')
+      logger = described_class.new(outputs: [sio])
+      test_logger = logger['test']
+      logger.info 'hello'
+      test_logger.info ''
+
+      expect(test_logger.progname).to eq 'test'
+      expect(logger.progname).to be_nil
+
+      logger.close
+
+      expect(sio.string).to match(/^.*hello.*$/)
+      expect(sio.string).to match(/^.*test.*$/)
+    end
+  end
+
+  describe "#reopen" do
+    it "reopens file IOs" do
+      io = double('io', path: 'foo', tty?: false, write: 0, sync: true)
+      expect(io).to receive(:reopen).with('foo', 'a')
+      expect(io).to receive(:sync=).with(true)
+
+      logger = described_class.new(outputs: [io])
+
+      logger.reopen
+    end
+  end
+end

data/spec/master/agent_monitor_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+require 'json'
+
+require 'villein/event'
+
+require 'mamiya/master/agent_monitor'
+
+describe Mamiya::Master::AgentMonitor do
+  let(:serf) { double('serf') }
+  let(:config) { {} }
+  let(:master) do
+    double('master', logger: Mamiya::Logger.new, serf: serf, config: config)
+  end
+
+  subject(:agent_monitor) do
+    described_class.new(master)
+  end
+
+  describe "#refresh" do
+    let(:query_response) do
+      {
+        "Acks" => ['a'],
+        "Responses" => {
+          'a' => {"foo" => "bar"}.to_json,
+        },
+      }
+    end
+
+    let(:members) do
+      [
+        {
+          "name"=>"a", "status"=>"alive",
+          "addr"=>"x.x.x.x:7676", "port"=>7676,
+          "protocol"=>{"max"=>4, "min"=>2, "version"=>4},
+          "tags"=>{},
+        },
+      ]
+    end
+
+    before do
+      allow(serf).to receive(:query).with('mamiya:status', '', {}).and_return(query_response)
+      allow(serf).to receive(:members).and_return(members)
+    end
+
+    it "updates #statuses" do
+      expect {
+        agent_monitor.refresh
+      }.to change {
+        agent_monitor.statuses["a"]
+      }.to("foo" => "bar")
+    end
+
+    it "updates #agents" do
+      expect {
+        agent_monitor.refresh
+      }.to change {
+        agent_monitor.agents
+      }.from({}).to("a" => members[0])
+    end
+
+    context "when some member is failing" do
+      let(:members) do
+        [
+          {
+            "name"=>"a", "status"=>"failed",
+            "addr"=>"x.x.x.x:7676", "port"=>7676,
+            "protocol"=>{"max"=>4, "min"=>2, "version"=>4},
+            "tags"=>{},
+          },
+        ]
+      end
+
+      it "appends to failed_agents" do
+        expect {
+          agent_monitor.refresh
+        }.to change {
+          agent_monitor.failed_agents
+        }.from([]).to(['a'])
+      end
+    end
+
+    context "when some agent returned invalid status" do
+      let(:query_response) do
+        {
+          "Acks" => ['a'],
+          "Responses" => {
+            'a' => '{',
+          },
+        }
+      end
+
+      it "appends to failed_agents" do
+        expect {
+          agent_monitor.refresh
+        }.to change {
+          agent_monitor.failed_agents
+        }.from([]).to(['a'])
+      end
+    end
+
+    context "with argument" do
+      it "passes args to serf query" do
+        expect(serf).to receive(:query).with('mamiya:status', '', node: 'foo').and_return(query_response)
+        agent_monitor.refresh(node: 'foo')
+      end
+    end
+  end
+
+  describe "(commiting events)" do
+    let(:query_response) do
+      {
+        "Acks" => ['a'],
+        "Responses" => {
+          'a' => status.to_json,
+        },
+      }
+    end
+
+    let(:members) do
+      [
+        {
+          "name"=>"a", "status"=>"alive",
+          "addr"=>"x.x.x.x:7676", "port"=>7676,
+          "protocol"=>{"max"=>4, "min"=>2, "version"=>4},
+          "tags"=>{},
+        },
+      ]
+    end
+
+    let(:status) do
+      {}
+    end
+
+    def commit(event, payload)
+      agent_monitor.commit_event(Villein::Event.new(
+        {
+          'SERF_EVENT' => 'user',
+          'SERF_USER_EVENT' => event,
+        },
+        payload: {name: "a"}.merge(payload).to_json
+      ))
+    end
+
+    before do
+      allow(serf).to receive(:query).with('mamiya:status', '', {}).and_return(query_response)
+      allow(serf).to receive(:members).and_return(members)
+
+      agent_monitor.refresh
+    end
+
+    subject(:new_status) { agent_monitor.statuses["a"] }
+
+    describe "fetch-result" do
+      describe ":ack" do
+        let(:status) do
+          {fetcher: {fetching: nil, pending: 0}}
+        end
+
+        it "updates pending" do
+          commit('mamiya:fetch-result:ack', pending: 72)
+          expect(new_status["fetcher"]["pending"]).to eq 72
+        end
+      end
+
+      describe ":start" do
+        let(:status) do
+          {fetcher: {fetching: nil, pending: 0}}
+        end
+
+        it "updates fetching" do
+          commit('mamiya:fetch-result:start',
+                 application: 'app', package: 'pkg', pending: 0)
+          expect(new_status["fetcher"]["fetching"]).to eq ['app', 'pkg']
+        end
+      end
+
+      describe ":error" do
+        let(:status) do
+          {fetcher: {fetching: ['app', 'pkg'], pending: 0}}
+        end
+
+        it "updates fetching" do
+          commit('mamiya:fetch-result:error',
+                 application: 'app', package: 'pkg', pending: 0)
+
+          expect(new_status["fetcher"]["fetching"]).to eq nil
+        end
+
+        context "when package doesn't match with present state" do
+          it "doesn't updates fetching" do
+            commit('mamiya:fetch-result:error',
+                   application: 'app', package: 'pkg2', pending: 0)
+
+            expect(new_status["fetcher"]["fetching"]).to \
+              eq(['app', 'pkg'])
+          end
+        end
+      end
+
+      describe ":success" do
+        let(:status) do
+          {fetcher: {fetching: ['app', 'pkg'], pending: 0},
+           packages: {}}
+        end
+
+        it "updates fetching" do
+          commit('mamiya:fetch-result:success',
+                 application: 'app', package: 'pkg', pending: 0)
+
+          expect(new_status["fetcher"]["fetching"]).to eq nil
+        end
+
+        it "updates packages" do
+          commit('mamiya:fetch-result:success',
+                 application: 'app', package: 'pkg', pending: 0)
+
+          expect(new_status["packages"]["app"]).to eq ["pkg"]
+        end
+
+        context "with existing packages" do
+          let(:status) do
+            {fetcher: {fetching: ['app', 'pkg2'], pending: 0},
+             packages: {"app" => ['pkg1']}}
+          end
+
+          it "updates packages" do
+            commit('mamiya:fetch-result:success',
+                   application: 'app', package: 'pkg2', pending: 0)
+
+            expect(new_status["packages"]["app"]).to eq %w(pkg1 pkg2)
+          end
+        end
+
+        context "when package doesn't match with present state" do
+          it "doesn't updates fetching" do
+            commit('mamiya:fetch-result:success',
+                   application: 'app', package: 'pkg2', pending: 0)
+
+            expect(agent_monitor.statuses["a"]["fetcher"]["fetching"]).to \
+              eq(['app', 'pkg'])
+          end
+
+          it "updates packages" do
+            commit('mamiya:fetch-result:success',
+                   application: 'app', package: 'pkg', pending: 0)
+
+            expect(new_status["packages"]["app"]).to eq ["pkg"]
+          end
+        end
+      end
+
+      describe ":remove" do
+        context "with existing packages" do
+          let(:status) do
+            {fetcher: {fetching: ['app', 'pkg2'], pending: 0},
+             packages: {"app" => ['pkg1']}}
+          end
+
+          it "updates packages" do
+            commit('mamiya:fetch-result:remove',
+                   application: 'app', package: 'pkg1', pending: 0)
+
+            expect(new_status["packages"]["app"]).to eq []
+          end
+        end
+      end
+    end
+  end
+end