frodata 0.9.1

data/spec/frodata/schema/enum_type_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe FrOData::Schema::EnumType, vcr: {cassette_name: 'schema/enum_type_specs'} do
+  before(:example) do
+    FrOData::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(:service) { FrOData::ServiceRegistry['ODataDemo'] }
+
+  let(:enum_type) { service.enum_types['ODataDemo.ProductStatus'] }
+  let(:subject) { enum_type.property_class.new('ProductStatus', nil) }
+
+  describe 'is properly parsed from service metadata' do
+    it { expect(enum_type.name).to eq('ProductStatus') }
+    it { expect(enum_type.namespace).to eq('ODataDemo') }
+    it { expect(enum_type.type).to eq('ODataDemo.ProductStatus') }
+    it { expect(enum_type.is_flags?).to eq(false) }
+    it { expect(enum_type.underlying_type).to eq('Edm.Byte') }
+    it { expect(enum_type.members.values).to eq(%w{Available LowStock Backordered Discontinued}) }
+  end
+
+  # Check property instance inheritance hierarchy
+  it { expect(subject).to be_a(FrOData::Property) }
+  it { expect(subject).to be_a(FrOData::Properties::Enum) }
+
+  it { expect(subject).to respond_to(:name) }
+  it { expect(subject).to respond_to(:type) }
+  it { expect(subject).to respond_to(:members) }
+
+  describe '#value=' do
+    it 'allows setting a valid value' do
+      subject.value = 'Available'
+      expect(subject.value).to eq('Available')
+    end
+
+    it 'does not allow setting an invalid value' do
+      expect {
+        subject.value = 'Invalid'
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'allows setting by numeric value' do
+      expect {
+        subject.value = 1
+      }.not_to raise_error
+      expect(subject.value).to eq('LowStock')
+    end
+
+    context 'when `IsFlags` is false' do
+      it 'does not allow setting multiple values' do
+        expect {
+          subject.value = 'Available, Backordered'
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when `IsFlags` is true' do
+      before do
+        subject.define_singleton_method(:is_flags?) { true }
+      end
+
+      it 'allows setting multiple values' do
+        subject.value = 'Available, Backordered'
+        expect(subject.value).to eq(%w[Available Backordered])
+      end
+
+      it 'does not allow setting invalid values' do
+        expect {
+          subject.value = 'Available, Invalid'
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'allows setting by numeric value' do
+        expect {
+          subject.value = '0, 1'
+        }.not_to raise_error
+        expect(subject.value).to eq(%w[Available LowStock])
+      end
+    end
+  end
+
+  describe 'lenient validation' do
+    let(:subject) do
+      enum_type.property_class.new('ProductStatus', nil, strict: false)
+    end
+
+    describe '#value=' do
+      it 'ignores invalid values' do
+        expect {
+          subject.value = 'Invalid'
+        }.not_to raise_error
+
+        expect(subject.value).to be_nil
+      end
+
+      context 'when `IsFlags` is true' do
+        before do
+          subject.define_singleton_method(:is_flags?) { true }
+        end
+
+        it 'ignores invalid values' do
+          expect {
+            subject.value = 'Available, Invalid'
+          }.not_to raise_error
+
+          expect(subject.value).to eq(['Available'])
+        end
+      end
+    end
+  end
+end

data/spec/frodata/schema_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe FrOData::Schema do
+  let(:subject) { FrOData::Schema.new(schema_xml, service) }
+  let(:service) do
+    FrOData::Service.new('http://services.odata.org/V4/OData/OData.svc', metadata_file: metadata_file)
+  end
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:schema_xml) { service.metadata.xpath('//Schema').first }
+
+  let(:entity_types) { %w{Product FeaturedProduct ProductDetail Category Supplier Person Customer Employee PersonDetail Advertisement} }
+  let(:complex_types) { %w{Address} }
+  let(:enum_types) { %w{ProductStatus} }
+
+  describe '#namespace' do
+    it { expect(subject).to respond_to(:namespace) }
+    it "returns the schema's namespace attribute" do
+      expect(subject.namespace).to eq('ODataDemo')
+    end
+  end
+
+  describe '#actions' do
+    # TODO add a action definition to metadata
+    it { expect(subject).to respond_to(:actions) }
+    it { expect(subject.actions.size).to eq(0) }
+  end
+
+  describe '#annotations' do
+    # TBD
+  end
+
+  describe '#complex_types' do
+    it { expect(subject).to respond_to(:complex_types) }
+    it { expect(subject.complex_types.size).to eq(1) }
+    it { expect(subject.complex_types.keys).to eq(complex_types) }
+  end
+
+  describe '#entity_types' do
+    it { expect(subject).to respond_to(:entity_types) }
+    it { expect(subject.entity_types.size).to eq(10) }
+    it { expect(subject.entity_types).to eq(entity_types) }
+  end
+
+  describe '#enum_types' do
+    it { expect(subject).to respond_to(:enum_types) }
+    it { expect(subject.enum_types.size).to eq(1) }
+    it { expect(subject.enum_types.keys).to eq(enum_types)}
+  end
+
+  describe '#functions' do
+    # TODO add a function definition to metadata
+    it { expect(subject).to respond_to(:functions) }
+    it { expect(subject.functions.size).to eq(0) }
+  end
+
+  describe '#terms' do
+    # TBD
+  end
+
+  describe '#type_definitions' do
+    # TODO add a type definition to metadata
+    it { expect(subject).to respond_to(:type_definitions) }
+    it { expect(subject.type_definitions.size).to eq(0) }
+  end
+
+  describe '#navigation_properties' do
+    it { expect(subject).to respond_to(:navigation_properties) }
+    it { expect(subject.navigation_properties['Product'].size).to eq(3) }
+    it { expect(subject.navigation_properties['Product'].values).to all(be_a(FrOData::NavigationProperty)) }
+  end
+
+  describe '#get_property_type' do
+    it { expect(subject).to respond_to(:get_property_type) }
+    it { expect(subject.get_property_type('Product', 'ID')).to eq('Edm.Int32') }
+    it { expect(subject.get_property_type('Product', 'ProductStatus')).to eq('ODataDemo.ProductStatus') }
+  end
+
+  describe '#primary_key_for' do
+    it { expect(subject).to respond_to(:primary_key_for) }
+    it { expect(subject.primary_key_for('Product')).to eq('ID') }
+  end
+
+  describe '#properties_for_entity' do
+    it { expect(subject).to respond_to(:properties_for_entity) }
+    it { expect(subject.properties_for_entity('Product').keys).to eq(%w[
+      ID
+      Name
+      Description
+      ReleaseDate
+      DiscontinuedDate
+      Rating
+      Price
+      ProductStatus
+    ]) }
+    it { expect(subject.properties_for_entity('Product').values).to all(be_a(FrOData::Property)) }
+  end
+end

data/spec/frodata/service/request_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe FrOData::Service::Request, vcr: {cassette_name: 'service/request_specs'} do
+  let(:subject) { FrOData::Service::Request.new(service, 'Products') }
+  let(:service) { FrOData::Service.new(service_url, name: 'ODataDemo', metadata_file: metadata_file) }
+  let(:service_url) { 'http://services.odata.org/V4/OData/OData.svc' }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+
+  describe '#url' do
+    it 'returns the full request URL' do
+      expect(subject.url).to eq('http://services.odata.org/V4/OData/OData.svc/Products')
+    end
+  end
+
+  describe '#method' do
+    it 'defaults to GET' do
+      expect(subject.method).to eq(:get)
+    end
+  end
+
+  describe '#format' do
+    it 'defaults to :auto' do
+      expect(subject.format).to eq(:auto)
+    end
+  end
+
+  describe '#content_type' do
+    it 'return all acceptable types when format = :auto' do
+      expect(subject.content_type).to eq(FrOData::Service::MIME_TYPES.values.join(','))
+    end
+
+    it 'returns the correct MIME type when format = :atom' do
+      subject.format = :atom
+      expect(subject.content_type).to eq('application/atom+xml')
+    end
+
+    it 'returns the correct MIME type when format = :json' do
+      subject.format = :json
+      expect(subject.content_type).to eq('application/json')
+    end
+  end
+
+  describe '#execute' do
+    it 'returns a response object' do
+      expect(subject.execute).to be_a(FrOData::Service::Response)
+    end
+    it 'retries on wrong content type'
+  end
+end

data/spec/frodata/service/response_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+shared_examples 'a valid response' do
+  it { expect(subject).to be_success }
+  it { expect(subject.count).to eq(11) }
+
+  describe '#empty?' do
+    it { expect(subject).to respond_to(:empty?) }
+    it { expect(subject.empty?).to eq(false) }
+  end
+
+  describe '#each' do
+    it { expect(subject).to respond_to(:each) }
+    it 'returns just FrOData::Entities of the right type' do
+      subject.each do |entity|
+        expect(entity).to be_a(FrOData::Entity)
+        expect(entity.type).to eq('ODataDemo.Product')
+      end
+    end
+  end
+end
+
+describe FrOData::Service::Response, vcr: {cassette_name: 'service/response_specs'} do
+  let(:subject) { FrOData::Service::Response.new(service, entity_set.query) { response } }
+  let(:service) { FrOData::Service.new(service_url, name: 'ODataDemo', metadata_file: metadata_file) }
+  let(:service_url) { 'http://services.odata.org/V4/OData/OData.svc' }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:entity_set) { service['Products'] }
+  let(:response) do
+    response = double('response')
+    allow(response).to receive_messages(
+      headers: { 'Content-Type' => content_type },
+      status: response_status,
+      body: response_body
+    )
+    response
+  end
+
+  context 'with Atom result' do
+    let(:content_type) { 'application/atom+xml' }
+    let(:response_status) { 200 }
+    let(:response_body) { File.read('spec/fixtures/files/products.xml') }
+
+    it_behaves_like 'a valid response'
+  end
+
+  context 'with JSON result' do
+    let(:content_type) { 'application/json' }
+    let(:response_status) { 200 }
+    let(:response_body) { File.read('spec/fixtures/files/products.json') }
+
+    it_behaves_like 'a valid response'
+  end
+
+  context 'with XML result' do
+    let(:content_type) { 'application/xml' }
+    let(:response_status) { 200 }
+    let(:response_body) { File.read('spec/fixtures/files/error.xml') }
+
+    it 'contains no entities' do
+      expect(subject.empty?).to eq(true)
+    end
+
+    it 'contains error message' do
+      expect(subject.error_message).to match(/Resource not found/)
+    end
+  end
+
+  context 'with plain text result' do
+    let(:content_type) { 'text/plain' }
+    let(:response_status) { 200 }
+    let(:response_body) { '123' }
+
+    it { expect(subject).to be_success }
+    it { expect(subject.body).to match(/123/) }
+  end
+
+  context 'with unregistered content type' do
+    let(:content_type) { 'text/unknown' }
+    let(:response_status) { 200 }
+    let(:response_body) { '123' }
+
+    it { expect { subject }.to raise_error(FrOData::RequestError) }
+  end
+end

data/spec/frodata/service_registry_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe FrOData::ServiceRegistry, vcr: {cassette_name: 'service_registry_specs'} do
+  let(:subject) { FrOData::ServiceRegistry }
+  let(:sample_service) { FrOData::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'demoService') }
+
+  it { expect(subject).to respond_to(:add) }
+  it { expect(subject).to respond_to(:[]) }
+
+  describe '#add' do
+    before(:example) do
+      subject.add(sample_service)
+    end
+
+    it { expect(subject['demoService']).to eq(sample_service) }
+    it { expect(subject['http://services.odata.org/V4/OData/OData.svc']).to eq(sample_service) }
+  end
+end

data/spec/frodata/service_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe FrOData::Service, vcr: {cassette_name: 'service_specs'} do
+  let(:service_url) { 'http://services.odata.org/V4/OData/OData.svc' }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:subject) { FrOData::Service.new(service_url, name: 'ODataDemo', metadata_file: metadata_file) }
+
+  describe '.new' do
+    it 'adds itself to FrOData::ServiceRegistry on creation' do
+      expect(FrOData::ServiceRegistry['ODataDemo']).to be_nil
+      expect(FrOData::ServiceRegistry[service_url]).to be_nil
+
+      service = FrOData::Service.new(service_url, name: 'ODataDemo')
+
+      expect(FrOData::ServiceRegistry['ODataDemo']).to eq(service)
+      expect(FrOData::ServiceRegistry[service_url]).to eq(service)
+    end
+
+    it 'registers custom types on creation' do
+      service = FrOData::Service.new(service_url, name: 'ODataDemo')
+
+      expect(FrOData::PropertyRegistry['ODataDemo.Address']).to be_a(Class)
+      expect(FrOData::PropertyRegistry['ODataDemo.ProductStatus']).to be_a(Class)
+    end
+
+    it 'allows connection to be set by passing it instead of service_url' do
+      connection = Faraday.new(service_url)
+      service = FrOData::Service.new(connection)
+      expect(service.connection).to eq(connection)
+    end
+
+    it 'allows connection to be customized via options hash' do
+      service = FrOData::Service.new(service_url, connection: {
+        headers: { 'X-Custom-Header' => 'foo' }
+      })
+      expect(service.connection.headers).to include('X-Custom-Header' => 'foo')
+    end
+
+    it 'allows connection to be customized via block argument' do
+      service = FrOData::Service.new(service_url) do |conn|
+        conn.headers['X-Custom-Header'] = 'foo'
+        conn.adapter Faraday.default_adapter
+      end
+      expect(service.connection.headers).to include('X-Custom-Header' => 'foo')
+    end
+
+    it 'allows logger to be set via option' do
+      logger = Logger.new(STDERR).tap { |l| l.level = Logger::ERROR }
+      service = FrOData::Service.new(service_url, logger: logger)
+      expect(service.logger).to eq(logger)
+    end
+  end
+
+  describe '#connection' do
+    it 'returns the connection object used by the service' do
+      expect(subject.connection).to be_a(Faraday::Connection)
+    end
+
+    it 'uses the service URL as URL prefix' do
+      expect(subject.connection.url_prefix.to_s).to eq(subject.service_url)
+    end
+  end
+
+  describe '#logger' do
+    let(:logger) { Logger.new(STDERR).tap { |l| l.level = Logger::ERROR } }
+
+    it 'returns the logger used by the service' do
+      expect(subject.logger).to be_a(Logger)
+    end
+
+    it 'returns the default logger if none was set' do
+      expect(subject.logger.level).to eq(Logger::WARN)
+    end
+
+    it 'uses Rails logger if available' do
+      stub_const 'Rails', Class.new { def self.logger; end }
+      allow(Rails).to receive(:logger).and_return(logger)
+      expect(subject.logger).to eq(logger)
+    end
+
+    it 'allows logger to be set via attribute writer' do
+      expect(subject.logger).not_to eq(logger)
+      subject.logger = logger
+      expect(subject.logger).to eq(logger)
+    end
+  end
+
+  describe '#service_url' do
+    it { expect(subject).to respond_to(:service_url) }
+    it { expect(subject.service_url).to eq(service_url) }
+  end
+
+  describe '#schemas' do
+    it { expect(subject).to respond_to(:schemas) }
+    it { expect(subject.schemas.keys).to eq(['ODataDemo']) }
+    it { expect(subject.schemas.values).to all(be_a(FrOData::Schema)) }
+    it {
+      subject.schemas.each do |namespace, schema|
+        expect(schema.namespace).to eq(namespace)
+      end
+    }
+  end
+
+  describe '#entity_types' do
+    it { expect(subject).to respond_to(:entity_types) }
+    it { expect(subject.entity_types.size).to eq(10) }
+    it { expect(subject.entity_types).to eq(%w[
+      ODataDemo.Product
+      ODataDemo.FeaturedProduct
+      ODataDemo.ProductDetail
+      ODataDemo.Category
+      ODataDemo.Supplier
+      ODataDemo.Person
+      ODataDemo.Customer
+      ODataDemo.Employee
+      ODataDemo.PersonDetail
+      ODataDemo.Advertisement
+    ]) }
+  end
+
+  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 '#complex_types' do
+    it { expect(subject).to respond_to(:complex_types) }
+    it { expect(subject.complex_types.size).to eq(1) }
+    it { expect(subject.complex_types.keys).to eq(['ODataDemo.Address']) }
+  end
+
+  describe '#enum_types' do
+    it { expect(subject).to respond_to(:enum_types) }
+    it { expect(subject.enum_types.size).to eq(1) }
+    it { expect(subject.enum_types.keys).to eq(['ODataDemo.ProductStatus'])}
+  end
+
+  describe '#namespace' do
+    it { expect(subject.namespace).to eq('ODataDemo') }
+  end
+
+  describe '#[]' do
+    let(:entity_sets) { subject.entity_sets.keys.map { |name| subject[name] } }
+    it { expect(entity_sets).to all(be_a(FrOData::EntitySet)) }
+    it { expect {subject['Nonexistant']}.to raise_error(ArgumentError) }
+  end
+
+  describe '#get_property_type' do
+    it { expect(subject).to respond_to(:get_property_type) }
+    it { expect(subject.get_property_type('ODataDemo.Product', 'ID')).to eq('Edm.Int32') }
+    it { expect(subject.get_property_type('ODataDemo.Product', 'ProductStatus')).to eq('ODataDemo.ProductStatus') }
+  end
+
+  describe '#primary_key_for' do
+    it { expect(subject).to respond_to(:primary_key_for) }
+    it { expect(subject.primary_key_for('ODataDemo.Product')).to eq('ID') }
+  end
+
+  describe '#properties_for_entity' do
+    it { expect(subject).to respond_to(:properties_for_entity) }
+    it { expect(subject.properties_for_entity('ODataDemo.Product').keys).to eq(%w[
+      ID
+      Name
+      Description
+      ReleaseDate
+      DiscontinuedDate
+      Rating
+      Price
+      ProductStatus
+    ]) }
+    it { expect(subject.properties_for_entity('ODataDemo.Product').values).to all(be_a(FrOData::Property)) }
+  end
+end