frodo 0.10.0

data/spec/frodo/entity_set_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Frodo::EntitySet, vcr: {cassette_name: 'entity_set_specs'} do
+  before(:example) do
+    Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo', metadata_file: metadata_file)
+  end
+
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:subject) { Frodo::EntitySet.new(options) }
+  let(:options) { {
+      container: 'DemoService', namespace: 'ODataDemo', name: 'Products',
+      type: 'ODataDemo.Product', service_name: 'ODataDemo'
+  } }
+
+  it { expect(subject).to respond_to(:name) }
+  it { expect(subject).to respond_to(:type) }
+  it { expect(subject).to respond_to(:container) }
+  it { expect(subject).to respond_to(:namespace) }
+  it { expect(subject).to respond_to(:service_name) }
+  it { expect(subject).to respond_to(:new_entity) }
+  # it { expect(subject).to respond_to(:[]) }
+  # it { expect(subject).to respond_to(:<<) }
+
+  it { expect(subject.name).to eq('Products') }
+  it { expect(subject.container).to eq('DemoService') }
+  it { expect(subject.namespace).to eq('ODataDemo') }
+  it { expect(subject.service_name).to eq('ODataDemo') }
+  it { expect(subject.type).to eq('ODataDemo.Product') }
+
+  # describe '#each' do
+  #   it { expect(subject).to respond_to(:each) }
+  #   it { expect(lambda {
+  #     @counter = 0
+  #     subject.each {|entity| @counter += 1}
+  #     @counter
+  #   }.call).to eq(11) }
+  #   it { expect(lambda {
+  #     @entities = []
+  #     subject.each {|entity| @entities << entity}
+  #     @entities
+  #   }.call.shuffle.first).to be_a(Frodo::Entity) }
+  # end
+
+  # describe '#first' do
+  #   it { expect(subject).to respond_to(:first) }
+
+  #   describe 'retrieving a single entity' do
+  #     it { expect(subject.first).to be_a(Frodo::Entity) }
+  #     it { expect(subject.first['ID']).to eq(0) }
+  #   end
+
+  #   describe 'retrieving multiple entities' do
+  #     it { expect(subject.first(5)).to be_a(Array) }
+  #     it { expect(subject.first(5).length).to eq(5) }
+  #     it do
+  #       subject.first(5).each do |entity|
+  #         expect(entity).to be_a(Frodo::Entity)
+  #       end
+  #     end
+  #   end
+  # end
+
+  # describe '#count' do
+  #   it { expect(subject).to respond_to(:count) }
+  #   it { expect(subject.count).to eq(11) }
+  # end
+
+  describe '#query' do
+    it { expect(subject).to respond_to(:query) }
+    it { expect(subject.query).to be_a(Frodo::Query) }
+  end
+
+  describe '#new_entity' do
+    let(:new_entity) { subject.new_entity(properties) }
+    let(:release_date) { DateTime.new(2014,7,5) }
+    let(:properties) { {
+        Name:             'Widget',
+        Description:      'Just a simple widget',
+        ReleaseDate:      release_date,
+        DiscontinuedDate: nil,
+        Rating:           4,
+        Price:            3.5
+    } }
+
+    it { expect(new_entity.entity_set).to eq(subject) }
+    it { expect(new_entity['ID']).to be_nil }
+    it { expect(new_entity['Name']).to eq('Widget') }
+    it { expect(new_entity['Description']).to eq('Just a simple widget') }
+    it { expect(new_entity['ReleaseDate']).to eq(release_date) }
+    it { expect(new_entity['DiscontinuedDate']).to be_nil }
+    it { expect(new_entity['Rating']).to eq(4) }
+    it { expect(new_entity['Price']).to eq(3.5) }
+  end
+
+  # describe '#[]' do
+  #   let(:existing_entity) { subject[0] }
+  #   let(:nonexistant_entity) { subject[99] }
+
+  #   it 'finds an entity by its primary key' do
+  #     expect(existing_entity).to be_a(Frodo::Entity)
+  #     expect(existing_entity['ID']).to eq(0)
+  #   end
+
+  #   it 'raises an error when no entity was found' do
+  #     expect { nonexistant_entity }.to raise_error(Frodo::Errors::NotFound)
+  #   end
+
+  #   describe 'eager loading' do
+  #     it 'works with a single property' do
+  #       product_with_categories = subject[1, expand: 'Categories']
+
+  #       expect(product_with_categories['Categories']).to eq([
+  #         { "ID" => 0, "Name" => "Food" },
+  #         { "ID" => 1, "Name" => "Beverages" }
+  #       ])
+  #     end
+
+  #     it 'works with multiple properties' do
+  #       product_with_details = subject[1, expand: %w[Categories Supplier]]
+
+  #       expect(product_with_details['Supplier']).to include('Name' => 'Exotic Liquids')
+  #       expect(product_with_details['Categories']).to be_a(Array)
+  #     end
+
+  #     it 'works with special shortcut for all properties' do
+  #       product_with_all_details = subject[1, expand: :all]
+
+  #       expect(product_with_all_details['Supplier']).to include('Name' => 'Exotic Liquids')
+  #       expect(product_with_all_details['Categories']).to be_a(Array)
+  #       expect(product_with_all_details['ProductDetail']).to include('Details' => 'Details of product 1')
+  #     end
+  #   end
+  # end
+
+  # describe '#<<' do
+  #   let(:new_entity) { subject.new_entity(properties) }
+  #   let(:bad_entity) { subject.new_entity }
+  #   let(:existing_entity) { subject.first }
+  #   let(:properties) { {
+  #       Name:             'Widget',
+  #       Description:      'Just a simple widget',
+  #       ReleaseDate:      DateTime.now.new_offset(0),
+  #       DiscontinuedDate: nil,
+  #       Rating:           4,
+  #       Price:            3.5
+  #   } }
+
+  #   xdescribe 'with an existing entity', vcr: {cassette_name: 'entity_set_specs/existing_entry'} do
+  #     before(:each) do
+  #       subject << existing_entity
+  #     end
+
+  #     it { expect(existing_entity.any_errors?).to eq(false) }
+  #   end
+
+  #   xdescribe 'with a new entity', vcr: {cassette_name: 'entity_set_specs/new_entry'} do
+  #     it do
+  #       expect(new_entity['ID']).to be_nil
+  #       expect {subject << new_entity}.to_not raise_error
+  #       expect(new_entity['ID']).to_not be_nil
+  #       expect(new_entity['ID']).to eq(9999)
+  #     end
+  #   end
+
+  #   xdescribe 'with a bad entity', vcr: {cassette_name: 'entity_set_specs/bad_entry'} do
+  #     it { expect{subject << bad_entity}.to raise_error }
+  #   end
+  # end
+end

data/spec/frodo/entity_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require_relative 'entity/shared_examples'
+
+describe Frodo::Entity, vcr: {cassette_name: 'entity_specs'} do
+  before(:example) do
+    Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo',  metadata_file: metadata_file)
+  end
+
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:subject) { Frodo::Entity.new(options) }
+  let(:options) { {
+      type:         'ODataDemo.Product',
+      namespace:    'ODataDemo',
+      service_name: 'ODataDemo'
+  } }
+
+  it { expect(subject).to respond_to(:name, :type, :namespace, :service_name) }
+
+  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') }
+
+  describe '.with_properties' do
+    let(:subject) { Frodo::Entity.with_properties(properties, options) }
+    let(:properties) { {
+      "ID"               => 0,
+      "Name"             => "Bread",
+      "Description"      => "Whole grain bread",
+      "ReleaseDate"      => "1992-01-01T00:00:00Z",
+      "DiscontinuedDate" => nil,
+      "Rating"           => 4,
+      "Price"            => 2.5
+    } }
+    let(:entity_set) {
+      Frodo::EntitySet.new(
+        container: 'DemoService',
+        namespace: 'ODataDemo',
+        name: 'Products',
+        type: 'Product',
+        service_name: 'ODataDemo')
+    }
+    let(:options) { {
+        type:         'ODataDemo.Product',
+        namespace:    'ODataDemo',
+        service_name: 'ODataDemo',
+        entity_set:   entity_set
+    } }
+
+    it_behaves_like 'a valid product'
+  end
+
+  describe '.from_xml' do
+    let(:subject) { Frodo::Entity.from_xml(product_xml, options) }
+    let(:product_xml) {
+      document = ::Nokogiri::XML(File.open('spec/fixtures/files/product_0.xml'))
+      document.remove_namespaces!
+      document.xpath('//entry').first
+    }
+
+    it { expect(Frodo::Entity).to respond_to(:from_xml) }
+
+    it_behaves_like 'a valid product'
+
+    context 'with a complex type property' do
+      let(:options) { {
+          type:         'ODataDemo.Supplier',
+          namespace:    'ODataDemo',
+          service_name: 'ODataDemo'
+      } }
+
+      let(:subject) { Frodo::Entity.from_xml(supplier_xml, options) }
+      let(:supplier_xml) {
+        document = ::Nokogiri::XML(File.open('spec/fixtures/files/supplier_0.xml'))
+        document.remove_namespaces!
+        document.xpath('//entry').first
+      }
+
+      it_behaves_like 'a valid supplier'
+    end
+  end
+
+  describe '#to_xml' do
+    let(:subject) { Frodo::Entity.with_properties(properties, options) }
+    let(:properties) { {
+      "ID"               => 0,
+      "Name"             => "Bread",
+      "Description"      => "Whole grain bread",
+      "ReleaseDate"      => "1992-01-01T00:00:00Z",
+      "DiscontinuedDate" => nil,
+      "Rating"           => 4,
+      "Price"            => 2.5
+    } }
+    let(:options) { {
+        type:         'ODataDemo.Product',
+        namespace:    'ODataDemo',
+        service_name: 'ODataDemo'
+    } }
+    let(:product_xml) {
+      File.read('spec/fixtures/files/entity_to_xml.xml')
+    }
+
+    # TODO: parse the XML and veryify property values instead?
+    # TODO: explicitly assert namespace URIs?
+    it { expect(subject.to_xml).to eq(product_xml) }
+  end
+
+  describe '.from_json' do
+    let(:subject) { Frodo::Entity.from_json(product_json, options) }
+    let(:product_json) {
+      File.read('spec/fixtures/files/product_0.json')
+    }
+
+    it { expect(Frodo::Entity).to respond_to(:from_json) }
+    it_behaves_like 'a valid product'
+
+    context 'with a complex type property' do
+      let(:options) { {
+          type:         'ODataDemo.Supplier',
+          namespace:    'ODataDemo',
+          service_name: 'ODataDemo'
+      } }
+
+      let(:subject) { Frodo::Entity.from_json(supplier_json, options) }
+      let(:supplier_json) {
+        File.read('spec/fixtures/files/supplier_0.json')
+      }
+
+      it_behaves_like 'a valid supplier'
+    end
+  end
+
+  describe '#to_json' do
+    let(:subject) { Frodo::Entity.with_properties(properties, options) }
+    let(:properties) { {
+      "ID"               => 0,
+      "Name"             => "Bread",
+      "Description"      => "Whole grain bread",
+      "ReleaseDate"      => "1992-01-01T00:00:00Z",
+      "DiscontinuedDate" => nil,
+      "Rating"           => 4,
+      "Price"            => 2.5,
+      "ProductStatus"    => nil
+    } }
+    let(:options) { {
+        type:         'ODataDemo.Product',
+        namespace:    'ODataDemo',
+        service_name: 'ODataDemo'
+    } }
+
+    it { expect(subject.to_json).to eq(properties.to_json) }
+  end
+end

data/spec/frodo/errors_spec.rb

@@ -0,0 +1,48 @@
+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

data/spec/frodo/middleware/authentication/token_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'webmock/rspec'
+
+describe Frodo::Middleware::Authentication::Token do
+  include WebMock::API
+
+  describe 'authentication middleware' do
+    let(:options) do
+      { refresh_token: 'refresh_token',
+        client_id: 'client_id',
+        client_secret: 'client_secret',
+        adapter: :net_http,
+        host: 'login.window.net'
+      }
+    end
+
+      let(:success_request) do
+        stub_request(:post, "https://login.window.net/common/oauth2/token").with(
+          body: "grant_type=refresh_token&refresh_token=refresh_token&" \
+                   "client_id=client_id&client_secret=client_secret"
+        ).to_return(status: 200, body: fixture("auth_success_response"))
+      end
+
+      let(:fail_request) do
+        stub_request(:post, "https://login.window.net/common/oauth2/token").with(
+          body: "grant_type=refresh_token&refresh_token=refresh_token&" \
+                   "client_id=client_id&client_secret=client_secret"
+        ).to_return(status: 400, body: fixture("refresh_error_response"))
+      end
+
+    describe '.authenticate!' do
+      context 'when successful' do
+        let!(:request) { success_request }
+
+        describe '@options' do
+          subject { options }
+
+          before do
+            middleware.authenticate!
+          end
+
+          it { expect(subject[:host]).to eq 'login.window.net' }
+
+          it { expect(subject[:oauth_token]).to eq "gfEzf4azkWZMTjlay7usiSWhc0eOLNkKMw" }
+
+          it { expect(subject[:refresh_token]).to eq "QswqIkdHSdbyvbDFuLwHNAoU1QgAA" }
+        end
+
+        context 'when an authentication_callback is specified' do
+          before(:each) do
+            options.merge!(authentication_callback: auth_callback)
+          end
+
+          it 'calls the authentication callback with the response body' do
+            expect(auth_callback).to receive(:call)
+            middleware.authenticate!
+          end
+        end
+      end
+
+      context 'when unsuccessful' do
+        let!(:request) { fail_request }
+
+        it 'raises an exception' do
+          expect {
+            middleware.authenticate!
+          }.to raise_error Frodo::AuthenticationError
+        end
+
+        context 'when an authentication_callback is specified' do
+          before(:each) do
+            options.merge!(authentication_callback: auth_callback)
+          end
+
+          it 'does not call the authentication callback' do
+            expect(auth_callback).to_not receive(:call)
+            expect do
+              middleware.authenticate!
+            end.to raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/frodo/middleware/authentication_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::Authentication do
+  let(:options) do
+    { host: 'login.windows.net',
+      proxy_uri: 'https://not-a-real-site.com',
+      authentication_retries: retries,
+      adapter: :net_http,
+      ssl: { version: :TLSv1_2 } }
+  end
+
+  describe '.authenticate!' do
+    subject { lambda { middleware.authenticate! } }
+    it      { should raise_error NotImplementedError }
+  end
+
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    context 'when successfull' do
+      before do
+        expect(app).to receive(:call).once
+      end
+
+      it { should_not raise_error }
+    end
+
+    context 'when an exception is thrown' do
+      before do
+        expect(middleware).to receive(:authenticate!)
+        expect(app).to receive(:call).once.
+          and_raise(Frodo::UnauthorizedError.new('something bad'))
+      end
+
+      it { should raise_error Frodo::UnauthorizedError }
+    end
+  end
+
+  describe '.connection' do
+    subject(:connection) { middleware.connection }
+
+    it { expect(subject.url_prefix).to eq(URI.parse('https://login.windows.net')) }
+
+    it "should have a proxy URI" do
+      expect(connection.proxy[:uri]).to eq(URI.parse('https://not-a-real-site.com'))
+    end
+
+    describe '.builder' do
+      subject(:builder) { connection.builder }
+
+      context 'with logging disabled' do
+        before do
+          expect(Frodo).to receive(:log?).and_return(false)
+        end
+
+        it { expect(subject.handlers).to include FaradayMiddleware::ParseJson, Faraday::Adapter::NetHttp }
+        it { expect(subject.handlers).not_to include Frodo::Middleware::Logger }
+      end
+
+      context 'with logging enabled' do
+        before do
+          expect(Frodo).to receive(:log?).and_return(true)
+        end
+
+        it { expect(subject.handlers).to include FaradayMiddleware::ParseJson, Faraday::Adapter::NetHttp, Frodo::Middleware::Logger }
+      end
+
+      context 'with specified adapter' do
+        before do
+          options[:adapter] = :typhoeus
+        end
+
+        it { expect(subject.handlers).to include FaradayMiddleware::ParseJson, Faraday::Adapter::Typhoeus }
+      end
+    end
+
+    it "should have SSL config set" do
+      expect(connection.ssl[:version]).to eq(:TLSv1_2)
+    end
+  end
+end

data/spec/frodo/middleware/authorization_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::Authorization do
+  let(:options) { { oauth_token: 'token' } }
+
+  describe '.call' do
+    subject { middleware }
+
+    before do
+      subject.call(env)
+    end
+
+    it { expect(env[:request_headers]['Authorization']).to eq 'Bearer token' }
+  end
+end

data/spec/frodo/middleware/custom_headers_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::CustomHeaders do
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    context 'when :request_headers are a Hash' do
+      let(:options) { { request_headers: { 'x-test-header' => 'Test Value' } } }
+
+      it { should change { env[:request_headers]['x-test-header'] }.to eq 'Test Value' }
+    end
+
+    context 'when :request_headers are not a Hash' do
+      let(:options) { { request_headers: 'bad header' } }
+
+      it { should_not(change { env[:request_headers] }) }
+    end
+  end
+end

data/spec/frodo/middleware/gzip_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::Gzip do
+  let(:options) { { oauth_token: 'token' } }
+
+  # Return a gzipped string.
+  def gzip(str)
+    StringIO.new.tap do |io|
+      gz = Zlib::GzipWriter.new(io)
+      gz.write(str)
+      gz.close
+    end.string
+  end
+
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    before do
+      expect(app).to receive(:on_complete) { middleware.on_complete(env) }
+      expect(app).to receive(:call) do
+        env[:body] = gzip fixture('leads')
+        env[:response_headers]['Content-Encoding'] = 'gzip'
+        app
+      end
+    end
+
+    it 'decompresses the body' do
+      should change { env[:body] }.to(fixture('leads'))
+    end
+
+    context 'when :compress is false' do
+      it { should_not(change { env[:request_headers]['Accept-Encoding'] }) }
+    end
+
+    context 'when :compress is true' do
+      before do
+        options[:compress] = true
+      end
+
+      it { should(change { env[:request_headers]['Accept-Encoding'] }.to('gzip')) }
+    end
+  end
+
+  describe '.decompress' do
+    let(:body) { gzip fixture('leads') }
+
+    subject { middleware.decompress(body) }
+    it { should eq fixture('leads') }
+  end
+
+  describe '.gzipped?' do
+    subject { middleware.gzipped?(env) }
+
+    context 'when gzipped' do
+      before do
+        env[:response_headers]['Content-Encoding'] = 'gzip'
+      end
+
+      it { should be_truthy }
+    end
+
+    context 'when not gzipped' do
+      it { should be_falsey }
+    end
+  end
+end

data/spec/frodo/middleware/instance_url_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::InstanceURL do
+  describe '.call' do
+    subject { lambda { middleware.call(nil) } }
+    let(:connection) { double("connection") }
+
+    context 'when the instance url is not set' do
+      before do
+        allow(client).to receive_message_chain :connection, url_prefix: URI.parse('http:/')
+      end
+
+      it { should raise_error Frodo::UnauthorizedError }
+    end
+
+    context 'when the instance url is set' do
+      before do
+        allow(client).to receive_message_chain :connection, url_prefix: URI.parse('http://foobar.com/')
+        expect(app).to receive(:call).once
+      end
+
+      it { should_not raise_error }
+    end
+  end
+end