odata4 0.7.0 → 0.8.0

data/lib/odata4/version.rb

@@ -1,3 +1,3 @@
 module OData4
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/odata4.gemspec

@@ -19,16 +19,16 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w{lib}
 
   spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'simplecov', '~> 0.15.1'
-  spec.add_development_dependency 'rspec', '~> 3.7.0'
-  spec.add_development_dependency 'rspec-autotest', '~> 1.0.0'
-  spec.add_development_dependency 'autotest', '~> 4.4.6'
-  spec.add_development_dependency 'vcr', '~> 4.0.0'
-  spec.add_development_dependency 'timecop', '~> 0.9.1'
-  spec.add_development_dependency 'equivalent-xml', '~> 0.6.0'
+  spec.add_development_dependency 'rake', '~> 0'
+  spec.add_development_dependency 'simplecov', '~> 0.15'
+  spec.add_development_dependency 'rspec', '~> 3.7'
+  spec.add_development_dependency 'rspec-autotest', '~> 1.0'
+  spec.add_development_dependency 'autotest', '~> 4.4'
+  spec.add_development_dependency 'vcr', '~> 4.0'
+  spec.add_development_dependency 'timecop', '~> 0.9'
+  spec.add_development_dependency 'equivalent-xml', '~> 0.6'
 
-  spec.add_dependency 'nokogiri', '~> 1.8.1'
-  spec.add_dependency 'typhoeus', '~> 1.3.0'
-  spec.add_dependency 'andand',   '~> 1.3.3'
+  spec.add_dependency 'nokogiri', '~> 1.8'
+  spec.add_dependency 'typhoeus', '~> 1.3'
+  spec.add_dependency 'andand',   '~> 1.3'
 end

data/spec/odata4/complex_type_spec.rb

@@ -7,26 +7,6 @@ describe OData4::ComplexType, vcr: {cassette_name: 'complex_type_specs'} do
 
   let(:service) { OData4::ServiceRegistry['ODataDemo'] }
 
-  describe '.new' do
-    it 'requires type name' do
-      expect {
-        OData4::ComplexType.new(service: service)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'requires service instance' do
-      expect {
-        OData4::ComplexType.new(name: 'Address')
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'requires name to refer to a valid complex type' do
-      expect {
-        OData4::ComplexType.new(name: 'NotAType', service: service)
-      }.to raise_error(ArgumentError)
-    end
-  end
-
   let(:address) { {
       'Street'  => '123 Main St',
       'City'    => 'Huntington Beach',
@@ -35,7 +15,7 @@ describe OData4::ComplexType, vcr: {cassette_name: 'complex_type_specs'} do
       'Country' => 'USA'
   } }
 
-  let(:complex_type) { service.complex_types['Address'] }
+  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

data/spec/odata4/entity_container_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe OData4::EntityContainer do
+  let(:subject) { OData4::EntityContainer.new(service) }
+  let(:service) do
+    OData4::Service.open('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(OData4::EntitySet)) }
+    it { expect {subject['Nonexistant']}.to raise_error(ArgumentError) }
+  end
+end

data/spec/odata4/entity_set_spec.rb

@@ -8,7 +8,7 @@ describe OData4::EntitySet, vcr: {cassette_name: 'entity_set_specs'} do
   let(:subject) { OData4::EntitySet.new(options) }
   let(:options) { {
       container: 'DemoService', namespace: 'ODataDemo', name: 'Products',
-      type: 'Product', service_name: 'ODataDemo'
+      type: 'ODataDemo.Product', service_name: 'ODataDemo'
   } }
 
   it { expect(subject).to respond_to(:name) }
@@ -24,7 +24,7 @@ describe OData4::EntitySet, vcr: {cassette_name: 'entity_set_specs'} do
   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('Product') }
+  it { expect(subject.type).to eq('ODataDemo.Product') }
 
   describe '#each' do
     it { expect(subject).to respond_to(:each) }

data/spec/odata4/enum_type_spec.rb

@@ -8,27 +8,7 @@ describe OData4::EnumType, vcr: {cassette_name: 'enum_type_specs'} do
   let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
   let(:service) { OData4::ServiceRegistry['ODataDemo'] }
 
-  describe '.new' do
-    it 'requires type name' do
-      expect {
-        OData4::EnumType.new(service: service)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'requires service instance' do
-      expect {
-        OData4::EnumType.new(name: 'Address')
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'requires name to refer to a valid enum type' do
-      expect {
-        OData4::EnumType.new(name: 'NotAType', service: service)
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  let(:enum_type) { service.enum_types['ProductStatus'] }
+  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
@@ -54,12 +34,10 @@ describe OData4::EnumType, vcr: {cassette_name: 'enum_type_specs'} do
       expect(subject.value).to eq('Available')
     end
 
-    it 'ignores invalid values' do
+    it 'does not allow setting an invalid value' do
       expect {
         subject.value = 'Invalid'
-      }.not_to raise_error
-
-      expect(subject.value).to be_nil
+      }.to raise_error(ArgumentError)
     end
 
     it 'allows setting by numeric value' do
@@ -87,12 +65,10 @@ describe OData4::EnumType, vcr: {cassette_name: 'enum_type_specs'} do
         expect(subject.value).to eq(%w[Available Backordered])
       end
 
-      it 'allows setting an invalid value' do
+      it 'does not allow setting invalid values' do
         expect {
           subject.value = 'Available, Invalid'
-        }.not_to raise_error
-
-        expect(subject.value).to eq(['Available'])
+        }.to raise_error(ArgumentError)
       end
 
       it 'allows setting by numeric value' do
@@ -104,29 +80,31 @@ describe OData4::EnumType, vcr: {cassette_name: 'enum_type_specs'} do
     end
   end
 
-  describe 'strict mode' do
-    let(:subject) { enum_type.property_class.new('ProductStatus', nil, strict: true) }
-
-    describe '#strict?' do
-      it { expect(subject).to be_strict }
+  describe 'lenient validation' do
+    let(:subject) do
+      enum_type.property_class.new('ProductStatus', nil, strict: false)
     end
 
     describe '#value=' do
-      it 'does not allow setting an invalid value' do
+      it 'ignores invalid values' do
         expect {
           subject.value = 'Invalid'
-        }.to raise_error(ArgumentError)
+        }.not_to raise_error
+
+        expect(subject.value).to be_nil
       end
 
-      context 'when is_flags=true' do
+      context 'when `IsFlags` is true' do
         before do
           subject.define_singleton_method(:is_flags?) { true }
         end
 
-        it 'does not allow setting invalid values' do
+        it 'ignores invalid values' do
           expect {
             subject.value = 'Available, Invalid'
-          }.to raise_error(ArgumentError)
+          }.not_to raise_error
+
+          expect(subject.value).to eq(['Available'])
         end
       end
     end

data/spec/odata4/properties/decimal_spec.rb

@@ -6,19 +6,46 @@ describe OData4::Properties::Decimal do
   it { expect(subject.type).to eq('Edm.Decimal') }
   it { expect(subject.value).to eq(BigDecimal('678.90325')) }
 
-  it { expect(subject.url_value).to eq('678.90325M') }
+  it { expect(subject.url_value).to eq('678.90325') }
 
   it { expect { subject.value = BigDecimal((7.9 * (10**28)), 2) + 1 }.to raise_error(ArgumentError) }
   it { expect { subject.value = BigDecimal((-7.9 * (10**28)), 2) - 1 }.to raise_error(ArgumentError) }
   it { expect { subject.value = BigDecimal((3.4 * (10**-28)), 2) * 3.14151 + 5 }.to raise_error(ArgumentError) }
 
-  it { expect(lambda {
-    subject.value = '19.89043256'
-    subject.value
-  }.call).to eq(BigDecimal('19.89043256')) }
+  describe '#value=' do
+    it 'allows BigDecimal to be set' do
+      subject.value = BigDecimal('19.89043256')
+      expect(subject.value).to eq(BigDecimal('19.89043256'))
+    end
 
-  it { expect(lambda {
-    subject.value = BigDecimal('19.89043256')
-    subject.value
-  }.call).to eq(BigDecimal('19.89043256')) }
-end
+    it 'allows string value to be set' do
+      subject.value = '19.89043256'
+      expect(subject.value).to eq(BigDecimal('19.89043256'))
+    end
+
+    it 'ignores invalid characters' do
+      subject.value = '123.4-foobar-5'
+      expect(subject.value).to eq(BigDecimal('123.4'))
+    end
+
+    it 'inteprets anything that is not a number as 0' do
+      subject.value = 'foobar'
+      expect(subject.value).to eq(BigDecimal(0))
+    end
+
+    it 'does not allow values outside a certain range' do
+      expect { subject.value = 'Infinity' }.to raise_error(ArgumentError)
+    end
+
+    describe 'lenient validation' do
+      let(:subject) do
+        OData4::Properties::Decimal.new('Decimal', '678.90325', strict: false)
+      end
+
+      it 'ignores invalid values' do
+        subject.value = 'Infinity'
+        expect(subject.value).to eq(BigDecimal('Infinity'))
+      end
+    end
+  end
+end

data/spec/odata4/property_spec.rb

@@ -1,32 +1,71 @@
 require 'spec_helper'
 
 describe OData4::Property do
+  let(:service) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', metadata_file: metadata_file)
+  end
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
   let(:subject) { OData4::Property.new('PropertyName', '1') }
   let(:good_comparison) { OData4::Property.new('GoodComparison', '1') }
   let(:bad_comparison) { OData4::Property.new('BadComparison', '2') }
 
-  it { expect(subject).to respond_to(:name) }
-  it { expect(subject.name).to eq('PropertyName') }
+  describe '#name' do
+    it { expect(subject).to respond_to(:name) }
+    it { expect(subject.name).to eq('PropertyName') }
+  end
 
-  it { expect(subject).to respond_to(:value) }
-  it { expect(subject.value).to eq('1') }
+  describe '#value' do
+    it { expect(subject).to respond_to(:value) }
+    it { expect(subject.value).to eq('1') }
+  end
 
-  it { expect(subject).to respond_to(:xml_value) }
-  it { expect(subject.xml_value).to eq('1') }
+  describe '#xml_value' do
+    it { expect(subject).to respond_to(:xml_value) }
+    it { expect(subject.xml_value).to eq('1') }
+  end
 
-  it { expect(subject).to respond_to(:url_value) }
-  it { expect(subject.url_value).to eq('1') }
+  describe '#url_value' do
+    it { expect(subject).to respond_to(:url_value) }
+    it { expect(subject.url_value).to eq('1') }
+  end
 
-  it { expect(subject).to respond_to(:type) }
-  it { expect(lambda {subject.type}).to raise_error(NotImplementedError) }
+  describe '#type' do
+    it { expect(subject).to respond_to(:type) }
+    it { expect(lambda {subject.type}).to raise_error(NotImplementedError) }
+  end
 
-  it { expect(subject).to respond_to(:allows_nil?) }
-  it { expect(subject.allows_nil?).to eq(true) }
+  describe '#allows_nil?' do
+    it { expect(subject).to respond_to(:allows_nil?) }
+    it { expect(subject.allows_nil?).to eq(true) }
+  end
 
-  it { expect(subject).to respond_to(:concurrency_mode) }
-  it { expect(subject.concurrency_mode).to eq(:none) }
+  describe '#strict?' do
+    it { expect(subject).to respond_to(:strict?) }
 
-  it { expect(subject).to respond_to(:==) }
-  it { expect(subject == good_comparison).to eq(true) }
-  it { expect(subject == bad_comparison).to eq(false) }
-end
+    it 'defaults to true' do
+      expect(subject.strict?).to eq(true)
+    end
+
+    it 'can be switched off via constructor option' do
+      subject = OData4::Property.new('PropertyName', '1', strict: false)
+      expect(subject.strict?).to eq(false)
+    end
+
+    it 'can be switched off via service level option' do
+      service.options[:strict] = false
+      subject = OData4::Property.new('PropertyName', '1', service: service)
+      expect(subject.strict?).to eq(false)
+    end
+  end
+
+  describe '#concurrency_mode' do
+    it { expect(subject).to respond_to(:concurrency_mode) }
+    it { expect(subject.concurrency_mode).to eq(:none) }
+  end
+
+  describe '#==' do
+    it { expect(subject).to respond_to(:==) }
+    it { expect(subject == good_comparison).to eq(true) }
+    it { expect(subject == bad_comparison).to eq(false) }
+  end
+end

data/spec/odata4/query/result_spec.rb

@@ -13,7 +13,7 @@ shared_examples 'valid result' do
     it 'returns just OData4::Entities of the right type' do
       result.each do |entity|
         expect(entity).to be_a(OData4::Entity)
-        expect(entity.type).to eq('Product')
+        expect(entity.type).to eq('ODataDemo.Product')
       end
     end
   end

data/spec/odata4/query_spec.rb

@@ -8,8 +8,11 @@ describe OData4::Query, vcr: {cassette_name: 'query_specs'} do
   let(:subject) { OData4::Query.new(entity_set) }
   let(:entity_set) { OData4::EntitySet.new(options) }
   let(:options) { {
-      container: 'DemoService', namespace: 'ODataDemo', name: 'Products',
-      service_name: 'ODataDemo', type: 'Product'
+    service_name: 'ODataDemo',
+    container: 'DemoService',
+    namespace: 'ODataDemo',
+    name: 'Products',
+    type: 'ODataDemo.Product'
   } }
 
   it { expect(subject).to respond_to(:to_s) }
@@ -168,7 +171,7 @@ describe OData4::Query, vcr: {cassette_name: 'query_specs'} do
 
         batch.each do |entity|
           expect(entity).to be_a(OData4::Entity)
-          expect(entity.type).to eq('Product')
+          expect(entity.type).to eq('ODataDemo.Product')
           entity_count += 1
         end
 
@@ -185,7 +188,7 @@ describe OData4::Query, vcr: {cassette_name: 'query_specs'} do
 
         subject.in_batches(of: 5).each do |entity|
           expect(entity).to be_a(OData4::Entity)
-          expect(entity.type).to eq('Product')
+          expect(entity.type).to eq('ODataDemo.Product')
           entity_count += 1
         end
 

data/spec/odata4/schema_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe OData4::Schema do
+  let(:subject) { OData4::Schema.new(schema_xml, service) }
+  let(:service) do
+    OData4::Service.open('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(OData4::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(OData4::Property)) }
+  end
+end