Merge pull request #1 from cb-talent-development/feature/results-object

Feature/results object

Author: Casao

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cortex-client (0.2.5)
+    cortex-client (0.2.6)
       faraday (~> 0.9)
       faraday_middleware (~> 0.9.0)
       oauth2 (~> 0.9)
@@ -15,6 +15,9 @@ GEM
     faraday_middleware (0.9.1)
       faraday (>= 0.7.4, < 0.10)
     jwt (1.0.0)
+    metaclass (0.0.4)
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
     multi_json (1.10.1)
     multi_xml (0.5.5)
     multipart-post (2.0.0)
@@ -44,5 +47,6 @@ PLATFORMS
 
 DEPENDENCIES
   cortex-client!
+  mocha
   rake (~> 10.3.2)
   rspec (~> 3.0)

cortex-client.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake', '~> 10.3.2'
   s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'mocha'
 
   s.add_dependency 'faraday', '~> 0.9'
   s.add_dependency 'faraday_middleware', '~> 0.9.0'

lib/cortex/client.rb

@@ -3,6 +3,7 @@
 require 'cortex/resource'
 require 'cortex/posts'
 require 'cortex/users'
+require 'cortex/result'
 require 'oauth2'
 
 module Cortex

lib/cortex/posts.rb

@@ -1,17 +1,21 @@
 module Cortex
   class Posts  < Cortex::Resource
-    def query(params = nil)
+    def query(params = {})
       client.get('/posts', params)
     end
 
-    def feed(params = nil)
+    def feed(params = {})
       client.get('/posts/feed', params)
     end
 
     def get(id)
       client.get("/posts/#{id}")
     end
 
+    def get_published(id)
+      client.get("/posts/feed/#{id}")
+    end
+
     def save(post)
       client.save('/posts', post)
     end
@@ -24,7 +28,7 @@ def filters
       client.get('/posts/filters')
     end
 
-    def related(id, params = nil)
+    def related(id, params = {})
       client.get("/posts/feed/#{id}/related", params)
     end
 

lib/cortex/request.rb

@@ -30,30 +30,15 @@ def delete(path)
       response = connection.delete do |r|
         r.url base_url + path
       end
-      response.status < 300
-    end
-
-    def delete!(path)
-      response = connection.delete do |r|
-        r.url base_url + path
-      end
-      if response.status < 300
-        true
-      else
-        raise parse_response(response)
-      end
+      parse_response(response)
     end
 
     def save(path, model)
       model[:id] ? put("#{path}/#{model[:id]}", model) : post(path, model)
     end
 
     def parse_response(response)
-      if response.status < 300 || (response.body.kind_of?(Hash) && response.body['error'])
-        OpenStruct.new({body: response.body, headers: { status: response.status }.merge(response.headers.select { |k| ['content-range', 'x-total-items'].include? k })  })
-      else
-        OpenStruct.new({body: {error: response.body, status: response.status, original: response}, headers: { status: response.status }})
-      end
+      Cortex::Result.new(response.body, response.headers, response.status)
     end
   end
 end

lib/cortex/result.rb

@@ -0,0 +1,50 @@
+module Cortex
+  class Result
+    attr_reader :raw_headers, :contents, :total_items, :page, :per_page, :errors, :range_start, :range_end, :range
+
+    def initialize(body, headers, status)
+      @contents = body
+      @raw_headers = headers
+      @status = status
+      @total_items = headers['x-total-items'] unless headers['x-total-items'].nil?
+      parse_headers(headers)
+      @errors = find_errors
+    end
+
+    def is_error?
+      @status >= 400 || (@contents.is_a?(Hash) && @contents.has_key?('errors'))
+    end
+
+    private
+
+    def parse_headers(headers)
+      if headers['x-total-items']
+        @count = headers['x-total-items']
+      end
+      if headers['content-range']
+        matches = headers['content-range'].match(/^(\w+) (\d+)\-(\d+):(\d+)\/\d+$/i)
+        @per_page = matches[4].to_i
+        @range_start = matches[2].to_i
+        @range_end = matches[3].to_i
+        @range = "#{@range_start}-#{@range_end}"
+        @page = (@range_end / @per_page) + 1
+      end
+    end
+
+    def find_errors
+      if is_error?
+        if @contents.is_a?(Hash)
+          if @contents.has_key?('errors')
+            Array(@contents['errors'])
+          else
+            Array(@contents['message'])
+          end
+        else
+          Array(@contents)
+        end
+      else
+        Array(nil)
+      end
+    end
+  end
+end

spec/client_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Cortex::Client do
+RSpec.describe Cortex::Client do
 
   let(:access_token) { '123' }
   let(:base_url) { 'http://localhost:3000' }

spec/posts_spec.rb

@@ -1,64 +1,71 @@
 require 'spec_helper'
 
-describe Cortex::Posts do
+RSpec.describe Cortex::Posts do
 
   let(:client) { Cortex::Client.new(access_token: '123') }
 
   describe :get do
     it 'should correctly make the request' do
-      expect(client).to receive(:get).with('/posts/1').and_return('response')
+      client.expects(:get).with('/posts/1').returns('response')
       expect(client.posts.get(1)).to eq('response')
     end
   end
 
+  describe :get_published do
+    it 'should correctly make the request' do
+      client.expects(:get).with('/posts/feed/1').returns('response')
+      expect(client.posts.get_published(1)).to eq('response')
+    end
+  end
+
   describe :feed do
     it 'should correctly make the request' do
-      expect(client).to receive(:get).with('/posts/feed', nil).and_return('response')
+      client.expects(:get).with('/posts/feed', {}).returns('response')
       expect(client.posts.feed()).to eq('response')
     end
 
     it 'should accept parameters and send them with the request' do
-      expect(client).to receive(:get).with('/posts/feed', {q: "Test*"}).and_return('success')
-      expect(client.posts.feed(q: 'Test*')).to eq('success')
+      client.expects(:get).with('/posts/feed', {q: "Test*"}).returns('response')
+      expect(client.posts.feed(q: 'Test*')).to eq('response')
     end
   end
 
   describe :save do
     context 'with an existing post' do
       it 'should correctly make the request' do
         post = {:id => 1, :title => 'Post'}
-        expect(client).to receive(:put).with('/posts/1', post).and_return('response')
+        client.expects(:put).with('/posts/1', post).returns('response')
         expect(client.posts.save(post)).to eq('response')
       end
     end
 
     context 'with a new post' do
       it 'should correctly make the request' do
         post = {:title => 'Post'}
-        expect(client).to receive(:post).with('/posts', post).and_return('response')
+        client.expects(:post).with('/posts', post).returns('response')
         expect(client.posts.save(post)).to eq('response')
       end
     end
   end
 
   describe :filters do
     it 'should correctly make the request' do
-      expect(client).to receive(:get).with('/posts/filters').and_return('success')
-      expect(client.posts.filters()).to eq('success')
+      client.expects(:get).with('/posts/filters').returns('response')
+      expect(client.posts.filters()).to eq('response')
     end
   end
 
   describe :related do
     it 'should correctly make the request' do
-      expect(client).to receive(:get).with('/posts/feed/1/related', nil).and_return('success')
-      expect(client.posts.related(1)).to eq('success')
+      client.expects(:get).with('/posts/feed/1/related', {}).returns('response')
+      expect(client.posts.related(1)).to eq('response')
     end
   end
 
   describe :authors do
     it 'should correctly make the request' do
-      expect(client).to receive(:get).with('/posts/feed/authors').and_return('success')
-      expect(client.posts.authors).to eq('success')
+      client.expects(:get).with('/posts/feed/authors').returns('response')
+      expect(client.posts.authors).to eq('response')
     end
   end
 end

spec/request_spec.rb

@@ -3,31 +3,82 @@
 describe Cortex::Request do
   let(:client) { Cortex::Client.new(access_token: '123') }
 
-  context 'with a cortex error response' do
-    it 'should return the error object' do
-      body = {'error' => 'Validation error or something'}
-      response = OpenStruct.new(status: 422, body: body, headers: { :whatever => "Whatever"})
-      expect(client.parse_response(response).to_h).to eq({ :body => body, :headers => {status: 422}})
+  context 'Request Methods' do
+    let(:response) { OpenStruct.new({body: "Body", headers: {}, status: 200} ) }
+    let(:model) { { title: 'Test' } }
+
+    before(:each) do
+      @connection = stub
+      Cortex::Client.any_instance.stubs(:connection).returns(@connection)
+      Cortex::Result.any_instance.stubs(:new).with(response).returns(true)
     end
-  end
 
-  context 'with a non-cortex error response' do
-    it 'should return a wrapped response' do
-      body = 'Catastrophic error'
-      response = OpenStruct.new(status: 500, body: body, headers: { whatever: "Whatever", status: 500 } )
-      parsed = client.parse_response(response)
-      expect(parsed.body[:error]).to eq(body)
-      expect(parsed.body[:status]).to eq(500)
-      expect(parsed.body[:original]).to eq(response)
-      expect(parsed.headers[:status]).to eq(500)
+    describe '#get' do
+      it 'should call get' do
+        @connection.stubs(:get).returns(response).once
+        expect(client.get('/test/')).to be_truthy
+      end
+    end
+
+    describe '#post' do
+      it 'should call post' do
+        @connection.stubs(:post).returns(response).once
+        expect(client.post('/test/')).to be_truthy
+      end
+    end
+
+    describe '#put' do
+      it 'should call put' do
+        @connection.stubs(:put).returns(response).once
+        expect(client.put('/test/')).to be_truthy
+      end
+    end
+
+    describe '#delete' do
+      it 'should call delete' do
+        @connection.stubs(:delete).returns(response).once
+        expect(client.delete('/test/')).to be_truthy
+      end
+    end
+
+    describe '#save' do
+      it 'should post when new' do
+        @connection.stubs(:post).returns(response).once
+        expect(client.save('/test/', model)).to be_truthy
+      end
+
+      it 'should put when updating' do
+        update = model
+        update[:id] = 1
+        @connection.stubs(:put).returns(response).once
+        expect(client.save('/test/', update)).to be_truthy
+      end
     end
   end
 
-  context 'with a successful response' do
-    it 'should return the parsed body' do
-      body = {:id => 1, title: 'A post'}
-      response = OpenStruct.new(status: 200, body: body, headers: { :whatever => "Whatever" })
-      expect(client.parse_response(response).to_h).to eq({ body: body, headers: {status: 200}})
+  context 'Record Parsing' do
+    let(:body) { "Body" }
+    let(:headers) { { } }
+    let(:status) { 200 }
+    let(:error_status) { 400 }
+    let(:response) { OpenStruct.new({body: 'Body', headers: {}, status: 200 } ) }
+
+    describe 'parse_response' do
+      before(:each) do
+        result = stub
+        Cortex::Result.any_instance.stubs(:new).with(body, headers, status).returns(true)
+        Cortex::Result.any_instance.stubs(:new).with(body, headers, error_status).returns(true)
+      end
+
+      it 'should construct a successful response' do
+        expect(client.parse_response(response)).to be_truthy
+      end
+
+      it 'should construct an error response' do
+        error = response
+        error.status = error_status
+        expect(client.parse_response(error)).to be_truthy
+      end
     end
   end
 end

spec/result_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe Cortex::Result do
+  let(:result) { Cortex::Result.new('body', {'x-total-items' => 10, 'content-range' => "posts 0-9:10/200"}, 200) }
+  let(:failed) { Cortex::Result.new('failed body', {}, 403) }
+
+  it 'should construct' do
+    expect(result).to be_truthy
+    expect(failed).to be_truthy
+  end
+
+  it 'should parse the headers' do
+    expect(result.page).to eq 1
+    expect(result.per_page).to eq 10
+    expect(result.range).to eq "0-9"
+  end
+
+  it 'should provide is_error?' do
+    expect(result.is_error?).to be_falsey
+    expect(failed.is_error?).to be_truthy
+  end
+
+  it 'should parse errors properly' do
+    expect(result.errors).to eq []
+    expect(failed.errors).to eq ['failed body']
+  end
+
+  it 'should expose the contents' do
+    expect(result.contents).to eq 'body'
+    expect(failed.contents).to eq 'failed body'
+  end
+
+  it 'should expose the headers' do
+    expect(result.raw_headers).to eq({ 'x-total-items' => 10, 'content-range' => "posts 0-9:10/200" })
+    expect(failed.raw_headers).to eq({})
+  end
+
+end