frodo 0.12.4 → 0.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6171a906fa516145d1ea9bbff61f771cdbf9b936ceb815071ac93390ab9775c2
-  data.tar.gz: 0f2c9b9d8d3c0311edd87b8a624ca8a6c807662a2522b3acfeffcdb29abb8b8b
+  metadata.gz: be94d246c0478f5b6e1f7b8816a9b2558c8f4e71649d50ce9722ae33dc8496a1
+  data.tar.gz: b09e077ea5a40039b571601c8c6a1e3576649dca6d81925c8df83a9842b35902
 SHA512:
-  metadata.gz: be855e21a2371911d083c079059cd79473826f310334e11b75bda47d9cc59d883da3649587b308bec88b1bb2a0af779cec8bc29acc5bae3532ecf84049fc8be3
-  data.tar.gz: 1de688ddb8d1695c59d29d42f92d14e1a86572d4cc2e0fd16268fe7f1a7a4bd8e56e145265aeb3b000ca4053f5ff4ac74328b20db31740053e93f03375e2fa43
+  metadata.gz: be646abf7839a1e9a726725691cffab8d41de9fd317664295b5bde64387b6e1fd434faef311bc6c1754fbc6f123e833ba4e806c605d3240799e0b7bce56b5440
+  data.tar.gz: adf218a868e0464583e32ebf1fc9b3e229e375ec89ec1344e2b4f7b4e05acc7716b9464dc17a28c392264934419a607320b46b037828faa20d3942805a06f27c

data/lib/frodo/concerns/api.rb

@@ -69,9 +69,9 @@ module Frodo
                     end
 
         body = api_get(url_chunk).body
-
         # if manual query as a string we detect the set on the response
         entity_set = body['@odata.context'].split('#')[-1] if entity_set.nil?
+
         build_entity(entity_set, body)
       end
 
@@ -109,13 +109,12 @@ module Frodo
       # Returns the primary key value of the newly created entity.
       # Raises exceptions if an error is returned from Dynamics.
       def create!(entity_set_name, attrs)
-        entity_set = service[entity_set_name]
-        url_chunk = entity_set_to_url_chunk(entity_set)
-        url = api_post(url_chunk, attrs).headers['odata-entityid']
+        url = api_post(entity_set_name, attrs).headers['odata-entityid']
         id_match = url.match(/\((.+)\)/)
         if id_match.nil?
           raise Frodo::Error.new "entity url not in expected format: #{url.inspect}"
         end
+
         return id_match[1]
       end
       alias insert! create!
@@ -150,12 +149,10 @@ module Frodo
       #
       # Returns true if the entity was successfully updated.
       # Raises an exception if an error is returned from Dynamics.
-      def update!(entity_set, attrs, additional_headers={})
-        entity = service[entity_set].new_entity(attrs)
-        url_chunk = to_url_chunk(entity)
-
-        raise ArgumentError, 'ID field missing from provided attributes' if entity.is_new?
+      def update!(entity_set_name, primary_key, attrs, additional_headers={})
+        raise ArgumentError, 'ID field missing from provided attributes' unless attrs.has_key?(primary_key)
 
+        url_chunk = "#{entity_set_name}(#{attrs[primary_key]})"
         api_patch url_chunk, attrs do |req|
           req.headers.merge!(additional_headers)
         end
@@ -208,7 +205,7 @@ module Frodo
       # Returns the Entity record.
       def find(entity_set, id)
         query = service[entity_set].query
-        url_chunk = query.find(id)
+        url_chunk = query.find(id, entity_set)
 
         body = api_get(url_chunk).body
         build_entity(entity_set, body)
@@ -225,7 +222,7 @@ module Frodo
         query = service[entity_set].query
 
         fields.each{|field| query.select(field)}
-        url_chunk = query.find(id)
+        url_chunk = query.find(id, entity_set)
 
         body = api_get(url_chunk).body
         build_entity(entity_set, body)
@@ -269,8 +266,11 @@ module Frodo
       end
 
       def build_entity(entity_set, data)
-        entity_options = service[entity_set].entity_options
-        single_entity?(data) ? parse_entity(data, entity_options) : parse_entities(data, entity_options)
+        if service.with_metadata?
+          entity_options = service[entity_set].entity_options
+          return single_entity?(data) ? parse_entity(data, entity_options) : parse_entities(data, entity_options)
+        end
+        single_entity?(data) ? data : data['value']
       end
 
       def single_entity?(body)
@@ -293,9 +293,7 @@ module Frodo
         entity.is_new? ? set : "#{set}(#{primary_key})"
       end
 
-      def entity_set_to_url_chunk(entity_set)
-        return entity_set.name
-      end
+
 
       # Internal: Errors that should be rescued from in non-bang methods
       def exceptions

data/lib/frodo/query.rb

@@ -30,12 +30,7 @@ module Frodo
     # @param key [to_s] primary key to lookup
     # @return the path and querystring [String]
     def find(key)
-      entity = @entity_set.new_entity
-      key_property = entity.get_property(entity.primary_key)
-      key_property.value = key
-
-      pathname = "#{entity_set.name}(#{key_property.url_value})"
-
+      pathname = "#{entity_set.name}(#{key})"
       select_criteria = if list_criteria(:select)
                           list_criteria(:select).map { |k, v| "#{k}=#{v}" }.join('&')
                         end

data/lib/frodo/service.rb

@@ -70,7 +70,11 @@ module Frodo
     # @param entity_set_name [to_s] the name of the EntitySet desired
     # @return [Frodo::EntitySet] an Frodo::EntitySet to query
     def [](entity_set_name)
-      entity_container[entity_set_name]
+      if with_metadata?
+        entity_container[entity_set_name]
+      else
+        EntitySet.new(name: entity_set_name)
+      end
     end
 
     # Returns the default namespace, that is, the namespace of the schema
@@ -168,6 +172,10 @@ module Frodo
       end
     end
 
+    def with_metadata?
+      !options.key?(:with_metadata) || options[:with_metadata]
+    end
+
     private
 
     def default_options
@@ -177,7 +185,7 @@ module Frodo
     end
 
     def default_logger
-        Frodo.configuration.logger if Frodo.log?
+      Frodo.configuration.logger if Frodo.log?
     end
 
     def read_metadata

data/lib/frodo/version.rb

@@ -1,3 +1,3 @@
 module Frodo
-  VERSION = '0.12.4'
+  VERSION = '0.12.5'
 end

data/spec/frodo/client_spec.rb

@@ -26,6 +26,7 @@ describe Frodo::Client do
         to_return(body: File.new('spec/fixtures/files/metadata.xml'), status: 200)
 
     service = client.service
+    allow(service).to receive(:with_metadata?).and_return(true)
 
     expect(service['Products']).to_not be_nil
     expect(service['Products'].name).to eql('Products')

data/spec/frodo/concerns/api_spec.rb

@@ -6,22 +6,23 @@ require 'json'
 describe Frodo::Concerns::API do
   let(:klass) do
     context = self
-    Class.new {
+    Class.new do
       include Frodo::Concerns::Base
       include Frodo::Concerns::Connection
 
       include context.described_class
-    }
+    end
   end
 
   let(:client) { klass.new }
-  let(:connection) {
-    Faraday.new('http://frodo.com', {}) do |conn|
+  let(:connection_uri) { 'http://frodo.com' }
+  let(:connection) do
+    Faraday.new(connection_uri, {}) do |conn|
       conn.request :json
       conn.response :json
       conn.adapter Faraday.default_adapter
     end
-  }
+  end
 
   subject { client }
 
@@ -58,7 +59,7 @@ describe Frodo::Concerns::API do
     let(:url_chunk) { "leads?$filter=firstname eq 'yo'" }
     let(:path) { url_chunk }
     let(:entity_name) { 'entity' }
-    let(:context) { "serviceRoot/$metadata##{entity_name}"}
+    let(:context) { "serviceRoot/$metadata##{entity_name}" }
     let(:body) { { '@odata.context' => context } }
 
     context 'url_chunk provided' do
@@ -105,7 +106,7 @@ describe Frodo::Concerns::API do
     it 'raises other errors' do
       allow(client).to receive(:create!).with(entity_type, attributes).and_raise(StandardError)
 
-      expect{ subject }.to raise_error(StandardError)
+      expect { subject }.to raise_error(StandardError)
     end
   end
 
@@ -116,27 +117,14 @@ describe Frodo::Concerns::API do
     let(:attributes) { {} }
     let(:options) { attributes }
     let(:headers) { { 'odata-entityid' => url } }
-    let(:entity_set_name) { 'things' }
 
+    before { stub_request(verb, "#{connection_uri}/#{entity_type}").to_return(body: body.to_json, headers: headers) }
     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(:name).and_return(entity_set_name)
-      allow(client).to receive(:entity_set_to_url_chunk).with(entity_set).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(StandardError)
-    end
-
     context 'alias .insert!' do
       subject { client.insert!(entity_type, attributes) }
 
@@ -145,38 +133,42 @@ describe Frodo::Concerns::API do
   end
 
   describe '.update' do
-    let(:attributes) { {} }
+    let(:attributes) { { 'typeid' => 'some_id' } }
+    let(:primary_key) { 'typeid' }
 
-    subject { client.update(entity_type, attributes) }
+    before { stub_request(verb, "#{connection_uri}/#{entity_type}(some_id)").to_return(body: body.to_json, headers: headers) }
+    subject { client.update(entity_type, primary_key, attributes) }
 
     it 'calls .create! and returns the result' do
-      allow(client).to receive(:update!).with(entity_type, attributes).and_return(true)
+      expect(client).to receive(:update!).with(entity_type, primary_key, 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)
+      allow(client).to receive(:update!).with(entity_type, primary_key, 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)
+      allow(client).to receive(:update!).with(entity_type, primary_key, attributes).and_raise(StandardError)
 
-      expect{ subject }.to raise_error(StandardError)
+      expect { subject }.to raise_error(StandardError)
     end
   end
 
   describe '.update!' do
     let(:verb) { :patch }
-    let(:attributes) { {} }
+    let(:attributes) { { 'typeid' => 'some_id' } }
     let(:options) { attributes }
     let(:is_new) { false }
+    let(:primary_key) { 'typeid' }
 
-    subject { client.update!(entity_type, attributes) }
+    subject { client.update!(entity_type, primary_key, attributes) }
 
     before do
+      stub_request(verb, "#{connection_uri}/#{entity_type}(some_id)").to_return(body: body.to_json, headers: headers)
       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)
@@ -189,37 +181,40 @@ describe Frodo::Concerns::API do
     end
 
     it 'raises errors that occur' do
-      allow(client).to receive(:service).and_raise(StandardError)
+      allow(client).to receive(:api_patch).and_raise(StandardError)
 
-      expect{ subject }.to raise_error(StandardError)
+      expect { subject }.to raise_error(StandardError)
     end
 
     context 'new entity (ie. has no id)' do
       let(:is_new) { true }
+      let(:attributes) { {} }
 
       it 'raises ArgumentError' do
-        expect{ subject }.to raise_error(ArgumentError)
+        expect { subject }.to raise_error(ArgumentError)
       end
     end
 
     context 'with @odata.bind properties' do
-      let(:attributes) {{
+      let(:attributes) do
+        {
           'ownerid@odata.bind': '/systemusers(12345)'
-      }}
+        }
+      end
       it 'calls .update! with unmodified attributes' do
-        expect(client).to receive(:update!).with(entity_type, attributes).and_return(true)
+        expect(client).to receive(:update!).with(entity_type, primary_key, attributes).and_return(true)
         expect(subject).to be(true)
       end
     end
 
     context 'with additional headers' do
-      let(:additional_header) { {"header" => '1' } }
+      let(:additional_header) { { 'header' => '1' } }
 
       before do
         stub_request(verb, uri).to_return(body: body.to_json, headers: headers.merge!(additional_header))
       end
 
-      subject { client.update!(entity_type, attributes, additional_header) }
+      subject { client.update!(entity_type, primary_key, attributes, additional_header) }
 
       it 'should update' do
         expect(subject).to be(true)
@@ -227,7 +222,7 @@ describe Frodo::Concerns::API do
 
       it 'sets headers on the built request object' do
         expect_any_instance_of(Faraday::Builder).to receive(:build_response)
-        .with(anything(), have_attributes(headers: hash_including(additional_header)))
+          .with(anything, have_attributes(headers: hash_including(additional_header)))
 
         subject
       end
@@ -235,7 +230,6 @@ describe Frodo::Concerns::API do
   end
 
   describe '.destroy' do
-
     subject { client.destroy(entity_type, id) }
 
     it 'calls .create! and returns true' do
@@ -253,7 +247,7 @@ describe Frodo::Concerns::API do
     it 'raises other errors' do
       allow(client).to receive(:destroy!).with(entity_type, id).and_raise(StandardError)
 
-      expect{ subject }.to raise_error(StandardError)
+      expect { subject }.to raise_error(StandardError)
     end
   end
 
@@ -279,14 +273,13 @@ describe Frodo::Concerns::API do
   end
 
   describe '.find' do
-
-    subject { client.find(entity_type, id)}
+    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(query).to receive(:find).with(id, entity_type).and_return(path)
       allow(client).to receive(:build_entity).with(entity_type, body).and_return(entity)
 
       expect(subject).to eq(entity)
@@ -329,7 +322,6 @@ describe Frodo::Concerns::API do
     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)
@@ -341,7 +333,7 @@ describe Frodo::Concerns::API do
       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)
+        expect { subject }.to raise_error(StandardError)
       end
     end
 
@@ -362,7 +354,7 @@ describe Frodo::Concerns::API do
       it 'raises any error that occurs' do
         allow(client).to receive(:service).and_raise(StandardError)
 
-        expect{ subject }.to raise_error(StandardError)
+        expect { subject }.to raise_error(StandardError)
       end
     end
   end
@@ -370,7 +362,6 @@ describe Frodo::Concerns::API do
   # private methods
 
   describe '.api_path' do
-
     subject { client.send(:api_path, path) }
 
     context 'base_path is defined' do
@@ -393,24 +384,43 @@ describe Frodo::Concerns::API do
 
     before do
       allow(client).to receive(:service).and_return(service)
+      allow(service).to receive(:with_metadata?).and_return(true)
       allow(service).to receive(:[]).with(entity_type).and_return(entity_set)
       allow(entity_set).to receive(:entity_options).and_return(options)
     end
+    context 'without metadata' do
+      before { allow(service).to receive(:with_metadata?).and_return(false) }
 
-    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
+      it 'parses single entity' do
+        allow(client).to receive(:single_entity?).with(data).and_return(true)
+        expect(subject).to eq(data)
+      end
 
-    context 'multiple entities' do
-      it 'parses multiple entities' do
-        allow(client).to receive(:single_entity?).with(data).and_return(false)
+      context 'multiple entities' do
+        let(:data) { { 'odata' => 'test', 'value' => 'data!!!' } }
+        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)
+          expect(subject).to eq(data['value'])
+        end
+      end
+    end
+    context 'with metadata' do
+      before { allow(service).to receive(:with_metadata?).and_return(true) }
+      it 'parses single entity' do
+        expect(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
+        let(:data) { { 'odata' => 'test', 'value' => 'data!!!' } }
+        it 'parses multiple entities' do
+          expect(client).to receive(:single_entity?).with(data).and_return(false)
+          expect(client).to receive(:parse_entities).with(data, options)
+          subject
+        end
+      end
     end
   end
 
@@ -442,9 +452,9 @@ describe Frodo::Concerns::API do
   end
 
   describe '.parse_entities' do
-    let(:entity_data) { "data!!!" }
+    let(:entity_data) { 'data!!!' }
     let(:data_value) { [entity_data, entity_data] }
-    let(:data) { { 'value' =>  data_value } }
+    let(:data) { { 'value' => data_value } }
 
     subject { client.send(:parse_entities, data, options) }
 
@@ -455,9 +465,9 @@ describe Frodo::Concerns::API do
   end
 
   describe '.to_url_chunk' do
-    let(:primary_key) { "I am the key!" }
-    let(:property) { double() }
-    let(:set) { "Who am I?" }
+    let(:primary_key) { 'I am the key!' }
+    let(:property) { double }
+    let(:set) { 'Who am I?' }
 
     subject { client.send(:to_url_chunk, entity) }
 

data/spec/frodo/service_spec.rb

@@ -130,7 +130,40 @@ describe Frodo::Service do
   describe '#[]' do
     let(:entity_sets) { subject.entity_sets.keys.map { |name| subject[name] } }
     it { expect(entity_sets).to all(be_a(Frodo::EntitySet)) }
-    it { expect {subject['Nonexistant']}.to raise_error(ArgumentError) }
+    it { expect { subject['Nonexistant'] }.to raise_error(ArgumentError) }
+    context 'when with_metadata returns false' do
+      before { allow(subject).to receive(:with_metadata?).and_return(false) }
+      it 'returns  empty EntitySet' do
+        expect(subject['Nonexistant']).to be_a(Frodo::EntitySet)
+      end
+    end
+  end
+
+  describe '#with_metadata?' do
+    let(:options){{
+      name: 'ODataDemo',
+      metadata_file: metadata_file
+    }}
+    let(:subject) { Frodo::Service.new(service_url, options) }
+
+    it { expect(subject.with_metadata?).to be true}
+
+    context "when with_metadata true" do
+      let(:options){{
+        name: 'ODataDemo',
+        metadata_file: metadata_file,
+        with_metadata: true
+      }}
+      it { expect(subject.with_metadata?).to be true}
+    end
+    context "when with_metadata true" do
+      let(:options){{
+        name: 'ODataDemo',
+        metadata_file: metadata_file,
+        with_metadata: true
+      }}
+      it { expect(subject.with_metadata?).to be true}
+    end
   end
 
   describe '#get_property_type' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frodo
 version: !ruby/object:Gem::Version
-  version: 0.12.4
+  version: 0.12.5
 platform: ruby
 authors:
 - Emmanuel Pinault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-15 00:00:00.000000000 Z
+date: 2019-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri