frodo 0.10.0

data/spec/frodo/middleware/logger_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::Logger do
+  let(:logger)     { double('logger') }
+  let(:middleware) { described_class.new app, logger, options }
+
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    before do
+      expect(app).to receive(:call).once.and_return(app)
+      expect(app).to receive(:on_complete).once { middleware.on_complete(env) }
+      expect(logger).to receive(:debug).with('request')
+      expect(logger).to receive(:debug).with('response')
+    end
+
+    it { should_not raise_error }
+  end
+end

data/spec/frodo/middleware/odata_headers_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::OdataHeaders do
+  describe '.call' do
+
+    before do
+      subject.call(env)
+    end
+
+    it { expect(env[:request_headers]['OData-Version']).to eq '4.0' }
+    it { expect(env[:request_headers]['Content-type']).to eq 'application/json' }
+  end
+end

data/spec/frodo/middleware/raise_error_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Frodo::Middleware::RaiseError do
+  let(:body)       { JSON.parse(fixture('error')) }
+  let(:env)        { { status: status, body: body } }
+  let(:middleware) { described_class.new app }
+
+  describe '.on_complete' do
+    subject(:on_complete) { middleware.on_complete(env) }
+
+    context 'when the status code is 404' do
+      let(:status) { 404 }
+
+      it "raises an error" do
+        expect { on_complete }.to raise_error Faraday::Error::ResourceNotFound
+      end
+    end
+
+    context 'when the status code is 300' do
+      let(:status) { 300 }
+
+      it "raises an error" do
+        expect { on_complete }.to raise_error Faraday::Error::ClientError,
+                                              /300: The external ID provided/
+      end
+    end
+
+    context 'when the status code is 400' do
+      let(:status) { 400 }
+
+      it "raises an error" do
+        expect { on_complete }.to raise_error Faraday::Error::ClientError,
+                                              /Resource not found for the segment/
+      end
+    end
+
+    context 'when the status code is 401' do
+      let(:status) { 401 }
+
+      it "raises an error" do
+        expect { on_complete }.to raise_error Frodo::UnauthorizedError,
+                                              /Resource not found for the segment/
+      end
+    end
+
+    context 'when the status code is 413' do
+      let(:status) { 413 }
+
+      it "raises an error" do
+        expect { on_complete }.to raise_error Faraday::Error::ClientError,
+                                              '413: Request Entity Too Large'
+      end
+    end
+
+    context 'when status is 400+ and body is a string' do
+      let(:body)   { 'An error occured' }
+      let(:status) { 406 }
+
+      it 'raises an error with a non-existing error code' do
+        expect { on_complete }.to raise_error Faraday::Error::ClientError, /An error occured/
+      end
+    end
+  end
+end

data/spec/frodo/navigation_property/proxy_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Frodo::NavigationProperty::Proxy, vcr: {cassette_name: 'navigation_property_proxy_specs'} do
+  before :each do
+    Frodo::Service.new('http://services.odata.org/V4/OData/OData.svc', name: 'ODataDemo', metadata_file: metadata_file)
+  end
+
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+  let(:entity) { Frodo::ServiceRegistry['ODataDemo']['Products'][1] }
+
+  let(:categories_proxy) { Frodo::NavigationProperty::Proxy.new(entity, 'Categories') }
+  let(:detail_proxy) { Frodo::NavigationProperty::Proxy.new(entity, 'ProductDetail') }
+  let(:supplier_proxy) { Frodo::NavigationProperty::Proxy.new(entity, 'Supplier') }
+
+  describe 'value' do
+    # FIXME Commenting until we figure out wether we need this or not
+    # it { expect(categories_proxy.value).to be_a(Enumerable) }
+    # it { expect(supplier_proxy.value).to be_a(Frodo::Entity) }
+    # it { expect(detail_proxy.value).to be_a(Frodo::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/frodo/navigation_property_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Frodo::NavigationProperty do
+  let(:options) { {
+      name: 'Categories',
+      type: 'Collection(ODataDemo.Category)',
+      partner: 'Products',
+  } }
+  let(:subject) do
+    Frodo::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 {
+        Frodo::NavigationProperty.new(type: 'Collection(ODataDemo.Category)')
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'requires type' do
+      expect {
+        Frodo::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) {
+      Frodo::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/frodo/properties/binary_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Binary do
+  let(:subject) { Frodo::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) { Frodo::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/frodo/properties/boolean_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Boolean do
+  let(:truthy1) { Frodo::Properties::Boolean.new('Truthy', 'true') }
+  let(:truthy2) { Frodo::Properties::Boolean.new('Truthy', '1') }
+  let(:falsey1) { Frodo::Properties::Boolean.new('Falsey', 'false') }
+  let(:falsey2) { Frodo::Properties::Boolean.new('Falsey', '0') }
+  let(:nily) { Frodo::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) { Frodo::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) { Frodo::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) { Frodo::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/frodo/properties/collection_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Collection do
+  let(:subject) { Frodo::Properties::Collection.new('Names', names) }
+  let(:names) { %w[Dan Greg Jon] }
+  let(:new_names) { %w[Andrew Doug Paul] }
+
+  it { expect(subject.type).to eq('Collection(Edm.String)') }
+  it { expect(subject.value).to eq(['Dan', 'Greg', 'Jon']) }
+  it { expect(subject.url_value).to eq("['Dan','Greg','Jon']") }
+
+  describe '#value=' do
+    it 'allows an array of string values to be set' do
+      subject.value = new_names
+      expect(subject.value).to eq(new_names)
+    end
+  end
+
+  # TODO: Make collection type work properly with data types other than string
+  xcontext 'with value type other than Edm.String' do
+    let(:subject) { Frodo::Properties::Collection.new('Bits', [1, 0, 1], value_type: 'Edm.Binary') }
+
+    it { expect(subject.type).to eq('Collection(Edm.Int32)') }
+    it { expect(subject.value).to eq([1, 0, 1]) }
+    it { expect(subject.url_value).to eq('[1,0,1]') }
+
+    it 'does not allow other property types to be set' do
+      expect {
+        subject.value = names
+      }.to raise_error(ArgumentError)
+    end
+
+    xdescribe 'lenient validation' do
+      let(:subject) do
+        Frodo::Properties::Collection.new('Names', names, value_type: 'Edm.String', strict: false)
+      end
+
+      it 'ignores invalid values' do
+        subject.value = [1, 2, 3]
+        expect(subject.value).to eq([])
+      end
+    end
+  end
+end

data/spec/frodo/properties/date_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Date do
+  let(:subject) { Frodo::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/frodo/properties/date_time_offset_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Frodo::Properties::DateTimeOffset do
+  let(:subject) { Frodo::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) { Frodo::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/frodo/properties/date_time_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Frodo::Properties::DateTime do
+  let(:subject) { Frodo::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/frodo/properties/decimal_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Decimal do
+  let(:subject) { Frodo::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.90325') }
+
+  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) }
+
+  describe '#value=' do
+    it 'allows BigDecimal to be set' do
+      subject.value = BigDecimal('19.89043256')
+      expect(subject.value).to eq(BigDecimal('19.89043256'))
+    end
+
+    it 'allows string value to be set' do
+      subject.value = '19.89043256'
+      expect(subject.value).to eq(BigDecimal('19.89043256'))
+    end
+
+    it 'ignores invalid characters' do
+      subject.value = '123.4-foobar-5'
+      expect(subject.value).to eq(BigDecimal('123.4'))
+    end
+
+    it 'inteprets anything that is not a number as 0' do
+      expect{ subject.value = 'foobar' }. to raise_error ArgumentError
+    end
+
+    it 'does not allow values outside a certain range' do
+      expect { subject.value = 'Infinity' }.to raise_error(ArgumentError)
+    end
+
+    describe 'lenient validation' do
+      let(:subject) do
+        Frodo::Properties::Decimal.new('Decimal', '678.90325', strict: false)
+      end
+
+      it 'ignores invalid values' do
+        subject.value = 'Infinity'
+        expect(subject.value).to eq(BigDecimal('Infinity'))
+      end
+    end
+  end
+end

data/spec/frodo/properties/float_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Frodo::Properties::Float do
+  describe 'double precision' do
+    let(:subject) { Frodo::Properties::Double.new('Float', '678.90325') }
+
+    it { expect(subject.type).to eq('Edm.Double') }
+    it { expect(subject.value).to eq(678.90325) }
+
+    it { expect { subject.value = (1.7 * (10**308) * 2) }.to raise_error(ArgumentError) }
+    it { expect { subject.value = (-1.7 * (10**308) * 2) }.to raise_error(ArgumentError) }
+
+    it { expect(lambda {
+      subject.value = '19.89043256'
+      subject.value
+    }.call).to eq(19.89043256) }
+
+    it { expect(lambda {
+      subject.value = 19.89043256
+      subject.value
+    }.call).to eq(19.89043256) }
+  end
+
+  describe 'single precision' do
+    let(:subject) { Frodo::Properties::Single.new('Float', '678.90325') }
+
+    it { expect(subject.type).to eq('Edm.Single') }
+    it { expect(subject.value).to eq(678.90325) }
+
+    it { expect(subject.url_value).to eq('678.90325F') }
+
+    it { expect { subject.value = (3.4 * (10**38) * 2) }.to raise_error(ArgumentError) }
+    it { expect { subject.value = (-3.4 * (10**38) * 2) }.to raise_error(ArgumentError) }
+
+    it { expect(lambda {
+      subject.value = '19.89043256'
+      subject.value
+    }.call).to eq(19.89043256) }
+
+    it { expect(lambda {
+      subject.value = 19.89043256
+      subject.value
+    }.call).to eq(19.89043256) }
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require_relative 'shared_examples'
+
+describe Frodo::Properties::Geography::LineString do
+  let(:klass) { Frodo::Properties::Geography::LineString }
+  let(:property_name) { 'Boundary' }
+  let(:srid)  { 4326 }
+  let(:coordinates)     { [[100.0, 0.0], [101.0, 1.0]] }
+  let(:property_as_text) { "geography'SRID=4326;LineString(100.0 0.0,101.0 1.0)'" }
+  let(:property_as_json) { {
+    type: 'LineString',
+    coordinates: [
+      [100.0, 0.0],
+      [101.0, 1.0]
+    ],
+    crs: {
+      type: 'name',
+      properties: { name: 'EPSG:4326' }
+    }
+  } }
+  let(:property_as_xml) { <<-END }
+    <data:Boundary metadata:type="Edm.GeographyLineString">
+      <gml:LineString gml:srsName="http://www.opengis.net/def/crs/EPSG/0/4326">
+        <gml:pos>100.0 0.0</gml:pos>
+        <gml:pos>101.0 1.0</gml:pos>
+      </gml:LineString>
+    </data:Boundary>
+  END
+  let(:new_value) { [[0.0, 100.0], [1.0, 101.0]] }
+  let(:new_value_as_text) { "geography'SRID=0;LineString(0.0 100.0,1.0 101.0)'" }
+
+  it_behaves_like 'a geographic property', 'Edm.GeographyLineString'
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require_relative 'shared_examples'
+
+describe Frodo::Properties::Geography::Point do
+  let(:klass) { Frodo::Properties::Geography::Point }
+  let(:property_name) { 'Location' }
+  let(:srid)  { 4326 }
+  let(:coordinates)    { [ 142.1, 64.1 ]}
+  let(:property_as_text) { "geography'SRID=4326;Point(142.1 64.1)'" }
+  let(:property_as_json) { {
+    type: 'Point',
+    coordinates: [142.1, 64.1],
+    crs: {
+      type: 'name',
+      properties: { name: 'EPSG:4326' }
+    }
+  } }
+  let(:property_as_xml) { <<-END }
+    <data:Location metadata:type="Edm.GeographyPoint">
+      <gml:Point gml:srsName="http://www.opengis.net/def/crs/EPSG/0/4326">
+        <gml:pos>142.1 64.1</gml:pos>
+      </gml:Point>
+    </data:Location>
+  END
+  let(:new_value) { [ 100.0, 0.0 ] }
+  let(:new_value_as_text) { "geography'SRID=0;Point(100.0 0.0)'" }
+
+  it_behaves_like 'a geographic property', 'Edm.GeographyPoint'
+end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require_relative 'shared_examples'
+
+describe Frodo::Properties::Geography::Polygon do
+  let(:klass) { Frodo::Properties::Geography::Polygon }
+  let(:property_name) { 'Area' }
+  let(:srid) { 4326 }
+  let(:coordinates) { [
+      [100.0, 0.0],
+      [101.0, 0.0],
+      [101.0, 1.0],
+      [100.0, 1.0],
+      [100.0, 0.0]
+  ] }
+  let(:property_as_text) { "geography'SRID=4326;Polygon((100.0 0.0,101.0 0.0,101.0 1.0,100.0 1.0,100.0 0.0))'" }
+  let(:property_as_json) { {
+    type: 'Polygon',
+    coordinates: [
+      [100.0, 0.0],
+      [101.0, 0.0],
+      [101.0, 1.0],
+      [100.0, 1.0],
+      [100.0, 0.0]
+    ],
+    crs: {
+      type: 'name',
+      properties: { name: 'EPSG:4326' }
+    }
+  } }
+  let(:property_as_xml) { <<-END }
+    <data:Area metadata:type="Edm.GeographyPolygon">
+      <gml:Polygon gml:srsName="http://www.opengis.net/def/crs/EPSG/0/4326">
+        <gml:exterior>
+          <gml:LinearRing>
+            <gml:pos>100.0 0.0</gml:pos>
+            <gml:pos>101.0 0.0</gml:pos>
+            <gml:pos>101.0 1.0</gml:pos>
+            <gml:pos>100.0 1.0</gml:pos>
+            <gml:pos>100.0 0.0</gml:pos>
+          </gml:LinearRing>
+        </gml:exterior>
+      </gml:Polygon>
+    </data:Area>
+  END
+  let(:new_value) { [
+      [200.0, 10.0],
+      [201.0, 10.0],
+      [201.0, 11.0],
+      [200.0, 11.0],
+      [200.0, 10.0]
+  ] }
+  let(:new_value_as_text) { "geography'SRID=0;Polygon((200.0 10.0,201.0 10.0,201.0 11.0,200.0 11.0,200.0 10.0))'" }
+
+  it_behaves_like 'a geographic property', 'Edm.GeographyPolygon'
+end