frodo 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8f56d9927d67dbbd6ffd716c73efde55b370083
-  data.tar.gz: bf09fc5ca9a219c6f6eb0593ef8e7890cbf240c6
+  metadata.gz: d4990d9c4a633bd34d89ad21e4b2dc22ce67403d
+  data.tar.gz: 49cf24c243adf8173b957b3b364e38a44d4d039d
 SHA512:
-  metadata.gz: 9ee5bef44ae2d6ff783deea44efeb4b3a562471e02ad0ea1d2204c6d19a8a77509a36ad36faecc7449e15cddd923f2485628b59a7239ca0ae74f9bd6fb92a4ac
-  data.tar.gz: 5a508d979808942225b9c68bcf1438aecff8404d90f3735f0d47caaff9a446c507d6ef80148d15b40838e9d5ce66350752175af407ffc586f30fa51a1e27d1fd
+  metadata.gz: 950fa068d71e394f5466260ce4c8dc187990882da04fae039c0bf7437527aa763497b751b1ec27d2640a5077aa175abe8a381817d09b060035502aa3a8b4783e
+  data.tar.gz: 9c61d5759570a975fa136a4f1c0399cbf88bbcb00edb0240c7d6b972f3840a8e7928b9325fa96e8a2cfda1364ae8d920c35e3c4544eb512b4dcd9e44e1ae83a9

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## 0.10.1
+
+[Fixed] Warning on Error definitions
+
+## 0.10.0
+
+[Breaking] New client was introduce. Uses Faraday and middlewares
+	   Query.first and Query.count do not execute either. Return the query as a string to execute
+	   Removed interface on EntitySet and Entity to make those more structural object for now
+[New Feature] Support Query.find with selecting specific fields
+	      Support Oauth token flow and refresh token callback
+	      Support for passing a service definition in memory
+	      New Primitive API for the client
+[Fixes] guid properly serializing in a query
+
 ## 0.9.3
 
 * Fix broken stack traces in response errors

data/lib/frodo/version.rb

@@ -1,3 +1,3 @@
 module Frodo
-  VERSION = '0.10.0'
+  VERSION = '0.10.1'
 end

data/lib/frodo.rb

@@ -34,7 +34,6 @@ require 'frodo/client'
 require 'frodo/config'
 
 require 'frodo/version'
-require 'frodo/errors'
 require 'frodo/property_registry'
 require 'frodo/property'
 require 'frodo/properties'

data/spec/frodo/concerns/api_spec.rb

@@ -0,0 +1,456 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'json'
+
+describe Frodo::Concerns::API do
+  let(:klass) do
+    context = self
+    Class.new {
+      include Frodo::Concerns::Base
+      include Frodo::Concerns::Connection
+
+      include context.described_class
+    }
+  end
+
+  let(:client) { klass.new }
+  let(:connection) {
+    Faraday.new('http://frodo.com', {}) do |conn|
+      conn.request :json
+      conn.response :json
+      conn.adapter Faraday.default_adapter
+    end
+  }
+
+  subject { client }
+
+  let(:id) { 'some-id' }
+  let(:body) { 'Body' }
+  let(:path) { 'something/foo' }
+  # Leverage WebMock match URI by pattern, needs to escape string otherwise chars like '$' are misinterpretted
+  let(:uri) { /#{Regexp.escape(path)}/ }
+  let(:options) { {} }
+  let(:verb) { :get }
+  let(:headers) { {} }
+  let(:entity_type) { 'Type' }
+  let(:entity_set) { double(Frodo::EntitySet) }
+  let(:entity) { double(Frodo::Entity) }
+  let(:service) { double(Frodo::Service) }
+  let(:query) { double(Frodo::Query) }
+  let(:client_error) { Faraday::Error::ClientError.new(StandardError.new) }
+
+  before do
+    stub_request(verb, uri).to_return(body: body.to_json, headers: headers)
+    allow(client).to receive(:options).and_return(options)
+    allow(client).to receive(:connection).and_return(connection)
+  end
+
+  describe '.metadata' do
+    let(:path) { '$metadata' }
+
+    it 'fetches body of GET $metadata' do
+      expect(subject.metadata).to eq(body)
+    end
+  end
+
+  describe '.query' do
+    let(:url_chunk) { "leads?$filter=firstname eq 'yo'" }
+    let(:path) { url_chunk }
+    let(:entity_name) { 'entity' }
+    let(:context) { "serviceRoot/$metadata##{entity_name}"}
+    let(:body) { { '@odata.context' => context } }
+
+    context 'url_chunk provided' do
+      let(:query) { url_chunk }
+
+      it 'returns entity fetched from url_chunk' do
+        allow(client).to receive(:build_entity).with(entity_name, body).and_return(entity)
+
+        expect(subject.query(query)).to eq(entity)
+      end
+    end
+
+    context 'Frodo::Query provided' do
+      let(:query) { double(Frodo::Query) }
+
+      it 'returns entity fetched from query' do
+        allow(query).to receive(:to_s).and_return(path)
+        allow(query).to receive(:entity_set).and_return(entity)
+        allow(entity).to receive(:name).and_return(entity_name)
+        allow(client).to receive(:build_entity).with(entity_name, body).and_return(entity)
+
+        expect(subject.query(query)).to eq(entity)
+      end
+    end
+  end
+
+  describe '.create' do
+    let(:attributes) { {} }
+
+    subject { client.create(entity_type, attributes) }
+
+    it 'calls .create! and returns the result' do
+      allow(client).to receive(:create!).with(entity_type, attributes).and_return(true)
+
+      expect(subject).to eq(true)
+    end
+
+    it 'returns false for expected exceptions' do
+      allow(client).to receive(:create!).with(entity_type, attributes).and_raise(client_error)
+
+      expect(subject).to eq(false)
+    end
+
+    it 'raises other errors' do
+      allow(client).to receive(:create!).with(entity_type, attributes).and_raise(StandardError)
+
+      expect{ subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.create!' do
+    let(:id) { '(an-id)' }
+    let(:url) { "blah/#{id}/foo" }
+    let(:verb) { :post }
+    let(:attributes) { {} }
+    let(:options) { attributes }
+    let(:headers) { { 'odata-entityid' => url } }
+
+    subject { client.create!(entity_type, attributes) }
+
+    before do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:new_entity).with(attributes).and_return(entity)
+      allow(client).to receive(:to_url_chunk).with(entity).and_return(path)
+    end
+
+    it 'posts entity_set info and returns resulting id' do
+      expect(subject).to eq(id)
+    end
+
+    it 'raises errors that occur' do
+      allow(client).to receive(:service).and_raise(StandardError)
+
+      expect{ subject }.to raise_error
+    end
+
+    context 'alias .insert!' do
+      subject { client.insert!(entity_type, attributes) }
+
+      it { should eq(id) }
+    end
+  end
+
+  describe '.update' do
+    let(:attributes) { {} }
+
+    subject { client.update(entity_type, attributes) }
+
+    it 'calls .create! and returns the result' do
+      allow(client).to receive(:update!).with(entity_type, attributes).and_return(true)
+
+      expect(subject).to be(true)
+    end
+
+    it 'returns false for expected exceptions' do
+      allow(client).to receive(:update!).with(entity_type, attributes).and_raise(client_error)
+
+      expect(subject).to eq(false)
+    end
+
+    it 'raises other errors' do
+      allow(client).to receive(:update!).with(entity_type, attributes).and_raise(StandardError)
+
+      expect{ subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.update!' do
+    let(:verb) { :patch }
+    let(:attributes) { {} }
+    let(:options) { attributes }
+    let(:is_new) { false }
+
+    subject { client.update!(entity_type, attributes) }
+
+    before do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:new_entity).with(attributes).and_return(entity)
+      allow(client).to receive(:to_url_chunk).with(entity).and_return(path)
+      allow(entity).to receive(:is_new?).and_return(is_new)
+    end
+
+    it 'posts entity_set info and returns true' do
+      expect(subject).to eq(true)
+    end
+
+    it 'raises errors that occur' do
+      allow(client).to receive(:service).and_raise(StandardError)
+
+      expect{ subject }.to raise_error(StandardError)
+    end
+
+    context 'new entity (ie. has no id)' do
+      let(:is_new) { true }
+
+      it 'raises ArgumentError' do
+        expect{ subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.destroy' do
+
+    subject { client.destroy(entity_type, id) }
+
+    it 'calls .create! and returns true' do
+      allow(client).to receive(:destroy!).with(entity_type, id).and_return(true)
+
+      expect(subject).to be(true)
+    end
+
+    it 'returns false for expected exceptions' do
+      allow(client).to receive(:destroy!).with(entity_type, id).and_raise(client_error)
+
+      expect(subject).to eq(false)
+    end
+
+    it 'raises other errors' do
+      allow(client).to receive(:destroy!).with(entity_type, id).and_raise(StandardError)
+
+      expect{ subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.destroy!' do
+    let(:verb) { :delete }
+
+    subject { client.destroy!(entity_type, id) }
+
+    it 'deletes entity_set and returns true' do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:query).and_return(query)
+      allow(query).to receive(:find).with(id).and_return(path)
+
+      expect(subject).to eq(true)
+    end
+
+    it 'raises exceptions' do
+      allow(client).to receive(:service).and_raise(StandardError)
+
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.find' do
+
+    subject { client.find(entity_type, id)}
+
+    it 'returns found entity_set' do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:query).and_return(query)
+      allow(query).to receive(:find).with(id).and_return(path)
+      allow(client).to receive(:build_entity).with(entity_type, body).and_return(entity)
+
+      expect(subject).to eq(entity)
+    end
+
+    it 'raises any error that occurs' do
+      allow(client).to receive(:service).and_raise(StandardError)
+
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.select' do
+    let(:fields) { ['field'] }
+
+    subject { client.select(entity_type, id, fields) }
+
+    it 'returns selected entity and fields' do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:query).and_return(query)
+      allow(query).to receive(:find).and_return(path)
+      allow(client).to receive(:build_entity).with(entity_type, body).and_return(entity)
+
+      expect(query).to receive(:select).exactly(fields.count).times
+      expect(subject).to eq(entity)
+    end
+
+    it 'raises any error that occurs' do
+      allow(client).to receive(:service).and_raise(StandardError)
+
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  describe '.count' do
+    let(:count) { 99 }
+    let(:body) { { '@odata.count' => count } }
+
+    subject { client.count(query) }
+
+    context 'provided a Frodo::Query' do
+
+      it 'uses query object to build count query and returns count' do
+        allow(query).to receive(:is_a?).with(Frodo::Query.class).and_return(true)
+        allow(query).to receive(:include_count)
+        allow(query).to receive(:to_s).and_return(path)
+
+        expect(subject).to eq(count.to_i)
+      end
+
+      it 'raises any error that occurs' do
+        allow(query).to receive(:is_a?).with(Frodo::Query.class).and_raise(StandardError)
+
+        expect{ subject }.to raise_error(StandardError)
+      end
+    end
+
+    context 'provided a string that is entity_type' do
+      let(:query) { entity_type }
+      let(:frodo_query) { double(Frodo::Query) }
+      let(:body) { count.to_s }
+
+      it 'makes count query and retuns count' do
+        allow(client).to receive(:service).and_return(service)
+        allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+        allow(entity_set).to receive(:query).and_return(frodo_query)
+        allow(frodo_query).to receive(:count).and_return(path)
+
+        expect(subject).to eq(count)
+      end
+
+      it 'raises any error that occurs' do
+        allow(client).to receive(:service).and_raise(StandardError)
+
+        expect{ subject }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  # private methods
+
+  describe '.api_path' do
+
+    subject { client.send(:api_path, path) }
+
+    context 'base_path is defined' do
+      let(:options) { { base_path: path } }
+
+      it 'returns base_path + path' do
+        allow(client).to receive(:options).and_return(options)
+
+        expect(subject).to eq("#{path}/#{path}")
+      end
+    end
+
+    it { should eq "/#{path}" }
+  end
+
+  describe '.build_entity' do
+    let(:data) { 'data!!!!!' }
+
+    subject { client.send(:build_entity, entity_type, data) }
+
+    before do
+      allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
+      allow(entity_set).to receive(:entity_options).and_return(options)
+    end
+
+    it 'parses single entity' do
+      allow(client).to receive(:single_entity?).with(data).and_return(true)
+
+      expect(client).to receive(:parse_entity).with(data, options)
+      subject
+    end
+
+    context 'multiple entities' do
+      it 'parses multiple entities' do
+        allow(client).to receive(:single_entity?).with(data).and_return(false)
+
+        expect(client).to receive(:parse_entities).with(data, options)
+        subject
+      end
+    end
+  end
+
+  describe '.single_entity?' do
+    let(:body) { { '@odata.context' => '$entity' } }
+
+    subject { client.send(:single_entity?, body) }
+
+    it "returns true when context contains string '$entity'" do
+      expect(subject).to be_truthy
+    end
+
+    context "body context does not contain '$entity'" do
+      let(:body) { { '@odata.context' => 'other' } }
+
+      it { should be(nil) }
+    end
+  end
+
+  describe '.parse_entity' do
+    let(:entity_data) { {} }
+
+    subject { client.send(:parse_entity, entity_data, options) }
+
+    it 'builds Frodo::Entity' do
+      expect(Frodo::Entity).to receive(:from_json).with(entity_data, options)
+      subject
+    end
+  end
+
+  describe '.parse_entities' do
+    let(:entity_data) { "data!!!" }
+    let(:data_value) { [entity_data, entity_data] }
+    let(:data) { { 'value' =>  data_value } }
+
+    subject { client.send(:parse_entities, data, options) }
+
+    it 'builds Frodo::Entity from body value' do
+      expect(Frodo::Entity).to receive(:from_json).with(entity_data, options).exactly(data_value.count).times
+      subject
+    end
+  end
+
+  describe '.to_url_chunk' do
+    let(:primary_key) { "I am the key!" }
+    let(:property) { double() }
+    let(:set) { "Who am I?" }
+
+    subject { client.send(:to_url_chunk, entity) }
+
+    before do
+      allow(entity).to receive(:primary_key).and_return(primary_key)
+      allow(entity).to receive(:get_property).with(primary_key).and_return(property)
+      allow(property).to receive(:url_value).and_return(primary_key)
+      allow(entity).to receive(:entity_set).and_return(entity_set)
+      allow(entity_set).to receive(:name).and_return(set)
+    end
+
+    context 'entities with ids' do
+      it 'returns key composed with private key' do
+        allow(entity).to receive(:is_new?).and_return(false)
+
+        expect(subject).to eq("#{set}(#{primary_key})")
+      end
+    end
+
+    context 'new entities' do
+      it 'returns key composed without private key' do
+        allow(entity).to receive(:is_new?).and_return(true)
+
+        expect(subject).to eq(set)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frodo
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Emmanuel Pinault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-15 00:00:00.000000000 Z
+date: 2019-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -262,7 +262,6 @@ files:
 - lib/frodo/entity.rb
 - lib/frodo/entity_container.rb
 - lib/frodo/entity_set.rb
-- lib/frodo/errors.rb
 - lib/frodo/middleware.rb
 - lib/frodo/middleware/authentication.rb
 - lib/frodo/middleware/authentication/token.rb
@@ -332,6 +331,7 @@ files:
 - spec/fixtures/refresh_error_response.json
 - spec/frodo/abstract_client_spec.rb
 - spec/frodo/client_spec.rb
+- spec/frodo/concerns/api_spec.rb
 - spec/frodo/concerns/authentication_spec.rb
 - spec/frodo/concerns/base_spec.rb
 - spec/frodo/concerns/caching_spec.rb
@@ -341,7 +341,6 @@ files:
 - spec/frodo/entity_container_spec.rb
 - spec/frodo/entity_set_spec.rb
 - spec/frodo/entity_spec.rb
-- spec/frodo/errors_spec.rb
 - spec/frodo/middleware/authentication/token_spec.rb
 - spec/frodo/middleware/authentication_spec.rb
 - spec/frodo/middleware/authorization_spec.rb
@@ -425,6 +424,7 @@ test_files:
 - spec/fixtures/refresh_error_response.json
 - spec/frodo/abstract_client_spec.rb
 - spec/frodo/client_spec.rb
+- spec/frodo/concerns/api_spec.rb
 - spec/frodo/concerns/authentication_spec.rb
 - spec/frodo/concerns/base_spec.rb
 - spec/frodo/concerns/caching_spec.rb
@@ -434,7 +434,6 @@ test_files:
 - spec/frodo/entity_container_spec.rb
 - spec/frodo/entity_set_spec.rb
 - spec/frodo/entity_spec.rb
-- spec/frodo/errors_spec.rb
 - spec/frodo/middleware/authentication/token_spec.rb
 - spec/frodo/middleware/authentication_spec.rb
 - spec/frodo/middleware/authorization_spec.rb

data/lib/frodo/errors.rb

@@ -1,70 +0,0 @@
-module Frodo
-  # Base class for Frodo errors
-  class Error < StandardError
-  end
-
-  # Base class for network errors
-  class RequestError < Error
-    attr_reader :response
-
-    def initialize(response, message = nil)
-      super(message)
-      @message  = message
-      @response = response
-    end
-
-    def http_status
-      response.status
-    end
-
-    def message
-      [default_message, @message].compact.join(': ')
-    end
-
-    def default_message
-      nil
-    end
-  end
-
-  class ClientError < RequestError
-  end
-
-  class ServerError < RequestError
-  end
-
-  module Errors
-    ERROR_MAP = []
-
-    CLIENT_ERRORS = {
-      400 => "Bad Request",
-      401 => "Access Denied",
-      403 => "Forbidden",
-      404 => "Not Found",
-      405 => "Method Not Allowed",
-      406 => "Not Acceptable",
-      413 => "Request Entity Too Large",
-      415 => "Unsupported Media Type"
-    }
-
-    CLIENT_ERRORS.each do |code, message|
-      klass = Class.new(ClientError) do
-        send(:define_method, :default_message) { "#{code} #{message}" }
-      end
-      const_set(message.delete(' \-\''), klass)
-      ERROR_MAP[code] = klass
-    end
-
-    SERVER_ERRORS = {
-      500 => "Internal Server Error",
-      503 => "Service Unavailable"
-    }
-
-    SERVER_ERRORS.each do |code, message|
-      klass = Class.new(ServerError) do
-        send(:define_method, :default_message) { "#{code} #{message}" }
-      end
-      const_set(message.delete(' \-\''), klass)
-      ERROR_MAP[code] = klass
-    end
-  end
-end

data/spec/frodo/errors_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Frodo::RequestError do
-  subject { Frodo::RequestError.new(response, 'The server made a boo-boo.') }
-  let(:response) { instance_double('Faraday::Response', status: 400) }
-
-  describe '#http_status' do
-    it 'returns the status code' do
-      expect(subject.http_status).to eq(response.status)
-    end
-  end
-
-  describe '#response' do
-    it 'returns the response' do
-      expect(subject.response).to eq(response)
-    end
-  end
-
-  describe '#message' do
-    it 'returns the error message' do
-      expect(subject.message).to eq('The server made a boo-boo.')
-    end
-  end
-end
-
-describe Frodo::Errors::InternalServerError do
-  let(:response) { instance_double('Faraday::Response', status: 500) }
-
-  context 'with custom error message' do
-    subject { Frodo::Errors::InternalServerError.new(response, 'The server made a boo-boo.')}
-
-    describe '#message' do
-      it 'combines default message with custom message' do
-        expect(subject.message).to eq('500 Internal Server Error: The server made a boo-boo.')
-      end
-    end
-  end
-
-  context 'without custom error message' do
-    subject { Frodo::Errors::InternalServerError.new(response) }
-
-    describe '#message' do
-      it 'returns the default message' do
-        expect(subject.message).to eq('500 Internal Server Error')
-      end
-    end
-  end
-end