odata-model 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83e49bd9f7c8f2d740de14d39b783fa5c15ae87c
-  data.tar.gz: 7293c767466539473d216cb3daddd8445ac91b19
+  metadata.gz: 0653979dfb88ea7148ac214b771b1133922e63bd
+  data.tar.gz: 12e5004a1054dc4645ef2a4b8a7e779eda35a000
 SHA512:
-  metadata.gz: 9b3ac6d07f37f8d07d4aadd50fded4e94f3c71ccd19c8d55b7701b26a97054d15785e83c34d2207b41997feca86255a14a511989ab32728625de72e404f4af6f
-  data.tar.gz: 30e92ac253e598e43f4f2fee80f23992395c882d5672cb8c6f26ca207899832e5caef0f61cf647515d125e9c39768834024220be99dac690d4e0830fe5be09b8
+  metadata.gz: 23e898b61aec37dafb51611b3e8778d0eb449783c0e5820786ac8e5d41ae3939a454963267f369399ad6932b93c2e692f129a8c45f99607df788d304d9785333
+  data.tar.gz: 4ebcf488bac36ae7c4fb17c8531bec5f77530c53f1ddc80c541e237426b838a3a5f1b6c814caf6f48b5835e0a264dfd99f366aa7845a32dd0a2bf6fb8e994add

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## 0.1.0
+
+* Basic model behavior via property mapping and query interface.

data/lib/odata/model/query.rb

@@ -1,5 +1,6 @@
 module OData
   module Model
+    # Provides the methods that make up the query interface for OData::Model.
     module Query
       extend ActiveSupport::Concern
 
@@ -9,10 +10,44 @@ module OData
 
       # Methods mixed in at the class level.
       module ClassMethods
-        # Starts a chain for building up an OData query.
-        # @return [OData::Query::Builder]
-        def find
-          OData::Query::Builder.new(self)
+        # Starts a query chain with a filter for a given property's name.
+        # @param property_name [to_sym]
+        # @return [OData::Model::Query]
+        def where(property_name)
+          query_proxy = OData::Model::QueryProxy.new(self)
+          query_proxy.where(property_name.to_sym)
+        end
+
+        # Starts a query chain with a limit to entities returned.
+        # @param value [to_i]
+        # @return [OData::Model::Query]
+        def limit(value)
+          query_proxy = OData::Model::QueryProxy.new(self)
+          query_proxy.limit(value.to_i)
+        end
+
+        # Starts a query chain with the number of entities to skip.
+        # @param value [to_i]
+        # @return [OData::Model::Query]
+        def skip(value)
+          query_proxy = OData::Model::QueryProxy.new(self)
+          query_proxy.skip(value.to_i)
+        end
+
+        # Starts a query chain with a order operator for a given property's name.
+        # @param property_name [to_sym]
+        # @return [OData::Model::Query]
+        def order_by(property_name)
+          query_proxy = OData::Model::QueryProxy.new(self)
+          query_proxy.order_by(property_name.to_sym)
+        end
+
+        # Starts a query chain with a list of properties to select.
+        # @param property_name [to_sym]
+        # @return [OData::Model::Query]
+        def select(property_name)
+          query_proxy = OData::Model::QueryProxy.new(self)
+          query_proxy.select(property_name.to_sym)
         end
 
         # Enables lookup of model entities by their primary key.

data/lib/odata/model/query_proxy.rb

@@ -0,0 +1,88 @@
+module OData
+  module Model
+    # Provides the proxy between OData::Query and OData::Model.
+    class QueryProxy
+      include Enumerable
+
+      # Last filter criteria set on the query.
+      attr_reader :last_criteria
+
+      # Instantiates a new QueryProxy for the supplied OData::Model class.
+      # @param model_class [Class]
+      # @api private
+      def initialize(model_class)
+        @target = model_class
+        @query = target.odata_entity_set.query
+        @last_criteria = nil
+      end
+
+      # Sets up a new criteria for filters for the given property name.
+      # @param property_name [Symbol]
+      # @return [self]
+      # @api private
+      def where(property_name)
+        @last_criteria = query[target.property_map[property_name]]
+        self
+      end
+
+      # Sets up last criteria with supplied argument sets.
+      # @param arguments [Hash]
+      # @return [self]
+      def is(arguments)
+        raise ArgumentError 'can only accept Hash argument' unless arguments.is_a?(Hash)
+        property_name = last_criteria.property
+        arguments.each do |operator, value|
+          @last_criteria = query[property_name].send(operator.to_sym, value)
+          query.where(@last_criteria)
+        end
+        self
+      end
+
+      # Specifies the limit for the query.
+      # @param value [to_i]
+      # @return [self]
+      def limit(value)
+        query.limit(value.to_i)
+        self
+      end
+
+      # Specifies the number of entities to skip for the query.
+      # @param value [to_i]
+      # @return [self]
+      def skip(value)
+        query.skip(value.to_i)
+        self
+      end
+
+      # Specified the ordering for the query.
+      # @param property_name [to_sym]
+      # @return [self]
+      def order_by(property_name)
+        query.order_by(target.property_map[property_name.to_sym])
+        self
+      end
+
+      # Selects specific properties to return with query.
+      # @param property_name [to_sym]
+      # @return [self]
+      def select(property_name)
+        query.select(target.property_map[property_name.to_sym])
+        self
+      end
+
+      # Executes the query and returns each instance of the target model in
+      # turn.
+      def each(&block)
+        query.execute.each do |entity|
+          model = target.new
+          model.instance_variable_set(:@odata_entity, entity)
+          block_given? ? block.call(model) : yield(model)
+        end
+      end
+
+      private
+
+      attr_reader :target, :query
+    end
+  end
+end

data/lib/odata/model/version.rb

@@ -1,5 +1,5 @@
 module OData
   module Model
-    VERSION = '0.0.3'
+    VERSION = '0.1.0'
   end
 end

data/lib/odata/model.rb

@@ -4,14 +4,13 @@ require 'active_support/concern'
 
 require 'odata'
 
-require 'odata/query/builder'
-
 require 'odata/model/version'
 require 'odata/model/active_model'
 require 'odata/model/configuration'
 require 'odata/model/attributes'
 require 'odata/model/persistence'
 require 'odata/model/query'
+require 'odata/model/query_proxy'
 
 # OData is the parent namespace for the OData::Model project.
 module OData

data/odata-model.gemspec

@@ -20,11 +20,11 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'simplecov', '~> 0.8.2'
+  spec.add_development_dependency 'simplecov', '~> 0.9.0'
   spec.add_development_dependency 'codeclimate-test-reporter'
   spec.add_development_dependency 'rspec', '~> 3.0.0'
 
-  spec.add_dependency 'odata', '~> 0.2'
+  spec.add_dependency 'odata', '~> 0.5'
   spec.add_dependency 'activesupport', '>= 3.0.0'
   spec.add_dependency 'activemodel', '>= 3.0.0'
 end

data/spec/model/query_interface_spec.rb

@@ -3,18 +3,35 @@ require 'spec_helper'
 describe OData::Model do
   describe 'query interface' do
     it { expect(Product).to respond_to(:[]) }
-    it { expect(Product).to respond_to(:find) }
-
     describe 'Product[]' do
       it 'finds a model instance' do
         expect(Product[0]).to be_a(Product)
       end
     end
 
-    describe 'Product.find' do
-      it 'returns an OData::Query::Builder' do
-        expect(Product.find).to be_a(OData::Query::Builder)
-      end
+    it { expect(Product).to respond_to(:where) }
+    describe 'Product#where' do
+      it { expect(Product.where(:name)).to be_a(OData::Model::QueryProxy) }
+    end
+
+    it { expect(Product).to respond_to(:limit) }
+    describe 'Product#limit' do
+      it { expect(Product.limit(3)).to be_a(OData::Model::QueryProxy) }
+    end
+
+    it { expect(Product).to respond_to(:skip) }
+    describe 'Product#skip' do
+      it { expect(Product.skip(6)).to be_a(OData::Model::QueryProxy) }
+    end
+
+    it { expect(Product).to respond_to(:order_by) }
+    describe 'Product#order_by' do
+      it { expect(Product.order_by(:rating)).to be_a(OData::Model::QueryProxy) }
+    end
+
+    it { expect(Product).to respond_to(:select) }
+    describe 'Product#order_by' do
+      it { expect(Product.select(:name)).to be_a(OData::Model::QueryProxy) }
     end
   end
 end

data/spec/model/query_proxy_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe OData::Model::QueryProxy do
+  let(:subject) { query_proxy }
+  let(:query_proxy) { OData::Model::QueryProxy.new(Product) }
+  let(:query_string) { subject.send(:query).to_s }
+
+  it { expect(subject).to respond_to(:where) }
+  describe '#where' do
+    let(:subject) { query_proxy.where(:name) }
+
+    it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+    it 'sets up last criteria properly' do
+      expect(subject.last_criteria).to be_a(OData::Query::Criteria)
+      expect(subject.last_criteria.property).to eq(Product.property_map[:name])
+    end
+  end
+
+  it { expect(subject).to respond_to(:is) }
+  describe '#is' do
+    %w{eq ne gt lt ge le}.each do |operator|
+      describe "with :#{operator} operator" do
+        let(:subject) { query_proxy.where(:rating).is(operator.to_sym => 4) }
+
+        it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+        it 'sets up last criteria properly' do
+          expect(subject.last_criteria).to be_a(OData::Query::Criteria)
+          expect(subject.last_criteria.property).to eq(Product.property_map[:rating])
+          expect(subject.last_criteria.operator).to eq(operator.to_sym)
+          expect(subject.last_criteria.value).to eq(4)
+        end
+
+        it 'properly generates query' do
+          expect(query_string).to eq("Products?$filter=Rating #{operator} 4")
+        end
+      end
+    end
+  end
+
+  it { expect(subject).to respond_to(:limit) }
+  describe '#limit' do
+    let(:subject) { query_proxy.limit(3) }
+
+    it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+    it 'properly generates query' do
+      expect(query_string).to eq('Products?$top=3')
+    end
+  end
+
+  it { expect(subject).to respond_to(:skip) }
+  describe '#skip' do
+    let(:subject) { query_proxy.skip(6) }
+
+    it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+    it 'properly generates query' do
+      expect(query_string).to eq('Products?$skip=6')
+    end
+  end
+
+  it { pending; expect(subject).to respond_to(:expand) }
+  describe '#expand' do
+    it { pending; fail }
+  end
+
+  it { expect(subject).to respond_to(:select) }
+  describe '#select' do
+    let(:subject) { query_proxy.select(:name) }
+
+    it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+    it 'properly generates query' do
+      expect(query_string).to eq('Products?$select=Name')
+    end
+  end
+
+  it { expect(subject).to respond_to(:order_by) }
+  describe '#order_by' do
+    let(:subject) { query_proxy.order_by(:rating) }
+
+    it { expect(subject).to be_a(OData::Model::QueryProxy) }
+
+    it 'properly generates query' do
+      expect(query_string).to eq('Products?$orderby=Rating')
+    end
+  end
+
+  it { pending; expect(subject).to respond_to(:and) }
+  describe '#and' do
+    it { pending; fail }
+  end
+
+  it { pending; expect(subject).to respond_to(:or) }
+  describe '#or' do
+    it { pending; fail }
+  end
+
+  it { pending; expect(subject).to respond_to(:not) }
+  describe '#not' do
+    it { pending; fail }
+  end
+
+  it { expect(subject).to respond_to(:each) }
+  describe '#each' do
+    it 'returns model instances in turn' do
+      counter = 0
+      subject.each do |model|
+        expect(model).to be_a(Product)
+        counter += 1
+      end
+      expect(counter).to eq(11)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ require 'odata/model'
 # Suppressing a deprecation warning
 I18n.enforce_available_locales = false
 
-OData::Service.open('http://services.odata.org/OData/OData.svc')
+OData::Service.open('http://services.odata.org/OData/OData.svc', name: 'ODataDemo')
 
 require 'example_models/bare_model'
 require 'example_models/odatademo_product'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: odata-model
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - James Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2014-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -133,6 +133,7 @@ files:
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -143,20 +144,16 @@ files:
 - lib/odata/model/configuration.rb
 - lib/odata/model/persistence.rb
 - lib/odata/model/query.rb
+- lib/odata/model/query_proxy.rb
 - lib/odata/model/version.rb
-- lib/odata/query/builder.rb
 - odata-model.gemspec
 - spec/example_models/bare_model.rb
 - spec/example_models/odatademo_product.rb
 - spec/model/active_model_lint_spec.rb
 - spec/model/property_defaults_spec.rb
 - spec/model/query_interface_spec.rb
+- spec/model/query_proxy_spec.rb
 - spec/model/service_integration_spec.rb
-- spec/query/builder/filters_spec.rb
-- spec/query/builder/order_by_spec.rb
-- spec/query/builder/pagination_spec.rb
-- spec/query/builder/select_spec.rb
-- spec/query/builder_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ruby-odata/odata-model
 licenses:
@@ -188,10 +185,6 @@ test_files:
 - spec/model/active_model_lint_spec.rb
 - spec/model/property_defaults_spec.rb
 - spec/model/query_interface_spec.rb
+- spec/model/query_proxy_spec.rb
 - spec/model/service_integration_spec.rb
-- spec/query/builder/filters_spec.rb
-- spec/query/builder/order_by_spec.rb
-- spec/query/builder/pagination_spec.rb
-- spec/query/builder/select_spec.rb
-- spec/query/builder_spec.rb
 - spec/spec_helper.rb

data/lib/odata/query/builder.rb

@@ -1,219 +0,0 @@
-module OData
-  class Query
-    # Provides a OData::Model aware means of building up queries using chained
-    # methods. Also implements the Enumerable module to support working with
-    # the results of any query in a sane way.
-    class Builder
-      include Enumerable
-
-      SUPPORTED_OPERATIONS = [:eq, :ne, :gt, :ge, :lt, :le, :not]
-
-      # Sets up a new Query Builder.
-      # @param model [OData::Model] the model to build the query for
-      def initialize(model)
-        @entity_set = model.odata_entity_set
-        @property_map = model.property_map
-      end
-
-      def each
-        # TODO implement
-      end
-      
-      # Set the number of entities to skip for the final query.
-      # @param value [to_i,nil]
-      # @return [self]
-      def skip(value)
-        value = nil if value == 0
-        query_structure[:skip] = value.try(:to_i)
-        self
-      end
-
-      # Set the number of entities to return in the final query.
-      # @param value [to_i,nil]
-      # @return [self]
-      def limit(value)
-        value = nil if value == 0
-        query_structure[:top] = value.try(:to_i)
-        self
-      end
-
-      # Set the options for ordering the final query.
-      # @param args [Symbol,Hash]
-      # @return [self]
-      def order_by(*args)
-        validate_order_by_arguments(args)
-        query_structure[:orderby] += process_order_by_arguments(args)
-        self
-      end
-
-      # Set the properties to select with the final query.
-      # @param args [Array<Symbol>]
-      # @return self
-      def select(*args)
-        args.each {|arg| query_structure[:select] << arg.to_sym}
-        self
-      end
-
-      # Sets up a new filter condition on the provided property mapping.
-      # @param value [to_s]
-      # @return self
-      def where(value)
-        last_filter = query_structure[:filter].last
-        clause = {
-          property:   lookup_property_name(value),
-          opeartion:  nil,
-          argument:   nil
-        }
-
-        if last_filter.is_a?(Array)
-          last_filter << clause
-        else
-          query_structure[:filter] << [clause]
-        end
-        self
-      end
-
-      # Sets the operation and argument for the last filter condition started
-      # by #where, #and or #or.
-      # @param value [Hash]
-      # @return self
-      def is(value)
-        value = value.first
-        validate_is_argument(value)
-        last_filter = query_structure[:filter].last.last
-        if last_filter[:operation].nil? && last_filter[:argument].nil?
-          last_filter[:operation] = value[0].to_sym
-          last_filter[:argument] = value[1]
-        else
-          query_structure[:filter].last << {
-              property:   last_filter[:property],
-              operation:  value[0].to_sym,
-              argument:   value[1]
-          }
-        end
-        self
-      end
-
-      # Adds another filter to the last supplied clause.
-      # @param value [to_s]
-      # @return self
-      def and(value)
-        query_structure[:filter].last << {
-          property:   lookup_property_name(value),
-          opeartion:  nil,
-          argument:   nil
-        }
-        self
-      end
-
-      # Adds an alternate filter after the last supplied clause.
-      # @param value [to_s]
-      # @return self
-      def or(value)
-        query_structure[:filter] << [{
-          property:   lookup_property_name(value),
-          opeartion:  nil,
-          argument:   nil
-        }]
-        self
-      end
-
-      # Returns the current query structure as a valid query string.
-      def to_s
-        # TODO validate the actual query structure
-
-        query_array = []
-        query_array << filters_to_query
-        query_array << orderby_to_query
-        query_array << select_to_query
-        query_array << top_to_query
-        query_array << skip_to_query
-        query_array.compact!
-
-        query_string = query_array.join('&')
-        "#{entity_set.name}?#{query_string}"
-      end
-
-      private
-
-      def query_structure
-        @query_structure ||= {
-            top:      nil,
-            skip:     nil,
-            orderby:  [],
-            select:   [],
-            filter:   []
-        }
-      end
-
-      def entity_set
-        @entity_set
-      end
-
-      def skip_to_query
-        return nil if query_structure[:skip].nil?
-        "$skip=#{query_structure[:skip]}"
-      end
-
-      def top_to_query
-        return nil if query_structure[:top].nil?
-        "$top=#{query_structure[:top]}"
-      end
-
-      def orderby_to_query
-        return nil if query_structure[:orderby].empty?
-        "$orderby=#{query_structure[:orderby].join(',')}"
-      end
-
-      def select_to_query
-        return nil if query_structure[:select].empty?
-        "$select=#{query_structure[:select].join(',')}"
-      end
-
-      def filters_to_query
-        str = "$filter="
-        clauses = []
-        query_structure[:filter].each do |clause|
-          clause_filters = []
-          clause.each do |filter|
-            clause_filters << "#{filter[:property]} #{filter[:operation]} #{filter[:argument]}"
-          end
-          clauses << clause_filters.join(' and ')
-        end
-        clauses.collect! {|clause| "(#{clause})"}
-        str << clauses.join(' or ')
-        str
-      end
-
-      def validate_order_by_arguments(args)
-        args.each do |arg|
-          unless arg.is_a?(Hash) || arg.is_a?(Symbol)
-            raise ArgumentError, 'must be a Hash or Symbol'
-          end
-        end
-      end
-
-      def validate_is_argument(value)
-        raise ArgumentError, 'argument must be a hash' unless value.size == 2
-        raise ArgumentError, "unsupported operation: #{value[0]}" unless SUPPORTED_OPERATIONS.include?(value[0].to_sym)
-      end
-
-      def process_order_by_arguments(args)
-        args.collect do |arg|
-          case arg
-            when is_a?(Symbol)
-              lookup_property_name(arg)
-            when is_a?(Hash)
-              arg.each do |key, value|
-                "#{lookup_property_name(key)} #{value}"
-              end
-          end
-        end
-      end
-
-      def lookup_property_name(mapping)
-        @property_map[mapping.to_s.to_sym]
-      end
-    end
-  end
-end

data/spec/query/builder/filters_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe OData::Query::Builder do
-  let(:subject) { OData::Query::Builder.new(Product) }
-
-  describe 'filter method' do
-    describe '#where' do
-      it { expect(subject).to respond_to(:where) }
-
-      it { expect(subject.where(:name)).to be_a(OData::Query::Builder) }
-      it { expect(subject.where(:name)).to eq(subject) }
-    end
-
-    describe '#is' do
-      let(:subject) { OData::Query::Builder.new(Product).where(:name) }
-
-      it { expect(subject).to respond_to(:is) }
-
-      it { expect(subject.is(eq: 'Bread')).to be_a(OData::Query::Builder) }
-      it { expect(subject.is(eq: 'Bread')).to eq(subject) }
-    end
-
-    describe '#and' do
-      let(:subject) { OData::Query::Builder.new(Product).where(:name).is(eq: 'Bread') }
-
-      it { expect(subject).to respond_to(:and) }
-
-      it { expect(subject.and(:name)).to be_a(OData::Query::Builder) }
-      it { expect(subject.and(:name)).to eq(subject) }
-    end
-
-    describe '#or' do
-      let(:subject) { OData::Query::Builder.new(Product).where(:name).is(eq: 'Bread') }
-
-      it { expect(subject).to respond_to(:or) }
-
-      it { expect(subject.or(:name)).to be_a(OData::Query::Builder) }
-      it { expect(subject.or(:name)).to eq(subject) }
-    end
-  end
-end

data/spec/query/builder/order_by_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe OData::Query::Builder do
-  let(:subject) { OData::Query::Builder.new(Product) }
-
-  describe '#order_by' do
-    it { expect(subject).to respond_to(:order_by) }
-
-    describe 'accepts Symbols' do
-      it { expect(subject.order_by(:name)).to be_a(OData::Query::Builder) }
-      it { expect(subject.order_by(:name)).to eq(subject) }
-
-      it { expect(subject.order_by(:price, :rating)).to be_a(OData::Query::Builder) }
-      it { expect(subject.order_by(:price, :rating)).to eq(subject) }
-    end
-
-    describe 'accepts a Hash' do
-      it { expect(subject.order_by(name: :asc)).to be_a(OData::Query::Builder) }
-      it { expect(subject.order_by(name: :asc)).to eq(subject) }
-    end
-  end
-end

data/spec/query/builder/pagination_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe OData::Query::Builder do
-  let(:subject) { OData::Query::Builder.new(Product) }
-
-  describe 'pagination method' do
-    describe '#skip' do
-      it { expect(subject).to respond_to(:skip) }
-      it { expect(subject.skip(5)).to be_a(OData::Query::Builder) }
-      it { expect(subject.skip(5)).to eq(subject) }
-    end
-
-    describe '#limit' do
-      it { expect(subject).to respond_to(:limit) }
-      it { expect(subject.limit(5)).to be_a(OData::Query::Builder) }
-      it { expect(subject.limit(5)).to eq(subject) }
-    end
-  end
-end

data/spec/query/builder/select_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe OData::Query::Builder do
-  let(:subject) { OData::Query::Builder.new(Product) }
-
-  describe '#select' do
-    it { expect(subject).to respond_to(:select) }
-
-    it { expect(subject.select(:name, :description)).to be_a(OData::Query::Builder) }
-    it { expect(subject.select(:name, :description)).to eq(subject) }
-  end
-end

data/spec/query/builder_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe OData::Query::Builder do
-  let(:subject) { OData::Query::Builder.new(Product) }
-
-  describe '#to_s' do
-    it 'properly builds queries' do
-      query_string = "Products?$filter=(Name eq 'Bread')"
-      query = subject.where(:name).is(eq: "'Bread'")
-      expect(query.to_s).to eq(query_string)
-    end
-
-    it 'properly builds queries' do
-      query_string = "Products?$filter=(Name eq 'Bread') or (Name eq 'Milk')"
-      query = subject.where(:name).is(eq: "'Bread'").or(:name).is(eq: "'Milk'")
-      expect(query.to_s).to eq(query_string)
-    end
-
-    it 'properly builds queries' do
-      query_string = 'Products?$filter=(Price lt 15 and Rating gt 3)'
-      query = subject.where(:price).is(lt: 15).and(:rating).is(gt: 3)
-      expect(query.to_s).to eq(query_string)
-    end
-  end
-end