frodo 0.10.0

data/spec/frodo/query_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Frodo::Query, vcr: {cassette_name: 'query_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::Query.new(entity_set) }
+  let(:entity_set) { Frodo::EntitySet.new(options) }
+  let(:options) { {
+    service_name: 'ODataDemo',
+    container: 'DemoService',
+    namespace: 'ODataDemo',
+    name: 'Products',
+    type: 'ODataDemo.Product'
+  } }
+
+  describe '#to_s' do
+    it { expect(subject).to respond_to(:to_s) }
+    it { expect(subject.to_s).to eq('Products')}
+  end
+
+  describe '#[]' do
+    it { expect(subject).to respond_to(:[]) }
+    it { expect(subject[:Name]).to be_a(Frodo::Query::Criteria) }
+    it { expect(subject[:Name].property).to be_a(Frodo::Property) }
+  end
+
+  describe '#find' do
+    let(:product) { subject.find(0) }
+
+    it { expect(subject).to respond_to(:find) }
+
+    it 'generate the query string to find an entity by its ID' do
+      expect(product).to eq("Products(0)")
+    end
+
+    it 'allows selecting specific fields only' do
+      product_with_name_only = subject.select('Name').find(0)
+      expect(product_with_name_only).to eq("Products(0)?$select=Name")
+    end
+  end
+
+  describe '#where' do
+    let(:criteria) { subject[:Name].eq('Bread') }
+    let(:params) {{ '$filter' => "Name eq 'Bread'" }}
+    let(:query_string) { "Products?$filter=Name eq 'Bread'" }
+
+    it { expect(subject).to respond_to(:where) }
+    it { expect(subject.where(criteria)).to eq(subject) }
+    it { expect(subject.where(criteria).params).to eq(params) }
+    it { expect(subject.where(criteria).to_s).to eq(query_string) }
+  end
+
+  describe '#search' do
+    let(:term) { '"mountain bike"' }
+    let(:params) {{ '$search' => '"mountain bike"' }}
+    let(:query_string) { 'Products?$search="mountain bike"' }
+
+    it { expect(subject).to respond_to(:search) }
+    it { expect(subject.search(term)).to eq(subject) }
+    it { expect(subject.search(term).params).to eq(params) }
+    it { expect(subject.search(term).to_s).to eq(query_string) }
+
+    describe 'with multiple terms' do
+      let(:params) {{ '$search' => '"mountain bike" AND NOT clothing' }}
+      let(:query_string) { 'Products?$search="mountain bike" AND NOT clothing' }
+
+      it { expect(subject.search(term).search('NOT clothing').params).to eq(params) }
+      it { expect(subject.search(term).search('NOT clothing').to_s).to eq(query_string) }
+    end
+  end
+
+  #it { expect(subject).to respond_to(:and) }
+  describe '#and' do
+    it { pending; fail }
+  end
+
+  #it { expect(subject).to respond_to(:or) }
+  describe '#or' do
+    it { pending; fail }
+  end
+
+  describe '#skip' do
+    it { expect(subject).to respond_to(:skip) }
+    it { expect(subject.skip(5)).to eq(subject) }
+    it 'properly formats query with skip specified' do
+      subject.skip(5)
+      expect(subject.params).to eq('$skip' => 5)
+      expect(subject.to_s).to eq('Products?$skip=5')
+    end
+  end
+
+  describe '#limit' do
+    it { expect(subject).to respond_to(:limit) }
+    it { expect(subject.limit(5)).to eq(subject) }
+    it 'properly formats query with limit specified' do
+      subject.limit(5)
+      expect(subject.params).to eq('$top' => 5)
+      expect(subject.to_s).to eq('Products?$top=5')
+    end
+  end
+
+  describe '#include_count' do
+    it { expect(subject).to respond_to(:include_count) }
+    it { expect(subject.include_count).to eq(subject) }
+    it 'properly formats query with include_count specified' do
+      subject.include_count
+      expect(subject.params).to eq('$count' => 'true')
+      expect(subject.to_s).to eq('Products?$count=true')
+    end
+  end
+
+  describe '#select' do
+    it { expect(subject).to respond_to(:select) }
+    it { expect(subject.select(:Name, :Price)).to eq(subject) }
+    it 'properly formats query with select operation specified' do
+      subject.select(:Name, :Price)
+      expect(subject.params).to eq('$select' => 'Name,Price')
+      expect(subject.to_s).to eq('Products?$select=Name,Price')
+    end
+  end
+
+  describe '#expand' do
+    it { expect(subject).to respond_to(:expand) }
+    it { expect(subject.expand(:Supplier)).to eq(subject) }
+    it 'properly formats query with expand operation specified' do
+      subject.expand(:Supplier)
+      expect(subject.params).to eq('$expand' => 'Supplier')
+      expect(subject.to_s).to eq('Products?$expand=Supplier')
+    end
+  end
+
+  describe '#order_by' do
+    it { expect(subject).to respond_to(:order_by) }
+    it { expect(subject.order_by(:Name, :Price)).to eq(subject) }
+    it 'properly formats query with orderby operation specified' do
+      subject.order_by(:Name, :Price)
+      expect(subject.params).to eq('$orderby' => 'Name,Price')
+      expect(subject.to_s).to eq('Products?$orderby=Name,Price')
+    end
+  end
+
+  describe '#count' do
+    it { expect(subject).to respond_to(:count) }
+    it { expect(subject.count).to eq("Products/$count") }
+
+    # FIXME: Should we support that?
+    # context 'with filters' do
+    #   let(:criteria) { subject[:Name].eq('Bread') }
+
+    #   it { expect(subject.where(criteria).count).to eq(1) }
+    # end
+  end
+
+end

data/spec/frodo/schema/complex_type_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Frodo::Schema::ComplexType, vcr: {cassette_name: 'schema/complex_type_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(:service) { Frodo::ServiceRegistry['ODataDemo'] }
+
+  let(:address) { {
+      'Street'  => '123 Main St',
+      'City'    => 'Huntington Beach',
+      'State'   => 'CA',
+      'ZipCode' => '92648',
+      'Country' => 'USA'
+  } }
+
+  let(:complex_type) { service.complex_types['ODataDemo.Address'] }
+  let(:subject) { complex_type.property_class.new('Address', nil) }
+
+  describe 'is properly parsed from service metadata' do
+    it { expect(complex_type.name).to eq('Address') }
+    it { expect(complex_type.namespace).to eq('ODataDemo') }
+    it { expect(complex_type.type).to eq('ODataDemo.Address') }
+    it { expect(complex_type.property_names).to eq(%w{Street City State ZipCode Country}) }
+  end
+
+  # Check property instance inheritance hierarchy
+  it { expect(subject).to be_a(Frodo::Property) }
+  it { expect(subject).to be_a(Frodo::Properties::Complex) }
+
+  it { expect(subject).to respond_to(:name) }
+  it { expect(subject).to respond_to(:type) }
+  it { expect(subject).to respond_to(:property_names) }
+  it { expect(subject).to respond_to(:[]) }
+  it { expect(subject).to respond_to(:[]=) }
+
+  it { expect(subject[ 'Street']).to be_nil }
+  it { expect(subject[   'City']).to be_nil }
+  it { expect(subject[  'State']).to be_nil }
+  it { expect(subject['ZipCode']).to be_nil }
+  it { expect(subject['Country']).to be_nil }
+
+  describe '#[]=' do
+    before do
+      address.each { |key, val| subject[key] = val }
+    end
+
+    it { expect(subject.value).to eq(address) }
+
+    it { expect(subject[ 'Street']).to eq(address[ 'Street']) }
+    it { expect(subject[   'City']).to eq(address[   'City']) }
+    it { expect(subject[  'State']).to eq(address[  'State']) }
+    it { expect(subject['ZipCode']).to eq(address['ZipCode']) }
+    it { expect(subject['Country']).to eq(address['Country']) }
+  end
+
+  describe '#value=' do
+    before { subject.value = address }
+
+    it { expect(subject.value).to eq(address) }
+
+    it { expect(subject[ 'Street']).to eq(address[ 'Street']) }
+    it { expect(subject[   'City']).to eq(address[   'City']) }
+    it { expect(subject[  'State']).to eq(address[  'State']) }
+    it { expect(subject['ZipCode']).to eq(address['ZipCode']) }
+    it { expect(subject['Country']).to eq(address['Country']) }
+  end
+
+  describe '#to_xml' do
+    let(:builder) do
+      Nokogiri::XML::Builder.new do |xml|
+        xml.entry(
+          'xmlns'           => 'http://www.w3.org/2005/Atom',
+          'xmlns:data'      => 'http://docs.oasis-open.org/odata/ns/data',
+          'xmlns:metadata'  => 'http://docs.oasis-open.org/odata/ns/metadata',
+        ) do
+          subject.to_xml(xml)
+        end
+      end
+    end
+    let(:xml) { Nokogiri::XML(builder.to_xml) }
+
+    before(:each) do
+      subject.value = address
+      xml.remove_namespaces!
+    end
+
+    it { expect(xml.xpath("/entry/Address[@type='ODataDemo.Address']").count).to eq(1) }
+    it { expect(xml.xpath('/entry/Address/Street').count).to eq(1) }
+    it { expect(xml.xpath('/entry/Address/City').count).to eq(1) }
+    it { expect(xml.xpath('/entry/Address/State').count).to eq(1) }
+    it { expect(xml.xpath('/entry/Address/ZipCode').count).to eq(1) }
+    it { expect(xml.xpath('/entry/Address/Country').count).to eq(1) }
+  end
+end

data/spec/frodo/schema/enum_type_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Frodo::Schema::EnumType, vcr: {cassette_name: 'schema/enum_type_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(:service) { Frodo::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(Frodo::Property) }
+  it { expect(subject).to be_a(Frodo::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/frodo/schema_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Frodo::Schema do
+  let(:subject) { Frodo::Schema.new(schema_xml, 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' }
+  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(Frodo::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
+    let(:metadata_file) { 'spec/fixtures/files/metadata_with_error.xml' }
+    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(Frodo::Property)) }
+    it { expect(subject.properties_for_entity('FeaturedProduct').keys).to eq(%w[
+      ID
+      Name
+      Description
+      ReleaseDate
+      DiscontinuedDate
+      Rating
+      Price
+      ProductStatus
+    ]) }
+    it 'has error message containing type name' do
+      expect {
+        subject.properties_for_entity('Error')
+      }.to raise_error(/Does.Not.Exist/)
+    end
+  end
+end

data/spec/frodo/service_registry_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Frodo::ServiceRegistry, vcr: {cassette_name: 'service_registry_specs'} do
+  let(:subject) { Frodo::ServiceRegistry }
+  let(:sample_service) { Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'demoService', metadata_file: metadata_file) }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+
+  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/frodo/service_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Frodo::Service do
+  let(:service_url) { 'http://services.odata.org/V4/OData/OData.svc' }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:subject) { Frodo::Service.new(service_url, name: 'ODataDemo', metadata_file: metadata_file) }
+
+  describe '.new' do
+    it 'adds itself to Frodo::ServiceRegistry on creation' do
+      expect(Frodo::ServiceRegistry['ODataDemo']).to be_nil
+      expect(Frodo::ServiceRegistry[service_url]).to be_nil
+
+      subject
+
+      expect(Frodo::ServiceRegistry['ODataDemo']).to eq(subject)
+      expect(Frodo::ServiceRegistry[service_url]).to eq(subject)
+    end
+
+    it 'registers custom types on creation' do
+      expect(Frodo::PropertyRegistry['ODataDemo.Address']).to be_a(Class)
+      expect(Frodo::PropertyRegistry['ODataDemo.ProductStatus']).to be_a(Class)
+    end
+
+    it 'allows logger to be set via option' do
+      logger = Logger.new(STDERR).tap { |l| l.level = Logger::ERROR }
+      service = Frodo::Service.new(service_url,  metadata_file: metadata_file, logger: logger)
+      expect(service.logger).to eq(logger)
+    end
+  end
+
+  describe '#logger' do
+    let(:subject) { Frodo::Service.new(service_url, name: 'ODataDemo', logger: logger, metadata_file: metadata_file) }
+    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::ERROR)
+    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
+  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(Frodo::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(Frodo::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(Frodo::Property)) }
+  end
+end