odata4 0.7.0

data/spec/odata4/enum_type_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe OData4::EnumType, vcr: {cassette_name: 'enum_type_specs'} do
+  before(:example) do
+    OData4::Service.open('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) { 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(: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(OData4::Property) }
+  it { expect(subject).to be_a(OData4::EnumType::Property) }
+
+  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 'ignores invalid values' do
+      expect {
+        subject.value = 'Invalid'
+      }.not_to raise_error
+
+      expect(subject.value).to be_nil
+    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 'allows setting an invalid value' do
+        expect {
+          subject.value = 'Available, Invalid'
+        }.not_to raise_error
+
+        expect(subject.value).to eq(['Available'])
+      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 'strict mode' do
+    let(:subject) { enum_type.property_class.new('ProductStatus', nil, strict: true) }
+
+    describe '#strict?' do
+      it { expect(subject).to be_strict }
+    end
+
+    describe '#value=' do
+      it 'does not allow setting an invalid value' do
+        expect {
+          subject.value = 'Invalid'
+        }.to raise_error(ArgumentError)
+      end
+
+      context 'when is_flags=true' do
+        before do
+          subject.define_singleton_method(:is_flags?) { true }
+        end
+
+        it 'does not allow setting invalid values' do
+          expect {
+            subject.value = 'Available, Invalid'
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/odata4/navigation_property/proxy_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe OData4::NavigationProperty::Proxy, vcr: {cassette_name: 'navigation_property_proxy_specs'} do
+  before :each do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:entity) { OData4::ServiceRegistry['ODataDemo']['Products'][1] }
+
+  let(:categories_proxy) { OData4::NavigationProperty::Proxy.new(entity, 'Categories') }
+  let(:detail_proxy) { OData4::NavigationProperty::Proxy.new(entity, 'ProductDetail') }
+  let(:supplier_proxy) { OData4::NavigationProperty::Proxy.new(entity, 'Supplier') }
+
+  describe 'value' do
+    it { expect(categories_proxy.value).to be_a(Enumerable) }
+    it { expect(supplier_proxy.value).to be_a(OData4::Entity) }
+    it { expect(detail_proxy.value).to be_a(OData4::Entity) }
+
+    context 'when value was explicitly set' do
+      let(:supplier) { double('supplier') }
+
+      it 'returns the set value' do
+        supplier_proxy.value = supplier
+        expect(supplier_proxy.value).to eq(supplier)
+      end
+    end
+
+    context 'when no links exist for an entity' do
+      before(:each) do
+        expect(entity).to receive(:links) do
+          { 'Categories' => nil, 'Supplier' => nil }
+        end
+      end
+
+      context 'for a many NavigationProperty' do
+        it { expect(categories_proxy.value).to eq([]) }
+      end
+
+      context 'for a singular NavigationProperty' do
+        it { expect(supplier_proxy.value).to eq(nil) }
+      end
+    end
+  end
+end

data/spec/odata4/navigation_property_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe OData4::NavigationProperty do
+  let(:options) { {
+      name: 'Categories',
+      type: 'Collection(ODataDemo.Category)',
+      partner: 'Products',
+  } }
+  let(:subject) do
+    OData4::NavigationProperty.new(options)
+  end
+
+  it { expect(subject).to respond_to(:name) }
+  it { expect(subject.name).to eq('Categories') }
+
+  it { expect(subject).to respond_to(:type) }
+  it { expect(subject.type).to eq('Collection(ODataDemo.Category)') }
+
+  it { expect(subject).to respond_to(:nav_type) }
+  it { expect(subject.nav_type).to eq(:collection) }
+
+  it { expect(subject).to respond_to(:nullable) }
+
+  it { expect(subject).to respond_to(:partner) }
+  it { expect(subject.partner).to eq('Products') }
+
+  describe '.new' do
+    it 'requires name' do
+      expect {
+        OData4::NavigationProperty.new(type: 'Collection(ODataDemo.Category)')
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'requires type' do
+      expect {
+        OData4::NavigationProperty.new(name: 'Categories')
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#build' do
+    let(:metadata_file) { File.read 'spec/fixtures/files/metadata.xml' }
+    let(:metadata_xml)  { Nokogiri::XML(metadata_file).remove_namespaces! }
+    let(:navigation_properties) { metadata_xml.xpath('//NavigationProperty') }
+    let(:subject) {
+      OData4::NavigationProperty.build(navigation_properties.first)
+    }
+
+    it { expect(subject.name).to eq('Categories') }
+    it { expect(subject.type).to eq('Collection(ODataDemo.Category)') }
+    it { expect(subject.partner).to eq('Products') }
+    it { expect(subject.nullable).to eq(true) }
+    it { expect(subject.nav_type).to eq(:collection) }
+  end
+end

data/spec/odata4/properties/binary_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe OData4::Properties::Binary do
+  let(:subject) { OData4::Properties::Binary.new('On', '1') }
+
+  it { expect(subject.type).to eq('Edm.Binary') }
+  it { expect(subject.value).to eq(1) }
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(subject.url_value).to eq("binary'1'") }
+
+  describe 'setting to 0' do
+    it { expect(lambda {
+      subject.value = 0
+      subject.value
+    }.call).to eq(0) }
+
+    it { expect(lambda {
+      subject.value = false
+      subject.value
+    }.call).to eq(0) }
+
+    it { expect(lambda {
+      subject.value = '0'
+      subject.value
+    }.call).to eq(0) }
+  end
+
+  describe 'setting to 1' do
+    let(:subject) { OData4::Properties::Binary.new('On', '0') }
+
+    it { expect(subject.value).to eq(0) }
+
+    it { expect(lambda {
+      subject.value = 1
+      subject.value
+    }.call).to eq(1) }
+
+    it { expect(lambda {
+      subject.value = true
+      subject.value
+    }.call).to eq(1) }
+
+    it { expect(lambda {
+      subject.value = '1'
+      subject.value
+    }.call).to eq(1) }
+  end
+end

data/spec/odata4/properties/boolean_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe OData4::Properties::Boolean do
+  let(:truthy1) { OData4::Properties::Boolean.new('Truthy', 'true') }
+  let(:truthy2) { OData4::Properties::Boolean.new('Truthy', '1') }
+  let(:falsey1) { OData4::Properties::Boolean.new('Falsey', 'false') }
+  let(:falsey2) { OData4::Properties::Boolean.new('Falsey', '0') }
+  let(:nily) { OData4::Properties::Boolean.new('Nily', nil) }
+
+  it { expect(truthy1.type).to eq('Edm.Boolean') }
+  it { expect(truthy1.value).to eq(true) }
+  it { expect(truthy2.value).to eq(true) }
+
+  it { expect(falsey1.value).to eq(false) }
+  it { expect(falsey2.value).to eq(false) }
+
+  it { expect(nily.value).to eq(nil) }
+
+  it { expect {truthy1.value = 'bad'}.to raise_error(ArgumentError) }
+
+  describe 'setting to false' do
+    let(:subject) { OData4::Properties::Boolean.new('Truthy', 'true') }
+
+    it { expect(subject.value).to eq(true) }
+
+    it { expect(lambda {
+      subject.value = false
+      subject.value
+    }.call).to eq(false) }
+
+    it { expect(lambda {
+      subject.value = 'false'
+      subject.value
+    }.call).to eq(false) }
+
+    it { expect(lambda {
+      subject.value = '0'
+      subject.value
+    }.call).to eq(false) }
+  end
+
+  describe 'setting to true' do
+    let(:subject) { OData4::Properties::Boolean.new('Falsey', 'false') }
+
+    it { expect(subject.value).to eq(false) }
+
+    it { expect(lambda {
+      subject.value = true
+      subject.value
+    }.call).to eq(true) }
+
+    it { expect(lambda {
+      subject.value = 'true'
+      subject.value
+    }.call).to eq(true) }
+
+    it { expect(lambda {
+      subject.value = '1'
+      subject.value
+    }.call).to eq(true) }
+  end
+
+  describe 'setting to null' do
+    let(:subject) { OData4::Properties::Boolean.new('Truthy', 'true') }
+
+    it { expect(subject.allows_nil?).to eq(true) }
+    it { expect(lambda {
+      subject.value = nil
+      subject.value
+    }.call).to eq(nil) }
+  end
+end

data/spec/odata4/properties/date_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe OData4::Properties::Date do
+  let(:subject) { OData4::Properties::Date.new('Date', '2000-01-01') }
+  let(:new_date) { Date.strptime('2004-05-01', '%Y-%m-%d') }
+
+  it { expect(subject.type).to eq('Edm.Date') }
+  it { expect(subject.value).to eq(Date.parse('2000-01-01')) }
+
+  it { expect(subject.url_value).to eq("2000-01-01")}
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(lambda {
+    subject.value = '2004-05-01'
+    subject.value
+  }.call).to eq(new_date) }
+
+  it { expect(lambda {
+    subject.value = new_date
+    subject.value
+  }.call).to eq(new_date) }
+end

data/spec/odata4/properties/date_time_offset_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe OData4::Properties::DateTimeOffset do
+  let(:subject) { OData4::Properties::DateTimeOffset.new('DateTime', '2000-01-01T16:00:00-09:00') }
+  let(:new_datetime) { DateTime.strptime('2004-05-01T14:32:00+02:00', '%Y-%m-%dT%H:%M:%S%:z') }
+
+  it { expect(subject.type).to eq('Edm.DateTimeOffset') }
+  it { expect(subject.value).to eq(DateTime.strptime('2000-01-01T16:00:00-09:00', '%Y-%m-%dT%H:%M:%S%:z')) }
+
+  it { expect(subject.url_value).to eq("2000-01-01T16:00:00-09:00")}
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(lambda {
+    subject.value = new_datetime
+    subject.value
+  }.call).to eq(new_datetime) }
+
+  it { expect(lambda {
+    subject.value = nil
+  }).not_to raise_error }
+
+  context 'with allows_nil option set to false' do
+    let(:subject) { OData4::Properties::DateTimeOffset.new('DateTime', '2000-01-01T16:00:00Z-09:00', allows_nil: false) }
+
+    it { expect(lambda {
+      subject.value = nil
+    }).to raise_error(ArgumentError) }
+  end
+end

data/spec/odata4/properties/date_time_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe OData4::Properties::DateTime do
+  let(:subject) { OData4::Properties::DateTime.new('DateTime', '2000-01-01T16:00:00.000') }
+  let(:new_datetime) { DateTime.strptime('2004-05-01T14:32:00.000', '%Y-%m-%dT%H:%M:%S.%L') }
+
+  it { expect(subject.type).to eq('Edm.DateTime') }
+  it { expect(subject.value).to eq(DateTime.parse('2000-01-01T16:00:00.000')) }
+
+  it { expect(subject.url_value).to eq("2000-01-01T16:00:00.000")}
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(lambda {
+    subject.value = '2004-05-01T14:32:00.000'
+    subject.value
+  }.call).to eq(new_datetime) }
+
+  it { expect(lambda {
+    subject.value = new_datetime
+    subject.value
+  }.call).to eq(new_datetime) }
+end

data/spec/odata4/properties/decimal_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe OData4::Properties::Decimal do
+  let(:subject) { OData4::Properties::Decimal.new('Decimal', '678.90325') }
+
+  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.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')) }
+
+  it { expect(lambda {
+    subject.value = BigDecimal('19.89043256')
+    subject.value
+  }.call).to eq(BigDecimal('19.89043256')) }
+end