fleet-api 0.9.0 → 1.0.0

data/spec/fleet/connection_spec.rb

@@ -2,73 +2,77 @@ require 'spec_helper'
 
 describe Fleet::Connection do
 
-  describe 'registered middleware' do
-
-    subject { Fleet::Client.new.connection }
-
-    handlers = [
-      Faraday::Request::UrlEncoded,
-      FaradayMiddleware::ParseJson,
-      Fleet::Middleware::Response::RaiseError,
-      FaradayMiddleware::FollowRedirects,
-      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' }
+    let(:open_timeout) { 30 }
+    let(:read_timeout) { 40 }
 
     subject do
       Fleet::Client.new(
-        fleet_api_url: url,
-        ssl_options: ssl_options,
-        proxy: proxy).connection
+        open_timeout: open_timeout,
+        read_timeout: read_timeout).connection
     end
 
-    describe 'scheme' do
-      it 'matches the scheme of the URL' do
-        expect(subject.scheme).to eq 'http'
+    describe 'open_timeout' do
+      it 'matches the the specified timeout value' do
+        expect(subject.data[:connect_timeout]).to eq open_timeout
       end
     end
 
-    describe 'host' do
-      it 'matches the host of the URL' do
-        expect(subject.host).to eq 'foo.com'
+    describe 'read_timeout' do
+      it 'matches the the specified timeout value' do
+        expect(subject.data[:read_timeout]).to eq read_timeout
       end
     end
 
-    describe 'port' do
-      it 'matches the port of the URL' do
-        expect(subject.port).to eq 80
+    context 'when URL is HTTP' do
+      let(:url) { 'http://foo.com/bar' }
+
+      subject do
+        Fleet::Client.new(fleet_api_url: url).connection
+      end
+      describe 'scheme' do
+        it 'matches the scheme of the URL' do
+          expect(subject.data[:scheme]).to eq 'http'
+        end
       end
-    end
 
-    describe 'path_prefix' do
-      it 'matches the path of the URL' do
-        expect(subject.path_prefix).to eq '/bar'
+      describe 'host' do
+        it 'matches the host of the URL' do
+          expect(subject.data[:host]).to eq 'foo.com'
+        end
       end
-    end
 
-    describe 'ssl' do
-      it 'matches the specified SSL options' do
-        expect(subject.ssl).to eq ssl_options
+      describe 'port' do
+        it 'matches the port of the URL' do
+          expect(subject.data[:port]).to eq 80
+        end
+      end
+
+      describe 'prefix' do
+        it 'matches the path of the URL' do
+          expect(subject.data[:path]).to eq '/bar'
+        end
       end
     end
 
-    describe 'proxy' do
-      it 'matches the specified SSL options' do
-        expect(subject.proxy[:uri].to_s).to eq proxy
+    context 'when URL is UNIX' do
+      let(:url) { 'unix:///foo/bar.socket' }
+
+      subject do
+        Fleet::Client.new(fleet_api_url: url).connection
+      end
+
+      describe 'scheme' do
+        it 'matches the scheme of the URL' do
+          expect(subject.data[:scheme]).to eq 'unix'
+        end
+      end
+
+      describe 'socket' do
+        it 'matches the port of the URL' do
+          expect(subject.data[:socket]).to eq '/foo/bar.socket'
+        end
       end
     end
 

data/spec/fleet/error_spec.rb

@@ -4,13 +4,11 @@ describe Fleet::Error do
 
   let(:message) { 'some message' }
   let(:error_code) { 12345 }
-  let(:cause) { 'user error' }
 
-  subject { Fleet::Error.new(message, error_code, cause) }
+  subject { Fleet::Error.new(message, error_code) }
 
   it { should respond_to(:message) }
   it { should respond_to(:error_code) }
-  it { should respond_to(:cause) }
 
   describe '#initialize' do
 
@@ -21,9 +19,5 @@ describe Fleet::Error do
     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

@@ -4,124 +4,91 @@ 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(:path) { '/foo bar@' }
 
   let(:response) do
-    double(:response, body: 'foo')
+    double(:response, body: '{"name":"foo"}', status: 200)
   end
 
   let(:connection) { double(:connection) }
 
   before do
-    allow(connection).to receive(:send).and_yield(request).and_return(response)
+    allow(connection).to receive(:send).and_return(response)
     allow(subject).to receive(:connection).and_return(connection)
   end
 
-  [:get, :delete, :head, :put, :post].each do |method|
-
-    context "##{method}" do
+  describe '#get' do
 
-      it 'sets the path' do
-        expect(request).to receive(:path=).with(path)
-        subject.send(method, path)
-      end
+    let(:options) do
+      { foo: 'bar' }
+    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 'invokes #get on the connection with the correct params' do
+      opts = { path: '/foo%20bar%40', query: options }
+      expect(connection).to receive(:send).with(:get, opts)
 
-      it 'returns the response body' do
-        expect(subject.send(method, path)).to eql(response.body)
-      end
+      subject.send(:get, path, options)
+    end
 
-      context 'when a Faraday::Error::ConnectionFailed error is raised' do
+    it 'returns the parsed response body' do
+      expect(subject.send(:get, path, options)).to eq('name' => 'foo')
+    end
 
-        before do
-          allow(connection).to receive(:send)
-            .and_raise(Faraday::Error::ConnectionFailed, 'oops')
-        end
+    context 'when there is a SocketError' do
+      before do
+        allow(connection).to receive(:send)
+          .and_raise(Excon::Errors::SocketError, Excon::Errors::Error.new('oops'))
+      end
 
-        it 'raises a Fleet::ConnectionError' do
-          expect { subject.send(method, path) }.to raise_error(Fleet::ConnectionError, 'oops')
-        end
+      it 'raises a Fleet::ConnectionError' do
+        expect { subject.send(:get, path, options) }.to raise_error(Fleet::ConnectionError)
       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
+    context 'when a non-200 status code is returned' do
+      let(:response) do
+        double(:response, body: '{"error": {"message": "oops", "code": "400"}}', status: 400)
       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
+      it 'raises a Fleet::ConnectionError' do
+        expect { subject.send(:get, path, options) }.to raise_error(Fleet::BadRequest, 'oops')
       end
     end
   end
 
-  [:put, :post].each do |method|
-
-    context "##{method}" do
+  describe '#put' 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
+    let(:options) do 
+      { foo: 'bar' } 
+    end
 
-      context 'when no options provided' do
+    it 'invokes #put on the connection with the correct params' do
+      opts = { 
+        path: '/foo%20bar%40', 
+        headers: { 'Content-Type' => 'application/json' },
+        body: JSON.dump(options)
+      }
+      expect(connection).to receive(:send).with(:put, opts)
 
-        it 'does not set options on the request' do
-          expect(request).to_not receive(:body=)
-          subject.send(method, path)
-        end
-      end
+      subject.send(:put, path, options)
+    end
 
-      context 'when querystring AND body provided' do
-        let(:options) { { querystring: { a: :b }, body: { c: :d } } }
+    it 'returns true' do
+      expect(subject.send(:put, path, options)).to eq(true)
+    end
+  end
 
-        before do
-          allow(request).to receive(:params=)
-          allow(request).to receive(:body=)
-        end
+  describe '#delete' do
 
-        it 'sets the querystring as request params' do
-          expect(request).to receive(:params=).with(options[:querystring])
-          subject.send(method, path, options)
-        end
+    it 'invokes #get on the connection with the correct params' do
+      opts = { path: '/foo%20bar%40' }
+      expect(connection).to receive(:send).with(:delete, opts)
 
-        it 'sets the body as request body' do
-          expect(request).to receive(:body=).with(options[:body])
-          subject.send(method, path, options)
-        end
-      end
+      subject.send(:delete, path, nil)
+    end
 
+    it 'returns true' do
+      expect(subject.send(:delete, path, nil)).to eq(true)
     end
   end
 

data/spec/fleet/service_definition_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Fleet::ServiceDefinition do
 
-  let(:name) { 'myservice.service' }
+  let(:name) { 'foo.service' }
 
   let(:service_hash) do
     {
@@ -16,64 +16,23 @@ describe Fleet::ServiceDefinition do
     }
   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) }
+    subject { described_class.new(service_hash) }
 
     it 'provides a fleet formatted unit definition' do
 
-      raw = <<UNIT_FILE
-[Unit]
-Description=#{service_hash['Unit']['Description']}
-
-[Service]
-ExecStartPre=#{service_hash['Service']['ExecStartPre'].first}
-ExecStartPre=#{service_hash['Service']['ExecStartPre'].last}
-ExecStart=#{service_hash['Service']['ExecStart']}
-UNIT_FILE
-
-      expected = { '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' => [173,163,19,156,23,184,6,223,77,240,208,230,238,54,179,201,80,147,228,89]
+        "name" => name,
+        "options"=> [
+          { "section" => "Unit", "name" => "Description", "value" => "infinite loop"}, 
+          { "section" => "Service", "name" => "ExecStartPre", "value" => "foo" },
+          { "section" => "Service", "name" => "ExecStartPre", "value" => "bar" },
+          { "section" => "Service", "name" => "ExecStart", "value" => "/bin/bash -c \"while true; do sleep 1; done\"" }
+        ]
       }
 
-      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 'ada3139c17b806df4df0d0e6ee36b3c95093e459'
+      expect(subject.to_unit(name)).to eq expected
     end
   end
 end

data/spec/fleet_spec.rb

@@ -38,15 +38,21 @@ describe Fleet do
     let(:url) { 'http://foo.com/bar' }
 
     before do
-      stub_const('Fleet::Configuration::DEFAULT_ETCD_API_URL', url)
+      stub_const('Fleet::Configuration::DEFAULT_FLEET_API_URL', url)
       Fleet.reset
     end
 
-    it 'defaults to the value of DEFAULT_ETCD_API_URL' do
+    it 'defaults to the value of DEFAULT_FLEET_API_URL' do
       expect(Fleet.fleet_api_url).to eq url
     end
   end
 
+  describe '.fleet_api_version' do
+    it 'defaults to v1' do
+      expect(Fleet.fleet_api_version).to eq 'v1'
+    end
+  end
+
   describe '.open_timeout' do
     it 'defaults to 2' do
       expect(Fleet.open_timeout).to eq 2
@@ -59,18 +65,6 @@ describe Fleet do
     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

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: fleet-api
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - CenturyLink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-14 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.9
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.9
-- !ruby/object:Gem::Dependency
-  name: faraday_middleware
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.27.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.27.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -112,18 +98,15 @@ files:
 - fleet-api.gemspec
 - lib/fleet.rb
 - lib/fleet/client.rb
-- lib/fleet/client/job.rb
 - lib/fleet/client/machines.rb
 - lib/fleet/client/state.rb
 - lib/fleet/client/unit.rb
 - lib/fleet/configuration.rb
 - lib/fleet/connection.rb
 - lib/fleet/error.rb
-- lib/fleet/middleware/response/raise_error.rb
 - lib/fleet/request.rb
 - lib/fleet/service_definition.rb
 - lib/fleet/version.rb
-- spec/fleet/client/job_spec.rb
 - spec/fleet/client/machines_spec.rb
 - spec/fleet/client/state_spec.rb
 - spec/fleet/client/unit_spec.rb
@@ -131,7 +114,6 @@ files:
 - spec/fleet/configuration_spec.rb
 - spec/fleet/connection_spec.rb
 - spec/fleet/error_spec.rb
-- spec/fleet/middleware/response/raise_error_spec.rb
 - spec/fleet/request_spec.rb
 - spec/fleet/service_definition_spec.rb
 - spec/fleet_spec.rb
@@ -161,7 +143,6 @@ signing_key:
 specification_version: 4
 summary: A simple REST client for the CoreOS Fleet API
 test_files:
-- spec/fleet/client/job_spec.rb
 - spec/fleet/client/machines_spec.rb
 - spec/fleet/client/state_spec.rb
 - spec/fleet/client/unit_spec.rb
@@ -169,7 +150,6 @@ test_files:
 - spec/fleet/configuration_spec.rb
 - spec/fleet/connection_spec.rb
 - spec/fleet/error_spec.rb
-- spec/fleet/middleware/response/raise_error_spec.rb
 - spec/fleet/request_spec.rb
 - spec/fleet/service_definition_spec.rb
 - spec/fleet_spec.rb

data/lib/fleet/client/job.rb

@@ -1,44 +0,0 @@
-module Fleet
-  class Client
-    module Job
-
-      JOB_RESOURCE = 'job'
-
-      def list_jobs
-        opts = { consistent: true, recursive: true, sorted: true }
-        get(job_path, opts)
-      end
-
-      def get_job(service_name)
-        opts = { consistent: true, recursive: true, sorted: false }
-        get(job_path(service_name, :object), opts)
-      end
-
-      def create_job(service_name, job)
-        opts = {
-          querystring: { 'prevExist' => false },
-          body: { value: job.to_json }
-        }
-        put(job_path(service_name, :object), opts)
-      end
-
-      def delete_job(service_name)
-        opts = { dir: false, recursive: true }
-        delete(job_path(service_name), opts)
-      end
-
-      # Valid values for state - :loaded, :launched, :inactive
-      def update_job_target_state(service_name, state)
-        opts = { value: state }
-        put(job_path(service_name, 'target-state'), opts)
-      end
-
-      private
-
-      def job_path(*parts)
-        resource_path(JOB_RESOURCE, *parts)
-      end
-
-    end
-  end
-end

data/lib/fleet/middleware/response/raise_error.rb

@@ -1,37 +0,0 @@
-require 'faraday'
-require 'json'
-require 'fleet/error'
-
-module Fleet::Middleware
-  module Response
-
-    class RaiseError < Faraday::Response::Middleware
-
-      def on_complete(env)
-        status = env[:status].to_i
-        return unless (400..600).include?(status)
-
-        error = parse_error(env[:body])
-
-        # Find the error class that matches the HTTP status code. Default to
-        # Error if no matching class exists.
-        class_name = Fleet::Error::HTTP_CODE_MAP.fetch(status, 'Error')
-
-        fail Fleet.const_get(class_name).new(
-          error['message'],
-          error['errorCode'],
-          error['cause'])
-      end
-
-      private
-
-      def parse_error(body)
-        JSON.parse(body)
-      rescue StandardError
-        { 'message' => body }
-      end
-    end
-
-    Faraday.register_middleware :response, raise_fleet_error: -> { RaiseError }
-  end
-end