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'))