frodata 0.9.1

data/spec/frodata/query/criteria_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+shared_examples 'an operator criterium' do |operator, value, to_s|
+  it { expect(criteria).to eq(subject) }
+  it { expect(criteria.operator).to eq(operator) }
+  it { expect(criteria.value).to eq(value) }
+  it { expect(criteria.to_s).to eq(to_s) }
+end
+
+shared_examples 'a function criterium' do |function, argument, to_s|
+  it { expect(criteria).to eq(subject) }
+  it { expect(criteria.function).to eq(function) }
+  it { expect(criteria.argument).to eq(argument) }
+  it { expect(criteria.to_s).to eq(to_s) }
+end
+
+shared_examples 'an operator-function criterium' do |function, operator, value, to_s|
+  it { expect(criteria).to eq(subject) }
+  it { expect(criteria.function).to eq(function) }
+  it { expect(criteria.operator).to eq(operator) }
+  it { expect(criteria.value).to eq(value) }
+  it { expect(criteria.to_s).to eq(to_s) }
+end
+
+describe FrOData::Query::Criteria do
+  let(:string_property) { FrOData::Properties::String.new(:Name, nil) }
+  let(:integer_property) { FrOData::Properties::Integer.new(:Age, nil) }
+  let(:datetime_property) { FrOData::Properties::DateTime.new(:BirthDate, nil) }
+  let(:geo_property) { FrOData::Properties::Geography::Point.new(:Position, nil) }
+  # TODO: use actual `NavigationProperty` class here
+  let(:navigation_property) { FrOData::Property.new(:Items, nil) }
+
+  let(:subject) { FrOData::Query::Criteria.new(property: string_property) }
+
+  it { expect(subject).to respond_to(:property) }
+  it { expect(subject.property).to eq(string_property)}
+
+  it { expect(subject).to respond_to(:operator) }
+  it { expect(subject).to respond_to(:value) }
+  it { expect(subject).to respond_to(:to_s) }
+
+  describe 'comparison operators' do
+    describe '#eq' do
+      let(:criteria) { subject.eq('Bread') }
+
+      it { expect(subject).to respond_to(:eq) }
+      it_behaves_like 'an operator criterium', :eq, 'Bread', "Name eq 'Bread'"
+    end
+
+    describe '#ne' do
+      let(:criteria) { subject.ne('Bread') }
+
+      it { expect(subject).to respond_to(:ne) }
+      it_behaves_like 'an operator criterium', :ne, 'Bread', "Name ne 'Bread'"
+    end
+
+    describe '#gt' do
+      let(:subject) { FrOData::Query::Criteria.new(property: integer_property) }
+      let(:criteria) { subject.gt(5) }
+
+      it { expect(subject).to respond_to(:gt) }
+      it_behaves_like 'an operator criterium', :gt, 5, "Age gt 5"
+    end
+
+    describe '#ge' do
+      let(:subject) { FrOData::Query::Criteria.new(property: integer_property) }
+      let(:criteria) { subject.ge(5) }
+
+      it { expect(subject).to respond_to(:ge) }
+      it_behaves_like 'an operator criterium', :ge, 5, 'Age ge 5'
+    end
+
+    describe '#lt' do
+      let(:subject) { FrOData::Query::Criteria.new(property: integer_property) }
+      let(:criteria) { subject.lt(5) }
+
+      it { expect(subject).to respond_to(:lt) }
+      it_behaves_like 'an operator criterium', :lt, 5, 'Age lt 5'
+    end
+
+    describe '#le' do
+      let(:subject) { FrOData::Query::Criteria.new(property: integer_property) }
+      let(:criteria) { subject.le(5) }
+
+      it { expect(subject).to respond_to(:le) }
+      it_behaves_like 'an operator criterium', :le, 5, 'Age le 5'
+    end
+  end
+
+  describe 'string functions' do
+    describe '#contains' do
+      let(:criteria) { subject.contains('freds') }
+
+      it { expect(subject).to respond_to(:contains) }
+      it_behaves_like 'a function criterium', :contains, 'freds', "contains(Name,'freds')"
+    end
+
+    describe '#startswith' do
+      let(:criteria) { subject.startswith('Alfreds') }
+
+      it { expect(subject).to respond_to(:startswith) }
+      it_behaves_like 'a function criterium', :startswith, 'Alfreds', "startswith(Name,'Alfreds')"
+    end
+
+    describe '#endswith' do
+      let(:criteria) { subject.endswith('Futterkiste') }
+
+      it { expect(subject).to respond_to(:endswith) }
+      it_behaves_like 'a function criterium', :endswith, 'Futterkiste', "endswith(Name,'Futterkiste')"
+    end
+
+    describe '#tolower' do
+      let(:criteria) { subject.tolower.eq('alfreds futterkiste') }
+
+      it { expect(subject).to respond_to(:tolower) }
+      it_behaves_like 'an operator-function criterium', :tolower, :eq, 'alfreds futterkiste', "tolower(Name) eq 'alfreds futterkiste'"
+    end
+
+    describe '#toupper' do
+      let(:criteria) { subject.toupper.eq('ALFREDS FUTTERKISTE') }
+
+      it { expect(subject).to respond_to(:toupper) }
+      it_behaves_like 'an operator-function criterium', :toupper, :eq, 'ALFREDS FUTTERKISTE', "toupper(Name) eq 'ALFREDS FUTTERKISTE'"
+    end
+  end
+
+  describe 'date functions' do
+    let(:subject) { FrOData::Query::Criteria.new(property: datetime_property) }
+
+    describe '#year' do
+      let(:criteria) { subject.year.eq(1981) }
+
+      it { expect(subject).to respond_to(:year) }
+      it_behaves_like 'an operator-function criterium', :year, :eq, 1981, 'year(BirthDate) eq 1981'
+    end
+
+    describe '#month' do
+      let(:criteria) { subject.month.eq(8) }
+
+      it { expect(subject).to respond_to(:month) }
+      it_behaves_like 'an operator-function criterium', :month, :eq, 8, 'month(BirthDate) eq 8'
+    end
+
+    describe '#day' do
+      let(:criteria) { subject.day.eq(27) }
+
+      it { expect(subject).to respond_to(:day) }
+      it_behaves_like 'an operator-function criterium', :day, :eq, 27, 'day(BirthDate) eq 27'
+    end
+
+    describe '#hour' do
+      let(:criteria) { subject.hour.eq(9) }
+
+      it { expect(subject).to respond_to(:hour) }
+      it_behaves_like 'an operator-function criterium', :hour, :eq, 9, 'hour(BirthDate) eq 9'
+    end
+
+    describe '#minute' do
+      let(:criteria) { subject.minute.eq(35) }
+
+      it { expect(subject).to respond_to(:minute) }
+      it_behaves_like 'an operator-function criterium', :minute, :eq, 35, 'minute(BirthDate) eq 35'
+    end
+
+    describe '#second' do
+      let(:criteria) { subject.second.eq(11) }
+
+      it { expect(subject).to respond_to(:second) }
+      it_behaves_like 'an operator-function criterium', :second, :eq, 11, 'second(BirthDate) eq 11'
+    end
+
+    describe '#fractionalseconds' do
+      let(:criteria) { subject.fractionalseconds.eq(0) }
+
+      it { expect(subject).to respond_to(:fractionalseconds) }
+      it_behaves_like 'an operator-function criterium', :fractionalseconds, :eq, 0, 'fractionalseconds(BirthDate) eq 0'
+    end
+
+    describe '#date' do
+      let(:criteria) { subject.date.ne('date(EndTime)') }
+
+      it { expect(subject).to respond_to(:date) }
+      it_behaves_like 'an operator-function criterium', :date, :ne, 'date(EndTime)', 'date(BirthDate) ne date(EndTime)'
+    end
+
+    describe '#time' do
+      let(:criteria) { subject.time.le('StartOfDay') }
+
+      it { expect(subject).to respond_to(:time) }
+      it_behaves_like 'an operator-function criterium', :time, :le, 'StartOfDay', 'time(BirthDate) le StartOfDay'
+    end
+  end
+
+  describe 'geospatial functions' do
+    let(:subject) { FrOData::Query::Criteria.new(property: geo_property) }
+
+    describe '#distance' do
+      let(:criteria) { subject.distance('TargetPosition').le(42) }
+
+      it { expect(subject).to respond_to(:distance) }
+      it_behaves_like 'an operator-function criterium', :'geo.distance', :le, 42, 'geo.distance(Position,TargetPosition) le 42'
+    end
+
+    describe '#intersects' do
+      let(:criteria) { subject.intersects('TargetArea') }
+
+      it { expect(subject).to respond_to(:intersects) }
+      it_behaves_like 'a function criterium', :'geo.intersects', 'TargetArea', 'geo.intersects(Position,TargetArea)'
+    end
+  end
+
+  describe 'lambda operators' do
+    let(:subject) { FrOData::Query::Criteria.new(property: navigation_property) }
+
+    describe '#any' do
+      let(:criteria) { subject.any('Quantity').gt(100) }
+
+      it { expect(subject).to respond_to(:any) }
+      it_behaves_like 'an operator-function criterium', :any, :gt, 100, 'Items/any(d:d/Quantity gt 100)'
+    end
+
+    describe '#all' do
+      let(:criteria) { subject.all('Quantity').gt(100) }
+
+      it { expect(subject).to respond_to(:all) }
+      it_behaves_like 'an operator-function criterium', :all, :gt, 100, 'Items/all(d:d/Quantity gt 100)'
+    end
+  end
+end

data/spec/frodata/query_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+describe FrOData::Query, vcr: {cassette_name: 'query_specs'} do
+  before(:example) do
+    FrOData::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:subject) { FrOData::Query.new(entity_set) }
+  let(:entity_set) { FrOData::EntitySet.new(options) }
+  let(:options) { {
+    service_name: 'ODataDemo',
+    container: 'DemoService',
+    namespace: 'ODataDemo',
+    name: 'Products',
+    type: 'ODataDemo.Product'
+  } }
+
+  it { expect(subject).to respond_to(:to_s) }
+  it { expect(subject.to_s).to eq('Products')}
+
+  it { expect(subject).to respond_to(:[]) }
+  describe '#[]' do
+    it { expect(subject[:Name]).to be_a(FrOData::Query::Criteria) }
+    it {  expect(subject[:Name].property).to be_a(FrOData::Property) }
+  end
+
+  it { expect(subject).to respond_to(:find) }
+  describe '#find' do
+    let(:product) { subject.find(0) }
+
+    it 'finds an entity by its ID' do
+      expect(product).to be_a(FrOData::Entity)
+      expect(product['ID']).to eq(0)
+    end
+
+    it 'allows expanding navigational properties' do
+      product_with_categories = subject.expand('Categories').find(0)
+      expect(product_with_categories['Categories']).to eq([
+        { "ID" => 0, "Name" => "Food" }
+      ])
+    end
+  end
+
+  it { expect(subject).to respond_to(:where) }
+  describe '#where' do
+    let(:criteria) { subject[:Name].eq('Bread') }
+    let(:query_string) { "Products?$filter=Name eq 'Bread'" }
+
+    it { expect(subject.where(criteria)).to eq(subject) }
+    it { expect(subject.where(criteria).to_s).to eq(query_string) }
+  end
+
+  it { expect(subject).to respond_to(:search) }
+  describe '#search' do
+    let(:term) { '"mountain bike"' }
+    let(:query_string) { 'Products?$search="mountain bike"' }
+
+    it { expect(subject.search(term)).to eq(subject) }
+    it { expect(subject.search(term).to_s).to eq(query_string) }
+
+    describe 'with multiple terms' do
+      let(:query_string) { 'Products?$search="mountain bike" AND NOT clothing' }
+
+      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
+
+  it { expect(subject).to respond_to(:skip) }
+  describe '#skip' do
+    it { expect(subject.skip(5)).to eq(subject) }
+    it 'properly formats query with skip specified' do
+      subject.skip(5)
+      expect(subject.to_s).to eq('Products?$skip=5')
+    end
+  end
+
+  it { expect(subject).to respond_to(:limit) }
+  describe '#limit' do
+
+    it { expect(subject.limit(5)).to eq(subject) }
+    it 'properly formats query with limit specified' do
+      subject.limit(5)
+      expect(subject.to_s).to eq('Products?$top=5')
+    end
+  end
+
+  it { expect(subject).to respond_to(:include_count) }
+  describe '#include_count' do
+    it { expect(subject.include_count).to eq(subject) }
+    it 'properly formats query with include_count specified' do
+      subject.include_count
+      expect(subject.to_s).to eq('Products?$count=true')
+    end
+  end
+
+  it { expect(subject).to respond_to(:select) }
+  describe '#select' do
+    it { expect(subject.select(:Name, :Price)).to eq(subject) }
+    it 'properly formats query with select operation specified' do
+      subject.select(:Name, :Price)
+      expect(subject.to_s).to eq('Products?$select=Name,Price')
+    end
+  end
+
+  it { expect(subject).to respond_to(:expand) }
+  describe '#expand' do
+    it { expect(subject.expand(:Supplier)).to eq(subject) }
+    it 'properly formats query with expand operation specified' do
+      subject.expand(:Supplier)
+      expect(subject.to_s).to eq('Products?$expand=Supplier')
+    end
+  end
+
+  it { expect(subject).to respond_to(:order_by) }
+  describe '#order_by' do
+    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.to_s).to eq('Products?$orderby=Name,Price')
+    end
+  end
+
+  describe '#execute' do
+    it { expect(subject).to respond_to(:execute) }
+    it { expect(subject.execute).to be_a(FrOData::Service::Response) }
+  end
+
+  describe '#count' do
+    it { expect(subject).to respond_to(:count) }
+    it { expect(subject.count).to be_a(Integer) }
+    it { expect(subject.count).to eq(11) }
+
+    context 'with filters' do
+      let(:criteria) { subject[:Name].eq('Bread') }
+
+      it { expect(subject.where(criteria).count).to eq(1) }
+    end
+  end
+
+  describe '#empty?' do
+    it { expect(subject).to respond_to(:empty?) }
+    it { expect(subject.empty?).to eq(false) }
+
+    context 'with filters' do
+      let(:non_empty_criteria) { subject[:Name].eq('Bread') }
+      let(:empty_criteria) { subject[:Name].eq('NonExistent') }
+
+      it { expect(subject.where(non_empty_criteria).empty?).to eq(false) }
+      it { expect(subject.where(empty_criteria).empty?).to eq(true) }
+    end
+  end
+
+  describe '#in_batches' do
+    it { expect(subject).to respond_to(:in_batches) }
+    it 'returns FrOData::Entities in batches of specified size' do
+      batch_count = entity_count = 0
+
+      subject.in_batches(of: 5) do |batch|
+        expect(batch).to be_a(FrOData::Service::Response)
+        expect(batch.count).to eq(5) unless batch_count == 2
+
+        batch.each do |entity|
+          expect(entity).to be_a(FrOData::Entity)
+          expect(entity.type).to eq('ODataDemo.Product')
+          entity_count += 1
+        end
+
+        batch_count += 1
+      end
+
+      expect(batch_count).to eq(3)
+      expect(entity_count).to eq(11)
+    end
+
+    describe '#each' do
+      it 'returns FrOData::Entities' do
+        entity_count = 0
+
+        subject.in_batches(of: 5).each do |entity|
+          expect(entity).to be_a(FrOData::Entity)
+          expect(entity.type).to eq('ODataDemo.Product')
+          entity_count += 1
+        end
+
+        expect(entity_count).to eq(11)
+      end
+    end
+  end
+end

data/spec/frodata/schema/complex_type_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe FrOData::Schema::ComplexType, vcr: {cassette_name: 'schema/complex_type_specs'} do
+  before(:example) do
+    FrOData::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:service) { FrOData::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(FrOData::Property) }
+  it { expect(subject).to be_a(FrOData::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