def test_PatientContextStateContainer_final(self):
def verifyEqual(origin, copied):
self.assertEqual(copied.Handle, origin.Handle)
self.assertEqual(copied.Givenname, origin.Givenname)
self.assertEqual(copied.Middlename, origin.Middlename)
self.assertEqual(copied.Familyname, origin.Familyname)
self.assertEqual(copied.DateOfBirth, origin.DateOfBirth)
self.assertEqual(copied.Height, origin.Height)
self.assertEqual(copied.Weight, origin.Weight)
self.assertEqual(copied.Race, origin.Race)
self.assertEqual(copied.Identification, origin.Identification)
self._verifyAbstractStateContainerDataEqual(copied, origin)
sc = statecontainers.PatientContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=None)
self.assertTrue(sc.Handle is not None)
sc.Givenname = 'Karl'
sc.Middlename = 'M.'
sc.Familyname = 'Klammer'
sc.Height = pmtypes.Measurement(88.2, pmtypes.CodedValue('abc', 'def'))
sc.Weight = pmtypes.Measurement(68.2, pmtypes.CodedValue('abc'))
sc.Race = pmtypes.CodedValue('123', 'def')
sc.DateOfBirth = datetime.date(2001, 3, 12)
print(sc.DateOfBirth)
sc.Identification.append(
pmtypes.InstanceIdentifier('abc', pmtypes.CodedValue('123'), [
pmtypes.LocalizedText('Peter', 'en'),
pmtypes.LocalizedText('Paul'),
pmtypes.LocalizedText('Mary')
]))
sc.Identification.append(
pmtypes.InstanceIdentifier('def', pmtypes.CodedValue('456'), [
pmtypes.LocalizedText('John'),
pmtypes.LocalizedText('Jim'),
pmtypes.LocalizedText('Jane')
]))
#test creation from node
node = sc.mkStateNode()
print(etree_.tostring(node, pretty_print=True))
sc2 = statecontainers.PatientContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=node)
verifyEqual(sc, sc2)
#test update from node
sc.Middlename = 'K.'
sc.DateOfBirth = datetime.datetime(2001, 3, 12, 14, 30, 1)
sc.incrementState()
sc.Height._value = 42
sc.Weight._value = 420
node = sc.mkStateNode()
sc2.updateFromNode(node)
verifyEqual(sc, sc2)
def test_AbstractMetricStateContainer_Final(self):
dc = descriptorcontainers.NumericMetricDescriptorContainer(
nsmapper=self.nsmapper,
nodeName='MyDescriptor',
handle='123',
parentHandle='456')
sc = statecontainers.NumericMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=None)
self.assertEqual(sc.ActivationState, 'On')
for value in ('foo', 'bar'):
sc.ActivationState = value
self.assertEqual(sc.ActivationState, value)
node = sc.mkStateNode()
self.assertEqual(node.get('ActivationState'), value)
self.assertEqual(sc.ActiveDeterminationPeriod, None)
for value in (21, 42):
sc.ActiveDeterminationPeriod = value
self.assertEqual(sc.ActiveDeterminationPeriod, value)
node = sc.mkStateNode()
self.assertEqual(
node.get('ActiveDeterminationPeriod'),
containerproperties.DurationConverter.toXML(value))
sc.BodySite = [pmtypes.CodedValue('ABC')]
sc.PhysicalConnector = pmtypes.PhysicalConnectorInfo(
[pmtypes.LocalizedText('ABC')], 1)
# test creation from node
node = sc.mkStateNode()
sc2 = statecontainers.NumericMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=node)
self.assertEqual(sc.ActivationState, sc2.ActivationState)
self.assertEqual(sc.ActiveDeterminationPeriod,
sc2.ActiveDeterminationPeriod)
self.assertEqual(sc.BodySite, sc2.BodySite)
self.assertEqual(sc.PhysicalConnector, sc2.PhysicalConnector)
self._verifyAbstractStateContainerDataEqual(sc, sc2)
# test update from Node
sc.ActivationState = 'something else'
sc.ActiveDeterminationPeriod += 1
sc.BodySite = [pmtypes.CodedValue('DEF')]
sc.PhysicalConnector = pmtypes.PhysicalConnectorInfo(
[pmtypes.LocalizedText('DEF')], 2)
sc.incrementState()
node = sc.mkStateNode()
sc2.updateFromNode(node)
self.assertEqual(sc.ActivationState, sc2.ActivationState)
self.assertEqual(sc.BodySite, sc2.BodySite)
self.assertEqual(sc.PhysicalConnector, sc2.PhysicalConnector)
self.assertEqual(sc.ActiveDeterminationPeriod,
sc2.ActiveDeterminationPeriod)
self._verifyAbstractStateContainerDataEqual(sc, sc2)
def test_ActivateOperationDescriptorContainer(self):
def _cmp_ActivateOperationDescriptorContainer(_dc, _dc2):
self.assertEqual(_dc.diff(_dc2), [])
self.assertEqual(_dc.Argument, _dc2.Argument)
# self.assertEqual(_dc.ActivationDuration, _dc2.ActivationDuration)
self.assertEqual(_dc.Retriggerable, _dc2.Retriggerable)
dc = descriptorcontainers.ActivateOperationDescriptorContainer(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = descriptorcontainers.ActivateOperationDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
_cmp_ActivateOperationDescriptorContainer(dc, dc2)
dc.Argument = [
pmtypes.Argument(argName=pmtypes.CodedValue('abc', 'def'),
arg=namespaces.domTag('blubb'))
]
node = dc.mkNode()
dc2.updateDescrFromNode(node)
_cmp_ActivateOperationDescriptorContainer(dc, dc2)
def setUp(self):
self.mdib = sdc11073.mdib.DeviceMdibContainer(SDC_v1_Definitions)
self.domSchema = self.mdib.bicepsSchema.pmSchema
self.msgSchema = self.mdib.bicepsSchema.bmmSchema
# this structure is not realistic, but sufficient for what we need here.
desc = dc.MdsDescriptorContainer(
self.mdib.nsmapper,
nodeName=sdc11073.namespaces.domTag('Mds'),
handle='42',
parentHandle=None,
)
self.mdib.descriptions.addObject(desc)
for h in HANDLES:
desc = dc.RealTimeSampleArrayMetricDescriptorContainer(
self.mdib.nsmapper,
sdc11073.namespaces.domTag('Metric'),
handle=h,
parentHandle='42',
)
desc.SamplePeriod = 0.1
desc.unit = pmtypes.CodedValue('abc')
desc.MetricAvailability = pmtypes.MetricAvailability.CONTINUOUS
desc.MetricCategory = pmtypes.MetricCategory.MEASUREMENT
self.mdib.descriptions.addObject(desc)
self.sdcDevice = None
self.nsmapper = sdc11073.namespaces.DocNamespaceHelper()
def test_AbstractMetricDescriptorContainer(self):
dc = descriptorcontainers.AbstractMetricDescriptorContainer(
nsmapper=self.nsmapper,
nodeName='MyDescriptor',
handle='123',
parentHandle='456',
)
self.assertEqual(dc.MetricAvailability, 'Cont') # the default value
self.assertEqual(dc.MetricCategory, 'Unspec') # the default value
self.assertEqual(dc.DeterminationPeriod, None)
self.assertEqual(dc.MaxMeasurementTime, None)
self.assertEqual(dc.MaxDelayTime, None)
#test creation from node
node = dc.mkNode()
dc2 = descriptorcontainers.AbstractMetricDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self.assertEqual(dc2.MetricAvailability, 'Cont')
self.assertEqual(dc2.MetricCategory, 'Unspec')
self.assertEqual(dc2.DeterminationPeriod, None)
self.assertEqual(dc2.MaxMeasurementTime, None)
self.assertEqual(dc2.MaxDelayTime, None)
#test update from node
dc.MetricAvailability = 'Avail'
dc.MetricCategory = 'Msmnt'
dc.DeterminationPeriod = 3.5
dc.MaxMeasurementTime = 2.1
dc.MaxDelayTime = 4
dc.Unit = pmtypes.CodedValue('abc', 'def')
dc.BodySite.append(pmtypes.CodedValue('ABC', 'DEF'))
dc.BodySite.append(pmtypes.CodedValue('GHI', 'JKL'))
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self.assertEqual(dc2.MetricAvailability, 'Avail')
self.assertEqual(dc2.MetricCategory, 'Msmnt')
self.assertEqual(dc2.DeterminationPeriod, 3.5)
self.assertEqual(dc2.MaxMeasurementTime, 2.1)
self.assertEqual(dc2.MaxDelayTime, 4)
self.assertEqual(dc2.Unit, dc.Unit)
self.assertEqual(dc2.BodySite, dc.BodySite)
self.assertEqual(dc2.BodySite, [
pmtypes.CodedValue('ABC', 'DEF'),
pmtypes.CodedValue('GHI', 'JKL')
])
def test_waveformSubscription(self):
self._model = sdc11073.pysoap.soapenvelope.DPWSThisModel(
manufacturer='Chinakracher GmbH',
manufacturerUrl='www.chinakracher.com',
modelName='BummHuba',
modelNumber='1.0',
modelUrl='www.chinakracher.com/bummhuba/model',
presentationUrl='www.chinakracher.com/bummhuba/presentation')
self._device = sdc11073.pysoap.soapenvelope.DPWSThisDevice(
friendlyName='Big Bang Practice',
firmwareVersion='0.99',
serialNumber='87kabuuum889')
tr = waveforms.TriangleGenerator(min_value=0,
max_value=10,
waveformperiod=2.0,
sampleperiod=0.02)
st = waveforms.SawtoothGenerator(min_value=0,
max_value=10,
waveformperiod=2.0,
sampleperiod=0.02)
si = waveforms.SinusGenerator(min_value=-8.0,
max_value=10.0,
waveformperiod=5.0,
sampleperiod=0.02)
self.mdib.registerWaveformGenerator(HANDLES[0], tr)
self.mdib.registerWaveformGenerator(HANDLES[1], st)
self.mdib.registerWaveformGenerator(HANDLES[2], si)
annotation = pmtypes.Annotation(pmtypes.CodedValue('a', 'b'))
self.mdib.registerAnnotationGenerator(annotation,
triggerHandle=HANDLES[2],
annotatedHandles=(HANDLES[0],
HANDLES[1],
HANDLES[2]))
self.wsDiscovery = mockstuff.MockWsDiscovery(['5.6.7.8'])
uuid = None # let device create one
self.sdcDevice = sdc11073.sdcdevice.SdcDevice(self.wsDiscovery,
uuid,
self._model,
self._device,
self.mdib,
logLevel=logging.DEBUG)
self.sdcDevice.startAll()
testSubscr = mockstuff.TestDevSubscription(
self.sdcDevice.mdib.sdc_definitions.Actions.Waveform,
self.sdcDevice.mdib.bicepsSchema)
self.sdcDevice.subscriptionsManager._subscriptions.addObject(
testSubscr)
time.sleep(3)
print(testSubscr.reports[-2].as_xml(pretty=True))
print(testSubscr.reports[-1].as_xml(pretty=True))
self.assertGreater(len(testSubscr.reports), 20)
def test_CodedValue(self):
c1 = pmtypes.CodedValue(42)
c2 = pmtypes.CodedValue(42, codingsystem='abc')
# compare with simple string or int shall imply default coding system
self.assertEqual(c1, 42)
self.assertEqual(c1, '42')
# if CodedValue does not have default coding systen, this compare shall return False
self.assertNotEqual(c2, 42)
# it shall be possible to compare with a Coding instance
self.assertEqual(
c1, pmtypes.Coding('42', pmtypes.DefaultCodingSystem, None))
# if two CodedValue instances are compared, the translations shall also be handled
c2.Translation.append(pmtypes.T_Translation(41))
self.assertNotEqual(c2, 41)
c3 = pmtypes.CodedValue(42)
c3.Translation.append(
pmtypes.T_Translation(41)) # same translation as c2
self.assertEqual(c2, c3)
def _test_ClockDescriptorContainer(self, cls):
dc = cls(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = cls.fromNode(nsmapper=self.nsmapper,
node=node,
parentHandle='467')
self.assertEqual(dc.TimeProtocol, dc2.TimeProtocol)
self.assertEqual(dc.Resolution, dc2.Resolution)
dc.TimeProtocol = [
pmtypes.CodedValue('abc', 'def'),
pmtypes.CodedValue('123', '456')
]
dc.Resolution = 3.14
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self.assertEqual(dc.TimeProtocol, dc2.TimeProtocol)
self.assertEqual(dc.Resolution, dc2.Resolution)
def test_RealTimeSampleArrayMetricStateContainer(self):
dc = descriptorcontainers.RealTimeSampleArrayMetricDescriptorContainer(
nsmapper=self.nsmapper,
nodeName='MyDescriptor',
handle='123',
parentHandle='456')
def verifyEqual(origin, copied):
self.assertEqual(copied.metricValue.Samples,
origin.metricValue.Samples)
self.assertEqual(copied.metricValue.DeterminationTime,
origin.metricValue.DeterminationTime)
self.assertEqual(copied.metricValue.Annotation,
origin.metricValue.Annotation)
self.assertEqual(copied.metricValue.ApplyAnnotations,
origin.metricValue.ApplyAnnotations)
self._verifyAbstractStateContainerDataEqual(copied, origin)
sc = statecontainers.RealTimeSampleArrayMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=None)
sc.mkMetricValue()
self.assertEqual(sc.nodeName, namespaces.domTag('State'))
self.assertTrue(isinstance(sc.metricValue, pmtypes.SampleArrayValue))
sc.metricValue.Samples = [1, 2, 3, 4, 5.5]
sc.metricValue.DeterminationTime = 1234567
sc.metricValue.Annotations = []
sc.metricValue.ApplyAnnotations = []
sc.ActivationState = 'act'
#test creation from node
node = sc.mkStateNode()
sc2 = statecontainers.RealTimeSampleArrayMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=node)
verifyEqual(sc, sc2)
#test update from node
sc.metricValue.Samples = [5.5, 6.6]
sc.metricValue.DeterminationTime = 2345678
sc.metricValue.Annotations = [
pmtypes.Annotation(pmtypes.CodedValue('a', 'b'))
]
sc.metricValue.ApplyAnnotations = [pmtypes.ApplyAnnotation(1, 2)]
sc.incrementState()
node = sc.mkStateNode()
sc2.updateFromNode(node)
verifyEqual(sc, sc2)
def test_AbstractDescriptorContainer(self):
dc = descriptorcontainers.AbstractDescriptorContainer(
nsmapper=self.nsmapper,
nodeName='MyDescriptor',
handle='123',
parentHandle='456',
)
self.assertEqual(dc.DescriptorVersion, 0)
self.assertEqual(dc.SafetyClassification, 'Inf')
self.assertEqual(dc.getActualValue('SafetyClassification'), None)
self.assertEqual(dc.Type, None)
#test creation from node
node = dc.mkNode()
dc2 = descriptorcontainers.AbstractDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self.assertEqual(dc2.DescriptorVersion, 0)
self.assertEqual(dc2.SafetyClassification, 'Inf')
self.assertEqual(dc.Type, None)
self.assertEqual(dc.ext_Extension, None)
#test update from node
dc.DescriptorVersion = 42
dc.SafetyClassification = 'MedA'
dc.Type = pmtypes.CodedValue('abc', 'def')
dc.ext_Extension = etree_.Element(namespaces.extTag('Extension'))
etree_.SubElement(dc.ext_Extension,
'foo',
attrib={'someattr': 'somevalue'})
etree_.SubElement(dc.ext_Extension,
'bar',
attrib={'anotherattr': 'differentvalue'})
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self.assertEqual(dc2.DescriptorVersion, 42)
self.assertEqual(dc2.SafetyClassification, 'MedA')
self.assertEqual(dc2.Type, dc.Type)
self.assertEqual(dc.codeId, 'abc')
self.assertEqual(dc.codingSystem, 'def')
self.assertEqual(dc2.ext_Extension.tag, namespaces.extTag('Extension'))
self.assertEqual(len(dc2.ext_Extension), 2)
def test_AbstractContextStateContainer(self):
def verifyEqual(origin, copied):
self.assertEqual(copied.ContextAssociation,
origin.ContextAssociation)
self.assertEqual(copied.BindingMdibVersion,
origin.BindingMdibVersion)
self.assertEqual(copied.UnbindingMdibVersion,
origin.UnbindingMdibVersion)
self.assertEqual(copied.BindingStartTime, origin.BindingStartTime)
self.assertEqual(copied.BindingEndTime, origin.BindingEndTime)
self.assertEqual(copied.Validator, origin.Validator)
self.assertEqual(copied.Identification, origin.Identification)
self._verifyAbstractStateContainerDataEqual(copied, origin)
sc = statecontainers.AbstractContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=None)
self.assertEqual(sc.ContextAssociation, 'No')
self.assertEqual(sc.BindingMdibVersion, None)
self.assertEqual(sc.UnbindingMdibVersion, None)
self.assertEqual(sc.BindingStartTime, None)
self.assertEqual(sc.BindingEndTime, None)
self.assertEqual(sc.Validator, [])
self.assertEqual(sc.Identification, [])
idents = [
pmtypes.InstanceIdentifier(
root='abc',
type_codedValue=pmtypes.CodedValue('abc', 'def'),
identifierNames=[pmtypes.LocalizedText('ABC')],
extensionString='123')
]
sc.Identification = idents
self.assertEqual(sc.Identification, idents)
validators = [
pmtypes.InstanceIdentifier(
root='ABC',
type_codedValue=pmtypes.CodedValue('123', '456'),
identifierNames=[pmtypes.LocalizedText('DEF')],
extensionString='321')
]
sc.Validator = validators
self.assertEqual(sc.Validator, validators)
for value in ('assoc', 'disassoc'):
sc.ContextAssociation = value
node = sc.mkStateNode()
self.assertEqual(node.get('ContextAssociation'), value)
for value in (12345.123, 67890.987):
sc.BindingStartTime = value
sc.BindingEndTime = value + 1
node = sc.mkStateNode()
self.assertEqual(
node.get('BindingStartTime'),
containerproperties.TimestampConverter.toXML(value))
self.assertEqual(
node.get('BindingEndTime'),
containerproperties.TimestampConverter.toXML(value + 1))
for value in (0, 42, 123):
sc.BindingMdibVersion = value
sc.UnbindingMdibVersion = value + 1
node = sc.mkStateNode()
self.assertEqual(node.get('BindingMdibVersion'),
containerproperties.IntegerConverter.toXML(value))
self.assertEqual(
node.get('UnbindingMdibVersion'),
containerproperties.IntegerConverter.toXML(value + 1))
node = etree_.Element(namespaces.domTag('State'),
attrib={
'StateVersion': '2',
'DescriptorHandle': '123',
'BindingStartTime': '1234567',
'BindingEndTime': '2345678',
'Handle': sc.Handle
})
sc.updateFromNode(node)
self.assertEqual(sc.BindingStartTime, 1234.567)
self.assertEqual(sc.BindingEndTime, 2345.678)
self.assertEqual(sc.node.get('BindingStartTime'), '1234567')
self.assertEqual(sc.node.get('BindingEndTime'), '2345678')
self.assertEqual(sc.Identification, [])
self.assertEqual(sc.Validator, [])
#test creation from node
sc.Identification = idents
sc.Validator = validators
node = sc.mkStateNode()
sc2 = statecontainers.AbstractContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=node)
verifyEqual(sc, sc2)
