frodo 0.10.0

data/spec/frodo/properties/geography/shared_examples.rb

@@ -0,0 +1,72 @@
+shared_examples 'a geographic property' do |type_name|
+  let(:subject) { klass.new(property_name, coordinates) }
+
+  describe '#type' do
+    it { expect(subject.type).to eq(type_name) }
+  end
+
+  describe '#srid' do
+    it { expect(subject.srid).to eq(srid) }
+  end
+
+  describe '#value' do
+    it { expect(subject.value).to eq(coordinates) }
+  end
+
+  describe '#value=' do
+    it { expect { subject.value = 'invalid' }.to raise_error(ArgumentError) }
+
+    it {
+      subject.value = new_value_as_text
+      expect(subject.value).to eq(new_value)
+      expect(subject.srid).to eq(0)
+    }
+
+    it {
+      subject.value = new_value
+      expect(subject.value).to eq(new_value)
+      expect(subject.srid).to eq(4326)
+    }
+  end
+
+  describe '#url_value' do
+    it { expect(subject.url_value).to eq(property_as_text) }
+  end
+
+  describe '#json_value' do
+    it 'renders property value as a hash' do
+      expect(subject.json_value).to eq(property_as_json)
+    end
+  end
+
+  describe '#to_xml' do
+    let(:builder) do
+      Nokogiri::XML::Builder.new do |xml|
+        xml.entry(Frodo::Entity::XML_NAMESPACES) do
+          subject.to_xml(xml)
+        end
+      end
+    end
+    let(:xml) { Nokogiri::XML(builder.to_xml) }
+    let(:property_xml) { xml.root.element_children.first.to_s }
+
+    it { expect(property_xml).to be_equivalent_to(property_as_xml) }
+  end
+
+  describe '.from_xml' do
+    let(:subject) { klass.from_xml(property_xml) }
+    let(:xml_doc) do
+      Nokogiri::XML::Builder.new do |xml|
+        xml.entry(Frodo::Entity::XML_NAMESPACES)
+      end.to_xml
+    end
+    let(:property_xml) do
+      document = Nokogiri::XML(xml_doc)
+      document.root << property_as_xml
+      document.remove_namespaces!.root.element_children.first
+    end
+
+    it { expect(subject.value).to eq(coordinates) }
+    it { expect(subject.srid).to eq(srid) }
+  end
+end

data/spec/frodo/properties/guid_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Guid do
+  let(:guid) { SecureRandom.uuid }
+  let(:guid2) { SecureRandom.uuid }
+  let(:subject) { Frodo::Properties::Guid.new('Stringy', guid) }
+
+  it { expect(subject.type).to eq('Edm.Guid') }
+  it { expect(subject.value).to eq(guid)}
+
+  it { expect(lambda {
+    subject.value = guid2
+    subject.value
+  }.call).to eq(guid2) }
+
+  it { expect(subject.url_value).to eq("#{guid}") }
+end

data/spec/frodo/properties/integer_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Integer do
+  let(:subject) { Frodo::Properties::Integer.new('Integer', '32') }
+  let(:subject16) { Frodo::Properties::Int16.new('Int16', '32') }
+  let(:subject32) { Frodo::Properties::Int32.new('Int32', '32') }
+  let(:subject64) { Frodo::Properties::Int64.new('Int64', '32') }
+  let(:subjectbyte) { Frodo::Properties::Byte.new('Byte', '32') }
+  let(:subjectsbyte) { Frodo::Properties::SByte.new('SByte', '32') }
+
+  it { expect(subject.type).to eq('Edm.Int64') }
+  it { expect(subject.value).to eq(32) }
+  it { expect {subject.value = (2**63)}.to raise_error(ArgumentError) }
+  it { expect {subject.value = (-(2**63) - 1)}.to raise_error(ArgumentError) }
+
+  it { expect(subject16.type).to eq('Edm.Int16') }
+  it { expect(subject16.value).to eq(32) }
+  it { expect {subject16.value = (2**15)}.to raise_error(ArgumentError) }
+  it { expect {subject16.value = (-(2**15) - 1)}.to raise_error(ArgumentError) }
+
+  it { expect(subject32.type).to eq('Edm.Int32') }
+  it { expect(subject32.value).to eq(32) }
+  it { expect {subject32.value = (2**31)}.to raise_error(ArgumentError) }
+  it { expect {subject32.value = (-(2**31) - 1)}.to raise_error(ArgumentError) }
+
+  it { expect(subject64.type).to eq('Edm.Int64') }
+  it { expect(subject64.value).to eq(32) }
+  it { expect {subject64.value = (2**63)}.to raise_error(ArgumentError) }
+  it { expect {subject64.value = (-(2**63) - 1)}.to raise_error(ArgumentError) }
+
+  it { expect(subjectbyte.type).to eq('Edm.Byte') }
+  it { expect(subjectbyte.value).to eq(32) }
+  it { expect {subjectbyte.value = 2**8}.to raise_error(ArgumentError) }
+  it { expect {subjectbyte.value = -1}.to raise_error(ArgumentError) }
+
+  it { expect(subjectsbyte.type).to eq('Edm.SByte') }
+  it { expect(subjectsbyte.value).to eq(32) }
+  it { expect {subjectsbyte.value = (2**7)}.to raise_error(ArgumentError) }
+  it { expect {subjectsbyte.value = (-(2**7) - 1)}.to raise_error(ArgumentError) }
+
+  describe '#value=' do
+    before(:example) do
+      subject.value = 128
+      subject16.value = 128
+      subject32.value = 128
+      subject64.value = 128
+      subjectbyte.value = 12
+      subjectsbyte.value = 12
+    end
+
+    it { expect(subject.value).to eq(128) }
+    it { expect(subject16.value).to eq(128) }
+    it { expect(subject32.value).to eq(128) }
+    it { expect(subject64.value).to eq(128) }
+    it { expect(subjectbyte.value).to eq(12) }
+    it { expect(subjectsbyte.value).to eq(12) }
+  end
+end

data/spec/frodo/properties/string_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Frodo::Properties::String do
+  let(:subject) { Frodo::Properties::String.new('Stringy', 'This is an example') }
+
+  it { expect(subject).to respond_to(:is_unicode?) }
+  it { expect(subject).to respond_to(:has_default_value?) }
+  it { expect(subject).to respond_to(:default_value) }
+
+  it { expect(subject.type).to eq('Edm.String') }
+  it { expect(subject.value).to eq('This is an example')}
+
+  it { expect(lambda {
+    subject.value = 'Another example'
+    subject.value
+  }.call).to eq('Another example') }
+
+  it { expect(lambda {
+    subject.value = nil
+    subject.value
+  }.call).to eq(nil) }
+
+  describe '#is_unicode?' do
+    let(:not_unicode) { Frodo::Properties::String.new('Stringy', 'This is an example', unicode: false) }
+
+    it { expect(subject.is_unicode?).to eq(true) }
+    it { expect(not_unicode.is_unicode?).to eq(false) }
+
+    it { expect(subject.value.encoding).to eq(Encoding::UTF_8) }
+    it { expect(not_unicode.value.encoding).to eq(Encoding::ASCII) }
+  end
+
+  describe 'when #allows_nil? is false' do
+    let(:subject) { Frodo::Properties::String.new('Stringy', 'This is an example', allows_nil: false) }
+
+    it { expect {subject.value = nil}.to raise_error(ArgumentError) }
+    it { expect {subject.value = 'Test'}.not_to raise_error }
+  end
+
+  describe 'with default_value' do
+    let(:subject) { Frodo::Properties::String.new('Stringy', nil, default_value: 'Sample Text') }
+
+    it { expect(subject.has_default_value?).to eq(true) }
+    it { expect(subject.default_value).to eq('Sample Text') }
+  end
+end

data/spec/frodo/properties/time_of_day_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Frodo::Properties::TimeOfDay do
+  let(:subject) { Frodo::Properties::TimeOfDay.new('TimeOfDay', '16:00:00.000') }
+  let(:new_time) { Time.strptime('14:32:00.000', '%H:%M:%S.%L') }
+
+  it { expect(subject.type).to eq('Edm.TimeOfDay') }
+  it { expect(subject.value).to eq(Time.parse('16:00:00.000')) }
+
+  it { expect(subject.url_value).to eq("16:00:00.000")}
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(lambda {
+    subject.value = '14:32:00.000'
+    subject.value
+  }.call).to eq(new_time) }
+
+  it { expect(lambda {
+    subject.value = new_time
+    subject.value
+  }.call).to eq(new_time) }
+end

data/spec/frodo/properties/time_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Time do
+  let(:subject) { Frodo::Properties::Time.new('Timely', '21:00:00-08:00') }
+
+  it { expect(subject.type).to eq('Edm.Time') }
+  it { expect(subject.value).to eq(Time.strptime('21:00:00-08:00', '%H:%M:%S%:z')) }
+
+  it { expect {subject.value = 'bad'}.to raise_error(ArgumentError) }
+
+  it { expect(lambda {
+    subject.value = Time.strptime('13:22:12+04:00', '%H:%M:%S%:z')
+    subject.value
+  }.call).to eq(Time.strptime('13:22:12+04:00', '%H:%M:%S%:z'))}
+end

data/spec/frodo/property_registry_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Frodo::PropertyRegistry do
+  let(:subject) { Frodo::PropertyRegistry }
+
+  it { expect(subject).to respond_to(:add) }
+  it { expect(subject).to respond_to(:[]) }
+
+  describe '#add' do
+    before(:each) do
+      subject.add('Edm.Guid', Frodo::Properties::Guid)
+    end
+
+    it { expect(subject['Edm.Guid']).to eq(Frodo::Properties::Guid) }
+  end
+end

data/spec/frodo/property_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Frodo::Property do
+  let(:service) do
+    Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', metadata_file: metadata_file)
+  end
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:subject) { Frodo::Property.new('PropertyName', '1') }
+  let(:good_comparison) { Frodo::Property.new('GoodComparison', '1') }
+  let(:bad_comparison) { Frodo::Property.new('BadComparison', '2') }
+
+  describe '#name' do
+    it { expect(subject).to respond_to(:name) }
+    it { expect(subject.name).to eq('PropertyName') }
+  end
+
+  describe '#value' do
+    it { expect(subject).to respond_to(:value) }
+    it { expect(subject.value).to eq('1') }
+  end
+
+  describe '#xml_value' do
+    it { expect(subject).to respond_to(:xml_value) }
+    it { expect(subject.xml_value).to eq('1') }
+  end
+
+  describe '#url_value' do
+    it { expect(subject).to respond_to(:url_value) }
+    it { expect(subject.url_value).to eq('1') }
+  end
+
+  describe '#type' do
+    it { expect(subject).to respond_to(:type) }
+    it { expect(lambda {subject.type}).to raise_error(NotImplementedError) }
+  end
+
+  describe '#allows_nil?' do
+    it { expect(subject).to respond_to(:allows_nil?) }
+    it { expect(subject.allows_nil?).to eq(true) }
+  end
+
+  describe '#strict?' do
+    it { expect(subject).to respond_to(:strict?) }
+
+    it 'defaults to true' do
+      expect(subject.strict?).to eq(true)
+    end
+
+    it 'can be switched off via constructor option' do
+      subject = Frodo::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 = Frodo::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/frodo/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 Frodo::Query::Criteria do
+  let(:string_property) { Frodo::Properties::String.new(:Name, nil) }
+  let(:integer_property) { Frodo::Properties::Integer.new(:Age, nil) }
+  let(:datetime_property) { Frodo::Properties::DateTime.new(:BirthDate, nil) }
+  let(:geo_property) { Frodo::Properties::Geography::Point.new(:Position, nil) }
+  # TODO: use actual `NavigationProperty` class here
+  let(:navigation_property) { Frodo::Property.new(:Items, nil) }
+
+  let(:subject) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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