frodo 0.10.0

data/spec/fixtures/refresh_error_response.json

@@ -0,0 +1,8 @@
+{
+  "error": "invalid_grant",
+  "error_description": "AADSTS9002313: Invalid request. Request is malformed or invalid.rnTrace ID: 48716257-6e4f-46fe-b7ec-f98d2f7d0e00rnCorrelation ID: 0127cc73-f029-44b2-a7e2-816525df2229rnTimestamp: 2019-03-12 21:40:14Z",
+  "error_codes": [9002313],
+  "timestamp": "2019-03-12 21:40:14Z",
+  "trace_id": "48716257-6e4f-46fe-b7ec-f98d2f7d0e00",
+  "correlation_id": "0127cc73-f029-44b2-a7e2-816525df2229"
+}

data/spec/frodo/abstract_client_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::AbstractClient do
+  subject { described_class }
+
+  it { should < Frodo::Concerns::Base }
+  it { should < Frodo::Concerns::Connection }
+  it { should < Frodo::Concerns::Authentication }
+  it { should < Frodo::Concerns::Caching }
+  it { should < Frodo::Concerns::API }
+end

data/spec/frodo/client_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Client do
+  subject { described_class }
+
+  let(:instance_url) { 'http://myservice.com'}
+  let(:base_path) { '/api'}
+  let(:service_url) { instance_url + base_path }
+
+  it "creates a client" do
+    client = subject.new(
+      instance_url: instance_url,
+      base_path: base_path,
+      client_id: 'client_id',
+      client_secret: 'secret'
+    )
+
+    expect(client.options[:client_id]).to eql("client_id")
+    expect(client.options[:client_secret]).to eql("secret")
+    expect(client.options[:instance_url]).to eql(instance_url)
+    expect(client.options[:base_path]).to eql("/api")
+
+    stub_request(:get, "#{service_url}/$metadata").
+        to_return(body: File.new('spec/fixtures/files/metadata.xml'), status: 200)
+
+    service = client.service
+
+    expect(service['Products']).to_not be_nil
+    expect(service['Products'].name).to eql('Products')
+    expect(service['Products'].type).to eql('ODataDemo.Product')
+  end
+
+  it "creates a client and inject a service instead of pulling the configured one" do
+    service = Frodo::Service.new(service_url, name: 'Demo', metadata_file: 'spec/fixtures/files/metadata.xml')
+    client = subject.new(
+      instance_url: instance_url,
+      base_path: base_path,
+      client_id: 'client_id',
+      client_secret: 'secret',
+      service: service
+    )
+
+    expect(client.options[:client_id]).to eql("client_id")
+    expect(client.options[:client_secret]).to eql("secret")
+    expect(client.options[:instance_url]).to eql(instance_url)
+    expect(client.options[:base_path]).to eql(base_path)
+
+    expect(client.service).to eql service
+
+    expect(service['Products']).to_not be_nil
+    expect(service['Products'].name).to eql('Products')
+    expect(service['Products'].type).to eql('ODataDemo.Product')
+  end
+
+end

data/spec/frodo/concerns/authentication_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Concerns::Authentication do
+  let(:klass) do
+    context = self
+    Class.new {
+      include Frodo::Concerns::Base
+      include context.described_class
+    }
+  end
+
+  let(:client) { klass.new }
+  subject { client }
+
+  describe '.authenticate!' do
+    subject(:authenticate!) { client.authenticate! }
+
+    context 'when there is no authentication middleware' do
+      before do
+        expect(client).to receive(:authentication_middleware).and_return(nil)
+      end
+
+      it "raises an error" do
+        expect { authenticate! }.to raise_error Frodo::AuthenticationError,
+                                                'No authentication middleware present'
+      end
+    end
+
+    context 'when there is authentication middleware' do
+      let(:authentication_middleware) { double('Authentication Middleware') }
+      subject(:result) { client.authenticate! }
+
+      it 'authenticates using the middleware' do
+        expect(client).to receive(:authentication_middleware).and_return(authentication_middleware).twice
+        expect(client).to receive(:options).twice
+
+        expect(authentication_middleware).to receive(:new).with(nil, client, client.options).and_return(double(authenticate!: 'foo'))
+        expect(result).to eq 'foo'
+      end
+    end
+  end
+
+  describe '.authentication_middleware' do
+    subject { client.authentication_middleware }
+
+    context 'when oauth options are provided' do
+      before do
+        expect(client).to receive(:oauth_refresh?).and_return(true)
+      end
+
+    it { should eq Frodo::Middleware::Authentication::Token }
+    end
+  end
+
+  describe '.oauth_refresh?' do
+    subject       { client.oauth_refresh? }
+    let(:options) { {} }
+
+    before do
+      expect(client).to receive(:options).and_return(options).at_least(1).times
+    end
+
+    context 'when oauth options are provided' do
+      let(:options) do
+        { refresh_token: 'token',
+          client_id: 'client',
+          client_secret: 'secret' }
+      end
+
+      it { should be_truthy}
+    end
+
+    context 'when oauth options are not provided' do
+      it { should_not be_truthy }
+    end
+  end
+end

data/spec/frodo/concerns/base_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Concerns::Base do
+
+  let(:klass) do
+    context = self
+    Class.new {
+      include Frodo::Concerns::Connection
+      include context.described_class
+    }
+  end
+
+  let(:client) { klass.new }
+
+  subject { client }
+
+  describe '#new' do
+    context 'without options passed in' do
+      it 'does not raise an exception' do
+        expect {
+          klass.new
+        }.to_not raise_error
+      end
+    end
+
+    context 'with a non-hash value' do
+      it 'raises an ArgumentError exception' do
+        expect {
+          klass.new 'foo'
+        }.to raise_error ArgumentError, 'Please specify a hash of options'
+      end
+    end
+
+    it 'yields the builder to the block' do
+      expect_any_instance_of(klass).to receive(:builder)
+      expect { |b| klass.new(&b) }.to yield_control
+    end
+  end
+
+  describe '.options' do
+    subject { lambda { client.options } }
+    it { should_not raise_error }
+  end
+
+  describe '.instance_url' do
+    subject { client.instance_url }
+
+    context 'when options[:instance_url] is unset' do
+      it 'triggers an authentication' do
+        def client.authenticate!
+        end
+        allow(client).to receive(:authenticate!)
+        expect(client).to receive :authenticate!
+        subject
+      end
+    end
+
+    context 'when options[:instance_url] is set' do
+      before do
+        expect(client).to receive(:options).and_return({ instance_url: 'foo' }).twice
+      end
+
+      it { should eq 'foo' }
+    end
+  end
+end

data/spec/frodo/concerns/caching_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Concerns::Caching do
+  describe '.without_caching' do
+    let(:options) { double('Options') }
+    let(:klass) do
+      context = self
+      Class.new {
+        include Frodo::Concerns::Base
+        include context.described_class
+      }
+    end
+    let(:client) { klass.new }
+    subject { client }
+
+    before do
+      expect(client).to receive(:options).and_return(options).twice
+    end
+
+    it 'runs the block with caching disabled' do
+      expect(options).to receive(:[]=).with(:use_cache, false)
+      expect(options).to receive(:delete).with(:use_cache)
+      expect { |b| client.without_caching(&b) }.to yield_control
+    end
+
+    context 'when an exception is raised' do
+      it 'ensures the :use_cache is deleted' do
+        expect(options).to receive(:[]=).with(:use_cache, false)
+        expect(options).to receive(:delete).with(:use_cache)
+        expect {
+          client.without_caching do
+            raise 'Foo'
+          end
+        }.to raise_error 'Foo'
+      end
+    end
+  end
+end

data/spec/frodo/concerns/connection_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Concerns::Connection do
+  let(:options) { double('Options') }
+  let(:klass) do
+    context = self
+    Class.new {
+      include Frodo::Concerns::Base
+      include Frodo::Concerns::Authentication
+      include Frodo::Concerns::Caching
+      include context.described_class
+    }
+  end
+
+  let(:client) { klass.new }
+  subject { client }
+
+  describe '.middleware' do
+    subject       { client.middleware }
+    let(:builder) { double('Faraday::Builder') }
+
+    before do
+      expect(client).to receive_message_chain(:connection, builder: builder)
+    end
+
+    it { should eq builder }
+  end
+
+  describe "#connection_options" do
+    let(:options) { { ssl: { verify: false } } }
+    before { expect(client).to receive(:options).and_return(options).exactly(4).times }
+
+    it "picks up passed-in SSL options" do
+      expect(client.send(:connection_options)).to include(options)
+    end
+  end
+
+  describe 'private #connection' do
+
+    describe ":logger option" do
+      let(:options) { { adapter: Faraday.default_adapter } }
+
+      before(:each) do
+        expect(client).to receive(:authentication_middleware)
+        expect(client).to receive(:cache)
+        expect(client).to receive(:options).and_return(options).at_least(1)
+        expect(Frodo).to receive(:log?).and_return(true)
+      end
+
+      it "must always be used last before the Faraday Adapter" do
+        expect(client.middleware.handlers.reverse.index(Frodo::Middleware::Logger)).to eq 1
+      end
+    end
+  end
+
+  describe '#adapter' do
+    before do
+      expect(client).to receive(:options).and_return({ adapter: :typhoeus })
+    end
+
+    it { expect(subject.options[:adapter]).to eq(:typhoeus) }
+  end
+end

data/spec/frodo/config_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo do
+  before do
+    ENV['DYNAMICS_V1_CLIENT_ID']      = nil
+    ENV['DYNAMICS_V1_CLIENT_SECRET']  = nil
+  end
+
+  after do
+    Frodo.instance_variable_set :@configuration, nil
+  end
+
+  describe '#configuration' do
+    subject { Frodo.configuration }
+
+    it { should be_a Frodo::Configuration }
+
+    context 'by default' do
+      it { expect(subject.host).to  eq 'login.microsoftonline.com' }
+      it { expect(subject.authentication_retries).to eq 3 }
+      it { expect(subject.adapter).to eq Faraday.default_adapter }
+      it { expect(subject.ssl).to eq({}) }
+      %i[client_id client_secret
+         oauth_token refresh_token instance_url compress timeout
+         proxy_uri authentication_callback request_headers].each do |attr|
+        it { expect(subject.send(attr)).to be_nil }
+      end
+    end
+
+    context 'when environment variables are defined' do
+      before do
+        {
+          'FRODATA_PROXY_URI'      => 'proxy',
+        }.
+          each { |var, value| allow(ENV).to receive(:[]).with(var).and_return(value) }
+      end
+
+      it { expect(subject.proxy_uri).to eq 'proxy' }
+    end
+  end
+
+  describe '#configure' do
+    %i[client_id client_secret compress
+       timeout oauth_token refresh_token instance_url host
+       authentication_retries proxy_uri authentication_callback ssl
+       request_headers log_level logger].each do |attr|
+      it "allows #{attr} to be set" do
+      Frodo.configure do |config|
+          config.send("#{attr}=", 'foobar')
+        end
+        expect(Frodo.configuration.send(attr)).to eq 'foobar'
+      end
+    end
+  end
+
+  describe '#log?' do
+    subject { Frodo.log? }
+
+    context 'by default' do
+      it { should be_falsey }
+    end
+  end
+
+  describe '#log' do
+    context 'with logging disabled' do
+      before do
+        allow(Frodo).to receive(:log?).and_return(false)
+      end
+
+      it 'doesnt log anytning' do
+        expect(Frodo.configuration.logger).not_to receive(:debug)
+        Frodo.log 'foobar'
+      end
+    end
+
+    context 'with logging enabled' do
+      before do
+        allow(Frodo).to receive(:log?).and_return(true)
+      end
+
+      it 'logs something' do
+        expect(Frodo.configuration.logger).to receive(:debug).with('foobar')
+        Frodo.log 'foobar'
+      end
+
+      context "with a custom logger" do
+        let(:fake_logger) { double(debug: true) }
+
+        before do
+          Frodo.configure do |config|
+            config.logger = fake_logger
+          end
+        end
+
+        it "logs using the provided logger" do
+          expect(fake_logger).to receive(:debug).with('foobar')
+          Frodo.log('foobar')
+        end
+      end
+
+      context "with a custom log_level" do
+        before do
+          Frodo.configure do |config|
+            config.log_level = :info
+          end
+        end
+
+        it 'logs with the provided log_level' do
+          expect(Frodo.configuration.logger).to receive(:info).with('foobar')
+          Frodo.log 'foobar'
+        end
+      end
+    end
+  end
+
+  describe '.new' do
+    it 'calls its block' do
+      checker = double(:block_checker)
+      expect(checker).to receive(:check!).once
+      Frodo.new do |builder|
+        checker.check!
+      end
+    end
+  end
+end

data/spec/frodo/entity/shared_examples.rb

@@ -0,0 +1,83 @@
+shared_examples 'a valid product' do
+  it { expect(subject).to be_a(Frodo::Entity) }
+
+  it { expect(subject.name).to eq('Product') }
+  it { expect(subject.type).to eq('ODataDemo.Product') }
+  it { expect(subject.namespace).to eq('ODataDemo') }
+  it { expect(subject.service_name).to eq('ODataDemo') }
+  it { expect(subject.context).to eq('http://services.odata.org/V4/OData/OData.svc/$metadata#Products/$entity') }
+  it { expect(subject.id).to eq('Products(0)') }
+
+  # Check property types
+  it { expect(subject.get_property('ID')).to be_a(Frodo::Properties::Integer) }
+  it { expect(subject.get_property('Name')).to be_a(Frodo::Properties::String) }
+  it { expect(subject.get_property('Description')).to be_a(Frodo::Properties::String) }
+  it { expect(subject.get_property('ReleaseDate')).to be_a(Frodo::Properties::DateTimeOffset) }
+  it { expect(subject.get_property('DiscontinuedDate')).to be_a(Frodo::Properties::DateTimeOffset) }
+  it { expect(subject.get_property('Rating')).to be_a(Frodo::Properties::Integer) }
+  it { expect(subject.get_property('Price')).to be_a(Frodo::Properties::Double) }
+
+  # Navigation property proxies
+  # FIXME should we support this or not?
+  # it { expect(subject.get_property('Categories')).to be_a(Frodo::NavigationProperty::Proxy)}
+  # it { expect(subject.get_property('ProductDetail')).to be_a(Frodo::NavigationProperty::Proxy)}
+  # it { expect(subject.get_property('Supplier')).to be_a(Frodo::NavigationProperty::Proxy)}
+
+  # Check property values
+  it { expect(subject['ID']).to eq(0) }
+  it { expect(subject['Name']).to eq('Bread') }
+  it { expect(subject['Description']).to eq('Whole grain bread') }
+  it { expect(subject['ReleaseDate']).to eq(DateTime.new(1992,1,1,0,0,0,0)) }
+  it { expect(subject['DiscontinuedDate']).to be_nil }
+  it { expect(subject['Rating']).to eq(4) }
+  it { expect(subject['Price']).to eq(2.5) }
+
+  # Navigation properties
+  # FIXME should we support this or not?
+  # it { expect(subject['Categories']).to be_a(Enumerable) }
+  # it { expect(subject['ProductDetail']).to be_nil }
+  # it { expect(subject['Supplier']).to be_a(Frodo::Entity) }
+
+  # it { expect {subject['NonExistant']}.to raise_error(ArgumentError) }
+  # it { expect {subject['NonExistant'] = 5}.to raise_error(ArgumentError) }
+
+  describe '#links' do
+    let(:links) do
+      {
+        'Categories'    => {type: :collection, href: 'Products(0)/Categories'},
+        'Supplier'      => {type: :entity, href: 'Products(0)/Supplier'},
+        'ProductDetail' => {type: :entity, href: 'Products(0)/ProductDetail'}
+      }
+    end
+
+    it { expect(subject).to respond_to(:links) }
+    it { expect(subject.links.size).to eq(3) }
+    it { expect(subject.links).to eq(links) }
+  end
+end
+
+shared_examples 'a valid supplier' do
+  it { expect(subject.name).to eq('Supplier') }
+  it { expect(subject.type).to eq('ODataDemo.Supplier') }
+  it { expect(subject.namespace).to eq('ODataDemo') }
+  it { expect(subject.service_name).to eq('ODataDemo') }
+  it { expect(subject.context).to eq('http://services.odata.org/V4/OData/OData.svc/$metadata#Suppliers/$entity') }
+  it { expect(subject.id).to eq('Suppliers(0)') }
+
+  # Check property types
+  it { expect(subject.get_property('ID')).to be_a(Frodo::Properties::Integer) }
+  it { expect(subject.get_property('Name')).to be_a(Frodo::Properties::String) }
+  it { expect(subject.get_property('Address')).to be_a(Frodo::Properties::Complex) }
+  it { expect(subject.get_property('Location')).to be_a(Frodo::Properties::Geography::Point) }
+
+  # Check property values
+  it { expect(subject['ID']).to eq(0) }
+  it { expect(subject['Name']).to eq('Exotic Liquids') }
+  it { expect(subject['Address'][ 'Street']).to eq('NE 228th') }
+  it { expect(subject['Address'][   'City']).to eq('Sammamish') }
+  it { expect(subject['Address'][  'State']).to eq('WA') }
+  it { expect(subject['Address']['ZipCode']).to eq('98074') }
+  it { expect(subject['Address']['Country']).to eq('USA') }
+  xit { expect(subject['Location']).to eq([47.6316604614258, -122.03547668457]) }
+  xit { expect(subject['Products']).to be_a(Frodo::Entity) }
+end

data/spec/frodo/entity_container_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Frodo::EntityContainer do
+  let(:subject) { Frodo::EntityContainer.new(service) }
+  let(:service) do
+    Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', metadata_file: metadata_file)
+  end
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+
+  describe '#entity_sets' do
+    it { expect(subject).to respond_to(:entity_sets) }
+    it { expect(subject.entity_sets.size).to eq(7) }
+    it { expect(subject.entity_sets.keys).to eq(%w[
+      Products
+      ProductDetails
+      Categories
+      Suppliers
+      Persons
+      PersonDetails
+      Advertisements
+    ]) }
+    it { expect(subject.entity_sets.values).to eq(%w[
+      ODataDemo.Product
+      ODataDemo.ProductDetail
+      ODataDemo.Category
+      ODataDemo.Supplier
+      ODataDemo.Person
+      ODataDemo.PersonDetail
+      ODataDemo.Advertisement
+    ]) }
+  end
+
+  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) }
+  end
+end