dynamics_crm 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98498eb29f5847c9e344859c2a728367d4e5227a
-  data.tar.gz: a6621ceb97f27de1298c7afba4b99cfd6f5fa44b
+  metadata.gz: f9b5b7d4367ee302f2a1e925b08b24f946c5c778
+  data.tar.gz: 105acef89d7636ed35fefecbf5e775f1d81f42d6
 SHA512:
-  metadata.gz: 1773ffbe9669459911e9c08bc44f241fa825ca14858f738084e7179cb5b46b965b8c01222c3c6c0b98651da0da0dbdd3f59d52c4cfe304197950e9473379b666
-  data.tar.gz: 261c9ae185cfdd0151ff118a56f78bb873ca69ef866dfbee46b9bc4e85265292c1cd1d5dad7ef1b18c143668fb9798938bf90089d92cb4dae3bb37d7a071e4a9
+  metadata.gz: 21555819445cc0def2c009775539fa497f927d81f635d57aa1b0a3f40a38cd344ca1b81fcbfb930e758d08689455c9f16b8ed4c58c200bbbebbac636ebd5de98
+  data.tar.gz: a7f4ed37563e4eae82536c63e4770820621d91bc520b8bbbddf3381db3cac92303a99b20ba2c4ed4208e14f9a0e6dfcc781dbca5fd6d7da33bca97ac0b117366

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.9.0 (March 13, 2017)
+* Adds Filters support to Query Criteria #60
+* Improve GUID attribute regex.
+* Fix logging for non-200 response codes.
+
 ## 0.8.0 (January 4, 2017)
 * Support ArrayOfEntity so one can create bound entities like ActivityParties on create #41
 * Add special case for nil value #43

data/README.md

@@ -70,6 +70,32 @@ while result.MoreRecords
 end
 ```
 
+### retrieve_multiple using complex Filters
+
+```ruby
+# Build QueryExpression
+query = DynamicsCRM::XML::QueryExpression.new('account')
+query.columns = %w(accountid name telephone1)
+# Switch to Or criteria
+query.criteria.filter_operator = 'Or'
+
+filter1 = DynamicsCRM::XML::FilterExpression.new('And')
+filter1.add_condition('name', 'Equal', 'Integration Specialists')
+filter1.add_condition('telephone1', 'In', ['(317) 845-2212', '3178452212'])
+
+filter2 = DynamicsCRM::XML::FilterExpression.new('And')
+filter2.add_condition('name', 'Equal', 'Thematics Development Inc.')
+filter2.add_condition('telephone1', 'Null')
+
+# Add Filters to criteria
+query.criteria.add_filter(filter1)
+query.criteria.add_filter(filter2)
+
+
+result = client.retrieve_multiple(query)
+```
+
+
 ### fetch (FetchXml)
 
 ```ruby

data/lib/dynamics_crm.rb

@@ -8,6 +8,7 @@ require "dynamics_crm/xml/condition_expression"
 require "dynamics_crm/xml/column_set"
 require "dynamics_crm/xml/criteria"
 require "dynamics_crm/xml/query_expression"
+require "dynamics_crm/xml/filter_expression"
 require "dynamics_crm/xml/fetch_expression"
 require "dynamics_crm/xml/entity"
 require "dynamics_crm/xml/entity_reference"

data/lib/dynamics_crm/client.rb

@@ -64,7 +64,6 @@ module DynamicsCRM
     #
     # Returns true on success or raises Fault
     def authenticate(username, password)
-
       @username = username
       @password = password
 
@@ -108,37 +107,34 @@ module DynamicsCRM
         end
       end
 
-
       true
     end
 
     # These are all the operations defined by the Dynamics WSDL.
     # Tag names are case-sensitive.
     def create(entity_name, attributes)
-
       entity = XML::Entity.new(entity_name)
       entity.attributes = XML::Attributes.new(attributes)
 
       xml_response = post(organization_endpoint, create_request(entity))
-      return Response::CreateResult.new(xml_response)
+      Response::CreateResult.new(xml_response)
     end
 
     # http://crmtroubleshoot.blogspot.com.au/2013/07/dynamics-crm-2011-php-and-soap-calls.html
     def retrieve(entity_name, guid, columns=[])
-
       column_set = XML::ColumnSet.new(columns)
       request = retrieve_request(entity_name, guid, column_set)
 
       xml_response = post(organization_endpoint, request)
-      return Response::RetrieveResult.new(xml_response)
+      Response::RetrieveResult.new(xml_response)
     end
 
     def rollup(target_entity, query, rollup_type="Related")
-        self.execute("Rollup", {
-          Target: target_entity,
-          Query: query,
-          RollupType: rollup_type
-        })
+      self.execute("Rollup", {
+        Target: target_entity,
+        Query: query,
+        RollupType: rollup_type
+      })
     end
 
     # Suports parameter list or QueryExpression object.
@@ -172,14 +168,14 @@ module DynamicsCRM
 
       request = update_request(entity)
       xml_response = post(organization_endpoint, request)
-      return Response::UpdateResponse.new(xml_response)
+      Response::UpdateResponse.new(xml_response)
     end
 
     def delete(entity_name, guid)
       request = delete_request(entity_name, guid)
 
       xml_response = post(organization_endpoint, request)
-      return Response::DeleteResponse.new(xml_response)
+      Response::DeleteResponse.new(xml_response)
     end
 
     def execute(action, parameters={}, response_class=nil)
@@ -187,19 +183,19 @@ module DynamicsCRM
       xml_response = post(organization_endpoint, request)
 
       response_class ||= Response::ExecuteResult
-      return response_class.new(xml_response)
+      response_class.new(xml_response)
     end
 
     def associate(entity_name, guid, relationship, related_entities)
       request = associate_request(entity_name, guid, relationship, related_entities)
       xml_response = post(organization_endpoint, request)
-      return Response::AssociateResponse.new(xml_response)
+      Response::AssociateResponse.new(xml_response)
     end
 
     def disassociate(entity_name, guid, relationship, related_entities)
       request = disassociate_request(entity_name, guid, relationship, related_entities)
       xml_response = post(organization_endpoint, request)
-      return Response::DisassociateResponse.new(xml_response)
+      Response::DisassociateResponse.new(xml_response)
     end
 
     def create_attachment(entity_name, entity_id, options={})
@@ -324,28 +320,23 @@ module DynamicsCRM
     end
 
     def post(url, request)
-      log_xml("REQUEST", request)
+      log_xml('REQUEST', request)
       uri = URI.parse(url)
 
       http = Net::HTTP.new uri.host, uri.port
       http.use_ssl = true
       http.verify_mode = OpenSSL::SSL::VERIFY_PEER
 
-      req = Net::HTTP::Post.new(uri.request_uri, {
-        "Connection" => "Keep-Alive",
-        "Content-type" => "application/soap+xml; charset=UTF-8",
-        "Content-length" => request.bytesize.to_s
-      })
+      req = Net::HTTP::Post.new(uri.request_uri,
+        'Connection' => 'Keep-Alive',
+        'Content-type' => 'application/soap+xml; charset=UTF-8',
+        'Content-length' => request.bytesize.to_s
+      )
       req.body = request
       response = http.request(req)
 
-      if response.code.to_i == 200
-        response_body = response.body
-      else
-        # Do something here on error.
-      end
-
-      log_xml("RESPONSE", response_body)
+      response_body = response.body
+      log_xml('RESPONSE', response_body)
 
       response_body
     end
@@ -354,6 +345,7 @@ module DynamicsCRM
       return unless logger
 
       logger.debug(title)
+
       doc = REXML::Document.new(xml)
       formatter.write(doc.root, logger)
       logger.debug("\n")

data/lib/dynamics_crm/response/result.rb

@@ -1,13 +1,10 @@
 module DynamicsCRM
   module Response
-
     class Result < Hash
-
       attr_reader :document
       attr_reader :result_response
 
       def initialize(xml)
-
         @document = REXML::Document.new(xml)
 
         fault_xml = @document.get_elements("//[local-name() = 'Fault']")
@@ -24,7 +21,7 @@ module DynamicsCRM
 
       # Returns base element of the response document to parse.
       def response_element
-        class_name = self.class.to_s.split("::").last
+        class_name = self.class.to_s.split('::').last
       end
 
       # Invoked by constructor, should be implemented in sub-classes.
@@ -35,7 +32,6 @@ module DynamicsCRM
 
       # Allows method-like access to the hash using camelcase field names.
       def method_missing(method, *args, &block)
-
         # First return local hash entry for symbol or string.
         return self[method] if self.has_key?(method)
 
@@ -50,13 +46,12 @@ module DynamicsCRM
         end
 
         # Finally return nil.
-        return value
+        value
       end
 
       def respond_to_missing?(method_name, include_private = false)
         self.has_key?(method_name.to_s) || self.has_key?(method_name) || super
       end
-
     end
 
     # There's nothing to parse in the UpdateResult
@@ -73,6 +68,5 @@ module DynamicsCRM
 
     class DisassociateResponse < Result
     end
-
   end
 end

data/lib/dynamics_crm/version.rb

@@ -1,3 +1,3 @@
 module DynamicsCRM
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/dynamics_crm/xml/attributes.rb

@@ -51,8 +51,8 @@ module DynamicsCRM
             end
         end
 
-        if type == "string" && value =~ /\w+{8}-\w+{4}-\w+{4}-\w+{4}-\w+{12}/
-          type = "guid"
+        if type == 'string' && value =~ /\A\{?\w{8}-\w{4}-\w{4}-\w{4}-\w{12}\}?\z/
+          type = 'guid'
         end
 
         type

data/lib/dynamics_crm/xml/condition_expression.rb

@@ -4,9 +4,11 @@ module DynamicsCRM
     # Creates a ConditionExpression element to be used in retrieve calls.
     class ConditionExpression
       attr_accessor :attr_name, :operator, :value, :type
-      def initialize(attr_name, operator, value, type: nil)
+
+      def initialize(attr_name, operator, value = nil, type: nil)
         @attr_name = attr_name
         @operator = operator
+        # value can be optional to support Null and NotNull operators
         @value = value
         @values = Array(value)
         @type = type

data/lib/dynamics_crm/xml/criteria.rb

@@ -2,6 +2,7 @@ module DynamicsCRM
   module XML
     class Criteria < Array
       SUPPORTED_OPERATORS = %w(And Or)
+      attr_accessor :filter_operator
 
       def initialize(tuples = [], filter_operator: nil)
         filter_operator ||= 'And'
@@ -15,31 +16,59 @@ module DynamicsCRM
           attr_name, operator, value, data_type = *tuple
           ConditionExpression.new(attr_name, operator, value, type: data_type)
         end
+
+        @filters = []
       end
 
-      def add_condition(attr_name, operator, value, type: nil)
+      def add_condition(attr_name, operator, value = nil, type: nil)
         @expressions << ConditionExpression.new(attr_name, operator, value, type: type)
       end
 
+      def add_filter(filter)
+        @filters << filter
+      end
+
       # ConditionExpression can be repeated multiple times
       # Operator: can be lots of values such as: eq (Equals), neq (Not Equals), gt (Greater Than)
       #           get the values from a fetch xml query
       # Values -> Value can be repeated multiple times
       # FilterOperator: and OR or depending on the filter requirements
+      # Filters: can contain FilterExpressions to support complex logical statements.
       def to_xml(options = {})
         ns = options[:namespace] ? options[:namespace] : 'a'
 
-        xml_expression = @expressions.map do |conditional|
-          conditional.to_xml(options)
-        end.join('')
-
         %(<#{ns}:Criteria>
-            <#{ns}:Conditions>
-              #{xml_expression}
-            </#{ns}:Conditions>
+            #{conditions_xml(options)}
             <#{ns}:FilterOperator>#{@filter_operator}</#{ns}:FilterOperator>
+            #{filters_xml(options)}
         </#{ns}:Criteria>)
       end
+
+      def conditions_xml(options)
+        ns = options[:namespace] ? options[:namespace] : 'a'
+
+        if @expressions.empty?
+          "<#{ns}:Conditions />"
+        else
+          xml_expression = @expressions.map do |conditional|
+            conditional.to_xml(options)
+          end.join('')
+
+          %(<#{ns}:Conditions>
+            #{xml_expression}
+          </#{ns}:Conditions>)
+        end
+      end
+
+      def filters_xml(options)
+        ns = options[:namespace] ? options[:namespace] : 'a'
+        if @filters.empty?
+          "<#{ns}:Filters />"
+        else
+          fx = @filters.map { |f| f.to_xml(options) }.join('')
+          %(<#{ns}:Filters>#{fx}</#{ns}:Filters>)
+        end
+      end
     end
     # Criteria
   end

data/lib/dynamics_crm/xml/filter_expression.rb

@@ -0,0 +1,65 @@
+module DynamicsCRM
+  module XML
+    # Represents FilterExpression XML fragment.
+    class FilterExpression
+      attr_accessor :conditions, :filters, :filter_operator
+
+      def initialize(operator = 'And')
+        @filter_operator = operator
+        @conditions = []
+        @filters = []
+      end
+
+      def add_condition(field, operator, value=nil)
+        conditions << ConditionExpression.new(field, operator, value)
+      end
+
+      def add_filter(filter)
+        filters << filter
+      end
+
+      def to_xml(options = {})
+        ns = options[:namespace] ? options[:namespace] : 'b'
+
+        query_xml = %(
+          <#{ns}:FilterExpression>
+            #{conditions_xml(options)}
+            <#{ns}:FilterOperator>#{@filter_operator}</#{ns}:FilterOperator>
+            #{filters_xml(options)}
+          </#{ns}:FilterExpression>
+        )
+
+        query_xml
+      end
+
+      protected
+
+      def conditions_xml(options)
+        ns = options[:namespace] ? options[:namespace] : 'b'
+
+        if conditions.empty?
+          "<#{ns}:Conditions />"
+        else
+          xml = conditions.map { |c| c.to_xml(options) }.join('')
+          %(<#{ns}:Conditions>
+              #{xml}
+            </#{ns}:Conditions>)
+        end
+      end
+
+      def filters_xml(options)
+        ns = options[:namespace] ? options[:namespace] : 'b'
+
+        if filters.empty?
+          "<#{ns}:Filters />"
+        else
+          sub_filters = filters.map { |f| f.to_xml(options) }.join('')
+          %(<#{ns}:Filters>
+              #{sub_filters}
+            </#{ns}:Filters>)
+        end
+      end
+    end
+    # FilterExpression
+  end
+end

data/spec/lib/xml/condition_expression_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe DynamicsCRM::XML::ConditionExpression do
+  it 'generates base ConditionExpresion' do
+    subject = DynamicsCRM::XML::ConditionExpression.new('name', 'Equal', 'GitHub')
+
+    fragment = %(
+      <b:ConditionExpression>
+        <b:AttributeName>name</b:AttributeName>
+        <b:Operator>Equal</b:Operator>
+        <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+          <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">GitHub</d:anyType>
+        </b:Values>
+      </b:ConditionExpression>)
+
+    expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+  end
+
+  it 'supports boolean values' do
+    subject = DynamicsCRM::XML::ConditionExpression.new('isactive', 'Equal', true)
+
+    fragment = %(
+      <b:ConditionExpression>
+        <b:AttributeName>isactive</b:AttributeName>
+        <b:Operator>Equal</b:Operator>
+        <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+          <d:anyType i:type="s:boolean" xmlns:s="http://www.w3.org/2001/XMLSchema">true</d:anyType>
+        </b:Values>
+      </b:ConditionExpression>)
+
+    expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+  end
+
+  it 'supports Array values' do
+    subject = DynamicsCRM::XML::ConditionExpression.new('salesstage', 'In', [0, 1, 2])
+
+    fragment = %(
+      <b:ConditionExpression>
+        <b:AttributeName>salesstage</b:AttributeName>
+        <b:Operator>In</b:Operator>
+        <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+          <d:anyType i:type="s:int" xmlns:s="http://www.w3.org/2001/XMLSchema">0</d:anyType>
+          <d:anyType i:type="s:int" xmlns:s="http://www.w3.org/2001/XMLSchema">1</d:anyType>
+          <d:anyType i:type="s:int" xmlns:s="http://www.w3.org/2001/XMLSchema">2</d:anyType>
+        </b:Values>
+      </b:ConditionExpression>)
+
+    expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+  end
+
+  it 'supports Null operator without value' do
+    subject = DynamicsCRM::XML::ConditionExpression.new('telephone1', 'Null')
+
+    fragment = %(
+      <b:ConditionExpression>
+        <b:AttributeName>telephone1</b:AttributeName>
+        <b:Operator>Null</b:Operator>
+        <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+        </b:Values>
+      </b:ConditionExpression>)
+
+    expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+  end
+end

data/spec/lib/xml/criteria_spec.rb

@@ -8,9 +8,9 @@ describe DynamicsCRM::XML::Criteria do
 
     it 'generates empty Criteria fragment' do
       expected = %(<a:Criteria>
-        <a:Conditions>
-        </a:Conditions>
+        <a:Conditions />
         <a:FilterOperator>And</a:FilterOperator>
+        <a:Filters />
       </a:Criteria>)
 
       expect(subject.to_xml).to match_xml(expected)
@@ -33,6 +33,7 @@ describe DynamicsCRM::XML::Criteria do
             </a:ConditionExpression>
           </a:Conditions>
           <a:FilterOperator>And</a:FilterOperator>
+          <a:Filters />
       </a:Criteria>)
     }
 
@@ -77,6 +78,7 @@ describe DynamicsCRM::XML::Criteria do
             </a:ConditionExpression>
           </a:Conditions>
           <a:FilterOperator>And</a:FilterOperator>
+          <a:Filters />
       </a:Criteria>)
     end
   end

data/spec/lib/xml/filter_expression_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe DynamicsCRM::XML::FilterExpression do
+  describe 'initialization' do
+    subject {
+      DynamicsCRM::XML::FilterExpression.new('And')
+    }
+
+    it 'generates empty FilterExpression fragment' do
+      fragment = %(<b:FilterExpression>
+                    <b:Conditions />
+                    <b:FilterOperator>And</b:FilterOperator>
+                    <b:Filters />
+                  </b:FilterExpression>)
+
+      expect(subject.to_xml).to match_xml fragment
+    end
+
+    it 'generates FilterExpression with condition' do
+      subject.add_condition('name', 'Equal', 'Integration Specialists')
+
+      fragment = %(
+        <b:FilterExpression>
+          <b:Conditions>
+            <b:ConditionExpression>
+              <b:AttributeName>name</b:AttributeName>
+              <b:Operator>Equal</b:Operator>
+              <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Integration Specialists</d:anyType>
+              </b:Values>
+            </b:ConditionExpression>
+          </b:Conditions>
+          <b:FilterOperator>And</b:FilterOperator>
+          <b:Filters />
+        </b:FilterExpression>)
+
+      expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+    end
+
+    it 'generates FilterExpression with sub-Filter' do
+      subject.add_condition('name', 'Equal', 'Integration Specialists')
+
+      filter = DynamicsCRM::XML::FilterExpression.new('And')
+      filter.add_condition('name', 'NotEqual', 'Bob')
+
+      subject.add_filter(filter)
+
+      fragment = %(
+        <b:FilterExpression>
+          <b:Conditions>
+            <b:ConditionExpression>
+              <b:AttributeName>name</b:AttributeName>
+              <b:Operator>Equal</b:Operator>
+              <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Integration Specialists</d:anyType>
+              </b:Values>
+            </b:ConditionExpression>
+          </b:Conditions>
+          <b:FilterOperator>And</b:FilterOperator>
+          <b:Filters>
+            <b:FilterExpression>
+              <b:Conditions>
+                <b:ConditionExpression>
+                  <b:AttributeName>name</b:AttributeName>
+                  <b:Operator>NotEqual</b:Operator>
+                  <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                    <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Bob</d:anyType>
+                  </b:Values>
+                </b:ConditionExpression>
+              </b:Conditions>
+              <b:FilterOperator>And</b:FilterOperator>
+              <b:Filters />
+            </b:FilterExpression>
+          </b:Filters>
+        </b:FilterExpression>)
+
+      expect(subject.to_xml(namespace: 'b')).to match_xml fragment
+    end
+  end
+
+  describe 'Criteria' do
+    subject do
+      criteria = DynamicsCRM::XML::Criteria.new
+      criteria.filter_operator = 'Or'
+
+      filter1 = DynamicsCRM::XML::FilterExpression.new('And')
+      filter1.add_condition('name', 'Equal', 'Integration Specialists')
+      filter1.add_condition('name', 'NotEqual', 'Bob')
+
+      filter2 = DynamicsCRM::XML::FilterExpression.new('And')
+      filter2.add_condition('name', 'Equal', 'Thematics Development Inc.')
+      filter2.add_condition('name', 'NotEqual', 'Bob')
+
+      criteria.add_filter(filter1)
+      criteria.add_filter(filter2)
+
+      criteria
+    end
+
+    it 'generates Criteria with Or Filters' do
+      expect(subject.to_xml(namespace: 'b')).to match_xml criteria_with_or_filters
+    end
+
+    def criteria_with_or_filters
+      %(<b:Criteria>
+          <b:Conditions />
+          <b:FilterOperator>Or</b:FilterOperator>
+          <b:Filters>
+            <b:FilterExpression>
+              <b:Conditions>
+                <b:ConditionExpression>
+                  <b:AttributeName>name</b:AttributeName>
+                  <b:Operator>Equal</b:Operator>
+                  <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                    <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Integration Specialists</d:anyType>
+                  </b:Values>
+                </b:ConditionExpression>
+                <b:ConditionExpression>
+                  <b:AttributeName>name</b:AttributeName>
+                  <b:Operator>NotEqual</b:Operator>
+                  <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                    <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Bob</d:anyType>
+                  </b:Values>
+                </b:ConditionExpression>
+              </b:Conditions>
+              <b:FilterOperator>And</b:FilterOperator>
+              <b:Filters />
+            </b:FilterExpression>
+            <b:FilterExpression>
+              <b:Conditions>
+                <b:ConditionExpression>
+                  <b:AttributeName>name</b:AttributeName>
+                  <b:Operator>Equal</b:Operator>
+                  <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                    <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Thematics Development Inc.</d:anyType>
+                  </b:Values>
+                </b:ConditionExpression>
+                <b:ConditionExpression>
+                  <b:AttributeName>name</b:AttributeName>
+                  <b:Operator>NotEqual</b:Operator>
+                  <b:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+                    <d:anyType i:type="s:string" xmlns:s="http://www.w3.org/2001/XMLSchema">Bob</d:anyType>
+                  </b:Values>
+                </b:ConditionExpression>
+              </b:Conditions>
+              <b:FilterOperator>And</b:FilterOperator>
+              <b:Filters />
+            </b:FilterExpression>
+          </b:Filters>
+        </b:Criteria>)
+    end
+  end
+end

data/spec/lib/xml/query_expression_spec.rb

@@ -9,7 +9,8 @@ describe DynamicsCRM::XML::QueryExpression do
 
     context "generate empty QueryExpression fragment" do
       it { expect(subject.to_xml).to include("<b:ColumnSet ") }
-      it { expect(subject.to_xml).to match(/<b:Conditions>\s+<\/b:Conditions>/) }
+      it { expect(subject.to_xml).to include("<b:Criteria>") }
+      it { expect(subject.to_xml).to include("<b:Conditions />") }
       it { expect(subject.to_xml).to include("<b:AllColumns>true</b:AllColumns>") }
       it { expect(subject.to_xml).to include("<b:Distinct>false</b:Distinct>") }
       it { expect(subject.to_xml).to include("<b:EntityName>opportunity</b:EntityName>") }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamics_crm
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Joe Heth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-22 00:00:00.000000000 Z
+date: 2017-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mimemagic
@@ -190,6 +190,7 @@ files:
 - lib/dynamics_crm/xml/entity_reference.rb
 - lib/dynamics_crm/xml/fault.rb
 - lib/dynamics_crm/xml/fetch_expression.rb
+- lib/dynamics_crm/xml/filter_expression.rb
 - lib/dynamics_crm/xml/message_builder.rb
 - lib/dynamics_crm/xml/message_parser.rb
 - lib/dynamics_crm/xml/money.rb
@@ -235,10 +236,12 @@ files:
 - spec/lib/response/retrieve_result_spec.rb
 - spec/lib/xml/attributes_spec.rb
 - spec/lib/xml/column_set_spec.rb
+- spec/lib/xml/condition_expression_spec.rb
 - spec/lib/xml/criteria_spec.rb
 - spec/lib/xml/entity_reference_spec.rb
 - spec/lib/xml/entity_spec.rb
 - spec/lib/xml/fault_spec.rb
+- spec/lib/xml/filter_expression_spec.rb
 - spec/lib/xml/message_builder_spec.rb
 - spec/lib/xml/money_spec.rb
 - spec/lib/xml/query_expression_spec.rb
@@ -309,10 +312,12 @@ test_files:
 - spec/lib/response/retrieve_result_spec.rb
 - spec/lib/xml/attributes_spec.rb
 - spec/lib/xml/column_set_spec.rb
+- spec/lib/xml/condition_expression_spec.rb
 - spec/lib/xml/criteria_spec.rb
 - spec/lib/xml/entity_reference_spec.rb
 - spec/lib/xml/entity_spec.rb
 - spec/lib/xml/fault_spec.rb
+- spec/lib/xml/filter_expression_spec.rb
 - spec/lib/xml/message_builder_spec.rb
 - spec/lib/xml/money_spec.rb
 - spec/lib/xml/query_expression_spec.rb