odata4 0.7.0

data/spec/odata4/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 OData4::Query::Criteria do
+  let(:string_property) { OData4::Properties::String.new(:Name, nil) }
+  let(:integer_property) { OData4::Properties::Integer.new(:Age, nil) }
+  let(:datetime_property) { OData4::Properties::DateTime.new(:BirthDate, nil) }
+  let(:geo_property) { OData4::Properties::Geography::Point.new(:Position, nil) }
+  # TODO: use actual `NavigationProperty` class here
+  let(:navigation_property) { OData4::Property.new(:Items, nil) }
+
+  let(:subject) { OData4::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) { OData4::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) { OData4::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) { OData4::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) { OData4::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) { OData4::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) { OData4::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) { OData4::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/odata4/query/result_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+shared_examples 'valid result' do
+  it { expect(result.count).to eq(11) }
+
+  describe '#empty?' do
+    it { expect(result).to respond_to(:empty?) }
+    it { expect(result.empty?).to eq(false) }
+  end
+
+  describe '#each' do
+    it { expect(result).to respond_to(:each) }
+    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')
+      end
+    end
+  end
+end
+
+describe OData4::Query::Result, vcr: {cassette_name: 'query/result_specs'} do
+  before(:example) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  let(:entity_set) { OData4::ServiceRegistry['ODataDemo']['Products'] }
+  # let(:subject) { entity_set.query.execute }
+
+  let(:response) do
+    response = double('response')
+    allow(response).to receive_messages(
+      headers: { 'Content-Type' => content_type },
+      body: response_body
+    )
+    response
+  end
+  let(:result) { OData4::Query::Result.new(entity_set.query, response) }
+
+  context 'with Atom Result' do
+    let(:content_type) { 'application/atom+xml' }
+    let(:response_body) { File.read('spec/fixtures/files/products.xml') }
+
+    it_behaves_like 'valid result'
+  end
+
+  context 'with JSON Result' do
+    let(:content_type) { 'application/json' }
+    let(:response_body) { File.read('spec/fixtures/files/products.json') }
+
+    it_behaves_like 'valid result'
+  end
+end

data/spec/odata4/query_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe OData4::Query, vcr: {cassette_name: 'query_specs'} do
+  before(:example) do
+    OData4::Service.open('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo')
+  end
+
+  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'
+  } }
+
+  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(OData4::Query::Criteria) }
+    it {  expect(subject[:Name].property).to be_a(OData4::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(OData4::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(OData4::Query::Result) }
+  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 OData4::Entities in batches of specified size' do
+      batch_count = entity_count = 0
+
+      subject.in_batches(of: 5) do |batch|
+        expect(batch).to be_a(OData4::Query::Result)
+        expect(batch.count).to eq(5) unless batch_count == 2
+
+        batch.each do |entity|
+          expect(entity).to be_a(OData4::Entity)
+          expect(entity.type).to eq('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 OData4::Entities' do
+        entity_count = 0
+
+        subject.in_batches(of: 5).each do |entity|
+          expect(entity).to be_a(OData4::Entity)
+          expect(entity.type).to eq('Product')
+          entity_count += 1
+        end
+
+        expect(entity_count).to eq(11)
+      end
+    end
+  end
+end