navyrb 0.0.1

data/spec/lib/navy/container_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Navy::Container do
+  let(:specification) do
+    {
+      :container_name => 'the_container_name',
+      :name => 'the_app_name',
+      :type => "application"
+    }
+  end
+
+  let(:dependencies) do
+    ['dep1', 'dep2']
+  end
+
+  let(:etcd) do
+    MockEtcd.new
+  end
+
+  subject do
+    described_class.new :specification => specification,
+                        :dependencies => dependencies
+  end
+
+  describe "#name" do
+    it "is the container_name in the specification" do
+      expect(subject.name).to eq 'the_container_name'
+    end
+  end
+
+  describe "#app" do
+    it "is the app name in the specification" do
+      expect(subject.app).to eq 'the_app_name'
+    end
+  end
+
+  describe "#daemon?" do
+    context "when the type is application" do
+      before :each do
+        specification[:type] = "application"
+      end
+      
+      it "is a daemon" do
+        expect(subject.daemon?).to be true
+      end
+    end
+
+    context "when the type is task" do
+      before :each do
+        specification[:type] = "task"
+      end
+      
+      it "is a daemon" do
+        expect(subject.daemon?).to be false
+      end
+    end
+  end
+
+  describe "#can_be_started?" do
+    context "when there are no dependencies" do
+      let(:dependencies) { [] }
+      it "can be started" do
+        expect(subject.can_be_started?(etcd)).to be true
+      end
+    end
+
+    context "when the dependencies are not in desired state" do
+      before :each do
+        etcd.setJSON('/navy/containers/dep1/desired', {:state => :desired})
+        etcd.setJSON('/navy/containers/dep1/actual', {:state => :not_desired})
+      end
+
+      it "cannot be started" do
+        expect(subject.can_be_started?(etcd)).to be false
+      end
+    end
+
+    context "when the dependencies are in desired state" do
+      before :each do
+        etcd.setJSON('/navy/containers/dep1/desired', {:state => :desired})
+        etcd.setJSON('/navy/containers/dep1/actual', {:state => :desired})
+        etcd.setJSON('/navy/containers/dep2/desired', {:state => :desired})
+        etcd.setJSON('/navy/containers/dep2/actual', {:state => :desired})
+      end
+
+      it "can be started" do
+        expect(subject.can_be_started?(etcd)).to be true
+      end
+    end
+  end
+
+  describe "#can_never_be_started?" do
+    context "when there are no dependencies" do
+      let(:dependencies) { [] }
+      it "can *always* be started" do
+        expect(subject.can_never_be_started?(etcd)).to be false
+      end
+    end
+
+    context "when the dependencies exist" do
+      context "when one of the dependencies is errored" do
+        before :each do
+          etcd.setJSON('/navy/containers/dep1/desired', {:state => :desired})
+          etcd.setJSON('/navy/containers/dep1/actual', {:state => :error})
+        end
+
+        it "can *never* be started" do
+          expect(subject.can_never_be_started?(etcd)).to be true
+        end
+      end
+
+      context "when the dependencies are in non errored states" do
+        before :each do
+          etcd.setJSON('/navy/containers/dep1/desired', {:state => :desired})
+          etcd.setJSON('/navy/containers/dep1/actual', {:state => :not_error})
+        end
+
+        it "can be *potentially* started" do
+          expect(subject.can_never_be_started?(etcd)).to be false
+        end
+
+      end
+    end
+  end
+
+  describe "#start" do
+    let(:cmd) { Navy::CommandBuilder.new(subject).build }
+    let(:launched) { [] }
+    let(:success) { true }
+
+    before :each do
+      allow(Navy::Runner).to receive(:launch) do |cmd|
+        launched << cmd
+        success
+      end
+    end
+
+    it "generates a command for the container and executes it" do
+      subject.start
+      expect(launched).to eq [cmd]
+    end
+
+    context "when the command succeeds" do
+      it "returns true" do
+        expect(subject.start).to be true
+      end
+    end
+
+    context "when the command fails" do
+      let(:success) { false }
+      it "returns false" do
+        expect(subject.start).to be false
+      end
+    end
+
+    context "when it is a task" do
+      before :each do
+        specification[:type] = "task"
+        specification[:cmds] = ["cmd1", "cmd2"]
+      end
+
+      it "runs each command" do
+        subject.start
+        expect(launched[0].last).to eq "cmd1"
+        expect(launched[1].last).to eq "cmd2"
+      end
+
+      context "when one of the items fails" do
+        let(:success) { false }
+
+        it "returns false and does not run other tasks" do
+          expect(subject.start).to be false
+          expect(launched.length).to eq 1
+        end
+      end
+    end
+  end
+
+  describe "#stop" do
+    let(:cmd) { ["docker rm -f", "the_container_name"] }
+    let(:launched) { [] }
+
+    before :each do
+      allow(Navy::Runner).to receive(:launch) do |cmd|
+        launched << cmd
+        true
+      end
+    end
+
+    it "generates a rm command for the container and executes it" do
+      subject.stop
+      expect(launched).to eq [cmd]
+    end
+  end
+end

data/spec/lib/navy/etcd_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'webmock/rspec'
+
+describe Navy::Etcd do
+  let(:options) do
+    {:host => 'etcdhost', :port => '1234'}
+  end
+
+  let(:example_record) do
+    <<-JSON
+    {
+      "action":"The Action",
+      "node": {
+           "createdIndex": 1,
+           "key": "/akey",
+           "modifiedIndex": 2,
+           "value": "New Value"
+        },
+      "prevNode": {
+            "createdIndex": 1,
+            "key": "/akey",
+            "value": "Prev Value",
+            "modifiedIndex": 3
+        }
+    }
+    JSON
+  end
+
+  let(:example_json_record) do
+    <<-JSON
+    {
+      "action":"The Action",
+      "node": {
+           "createdIndex": 1,
+           "key": "/akey",
+           "modifiedIndex": 2,
+           "value": "{\\"key\\":\\"value\\"}"
+        },
+      "prevNode": {
+            "createdIndex": 1,
+            "key": "/akey",
+            "value": "Prev Value",
+            "modifiedIndex": 3
+        }
+    }
+    JSON
+  end
+
+  let(:example_headers) do
+    {
+      "X-Etcd-Index" => "999"
+    }
+  end
+
+  subject { described_class.client options }
+
+  describe "Retrieval" do
+    describe "#get" do
+      before :each do
+        @request = stub_request(:get, 'http://etcdhost:1234/v2/keys/some/key').
+          to_return(:body => example_record, :headers => example_headers)
+      end
+
+      it "fetches a response from the given key" do
+        record = subject.get('/some/key')
+
+        #expect(@request).to have_been_made
+
+        expect(record.key).to eq '/akey'
+        expect(record.etcd_index).to be 999
+        expect(record.action).to eq "The Action"
+        expect(record.node.createdIndex).to eq 1
+        expect(record.node.modifiedIndex).to eq 2
+        expect(record.node.value).to eq "New Value"
+        expect(record.prevNode.value).to eq "Prev Value"
+      end
+    end
+
+    describe "#getJSON" do
+      before :each do
+        @request = stub_request(:get, 'http://etcdhost:1234/v2/keys/some/key').
+          to_return(:body => example_json_record, :headers => example_headers)
+      end
+
+      it "fetches and parses as JSON the given jey" do
+        hash = subject.getJSON('/some/key')
+        #expect(@request).to have_been_made
+
+        expect(hash['key']).to eq 'value'
+      end
+    end
+
+    describe "#watch" do
+      before :each do
+        @request = stub_request(:get, 'http://etcdhost:1234/v2/keys/some/key?wait=true').
+          to_return(:body => example_record, :headers => example_headers)
+      end
+
+      it "fetches with a wait" do
+        record = subject.watch('/some/key')
+        #expect(@request).to have_been_made
+      end
+    end
+
+    describe "#ls" do
+      let(:exampledir) do
+        {
+          :node => {
+            :nodes => [
+              {:key => '/some/dir/item1'},
+              {:key => '/some/dir/item2'}
+            ]
+          }
+        }.to_json
+      end
+
+      before :each do
+        @request = stub_request(:get, 'http://etcdhost:1234/v2/keys/some/dir').
+          to_return(:body => exampledir)
+      end
+
+      it "returns the keys in the given directory" do
+        keys = subject.ls('/some/dir')
+        #expect(@request).to have_been_made
+        expect(keys).to include '/some/dir/item1'
+        expect(keys).to include '/some/dir/item2'
+        expect(keys.length).to eq 2
+      end
+    end
+
+  end
+
+  describe "Storage" do
+    describe "#setJSON" do
+      let(:data) do
+        data = {:some => :json, :data => [:here]}
+      end
+
+      before :each do
+        @request = stub_request(:put, 'http://etcdhost:1234/v2/keys/some/json/key').
+          with(:body => {:value => data.to_json})
+      end
+
+      it "stores JSON encoded value at given key" do
+        subject.setJSON('/some/json/key', data)
+        #expect(@request).to have_been_made
+      end
+    end
+
+    describe "#delete" do
+      before :each do
+        @request = stub_request(:delete, 'http://etcdhost:1234/v2/keys/some/key?with=param').to_return(:status => 202)
+      end
+
+      it "deletes the specified key" do
+        result = subject.delete('/some/key', :with => :param)
+        expect(@request).to have_been_made
+        expect(result).to be true
+      end
+
+      context "when the key is missing" do
+        before :each do
+          @request = stub_request(:delete, 'http://etcdhost:1234/v2/keys/some/key?with=param').to_return(:status => 404)
+        end
+
+        it "returns false" do
+          result = subject.delete('/some/key', :with => :param)
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe "#set" do
+      let(:data) { "some data " }
+
+      before :each do
+        @request = stub_request(:put, 'http://etcdhost:1234/v2/keys/some/data/value').
+          with(:body => {:value => data })
+      end
+
+      it "stores the string at the given value" do
+        subject.set('/some/data/value', data)
+        #expect(@request).to have_been_made
+      end
+    end
+
+    describe "#queueJSON" do
+      let(:data) { {:some => :json } }
+
+      before :each do
+        @request = stub_request(:post, 'http://etcdhost:1234/v2/keys/some/queue').
+          with(:body => {:value => data.to_json })
+      end
+
+      it "stores the string at the given value" do
+        subject.queueJSON('/some/queue', data)
+        expect(@request).to have_been_made
+      end
+    end
+  end
+
+end

data/spec/lib/navy/router_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Navy::Router do
+  class ExampleHandler
+    def self.handled
+      @handled ||= {}
+    end
+
+    def handle_set(params, request)
+      self.class.handled[:set] = params, request
+    end
+
+    def handle_delete(params, request)
+      self.class.handled[:delete] = params, request
+    end
+
+  end
+
+  let(:handler1) { Class.new(ExampleHandler) }
+  let(:handler2) { Class.new(ExampleHandler) }
+
+  subject do
+    described_class.new do |r|
+      r.route '^/a/route$', handler1
+      r.route '^/a/:pattern/route$', handler2
+    end
+  end
+
+  it "routes through to defined handlers" do
+    request = double :key => '/a/route',
+                     :action => :set
+
+    subject.route(request)
+    expect(handler1.handled[:set]).to eq [{}, request]
+  end
+
+  it "matches placeholder patters" do
+    request = double :key => '/a/matching/route',
+                     :action => :delete
+
+    subject.route(request)
+    expect(handler2.handled[:delete]).to eq [{'pattern' => 'matching'}, request]
+  end
+
+  it "gracefully handles unknown paths" do
+    request = double :key => '/unkonwn/path',
+                     :action => :delete
+    expect { subject.route(request) }.to_not raise_error
+  end
+
+  it "gracefully handle unmapped action" do
+    request = double :key => '/a/route',
+                     :action => :unmapped
+    expect { subject.route(request) }.to_not raise_error
+  end
+
+  it "passes down global options into the params" do
+    options = {:foo => :bar}
+    router = described_class.new(options) do |r|
+      r.route 'example', handler1
+    end
+
+    request = double :key => 'example', :action => :set
+
+    router.route(request)
+
+    expect(handler1.handled[:set][0]).to eq({:foo => :bar})
+  end
+end