def test_equality(self): """Test equality of ServiceParameter subclasses.""" prim_a = MaximumLengthNegotiation() prim_b = MaximumLengthNegotiation() assert prim_a == prim_b assert not prim_a == 'test' assert not prim_a != prim_b prim_b.maximum_length_received = 12 assert not prim_a == prim_b assert prim_a != prim_b
def test_equality(self): """Test equality of ServiceParameter subclasses.""" prim_a = MaximumLengthNegotiation() prim_b = MaximumLengthNegotiation() self.assertTrue(prim_a == prim_b) self.assertFalse(prim_a == 'test') self.assertFalse(prim_a != prim_b) prim_b.maximum_length_received = 12 self.assertFalse(prim_a == prim_b) self.assertTrue(prim_a != prim_b)
def test_conversion(self): """ Check converting to PDU item works correctly """ ## Check conversion to item using default value primitive = MaximumLengthNegotiation() item = primitive.from_primitive() # \x3F\xFE = 16382 self.assertTrue(item.encode() == b"\x51\x00\x00\x04\x00\x00\x3f\xfe") ## Check conversion using 0 (unlimited) primitive.maximum_length_received = 0 item = primitive.from_primitive() # \x00\x00 = 0 self.assertTrue(item.encode() == b"\x51\x00\x00\x04\x00\x00\x00\x00")
def test_assignment_and_exceptions(self): """ Check incorrect types/values for maximum_length_received raise exceptions """ primitive = MaximumLengthNegotiation() # Check default assignment self.assertTrue(primitive.maximum_length_received == 16382) # Check new assignment primitive.maximum_length_received = 45 self.assertTrue(primitive.maximum_length_received == 45) # Check exceptions with pytest.raises(TypeError): primitive.maximum_length_received = 45.2 with pytest.raises(ValueError): primitive.maximum_length_received = -1 with pytest.raises(TypeError): primitive.maximum_length_received = 'abc'
def request_assoc(self, local_ae, peer_ae, max_pdu_size, pcdl, userspdu=None): """Request an Association with a peer Application Entity SCP. Issues an A-ASSOCIATE request primitive to the DICOM UL service provider Requests an association with a remote AE and waits for association response (local AE is acting as an SCU) Parameters ---------- local_ae : dict Contains information about the local AE, keys 'ae_title', 'port', 'address', 'pdv_size', 'propsed_contexts'. peer_ae : dict Contains information about the peer AE, keys 'ae_title', 'port', 'address'. max_pdu_size : int Maximum PDU size in bytes pcdl : list of pynetdicom3.presentation.PresentationContext A list of the proposed Presentation Contexts for the association If local_ae is ApplicationEntity then this is doubled up unnecessarily userpdu : List of UserInformation objects List of items to be added to the requests user information for use in extended negotiation. See PS3.7 Annex D.3.3 Returns ------- bool True if the Association was accepted, False if rejected or aborted """ self.local_ae = local_ae self.local_ae['pdv_size'] = max_pdu_size self.remote_ae = peer_ae self.local_max_pdu = max_pdu_size ## Build an A-ASSOCIATE request primitive # # The following parameters must be set for a request primitive # ApplicationContextName # CallingAETitle # CalledAETitle # UserInformation # Maximum PDV Length (required) # Implementation Identification - Class UID (required) # CallingPresentationAddress # CalledPresentationAddress # PresentationContextDefinitionList assoc_rq = A_ASSOCIATE() assoc_rq.application_context_name = self.application_context_name assoc_rq.calling_ae_title = self.local_ae['ae_title'] assoc_rq.called_ae_title = self.remote_ae['ae_title'] # Build User Information - PS3.7 Annex D.3.3 # # Maximum Length Negotiation (required) max_length = MaximumLengthNegotiation() max_length.maximum_length_received = self.local_ae['pdv_size'] assoc_rq.user_information = [max_length] # Implementation Identification Notification (required) # Class UID (required) implementation_class_uid = ImplementationClassUIDNotification() implementation_class_uid.implementation_class_uid = UID( pynetdicom_implementation_uid) assoc_rq.user_information.append(implementation_class_uid) # Version Name (optional) implementation_version_name = ImplementationVersionNameNotification() implementation_version_name.implementation_version_name = ( pynetdicom_version) assoc_rq.user_information.append(implementation_version_name) # Add the extended negotiation information (optional) if userspdu is not None: assoc_rq.user_information += userspdu assoc_rq.calling_presentation_address = (self.local_ae['address'], self.local_ae['port']) assoc_rq.called_presentation_address = (self.remote_ae['address'], self.remote_ae['port']) assoc_rq.presentation_context_definition_list = pcdl # ## A-ASSOCIATE request primitive is now complete # Send the A-ASSOCIATE request primitive to the peer via the # DICOM UL service LOGGER.info("Requesting Association") self.dul.send_pdu(assoc_rq) ## Receive the response from the peer # This may be an A-ASSOCIATE confirmation primitive or an # A-ABORT or A-P-ABORT request primitive # assoc_rsp = self.dul.receive_pdu(wait=True, timeout=self.acse_timeout) # Association accepted or rejected if isinstance(assoc_rsp, A_ASSOCIATE): # Accepted if assoc_rsp.result == 0x00: # Get maximum pdu length from answer self.peer_max_pdu = assoc_rsp.maximum_length_received self.parent.peer_ae['pdv_size'] = ( assoc_rsp.maximum_length_received) # FIXME self.parent.peer_max_pdu = assoc_rsp.maximum_length_received # Get accepted presentation contexts using the manager self.context_manager.requestor_contexts = pcdl self.context_manager.acceptor_contexts = ( assoc_rsp.presentation_context_definition_results_list) # Once the context manager gets both sets of contexts it # automatically determines which are accepted and refused self.accepted_contexts = self.context_manager.accepted self.rejected_contexts = self.context_manager.rejected return True, assoc_rsp # Rejected elif assoc_rsp.result in [0x01, 0x02]: # 0x01 is rejected (permanent) # 0x02 is rejected (transient) return False, assoc_rsp # Invalid Result value elif assoc_rsp.result is None: return False, assoc_rsp else: LOGGER.error( "ACSE received an invalid result value from " "the peer AE: '%s'", assoc_rsp.result) raise ValueError("ACSE received an invalid result value from " "the peer AE: '{}'".format(assoc_rsp.result)) # Association aborted elif isinstance(assoc_rsp, (A_ABORT, A_P_ABORT)): return False, assoc_rsp elif assoc_rsp is None: return False, assoc_rsp else: raise ValueError("Unexpected response by the peer AE to the " "ACSE association request")
def test_string(self): """Check the string output.""" primitive = MaximumLengthNegotiation() self.assertTrue('16382 bytes' in primitive.__str__())
def test_assignment(self): """ Check assignment works correctly """ assoc = A_ASSOCIATE() def test_mode(): assoc.mode = "test value" self.assertRaises(AttributeError, test_mode) def test_preq(): assoc.presentation_requirements = "test value2" self.assertRaises(AttributeError, test_preq) def test_sreq(): assoc.session_requirements = "test value3" self.assertRaises(AttributeError, test_sreq) assoc.application_context_name = "1.2.840.10008.3.1.1.1" self.assertTrue( assoc.application_context_name == UID('1.2.840.10008.3.1.1.1')) assoc.application_context_name = b"1.2.840.10008.3.1.1.1" self.assertTrue( assoc.application_context_name == UID('1.2.840.10008.3.1.1.1')) assoc.application_context_name = UID("1.2.840.10008.3.1.1.1") self.assertTrue( assoc.application_context_name == UID('1.2.840.10008.3.1.1.1')) assoc.calling_ae_title = 'ABCD1234ABCD12345' self.assertTrue(assoc.calling_ae_title == b'ABCD1234ABCD1234') assoc.called_ae_title = 'ABCD1234ABCD12345' self.assertTrue(assoc.called_ae_title == b'ABCD1234ABCD1234') self.assertTrue(assoc.responding_ae_title == b'ABCD1234ABCD1234') max_length = MaximumLengthNegotiation() max_length.maximum_length_received = 31222 assoc.user_information.append(max_length) self.assertTrue( assoc.user_information[0].maximum_length_received == 31222) assoc.user_information = ['a', max_length] self.assertEqual(assoc.user_information, [max_length]) assoc.result = 0 self.assertTrue(assoc.result == 0) assoc.result = 1 self.assertTrue(assoc.result == 1) assoc.result = 2 self.assertTrue(assoc.result == 2) assoc.result_source = 1 self.assertTrue(assoc.result_source == 1) assoc.result_source = 2 self.assertTrue(assoc.result_source == 2) assoc.result_source = 3 self.assertTrue(assoc.result_source == 3) assoc.diagnostic = 1 self.assertTrue(assoc.diagnostic == 1) assoc.diagnostic = 2 self.assertTrue(assoc.diagnostic == 2) assoc.diagnostic = 3 self.assertTrue(assoc.diagnostic == 3) assoc.diagnostic = 7 self.assertTrue(assoc.diagnostic == 7) assoc.calling_presentation_address = ('10.40.94.43', 105) self.assertTrue(assoc.calling_presentation_address == ('10.40.94.43', 105)) assoc.called_presentation_address = ('10.40.94.44', 106) self.assertTrue(assoc.called_presentation_address == ('10.40.94.44', 106)) pc = PresentationContext() pc.context_id = 1 assoc.presentation_context_definition_list = [pc] self.assertTrue(assoc.presentation_context_definition_list == [pc]) assoc.presentation_context_definition_list = ['a', pc] self.assertTrue(assoc.presentation_context_definition_list == [pc]) assoc.presentation_context_definition_results_list = [pc] self.assertTrue( assoc.presentation_context_definition_results_list == [pc]) assoc.presentation_context_definition_results_list = ['a', pc] self.assertTrue( assoc.presentation_context_definition_results_list == [pc]) assoc = A_ASSOCIATE() # No maximum_length_received set self.assertEqual(assoc.maximum_length_received, None) # No MaximumLengthNegotiation present assoc.maximum_length_received = 31223 self.assertTrue( assoc.user_information[0].maximum_length_received == 31223) self.assertTrue(assoc.maximum_length_received == 31223) # MaximumLengthNegotiation already present assoc.maximum_length_received = 31224 self.assertTrue(assoc.maximum_length_received == 31224) # No ImplementationClassUIDNegotiation present assoc.implementation_class_uid = '1.1.2.3.4' self.assertTrue(assoc.user_information[1].implementation_class_uid == UID('1.1.2.3.4')) self.assertTrue(assoc.implementation_class_uid == UID('1.1.2.3.4')) # ImplementationClassUIDNegotiation already present assoc.implementation_class_uid = '1.1.2.3.4' self.assertTrue(assoc.implementation_class_uid == UID('1.1.2.3.4'))