plan_executor 1.0.2

data/lib/tests/suites/history_test.rb

@@ -0,0 +1,311 @@
+module Crucible
+  module Tests
+    class HistoryTest < BaseSuite
+
+      def id
+        'History001'
+      end
+
+      def description
+        'Initial Sprinkler tests (HI01,HI02,HI03,HI04,HI05,HI06,HI07,HI08,HI09,HI10,HI11) for testing resource history requests.'
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+        @category = {id: 'core_functionality', title: 'Core Functionality'}
+      end
+
+      def setup
+        @resources = Crucible::Generator::Resources.new
+        @patient = @resources.minimal_patient
+
+        @create_date = Time.now.utc
+
+        @version = []
+        result = @client.create(@patient)
+        assert_response_ok(result)
+        @id = result.id
+        @version << result.version
+
+        @patient.xmlId = @id
+        @patient.telecom << FHIR::ContactPoint.new(system: 'email', value: 'foo@example.com')
+
+        update_result = @client.update(@patient, @id)
+        assert_response_ok(update_result)
+        @version << update_result.version
+        del_result = @client.destroy(FHIR::Patient, @id)
+        assert_response_code(del_result,204)
+        
+        @entry_count = @version.length
+        # add one for deletion
+        @version_count = @entry_count + 1
+      end
+
+      test  'HI01','History for specific resource' do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history"]
+        }
+
+        result = @client.resource_instance_history(FHIR::Patient,@id)
+        assert_response_ok result
+        bundle = result.resource
+
+        assert_equal "history", bundle.fhirType, "The bundle type is not correct"
+        assert_equal @version_count, bundle.total, "the number of returned versions is not correct"
+        check_sort_order(bundle.entry)
+      end
+
+      test  'HI01.1','History request entries' do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history"]
+        }
+        result = @client.resource_instance_history(FHIR::Patient,@id)
+        assert_response_ok result
+        bundle = result.resource
+        entries = bundle.entry
+
+        assert_equal 1, entries.select{|entry| entry.request.try(:method) == 'DELETE' }.size, 'Wrong number of DELETE transactions in the history bundle'
+        assert_equal 1, entries.select{|entry| entry.request.try(:method) == 'PUT' }.size, 'Wrong number of PUT transactions in the history bundle'
+        assert_equal 1, entries.select{|entry| entry.request.try(:method) == 'POST' }.size, 'Wrong number of POST transactions in the history bundle'
+
+      end
+
+      test "HI02", "full history of a resource by id with since" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history"]
+        }
+
+        before = @create_date - 1.minute
+        after = before + 1.hour
+
+        all_history = @client.resource_instance_history(FHIR::Patient,@id)
+
+        result = @client.resource_instance_history_as_of(FHIR::Patient,@id,before)
+        assert_response_ok result
+        bundle = result.resource
+
+        assert_equal @version_count, bundle.total, "the number of returned versions since the creation date is not correct"
+
+        entry_ids_are_present(bundle.entry)
+        check_sort_order(bundle.entry)
+
+        result = @client.resource_instance_history_as_of(FHIR::Patient,@id,after)
+        assert_response_ok result
+        assert_equal 0, result.resource.total, "there should not be any history one hour after the creation date"
+      end
+
+      test "HI03", "individual history versions" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["vread", "history"]
+        }
+
+        result = @client.resource_instance_history(FHIR::Patient,@id)
+        assert_response_ok result
+
+        bundle = result.resource
+
+        active_entries(bundle.entry).each do |entry|
+          pulled = @client.vread(FHIR::Patient, entry.resource.xmlId, entry.resource.meta.versionId)
+          assert_response_ok pulled
+          assert !pulled.nil?, "Cannot find version that was present in history"
+        end
+
+        deleted_entries(bundle.entry).each do |entry|
+          # FIXME: Should we parse the request URL or drop this assertion?
+          if entry.resource
+            pulled = @client.vread(FHIR::Patient, entry.resource.xmlId, entry.resource.meta.versionId)
+            assert pulled.resource.nil?, "resource should not be found since it was deleted"
+            assert_response_gone pulled
+          end
+        end
+      end
+
+      test "HI04", "history for missing resource" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history"]
+        }
+
+        result = @client.resource_instance_history(FHIR::Patient,'3141592unlikely')
+        assert_response_not_found result
+        assert result.resource.nil?, 'bad history request should not return a resource'
+      end
+
+      test "HI06", "all history for resource with since" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history-type"]
+        }
+
+        before = @create_date - 1.minute
+        after = Time.now.utc + 1.hour
+
+        result = @client.resource_history_as_of(FHIR::Patient,before)
+        assert_response_ok result
+        bundle = result.resource
+
+        entry_ids_are_present(bundle.entry)
+        check_sort_order(bundle.entry)
+
+
+        result = @client.resource_history_as_of(FHIR::Patient,after)
+        assert_response_ok result
+        assert_equal 0, result.resource.total, "Setting since to a future moment still returns history"
+
+      end
+
+      test "HI08", "all history whole system with since" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: nil, methods: ["history-system"]
+        }
+
+        before = @create_date - 1.minute
+        after = Time.now.utc + 1.hour
+
+        result = @client.all_history_as_of(before)
+        assert_response_ok result
+        bundle = result.resource
+        entry_ids_are_present(bundle.entry)
+        check_sort_order(bundle.entry)
+
+        warning { assert_navigation_links(bundle) }
+
+        result = @client.resource_history_as_of(FHIR::Patient,after)
+        assert_response_ok result
+        assert_equal 0, result.resource.total, "Setting since to a future moment still returns history"
+
+      end
+
+
+      test "HI09", "resource history page forward" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history-type"]
+        }
+
+        page_size = 2
+        page = @client.history(resource: FHIR::Patient, history: {since: (Time.now.utc - 1.hour), count: page_size})
+
+        forward_count = 0
+        # browse forwards
+        while page != nil
+          assert !page.resource.nil?, "Unable to page forward through results.  A bundle was not returned from the page forward request."
+          warning { entry_ids_are_present(page.resource.entry) }
+          assert page.resource.entry.size <= page_size, "Server returned a page with more entries than set by _count"
+          forward_count += page.resource.entry.size
+          page = @client.next_page(page)
+        end
+
+        assert forward_count > 2, "there should be at least 2 history entries"
+      end
+
+      test "HI10", "resource history page backwards" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: "Patient", methods: ["history-type"]
+        }
+
+        page_size = 2
+        page = @client.history(resource: FHIR::Patient, history: {since: (Time.now.utc - 1.hour), count: page_size})
+
+        forward_count = 0
+        last_page = page
+        # browse forwards
+        while page != nil
+          assert !page.resource.nil?, "Unable to page forward through results.  A bundle was not returned from the page forward request."
+          forward_count += page.resource.entry.size
+          page = @client.next_page(page)
+          last_page = page if page
+        end
+
+        backward_count = 0
+        page = last_page
+        # browse backwards
+        while page != nil
+          warning { entry_ids_are_present(page.resource.entry) }
+          assert page.resource.entry.size <= page_size, "Server returned a page with more entries than set by _count"
+          backward_count += page.resource.entry.size
+          page = @client.next_page(page, FHIR::Sections::Feed::BACKWARD)
+        end
+
+        assert_equal forward_count, backward_count, "entry numbers were different moving forwards and backwards"
+
+      end
+
+      test "HI11", "first page full history" do
+        metadata {
+          links "#{REST_SPEC_LINK}#history"
+          requires resource: "Patient", methods: ["create", "update", "delete"]
+          validates resource: nil, methods: ["history-system"]
+        }
+
+        history = @client.all_history
+        assert !history.resource.nil?, "A bundle was not returned from the history request."
+        assert history.resource.entry.size >= 3, "there should be at least 3 history entries"
+      end
+
+      ###
+      ### Test first and last pages
+      ###
+
+
+      ####
+      #### Check sice with timezones?????
+      ####
+
+      def deleted_entries(entries)
+        entries.select do |entry|
+          assert !entry.request.nil?, "history bundle entries do not have request elements, deleted entries cannot be distinguished"
+          entry.request.try(:method) == "DELETE"
+        end
+      end
+
+      def active_entries(entries)
+        entries - deleted_entries(entries)
+      end
+
+
+      def entry_ids_are_present(entries)
+        relevant_entries = entries.select{|x|x.request.try(:method)!='DELETE'}
+        ids = relevant_entries.map(&:resource).map(&:xmlId).compact rescue assert(false, 'Unable to find IDs for resources returned by the bundle')
+
+        # check that we have ids and self links
+        assert_equal relevant_entries.length, ids.size, 'All PUT and POST entries must have an ID'
+      end
+
+      def url?(v)
+        v =~ /\A#{URI::regexp}\z/
+      end
+
+      def check_sort_order(entries)
+        relevant_entries = entries.select{|x|x.request.try(:method)!='DELETE'}
+        relevant_entries.map!(&:resource).map!(&:meta).compact rescue assert(false, 'Unable to find meta for resources returned by the bundle')
+
+        relevant_entries.each_cons(2) do |left, right|
+          if !left.versionId.nil? && !right.versionId.nil?
+            assert (left.versionId > right.versionId), 'Result contains entries in the wrong order.'
+          elsif !left.lastUpdated.nil? && !right.lastUpdated.nil?
+            assert (left.lastUpdated >= right.lastUpdated), 'Result contains entries in the wrong order.'
+          else
+            raise AssertionException.new 'Unable to determine if entries are in the correct order -- no meta.versionId or meta.lastUpdated'
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/tests/suites/read_test.rb

@@ -0,0 +1,104 @@
+module Crucible
+  module Tests
+    class ReadTest < BaseSuite
+
+      def id
+        'ReadTest'
+      end
+
+      def description
+        'Initial Sprinkler tests (R001, R002, R003, R004) for testing basic READ requests.'
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+        @category = {id: 'core_functionality', title: 'Core Functionality'}
+      end
+
+      def setup
+        @patient = ReadTest.createPatient('Emerald', 'Caro')
+        reply = @client.create(@patient)
+        @id = reply.id
+        @body = reply.body
+      end
+
+      def teardown
+        @client.destroy(FHIR::Patient, @id)
+      end
+
+      def self.createPatient(family, given)
+        patient = FHIR::Patient.new(name: [FHIR::HumanName.new(family: [family], given: [given])])
+      end
+
+      # [SprinklerTest("R001", "Result headers on normal read")]
+      test 'R001', 'Result headers on normal read.' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          requires resource: "Patient", methods: ["create", "read", "delete"]
+          validates resource: "Patient", methods: ["read"]
+        }
+
+        assert(@id, 'Setup was unable to create a patient.',@body)
+        reply = @client.read(FHIR::Patient, @id)
+        assert_response_ok(reply)
+        assert_equal @id, reply.id, 'Server returned wrong patient.'
+        warning { assert_valid_resource_content_type_present(reply) }
+        warning { assert_etag_present(reply) }
+        warning { assert_last_modified_present(reply) }
+      end
+
+      # [SprinklerTest("R002", "Read unknown resource type")]
+      test 'R002', 'Read unknown resource type.' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          links "#{REST_SPEC_LINK}#update"
+        }
+
+        reply = @client.read(Crucible::Tests::ReadTest, @id)
+        assert_response_not_found(reply)
+      end
+
+      # [SprinklerTest("R003", "Read non-existing resource id")]
+      test 'R003', 'Read non-existing resource id.' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          requires resource: "Patient", methods: ["create", "read", "delete"]
+          validates resource: "Patient", methods: ["read"]
+        }
+
+        reply = @client.read(FHIR::Patient, 'Supercalifragilisticexpialidocious')
+        assert_response_not_found(reply)
+      end
+
+      # [SprinklerTest("R004", "Read bad formatted resource id")]
+      test 'R004', 'Read invalid format resource id' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          links "#{BASE_SPEC_LINK}/datatypes.html#id"
+          links "#{BASE_SPEC_LINK}/resource.html#id"
+          requires resource: "Patient", methods: ["create", "read", "delete"]
+          validates resource: "Patient", methods: ["read"]
+        }
+
+        reply = @client.read(FHIR::Patient, 'Invalid-ID-Because_Of_!@$Special_Characters_and_Length_Over_Sixty_Four_Characters')
+        assert_response_bad(reply)
+      end
+
+      test 'R005', 'Read _summary=text' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          links "#{BASE_SPEC_LINK}/datatypes.html#id"
+          links "#{BASE_SPEC_LINK}/resource.html#id"
+          requires resource: "Patient", methods: ["create", "read", "delete"]
+          validates resource: "Patient", methods: ["read"]
+        }
+
+        assert(@id, 'Setup was unable to create a patient.', @body)
+        reply = @client.read(FHIR::Patient, @id, @client.default_format, 'text')
+        assert_response_ok(reply)
+        assert(reply.try(:resource).try(:text), 'Requested summary narrative was not provided.', reply.body)
+      end      
+
+    end
+  end
+end