plan_executor 1.0.2 → 1.8.0

data/lib/tests/suites/format_test.rb

@@ -2,6 +2,12 @@ module Crucible
   module Tests
     class FormatTest < BaseSuite
 
+      @@xml_format = FHIR::Formats::ResourceFormat::RESOURCE_XML
+      @@json_format = FHIR::Formats::ResourceFormat::RESOURCE_JSON
+      @@xml_format_params = ['xml', 'text/xml', 'application/xml', @@xml_format]
+      @@json_format_params = ['json', 'application/json', @@json_format]
+      @@alpha = ['A', 'B', 'C', 'D']
+
       def id
         'Format001'
       end
@@ -17,10 +23,6 @@ module Crucible
 
       # Create a patient and store its details for format requests
       def setup
-        @xml_format = FHIR::Formats::ResourceFormat::RESOURCE_XML
-        @json_format = FHIR::Formats::ResourceFormat::RESOURCE_JSON
-        @xml_format_params = ['xml', 'text/xml', 'application/xml', @xml_format]
-        @json_format_params = ['json', 'application/json', @json_format]
         @resources = Crucible::Generator::Resources.new
         @resource = @resources.minimal_patient
         @create_failed = false
@@ -40,7 +42,7 @@ module Crucible
             bundle_reply = request_bundle(FHIR::Patient, @xml_format)
             assert_response_ok bundle_reply
             bundle_patient = bundle_reply.resource.entry.first.resource
-            @id = bundle_patient.xmlId
+            @id = bundle_patient.id
             @create_failed = false
           rescue Exception
             @create_failed = true            
@@ -66,83 +68,31 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['XML']
         }
         begin
-          patient = request_entry(FHIR::Patient, @id, @xml_format)
-          assert compare_response_format(patient, @xml_format), "XML format header mismatch: requested #{@xml_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested XML (headers) resource does not match created resource' }
+          patient = request_entry(FHIR::Patient, @id, @@xml_format)
+          assert compare_response_format(patient, @@xml_format), "XML format header mismatch: requested #{@@xml_format}, received #{patient.response_format}"
+          warning { assert compare_response(patient), 'requested XML response does not match created resource' }
         rescue => e
           raise AssertionException.new("CTO1 - Failed to handle XML format header response. Error: #{e.message}")
         end
       end
 
-      test 'CT02A', 'Request [xml] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @xml_format_params[0], true)
-          assert compare_response_format(patient, @xml_format), "XML format param mismatch: requested #{@xml_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested XML (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO2 - Failed to handle XML format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'CT02B', 'Request [text/xml] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @xml_format_params[1], true)
-          assert compare_response_format(patient, @xml_format), "XML format param mismatch: requested #{@xml_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested XML (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO2 - Failed to handle XML format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'CT02C', 'Request [application/xml] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @xml_format_params[2], true)
-          assert compare_response_format(patient, @xml_format), "XML format param mismatch: requested #{@xml_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested XML (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO2 - Failed to handle XML format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'CT02D', 'Request [application/xml+fhir] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @xml_format_params[3], true)
-          assert compare_response_format(patient, @xml_format), "XML format param mismatch: requested #{@xml_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested XML (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO2 - Failed to handle XML format param response. Error: #{e.message}")
+      @@xml_format_params.each_with_index do |format, index|
+        test "CT02#{@@alpha[index]}", "Request [#{format}] using _format" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/formats.html"
+            links "#{REST_SPEC_LINK}#mime-type"
+            links "#{REST_SPEC_LINK}#read"
+            requires resource: 'Patient', methods: ['create','read']
+            validates resource: 'Patient', methods: ['read'], formats: ['XML']
+          }
+          begin
+            patient = request_entry(FHIR::Patient, @id, format, true)
+            assert compare_response_format(patient, @@xml_format), "XML format param mismatch: requested #{format}, received #{patient.response_format}"
+            warning { assert compare_response(patient), 'requested XML response does not match created resource' }
+          rescue => e
+            @client.use_format_param = false
+            raise AssertionException.new("CTO2 - Failed to handle XML format param response. Error: #{e.message}")
+          end
         end
       end
 
@@ -155,65 +105,31 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['JSON']
         }
         begin
-          patient = request_entry(FHIR::Patient, @id, @json_format)
-          assert compare_response_format(patient, @json_format), "JSON format header mismatch: requested #{@json_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested JSON (headers) resource does not match created resource' }
+          patient = request_entry(FHIR::Patient, @id, @@json_format)
+          assert compare_response_format(patient, @@json_format), "JSON format header mismatch: requested #{@@json_format}, received #{patient.response_format}"
+          warning { assert compare_response(patient), 'requested JSON resource does not match created resource' }
         rescue => e
           raise AssertionException.new("CTO3 - Failed to handle JSON format header response. Error: #{e.message}")
         end
       end
 
-      test 'CT04A', 'Request [json] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @json_format_params[0], true)
-          assert compare_response_format(patient, @json_format), "JSON format param mismatch: requested #{@json_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested JSON (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO4 - Failed to handle JSON format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'CT04C', 'Request [application/json] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @json_format_params[1], true)
-          assert compare_response_format(patient, @json_format), "JSON format param mismatch: requested #{@json_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested JSON (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO4 - Failed to handle JSON format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'CT04D', 'Request [application/json+fhir] using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
-        }
-        begin
-          patient = request_entry(FHIR::Patient, @id, @json_format_params[2], true)
-          assert compare_response_format(patient, @json_format), "JSON format param mismatch: requested #{@json_format}, received #{patient.response_format}"
-          warning { assert compare_response(patient), 'requested JSON (_format) resource does not match created resource' }
-        rescue => e
-          @client.use_format_param = false
-          raise AssertionException.new("CTO4 - Failed to handle JSON format param response. Error: #{e.message}")
+      @@json_format_params.each_with_index do |format, index|
+        test "CT04#{@@alpha[index]}", "Request [#{format}] using _format" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/formats.html"
+            links "#{REST_SPEC_LINK}#mime-type"
+            links "#{REST_SPEC_LINK}#read"
+            requires resource: 'Patient', methods: ['create','read']
+            validates resource: 'Patient', methods: ['read'], formats: ['JSON']
+          }
+          begin
+            patient = request_entry(FHIR::Patient, @id, format, true)
+            assert compare_response_format(patient, @@json_format), "JSON format param mismatch: requested #{format}, received #{patient.response_format}"
+            warning { assert compare_response(patient), 'requested JSON response does not match created resource' }
+          rescue => e
+            @client.use_format_param = false
+            raise AssertionException.new("CTO4 - Failed to handle JSON format param response. Error: #{e.message}")
+          end
         end
       end
 
@@ -226,19 +142,19 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['XML','JSON']
         }
         begin
-          patient_xml = request_entry(FHIR::Patient, @id, @xml_format)
-          patient_json = request_entry(FHIR::Patient, @id, @json_format)
+          patient_xml = request_entry(FHIR::Patient, @id, @@xml_format)
+          patient_json = request_entry(FHIR::Patient, @id, @@json_format)
 
-          assert compare_response_format(patient_xml, @xml_format), "XML format header mismatch: requested #{@xml_format}, received #{patient_xml.response_format}"
-          assert compare_response_format(patient_json, @json_format), "JSON format header mismatch: requested #{@json_format}, received #{patient_json.response_format}"
-          warning { assert compare_entries(patient_xml, patient_json), 'requested XML & JSON (headers) resources do not match created resource or each other' }
+          assert compare_response_format(patient_xml, @@xml_format), "XML format header mismatch: requested #{@@xml_format}, received #{patient_xml.response_format}"
+          assert compare_response_format(patient_json, @@json_format), "JSON format header mismatch: requested #{@@json_format}, received #{patient_json.response_format}"
+          warning { assert compare_entries(patient_xml, patient_json), 'requested XML & JSON resources do not match created resource or each other' }
         rescue => e
           @client.use_format_param = false
-          raise AssertionException.new("FTO1 - Failed to handle XML & JSON header param response. Error: #{e.message}")
+          raise AssertionException.new("FT01 - Failed to handle XML & JSON header param response. Error: #{e.message}")
         end
       end
 
-      test 'FT02', 'Request xml and json using [_format]' do
+      test 'FT02', 'Request xml and json using _format' do
         metadata {
           links "#{BASE_SPEC_LINK}/formats.html"
           links "#{REST_SPEC_LINK}#mime-type"
@@ -247,15 +163,15 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['XML','JSON']
         }
         begin
-          patient_xml = request_entry(FHIR::Patient, @id, @xml_format, true)
-          patient_json = request_entry(FHIR::Patient, @id, @json_format, true)
+          patient_xml = request_entry(FHIR::Patient, @id, @@xml_format, true)
+          patient_json = request_entry(FHIR::Patient, @id, @@json_format, true)
 
-          assert compare_response_format(patient_xml, @xml_format), "XML format header mismatch: requested #{@xml_format}, received #{patient_xml.response_format}"
-          assert compare_response_format(patient_json, @json_format), "JSON format header mismatch: requested #{@json_format}, received #{patient_json.response_format}"
-          warning { assert compare_entries(patient_xml, patient_json), 'requested XML & JSON (_format) resources do not match created resource or each other' }
+          assert compare_response_format(patient_xml, @@xml_format), "XML format header mismatch: requested #{@@xml_format}, received #{patient_xml.response_format}"
+          assert compare_response_format(patient_json, @@json_format), "JSON format header mismatch: requested #{@@json_format}, received #{patient_json.response_format}"
+          warning { assert compare_entries(patient_xml, patient_json), 'requested XML & JSON responses do not match created resource or each other' }
         rescue => e
           @client.use_format_param = false
-          raise AssertionException.new("FTO2 - Failed to handle XML & JSON format param response. Error: #{e.message}")
+          raise AssertionException.new("FT02 - Failed to handle XML & JSON format param response. Error: #{e.message}")
         end
       end
 
@@ -268,79 +184,30 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['XML']
         }
         begin
-          patients_bundle = request_bundle(FHIR::Patient, @xml_format)
-
-          assert compare_response_format(patients_bundle, @xml_format), "Bundle XML format header mismatch: requested #{@xml_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO3 - Failed to handle Bundle XML format header response. Error: #{e.message}")
-        end
-      end
-
-      test 'FT04A', 'Request [xml] Bundle using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @xml_format_params[0], true)
-
-          assert compare_response_format(patients_bundle, @xml_format), "Bundle XML format param mismatch: requested #{@xml_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO4- Failed to handle Bundle XML format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'FT04B', 'Request [text/xml] Bundle using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @xml_format_params[1], true)
-
-          assert compare_response_format(patients_bundle, @xml_format), "Bundle XML format param mismatch: requested #{@xml_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO4- Failed to handle Bundle XML format param response. Error: #{e.message}")
-        end
-      end
-
-      test 'FT04C', 'Request [application/xml] Bundle using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @xml_format_params[2], true)
+          patients_bundle = request_bundle(FHIR::Patient, @@xml_format)
 
-          assert compare_response_format(patients_bundle, @xml_format), "Bundle XML format param mismatch: requested #{@xml_format}, received #{patients_bundle.response_format}"
+          assert compare_response_format(patients_bundle, @@xml_format), "Bundle XML format header mismatch: requested #{@@xml_format}, received #{patients_bundle.response_format}"
         rescue => e
-          raise AssertionException.new("FTO4- Failed to handle Bundle XML format param response. Error: #{e.message}")
+          raise AssertionException.new("FT03 - Failed to handle Bundle XML format header response. Error: #{e.message}")
         end
       end
 
-      test 'FT04D', 'Request [application/xml+fhir] Bundle using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['XML']
-        }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @xml_format_params[3], true)
+      @@xml_format_params.each_with_index do |format, index|
+        test "FT04#{@@alpha[index]}", "Request [#{format}] Bundle using _format" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/formats.html"
+            links "#{REST_SPEC_LINK}#mime-type"
+            links "#{REST_SPEC_LINK}#read"
+            requires resource: 'Patient', methods: ['create','read']
+            validates resource: 'Patient', methods: ['read'], formats: ['XML']
+          }
+          begin
+            patients_bundle = request_bundle(FHIR::Patient, format, true)
 
-          assert compare_response_format(patients_bundle, @xml_format), "Bundle XML format param mismatch: requested #{@xml_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO4- Failed to handle Bundle XML format param response. Error: #{e.message}")
+            assert compare_response_format(patients_bundle, @@xml_format), "Bundle XML format param mismatch: requested #{format}, received #{patients_bundle.response_format}"
+          rescue => e
+            raise AssertionException.new("FT04- Failed to handle Bundle XML format param response. Error: #{e.message}")
+          end
         end
       end
 
@@ -353,70 +220,61 @@ module Crucible
           validates resource: 'Patient', methods: ['read'], formats: ['JSON']
         }
         begin
-          patients_bundle = request_bundle(FHIR::Patient, @json_format)
+          patients_bundle = request_bundle(FHIR::Patient, @@json_format)
 
-          assert compare_response_format(patients_bundle, @json_format), "Bundle JSON format header mismatch: requested #{@json_format}, received #{patients_bundle.response_format}"
+          assert compare_response_format(patients_bundle, @@json_format), "Bundle JSON format header mismatch: requested #{@@json_format}, received #{patients_bundle.response_format}"
         rescue => e
           raise AssertionException.new("FT05 - Failed to handle Bundle JSON format header response. Error: #{e.message}")
         end
       end
 
-      test 'FT06A', 'Request [json] Bundle using [_format]' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
-        }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @json_format_params[0], true)
+      @@json_format_params.each_with_index do |format, index|
+        test "FT06#{@@alpha[index]}", "Request [#{format}] Bundle using _format" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/formats.html"
+            links "#{REST_SPEC_LINK}#mime-type"
+            links "#{REST_SPEC_LINK}#read"
+            requires resource: 'Patient', methods: ['create','read']
+            validates resource: 'Patient', methods: ['read'], formats: ['JSON']
+          }
+          begin
+            patients_bundle = request_bundle(FHIR::Patient, format, true)
 
-          assert compare_response_format(patients_bundle, @json_format), "Bundle JSON format param mismatch: requested #{@json_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO6 - Failed to handle Bundle JSON format param response. Error: #{e.message}")
+            assert compare_response_format(patients_bundle, @@json_format), "Bundle JSON format param mismatch: requested #{format}, received #{patients_bundle.response_format}"
+          rescue => e
+            raise AssertionException.new("FT06 - Failed to handle Bundle JSON format param response. Error: #{e.message}")
+          end
         end
       end
 
-      test 'FT06C', 'Request [application/json] Bundle using [_format]' do
+      test 'FT07', 'Request invalid mime-type using headers' do
         metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
+          links "#{BASE_SPEC_LINK}/formats.html#wire"
+          requires resource: 'Patient', methods: ['read']
+          validates resource: 'Patient', methods: ['read']
         }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @json_format_params[1], true)
-
-          assert compare_response_format(patients_bundle, @json_format), "Bundle JSON format param mismatch: requested #{@json_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO6 - Failed to handle Bundle JSON format param response. Error: #{e.message}")
-        end
+        @client.use_format_param = false
+        reply = @client.read_feed(FHIR::Patient,'application/foobar')
+        assert( (reply.code==415), 'Request for invalid mime-type should return HTTP 415 Unsupported Media Type.')
       end
 
-      test 'FT06D', 'Request [application/json+fhir] Bundle using [_format]' do
+      test 'FT08', 'Request invalid mime-type using _format' do
         metadata {
-          links "#{BASE_SPEC_LINK}/formats.html"
-          links "#{REST_SPEC_LINK}#mime-type"
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: 'Patient', methods: ['create','read']
-          validates resource: 'Patient', methods: ['read'], formats: ['JSON']
+          links "#{BASE_SPEC_LINK}/formats.html#wire"
+          requires resource: 'Patient', methods: ['read']
+          validates resource: 'Patient', methods: ['read']
         }
-        begin
-          patients_bundle = request_bundle(FHIR::Patient, @json_format_params[2], true)
-
-          assert compare_response_format(patients_bundle, @json_format), "Bundle JSON format param mismatch: requested #{@json_format}, received #{patients_bundle.response_format}"
-        rescue => e
-          raise AssertionException.new("FTO6 - Failed to handle Bundle JSON format param response. Error: #{e.message}")
-        end
+        @client.use_format_param = true
+        reply = @client.read_feed(FHIR::Patient,'application/foobar')
+        @client.use_format_param = false
+        assert( (reply.code==415), 'Request for invalid mime-type should return HTTP 415 Unsupported Media Type.')
       end
 
       private
 
       # Compare requested resource with created resource
       def compare_response(entry)
-        @create_failed || entry != nil && entry.resource != nil && entry.resource == @resource
+        entry != nil && entry.resource != nil && entry.resource.equals?(@resource,['id'])
       end
 
       # Compare response format with requested format
@@ -426,7 +284,7 @@ module Crucible
 
       # Compare two requested entries
       def compare_entries(entry1, entry2)
-        @create_failed || compare_response(entry1) && compare_response(entry2) && entry1.resource == entry2.resource
+        compare_response(entry1) && compare_response(entry2) && entry1.resource.equals?(entry2.resource,['id'])
       end
 
       # Unify resource requests and format specification
@@ -435,7 +293,7 @@ module Crucible
         entry = @client.read(resource_class, id, format)
         @client.use_format_param = false
         assert_response_ok entry, "Failed to retrieve resource: #{entry.request[:url]}"
-        entry.resource.id = id
+        # entry.resource.id = id if !entry.resource.nil?
         entry
       end