odata4 0.7.0

data/spec/odata4/complex_type_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe OData4::ComplexType, vcr: {cassette_name: 'complex_type_specs'} do
+  before(:example) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  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',
+      'State'   => 'CA',
+      'ZipCode' => '92648',
+      'Country' => 'USA'
+  } }
+
+  let(:complex_type) { service.complex_types['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(OData4::Property) }
+  it { expect(subject).to be_a(OData4::ComplexType::Property) }
+
+  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/odata4/entity/shared_examples.rb

@@ -0,0 +1,82 @@
+shared_examples 'a valid product' do
+  it { expect(subject).to be_a(OData4::Entity) }
+
+  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') }
+  it { expect(subject.context).to eq('http://services.odata.org/V4/OData/OData.svc/$metadata#Products/$entity') }
+  it { expect(subject.id).to eq('Products(0)') }
+
+  # Check property types
+  it { expect(subject.get_property('ID')).to be_a(OData4::Properties::Integer) }
+  it { expect(subject.get_property('Name')).to be_a(OData4::Properties::String) }
+  it { expect(subject.get_property('Description')).to be_a(OData4::Properties::String) }
+  it { expect(subject.get_property('ReleaseDate')).to be_a(OData4::Properties::DateTimeOffset) }
+  it { expect(subject.get_property('DiscontinuedDate')).to be_a(OData4::Properties::DateTimeOffset) }
+  it { expect(subject.get_property('Rating')).to be_a(OData4::Properties::Integer) }
+  it { expect(subject.get_property('Price')).to be_a(OData4::Properties::Double) }
+
+  # Navigation property proxies
+  it { expect(subject.get_property('Categories')).to be_a(OData4::NavigationProperty::Proxy)}
+  it { expect(subject.get_property('ProductDetail')).to be_a(OData4::NavigationProperty::Proxy)}
+  it { expect(subject.get_property('Supplier')).to be_a(OData4::NavigationProperty::Proxy)}
+
+  # Check property values
+  it { expect(subject['ID']).to eq(0) }
+  it { expect(subject['Name']).to eq('Bread') }
+  it { expect(subject['Description']).to eq('Whole grain bread') }
+  it { expect(subject['ReleaseDate']).to eq(DateTime.new(1992,1,1,0,0,0,0)) }
+  it { expect(subject['DiscontinuedDate']).to be_nil }
+  it { expect(subject['Rating']).to eq(4) }
+  it { expect(subject['Price']).to eq(2.5) }
+
+  # Navigation properties
+  it { expect(subject['Categories']).to be_a(Enumerable) }
+  it { expect(subject['ProductDetail']).to be_nil }
+  it { expect(subject['Supplier']).to be_a(OData4::Entity) }
+
+  it { expect {subject['NonExistant']}.to raise_error(ArgumentError) }
+  it { expect {subject['NonExistant'] = 5}.to raise_error(ArgumentError) }
+
+  describe '#links' do
+    let(:links) do
+      {
+        'Categories'    => {type: :collection, href: 'Products(0)/Categories'},
+        'Supplier'      => {type: :entity, href: 'Products(0)/Supplier'},
+        'ProductDetail' => {type: :entity, href: 'Products(0)/ProductDetail'}
+      }
+    end
+
+    it { expect(subject).to respond_to(:links) }
+    it { expect(subject.links.size).to eq(3) }
+    it { expect(subject.links).to eq(links) }
+  end
+end
+
+shared_examples 'a valid supplier' do
+  it { expect(subject.name).to eq('Supplier') }
+  it { expect(subject.type).to eq('ODataDemo.Supplier') }
+  it { expect(subject.namespace).to eq('ODataDemo') }
+  it { expect(subject.service_name).to eq('ODataDemo') }
+  it { expect(subject.context).to eq('http://services.odata.org/V4/OData/OData.svc/$metadata#Suppliers/$entity') }
+  it { expect(subject.id).to eq('Suppliers(0)') }
+
+  # Check property types
+  it { expect(subject.get_property('ID')).to be_a(OData4::Properties::Integer) }
+  it { expect(subject.get_property('Name')).to be_a(OData4::Properties::String) }
+  it { expect(subject.get_property('Address')).to be_a(OData4::ComplexType::Property) }
+  it { expect(subject.get_property('Location')).to be_a(OData4::Properties::Geography::Point) }
+  # it { expect(subject.get_property('Products')).to be_a(OData4::NavigationProperty::Proxy)}
+
+  # Check property values
+  it { expect(subject['ID']).to eq(0) }
+  it { expect(subject['Name']).to eq('Exotic Liquids') }
+  it { expect(subject['Address'][ 'Street']).to eq('NE 228th') }
+  it { expect(subject['Address'][   'City']).to eq('Sammamish') }
+  it { expect(subject['Address'][  'State']).to eq('WA') }
+  it { expect(subject['Address']['ZipCode']).to eq('98074') }
+  it { expect(subject['Address']['Country']).to eq('USA') }
+  xit { expect(subject['Location']).to eq([47.6316604614258, -122.03547668457]) }
+  xit { expect(subject['Products']).to be_a(OData4::Entity) }
+end

data/spec/odata4/entity_set_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe OData4::EntitySet, vcr: {cassette_name: 'entity_set_specs'} do
+  before(:example) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:subject) { OData4::EntitySet.new(options) }
+  let(:options) { {
+      container: 'DemoService', namespace: 'ODataDemo', name: 'Products',
+      type: '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('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(OData4::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(OData4::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(OData4::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(OData4::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(OData4::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(RuntimeError, /Not Found/)
+    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/odata4/entity_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require_relative 'entity/shared_examples'
+
+describe OData4::Entity, vcr: {cassette_name: 'entity_specs'} do
+  before(:example) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:subject) { OData4::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) { OData4::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) {
+      OData4::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) { OData4::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(OData4::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) { OData4::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) { OData4::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) { OData4::Entity.from_json(product_json, options) }
+    let(:product_json) {
+      File.read('spec/fixtures/files/product_0.json')
+    }
+
+    it { expect(OData4::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) { OData4::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) { OData4::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'
+    } }
+
+    it { expect(subject.to_json).to eq(properties.to_json) }
+  end
+end