frodo 0.10.0

data/spec/frodo/usage_example_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe 'Usage examples', vcr: { cassette_name: 'usage_example_specs' } do
+  let(:service_url) { 'http://services.odata.org/V4/OData/OData.svc' }
+  let(:service) { Frodo::Service.new(service_url, name: 'ODataDemo', metadata_file: metadata_file) }
+  let(:metadata_file) { 'spec/fixtures/files/metadata.xml' }
+
+  describe 'getting information' do
+    it 'returns the service URL' do
+      expect(service.service_url).to eq(service_url)
+    end
+
+    it 'returns the service namespace' do
+      expect(service.namespace).to eq('ODataDemo')
+    end
+
+    it 'lists entity types' do
+      expect(service.entity_types).to eq(%w[
+        ODataDemo.Product
+        ODataDemo.FeaturedProduct
+        ODataDemo.ProductDetail
+        ODataDemo.Category
+        ODataDemo.Supplier
+        ODataDemo.Person
+        ODataDemo.Customer
+        ODataDemo.Employee
+        ODataDemo.PersonDetail
+        ODataDemo.Advertisement
+      ])
+    end
+
+    it 'lists entity sets' do
+      expect(service.entity_sets).to eq({
+        "Products"       => "ODataDemo.Product",
+        "ProductDetails" => "ODataDemo.ProductDetail",
+        "Categories"     => "ODataDemo.Category",
+        "Suppliers"      => "ODataDemo.Supplier",
+        "Persons"        => "ODataDemo.Person",
+        "PersonDetails"  => "ODataDemo.PersonDetail",
+        "Advertisements" => "ODataDemo.Advertisement"
+      })
+    end
+  end
+
+  describe 'working with entity sets' do
+    # it 'accessing entity sets' do
+    #   service.entity_sets.each do |entity_set_name, entity_name|
+    #     entity_set = service[entity_set_name]
+
+    #     expect(entity_set).to be_a(Frodo::EntitySet)
+    #     expect(entity_set.name).to eq(entity_set_name)
+    #     expect(entity_set.type).to eq(entity_name)
+    #     expect(entity_set.namespace).to eq(service.namespace)
+    #   end
+    # end
+
+    # describe 'accessing entities' do
+      # let(:products) { service['Products'] }
+
+      # it 'getting the first entity in a set' do
+      #   expect(products.first).to be_a(Frodo::Entity)
+      #   expect(products.first.name).to eq('Product')
+      # end
+
+      # it 'iterating over the entire set' do
+      #   products.each do |product|
+      #     expect(product).to be_a(Frodo::Entity)
+      #     expect(product.name).to eq('Product')
+      #   end
+      # end
+
+      # it 'counting entities' do
+      #   expect(products.count).to eq(11)
+      # end
+
+      # it 'creating a new entity' do
+      #   new_product = products.new_entity
+
+      #   expect(new_product).to be_a(Frodo::Entity)
+      #   expect(new_product.name).to eq('Product')
+      # end
+    # end
+
+    # describe 'querying' do
+    #   let(:products) { service['Products'] }
+    #   let(:query)    { products.query }
+
+    #   it 'obtain a query object using #query' do
+    #     expect(products.query).to be_a(Frodo::Query)
+    #   end
+
+    #   it 'executing query' do
+    #     results = query.execute
+
+    #     expect(results.map { |p| p['Name']}).to eq([
+    #       "Bread",
+    #       "Milk",
+    #       "Vint soda",
+    #       "Havina Cola",
+    #       "Fruit Punch",
+    #       "Cranberry Juice",
+    #       "Pink Lemonade",
+    #       "DVD Player",
+    #       "LCD HDTV",
+    #       "Lemonade",
+    #       "Coffee"
+    #     ])
+    #   end
+
+    #   it 'adding criteria' do
+    #     query.where(query['Name'].eq('Milk'))
+    #     results = query.execute
+
+    #     expect(query.to_s).to eq("Products?$filter=Name eq 'Milk'")
+    #     results.each do |product|
+    #       expect(product).to be_a(Frodo::Entity)
+    #       expect(product.name).to eq('Product')
+    #       expect(product['Name']).to eq('Milk')
+    #     end
+    #   end
+
+    #   it 'ordering results' do
+    #     results = query.order_by('Name').execute
+
+    #     expect(results.map { |p| p['Name'] }).to eq([
+    #       "Bread",
+    #       "Coffee",
+    #       "Cranberry Juice",
+    #       "DVD Player",
+    #       "Fruit Punch",
+    #       "Havina Cola",
+    #       "LCD HDTV",
+    #       "Lemonade",
+    #       "Milk",
+    #       "Pink Lemonade",
+    #       "Vint soda"
+    #     ])
+    #   end
+    # end
+  end
+
+  describe 'working with entities' do
+    # let(:product) { service['Products'][1] }
+
+    # it 'getting a list of property names' do
+    #   expect(product.property_names).to eq([
+    #     "ID", "Name", "Description", "ReleaseDate", "DiscontinuedDate", "Rating", "Price"
+    #   ])
+    # end
+
+    # it 'accessing entity properties' do
+    #   expect(product["ID"]).to eq(1)
+    #   expect(product["Name"]).to eq("Milk")
+    #   expect(product["Description"]).to eq("Low fat milk")
+    #   expect(product["ReleaseDate"]).to eq(DateTime.parse("1995-10-01T00:00:00Z"))
+    #   expect(product["DiscontinuedDate"]).to be_nil
+    #   expect(product["Rating"]).to eq(3)
+    #   expect(product["Price"]).to eq(3.5)
+    # end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'frodo'
+require 'rspec/matchers' # required for 'equivalent-xml'
+require 'equivalent-xml'
+require 'securerandom'
+require 'timecop'
+require 'webmock/rspec'
+
+# Load all files from `spec/support`
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f }
+
+WebMock.disable_net_connect!
+
+RSpec.configure do |config|
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 3
+  config.order = :random
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.after(:example) do
+    # We're calling this as a private method because there should not be any
+    # reasons to have to flush the service registry except in testing.
+    Frodo::ServiceRegistry.instance.send(:flush)
+  end
+end

data/spec/support/coverage.rb

@@ -0,0 +1,2 @@
+require 'simplecov'
+SimpleCov.start

data/spec/support/fixture_helpers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FixtureHelpers
+    module InstanceMethods
+
+      def fixture(f)
+        File.read(File.expand_path("../../fixtures/#{f}.json", __FILE__))
+      end
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include FixtureHelpers::InstanceMethods
+  end

data/spec/support/middleware.rb

@@ -0,0 +1,19 @@
+module MiddlewareExampleGroup
+    def self.included(base)
+      base.class_eval do
+        let(:app)            { double('@app', call: nil) }
+        let(:env)            { { request_headers: {}, response_headers: {} } }
+        let(:retries)        { 3 }
+        let(:options)        { {} }
+        let(:client)         { double(Frodo::AbstractClient) }
+        let(:auth_callback)  { double(Proc) }
+
+        subject(:middleware) { described_class.new app, client, options }
+      end
+    end
+
+    RSpec.configure do |config|
+      config.include self,
+                     example_group: { file_path: %r{spec/frodo/middleware} }
+    end
+  end