fleet-api 0.0.1

data/spec/fleet/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'fleet/configuration'
+
+describe Fleet::Configuration do
+
+  subject { Class.new { extend Fleet::Configuration } }
+
+  describe 'exposed attribes' do
+    Fleet::Configuration::VALID_OPTIONS_KEYS.each do |key|
+      it { should respond_to key.to_sym }
+    end
+  end
+
+  describe 'default values' do
+
+    describe 'adapter' do
+      it 'is matches DEFAULT_ADAPTER' do
+        expect(subject.adapter).to eq Fleet::Configuration::DEFAULT_ADAPTER
+      end
+    end
+
+    describe 'fleet_api_url' do
+      it 'is matches DEFAULT_ETCD_API_URL' do
+        expect(subject.fleet_api_url).to eq Fleet::Configuration::DEFAULT_ETCD_API_URL
+      end
+    end
+
+    describe 'open_timeout' do
+      it 'is matches DEFAULT_OPEN_TIMEOUT' do
+        expect(subject.open_timeout).to eq Fleet::Configuration::DEFAULT_OPEN_TIMEOUT
+      end
+    end
+
+    describe 'read_timeout' do
+      it 'is matches DEFAULT_READ_TIMEOUT' do
+        expect(subject.read_timeout).to eq Fleet::Configuration::DEFAULT_READ_TIMEOUT
+      end
+    end
+
+    describe 'logger' do
+      it 'is matches DEFAULT_LOGGER' do
+        expect(subject.logger).to eq Fleet::Configuration::DEFAULT_LOGGER
+      end
+    end
+  end
+end

data/spec/fleet/connection_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Fleet::Connection do
+
+  describe 'registered middleware' do
+
+    subject { Fleet::Client.new.connection }
+
+    handlers = [
+      Faraday::Request::UrlEncoded,
+      FaradayMiddleware::ParseJson,
+      Middleware::Response::RaiseError,
+      Faraday::Adapter::NetHttp
+    ]
+
+    handlers.each do |handler|
+      it { expect(subject.builder.handlers).to include handler }
+    end
+
+    it "includes exactly #{handlers.count} handlers" do
+      expect(subject.builder.handlers.count).to eql handlers.count
+    end
+  end
+
+  describe 'connection options' do
+
+    let(:url) { 'http://foo.com/bar' }
+    let(:ssl_options) { { verify: true } }
+    let(:proxy) { 'http://proxy.com' }
+
+    subject do
+      Fleet::Client.new(
+        fleet_api_url: url,
+        ssl_options: ssl_options,
+        proxy: proxy).connection
+    end
+
+    describe 'scheme' do
+      it 'matches the scheme of the URL' do
+        expect(subject.scheme).to eq 'http'
+      end
+    end
+
+    describe 'host' do
+      it 'matches the host of the URL' do
+        expect(subject.host).to eq 'foo.com'
+      end
+    end
+
+    describe 'port' do
+      it 'matches the port of the URL' do
+        expect(subject.port).to eq 80
+      end
+    end
+
+    describe 'path_prefix' do
+      it 'matches the path of the URL' do
+        expect(subject.path_prefix).to eq '/bar'
+      end
+    end
+
+    describe 'ssl' do
+      it 'matches the specified SSL options' do
+        expect(subject.ssl).to eq ssl_options
+      end
+    end
+
+    describe 'proxy' do
+      it 'matches the specified SSL options' do
+        expect(subject.proxy[:uri].to_s).to eq proxy
+      end
+    end
+
+  end
+end

data/spec/fleet/error_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Fleet::Error do
+
+  let(:message) { 'some message' }
+  let(:error_code) { 12345 }
+  let(:cause) { 'user error' }
+
+  subject { Fleet::Error.new(message, error_code, cause) }
+
+  it { should respond_to(:message) }
+  it { should respond_to(:error_code) }
+  it { should respond_to(:cause) }
+
+  describe '#initialize' do
+
+    it 'saves the passed-in message' do
+      expect(subject.message).to eq message
+    end
+
+    it 'saves the passed-in error code' do
+      expect(subject.error_code).to eq error_code
+    end
+
+    it 'saves the passed-in cause' do
+      expect(subject.cause).to eq cause
+    end
+  end
+end

data/spec/fleet/request_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Fleet::Request do
+
+  subject { Fleet::Client.new }
+
+  let(:path) { '/path' }
+
+  let(:request) do
+    double(:request,
+      options: {},
+      headers: {},
+      params: {},
+      'headers=' => nil,
+      'path=' => nil)
+  end
+
+  let(:response) do
+    double(:response, body: 'foo')
+  end
+
+  let(:connection) { double(:connection) }
+
+  before do
+    allow(connection).to receive(:send).and_yield(request).and_return(response)
+    allow(subject).to receive(:connection).and_return(connection)
+  end
+
+  [:get, :delete, :head, :put, :post].each do |method|
+
+    context "##{method}" do
+
+      it 'sets the path' do
+        expect(request).to receive(:path=).with(path)
+        subject.send(method, path)
+      end
+
+      it 'sets the headers' do
+        headers = { foo: :bar }
+        expect(request).to receive(:headers=).with(hash_including(headers))
+        subject.send(method, path, {}, headers)
+      end
+
+      it 'returns the response body' do
+        expect(subject.send(method, path)).to eql(response.body)
+      end
+
+      context 'when a Faraday::Error::ConnectionFailed error is raised' do
+
+        before do
+          allow(connection).to receive(:send)
+            .and_raise(Faraday::Error::ConnectionFailed, 'oops')
+        end
+
+        it 'raises a Fleet::ConnectionError' do
+          expect { subject.send(method, path) }.to raise_error(Fleet::ConnectionError, 'oops')
+        end
+      end
+    end
+  end
+
+  [:get, :delete, :head].each do |method|
+
+    context "##{method}" do
+
+      context 'when options provided' do
+
+        it 'sets options on the request' do
+          options = { a: :b }
+          expect(request).to receive(:params=).with(options)
+          subject.send(method, path, options)
+        end
+      end
+
+      context 'when no options provided' do
+
+        it 'does not set options on the request' do
+          expect(request).to_not receive(:params=)
+          subject.send(method, path)
+        end
+      end
+    end
+  end
+
+  [:put, :post].each do |method|
+
+    context "##{method}" do
+
+      context 'when options provided' do
+
+        it 'sets options on the request' do
+          options = { a: :b }
+          expect(request).to receive(:body=).with(options)
+          subject.send(method, path, options)
+        end
+      end
+
+      context 'when no options provided' do
+
+        it 'does not set options on the request' do
+          expect(request).to_not receive(:body=)
+          subject.send(method, path)
+        end
+      end
+
+      context 'when querystring AND body provided' do
+        let(:options) { { querystring: { a: :b }, body: { c: :d } } }
+
+        before do
+          allow(request).to receive(:params=)
+          allow(request).to receive(:body=)
+        end
+
+        it 'sets the querystring as request params' do
+          expect(request).to receive(:params=).with(options[:querystring])
+          subject.send(method, path, options)
+        end
+
+        it 'sets the body as request body' do
+          expect(request).to receive(:body=).with(options[:body])
+          subject.send(method, path, options)
+        end
+      end
+
+    end
+  end
+
+end

data/spec/fleet/service_definition_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Fleet::ServiceDefinition do
+
+  let(:name) { 'myservice.service' }
+
+  let(:service_hash) do
+    {
+      'Unit' => {
+        'Description' => 'infinite loop'
+      },
+      'Service' => {
+        'ExecStart' => "/bin/bash -c \"while true; do sleep 1; done\""
+      }
+    }
+  end
+
+  subject { described_class.new(name) }
+
+  it { should respond_to :name }
+
+  describe '#initialize' do
+
+    subject { described_class.new(name) }
+
+    describe 'name' do
+      it 'should equal the passed-in name' do
+        expect(subject.name).to eq name
+      end
+    end
+  end
+
+  describe '#to_unit' do
+
+    subject { described_class.new(name, service_hash) }
+
+    it 'provides a fleet formatted unit definition' do
+
+      raw = <<UNIT_FILE
+[Unit]
+Description=#{service_hash['Unit']['Description']}
+
+[Service]
+ExecStart=#{service_hash['Service']['ExecStart']}
+UNIT_FILE
+
+      expected = {
+        'Contents' => {
+          'Unit' => {
+            'Description' => [service_hash['Unit']['Description']]
+          },
+          'Service' => {
+            'ExecStart' => [service_hash['Service']['ExecStart']]
+          }
+        },
+        'Raw' => raw
+      }
+
+      expect(subject.to_unit).to eq expected
+    end
+  end
+
+  describe '#to_job' do
+
+    subject { described_class.new(name, service_hash) }
+
+    it 'generates the appropriate job definition' do
+
+      expected = {
+        'Name' => name,
+        'UnitHash' => [111, 150, 87, 109, 217, 26, 190, 221, 31, 28, 8, 211, 198, 126, 76, 157, 106, 164, 220, 134]
+      }
+
+      expect(subject.to_job).to eq expected
+    end
+  end
+
+  describe '#sha1' do
+
+    subject { described_class.new(name, service_hash) }
+
+    it 'generates the appropriate sha1 hash' do
+      expect(subject.sha1).to eq '6f96576dd91abedd1f1c08d3c67e4c9d6aa4dc86'
+    end
+  end
+end

data/spec/fleet_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Fleet do
+
+  after do
+    Fleet.reset
+  end
+
+  describe '.new' do
+
+    it 'returns a Fleet::Client' do
+      expect(Fleet.new).to be_a Fleet::Client
+    end
+
+    context 'when no options specified' do
+
+      Fleet::Configuration::VALID_OPTIONS_KEYS.each do |option|
+
+        it "new Fleet::Client inherits :#{option} default from Fleet" do
+          expect(Fleet.new.send(option)).to eq Fleet.send(option)
+        end
+      end
+    end
+
+    context 'when options are specified' do
+
+      Fleet::Configuration::VALID_OPTIONS_KEYS.each do |option|
+
+        it "new Fleet::Client receives specified :#{option} value" do
+          expect(Fleet.new({option => 'foo'}).send(option)).to eq 'foo'
+        end
+      end
+    end
+  end
+
+  describe '.fleet_api_url' do
+
+    let(:url) { 'http://foo.com/bar' }
+
+    before do
+      stub_const('Fleet::Configuration::DEFAULT_ETCD_API_URL', url)
+      Fleet.reset
+    end
+
+    it 'defaults to the value of DEFAULT_ETCD_API_URL' do
+      expect(Fleet.fleet_api_url).to eq url
+    end
+  end
+
+  describe '.open_timeout' do
+    it 'defaults to 2' do
+      expect(Fleet.open_timeout).to eq 2
+    end
+  end
+
+  describe '.read_timeout' do
+    it 'defaults to 5' do
+      expect(Fleet.read_timeout).to eq 5
+    end
+  end
+
+  describe '.ssl_options' do
+    it 'defaults to { verify: false }' do
+      expect(Fleet.ssl_options).to eq(verify: false)
+    end
+  end
+
+  describe '.proxy' do
+    it 'defaults to nil' do
+      expect(Fleet.proxy).to be_nil
+    end
+  end
+
+  describe '.configure' do
+    it "accepts a block" do
+      expect { Fleet.configure {} }.to_not raise_error
+    end
+
+    it "yields self" do
+      Fleet.configure { |conf| expect(conf).to be(Fleet) }
+    end
+
+    it "returns true" do
+      expect(Fleet.configure {}).to eq true
+    end
+  end
+end

data/spec/middleware/response/raise_error_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Middleware::Response::RaiseError do
+
+  describe '#on_complete' do
+
+    context 'when HTTP status is 200' do
+
+      let(:env) { { status: 200 } }
+
+      it 'raises no errors' do
+        expect { subject.on_complete(env) }.to_not raise_error
+      end
+    end
+
+    context 'when the HTTP status is a known error (404)' do
+
+      let(:message) { 'not found' }
+      let(:error_code) { 999 }
+      let(:cause) { 'just because ' }
+
+      let(:env) do
+        {
+          status: 404,
+          body: "{ \"message\": \"#{message}\", \"errorCode\": #{error_code}, \"cause\": \"#{cause}\" }"
+        }
+      end
+
+      it 'raises a NotFound execption' do
+        expect { subject.on_complete(env) }.to raise_error(Fleet::NotFound)
+      end
+
+      it 'sets the message on the exception' do
+        begin
+          subject.on_complete(env)
+        rescue Fleet::NotFound => ex
+          expect(ex.message).to eq message
+        end
+      end
+
+      it 'sets the error code on the exception' do
+        begin
+          subject.on_complete(env)
+        rescue Fleet::NotFound => ex
+          expect(ex.error_code).to eq error_code
+        end
+      end
+
+      it 'sets the cause on the exception' do
+        begin
+          subject.on_complete(env)
+        rescue Fleet::NotFound => ex
+          expect(ex.cause).to eq cause
+        end
+      end
+    end
+
+    context 'when HTTP status is an unknown error' do
+
+      let(:env) do
+        {
+          status: 499,
+          body: "{ \"message\": \"err\" }"
+        }
+      end
+
+      it 'raises an Error execption' do
+        expect { subject.on_complete(env) }.to raise_error(Fleet::Error)
+      end
+    end
+
+    context 'when error body is not JSON parseable' do
+
+      let(:env) do
+        {
+          status: 499,
+          body: 'FOO BAR'
+        }
+      end
+
+      it 'sets the error message to be the response body' do
+        begin
+          subject.on_complete(env)
+        rescue Fleet::Error => ex
+          expect(ex.message).to eq env[:body]
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+require 'simplecov-rcov'
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start do
+  add_filter '/spec'
+end
+
+require 'fleet'