messages.py 46.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
# -*- coding: utf-8 -*-

"""
This module provides the API message formats used in F-Interop.

The idea is to be able to have an
- organized and centralized way of dealing with the big amount of messages formats used in the platform;
- to be able to import (or just copy/paste) these messages formats from any component in the F-Interop platform,
- re-use this also for the integration testing;
- to have version control the messages e.g. messages_testcase_start API v1 and API v2;
- to have a direct way of exporting this as doc.

Usage:
------
15
>>> from messages import * # doctest: +SKIP
16
>>> m = MsgTestCaseSkip()
17
>>> m
18
MsgTestCaseSkip(_type = testcoordination.testcase.skip, _api_version = 0.1.26, testcase_id = TD_COAP_CORE_02_v01, )
19 20
>>> m.routing_key
'control.testcoordination'
21 22
>>> m.message_id # doctest: +SKIP
'802012eb-24e3-45c4-9dcc-dc293c584f63'
23 24
>>> m.testcase_id
'TD_COAP_CORE_02_v01'
25

26 27 28
# also we can modify some of the fields (rewrite the default ones)
>>> m = MsgTestCaseSkip(testcase_id = 'TD_COAP_CORE_03_v01')
>>> m
29
MsgTestCaseSkip(_type = testcoordination.testcase.skip, _api_version = 0.1.26, testcase_id = TD_COAP_CORE_03_v01, )
30 31
>>> m.testcase_id
'TD_COAP_CORE_03_v01'
32

33 34
# and even export the message in json format (for example for sending the message though the amqp event bus)
>>> m.to_json()
35
'{"_type": "testcoordination.testcase.skip", "_api_version": "0.1.26", "testcase_id": "TD_COAP_CORE_03_v01"}'
Federico Sismondi's avatar
Federico Sismondi committed
36

37
# We can use the Message class to import json into Message objects:
Federico Sismondi's avatar
Federico Sismondi committed
38 39
>>> m=MsgTestSuiteStart()
>>> m.to_json()
40
'{"_type": "testcoordination.testsuite.start", "_api_version": "0.1.26"}'
Federico Sismondi's avatar
Federico Sismondi committed
41 42 43
>>> json_message = m.to_json()
>>> obj=Message.from_json(json_message)
>>> type(obj)
44
<class 'messages.MsgTestSuiteStart'>
45 46 47 48 49 50 51 52

# We can use the library for generating error responses to the requests:
# the request:
>>> m = MsgSniffingStart()
>>>
# the error reply (note that we pass the message of the request to build the reply):
>>> err = MsgErrorReply(m)
>>> err
53 54
MsgErrorReply(_type = sniffing.start, _api_version = 0.1.26, ok = False, error_code = Some error code TBD,
error_message = Some error message TBD, )
55 56 57 58 59 60 61 62 63
>>> m.reply_to
'control.sniffing.service.reply'
>>> err.routing_key
'control.sniffing.service.reply'

>>> m.correlation_id # doctest: +SKIP
'360b0f67-4455-43e3-a00f-eca91f2e84da'
>>> err.correlation_id # doctest: +SKIP
'360b0f67-4455-43e3-a00f-eca91f2e84da'
Federico Sismondi's avatar
Federico Sismondi committed
64

65 66 67
"""

from collections import OrderedDict
68
import time
69 70 71
import json
import uuid

72
API_VERSION = '0.1.26'
73

74 75 76 77 78 79 80 81 82 83 84

# TODO use metaclasses instead?

class NonCompliantMessageFormatError(Exception):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


85 86
class Message:
    def __init__(self, **kwargs):
87 88 89
        global API_VERSION

        # hard copy the message template
90
        self._msg_data = {k: v for k, v in self._msg_data_template.items()}
91

92 93
        # init properties
        self._properties = dict(
94 95
                content_type='application/json',
                message_id=str(uuid.uuid4()),
96
                timestamp=int(time.time())
97 98
        )

99 100 101 102 103
        try:
            if self.routing_key.endswith('.service'):
                self._properties['reply_to'] = '%s.%s' % (self.routing_key, 'reply')
                self._properties['correlation_id'] = self._properties['message_id']
        except AttributeError:
104
            pass
105

106
        # rewrite default data fields with the passed args
107 108 109 110 111 112 113 114 115
        self._msg_data.update(kwargs)

        # add API's version
        self._msg_data['_api_version'] = API_VERSION

        # add values as objects attributes
        for key in self._msg_data:
            setattr(self, key, self._msg_data[key])

116 117 118 119
        # add props as objects attributes
        for key in self._properties:
            setattr(self, key, self._properties[key])

120 121
    def to_dict(self):
        resp = {}
122 123
        # let's use sorted so API returns items inside always in the same order
        for field in sorted(self._msg_data.keys()):
124
            resp[field] = getattr(self, field)
125

126
        return OrderedDict(sorted(resp.items(), key=lambda t: t[0]))  # sorted by key
127 128 129 130

    def to_json(self):
        return json.dumps(self.to_dict())

131
    def get_properties(self):
132 133 134 135
        resp = OrderedDict()
        for field in self._properties:
            resp[field] = getattr(self, field)
        return resp
136

137
    def __str__(self):
138 139 140 141 142 143 144 145
        s = ' - ' * 20 + '\n'
        s += 'Message routing key: %s' % self.routing_key
        s += '\n -  -  - \n'
        s += 'Message properties: %s' % json.dumps(self.get_properties(), indent=4, )
        s += '\n -  -  - \n'
        s += 'Message body: %s' % json.dumps(self.to_dict(), indent=4, )
        s += '\n' + ' - ' * 20
        return s
146

147 148 149 150 151
    def update_properties(self, **kwargs):
        for key, value in kwargs.items():
            if key in self._properties:
                setattr(self, key, value)

152 153
    @classmethod
    def from_json(cls, body):
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
        """
        :param body: json string or string encoded as utf-8
        :return:  Message object generated from the body
        :raises NonCompliantMessageFormatError: If the message cannot be build from the provided json
        """

        if type(body) is str:
            message_dict = json.loads(body)
        # Note: pika re-encodes json.dumps strings as utf-8 for some reason, the following line undoes this
        elif type(body) is bytes:
            message_dict = json.loads(body.decode('utf-8'))
        else:
            raise NonCompliantMessageFormatError('Not a Json')

        # check fist if it's a response
        if 'ok' in message_dict:
            # cannot build a complete reply message just from the json representation
171
            return
172 173 174 175 176

        message_type = message_dict['_type']
        if message_type in message_types_dict:
            return message_types_dict[message_type](**message_dict)
        else:
177
            raise NonCompliantMessageFormatError('Cannot load json message: %s' % str(body))
178

179
    def __repr__(self):
180
        ret = '%s(' % self.__class__.__name__
181
        for key, value in self.to_dict().items():
182
            ret += '%s = %s, ' % (key, value)
183 184 185
        ret += ')'
        return ret

186

187 188 189 190 191
class MsgReply(Message):
    """
    Auxiliary class which creates replies messages with fields based on the request.
    Routing key, corr_id and _type are generated based on the request message
    """
192

193 194 195 196 197 198 199 200
    def __init__(self, request_message, **kwargs):
        assert request_message

        self.routing_key = request_message.routing_key + ".reply"

        # if not data template, then let's build one for a reply
        # (possible when creating a MsgReply directly and not by using subclass)
        if not hasattr(self, '_msg_data_template'):
201 202
            self._msg_data_template = {
                '_type': request_message._type,
203
                'ok':    True,
204 205
            }

206
        super(MsgReply, self).__init__(**kwargs)
207

208
        # overwrite correlation id template and attribute
209 210 211 212 213 214 215 216 217 218 219 220
        self._properties['correlation_id'] = request_message.correlation_id
        self.correlation_id = request_message.correlation_id


class MsgErrorReply(MsgReply):
    """
    F-Interop conventions:
        - if event is a service request then the routing keys is control.someFunctionality.service
        also, its reply will be control.someFunctionality.service.reply
        - reply.correlation_id = request.correlation_id

    """
221

222 223
    def __init__(self, request_message, **kwargs):
        assert request_message
224
        # msg_data_template doesnt include _type cause this class is generic, we can only get this at init from request
225 226
        # so, let's copy the _type from request and let the MsgReply handle the rest of the fields
        self._msg_data_template['_type'] = request_message._type
227
        super(MsgErrorReply, self).__init__(request_message, **kwargs)
228 229

    _msg_data_template = {
230
        'ok':            False,
231
        'error_message': 'Some error message TBD',
232
        'error_code':    'Some error code TBD'
233 234
    }

235 236

# # # # # # AGENT MESSAGES # # # # # #
Federico Sismondi's avatar
Federico Sismondi committed
237 238 239 240 241 242 243 244

class MsgAgentTunStart(Message):
    """
    Message for triggering start IP tun interface in OS where the agent is running
    """
    routing_key = 'control.tun.toAgent.agent_TT'

    _msg_data_template = {
245 246 247 248
        '_type':              'tun.start',
        'name':               'agent_TT',
        'ipv6_prefix':        'bbbb',
        'ipv6_host':          ':3',
Federico Sismondi's avatar
Federico Sismondi committed
249
        'ipv6_no_forwarding': False,
250 251 252
        'ipv4_host':          None,
        'ipv4_network':       None,
        'ipv4_netmask':       None,
Federico Sismondi's avatar
Federico Sismondi committed
253 254 255 256 257 258 259 260 261 262
    }


class MsgAgentTunStarted(Message):
    """
    Message for indicating that agent tun has been started
    """
    routing_key = 'control.tun.from.agent_TT'

    _msg_data_template = {
263 264 265 266 267 268 269
        '_type':              'tun.started',
        'name':               'agent_TT',
        'ipv6_prefix':        'bbbb',
        'ipv6_host':          ':3',
        'ipv4_host':          None,
        'ipv4_network':       None,
        'ipv4_netmask':       None,
Federico Sismondi's avatar
Federico Sismondi committed
270 271 272
        'ipv6_no_forwarding': False,
    }

273

Federico Sismondi's avatar
Federico Sismondi committed
274 275 276 277 278 279 280 281
'''
TODO add packet.sniffed.raw
ROUTING_KEY: data.tun.fromAgent.coap_server_agent
 - - -
PROPS: {"delivery_mode": 2, "content_type": "application/json", "headers": {}, "priority": 0, "content_encoding": "utf-8"}
 - - -
BODY {"timestamp": "1488586183.45", "_type": "packet.sniffed.raw", "interface_name": "tun0", "data": [96, 0, 0, 0, 0, 36, 0, 1, 254, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 255, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 58, 0, 5, 2, 0, 0, 1, 0, 143, 0, 112, 7, 0, 0, 0, 1, 4, 0, 0, 0, 255, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]}
'''
282

283 284

# # # # # # SESSION MESSAGES # # # # # #
285

286
class MsgTestingToolTerminate(Message):
287 288 289 290 291
    """
    Testing Tool MUST-implement API endpoint
    GUI, (or Orchestrator?) -> Testing Tool
    Testing tool should stop all it's processes gracefully.
    """
292
    routing_key = 'control.session'
293 294

    _msg_data_template = {
295 296 297 298 299 300 301 302 303 304 305 306 307 308
        '_type': 'testingtool.terminate',
    }


class MsgTestingToolReady(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    Used to indicate to the GUI that testing is ready to start the test suite
    """
    routing_key = 'control.session'

    _msg_data_template = {
309
        '_type':   'testingtool.ready',
310 311 312 313 314 315 316 317 318 319 320 321 322
        "message": "Testing tool ready to start test suite."
    }


class MsgTestingToolComponentReady(Message):
    """
    Testing Tools'internal call.
    Component x -> Test Coordinator
    Testing Tool SHOULD implement (design recommendation)
    """
    routing_key = 'control.session'

    _msg_data_template = {
323
        '_type':     'testingtool.component.ready',
324
        'component': 'SomeComponent',
325
        "message":   "Component ready to start test suite."
326 327 328 329 330 331 332 333 334 335 336 337
    }


class MsgTestingToolComponentShutdown(Message):
    """
    Testing Tools'internal call.
    Component x -> Test Coordinator
    Testing Tool SHOULD implement (design recommendation)
    """
    routing_key = 'control.session'

    _msg_data_template = {
338
        '_type':     'testingtool.component.shutdown',
339
        'component': 'SomeComponent',
340
        "message":   "Component is shutting down. Bye!"
341 342
    }

343

344
# # # # # # TEST COORDINATION MESSAGES # # # # # #
345 346 347 348 349 350 351

class MsgTestSuiteStart(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI -> Testing Tool
    """

352
    routing_key = "control.testcoordination"
353 354 355 356 357 358

    _msg_data_template = {
        '_type': "testcoordination.testsuite.start",
    }


359 360 361 362 363 364 365 366 367 368 369 370
class MsgTestSuiteFinish(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI -> Testing Tool
    """

    routing_key = "control.testcoordination"

    _msg_data_template = {
        '_type': "testcoordination.testsuite.finish",
    }

371

372 373 374 375 376 377 378 379 380 381 382 383
class MsgTestCaseReady(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    Used to indicate to the GUI (or automated-iut) which is the next test case to be executed.
    This message is normally followed by a MsgTestCaseStart (from GUI-> Testing Tool)
    """

    routing_key = 'control.testcoordination'

    _msg_data_template = {
384 385 386
        "_type":        "testcoordination.testcase.ready",
        "message":      "Next test case to be executed is TD_COAP_CORE_01_v01",
        "testcase_id":  "TD_COAP_CORE_01_v01",
387
        "testcase_ref": "http://doc.f-interop.eu/tests/TD_COAP_CORE_01_v01",
388 389
        "objective":    "Perform GET transaction(CON mode)",
        "state":        None
390 391 392
    }


393 394 395 396 397 398
class MsgTestCaseStart(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI -> Testing Tool
    Message used for indicating the testing tool to start the test case (the one previously selected)
    """
399
    routing_key = "control.testcoordination"
400 401 402 403 404 405

    _msg_data_template = {
        '_type': "testcoordination.testcase.start",
    }


406 407 408 409 410 411 412 413 414
class MsgTestCaseConfiguration(Message):
    """
    Testing Tool MUST-implement notification
    Testing Tool -> GUI
    Messages used to indicate GUI which configuration to use.
    """
    routing_key = "control.testcoordination"

    _msg_data_template = {
415
        "_type":            "testcoordination.testcase.configuration",
416
        "configuration_id": "COAP_CFG_01_v01",
417 418 419
        "node":             "coap_server",
        "testcase_id":      "TBD",
        "testcase_ref":     "TBD",
420
        "message":
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
                            ["CoAP servers running service at [bbbb::2]:5683",
                             "CoAP servers are requested to offer the following resources",
                             ["/test", "Default test resource", "Should not exceed 64bytes"],
                             ["/seg1/seg2/seg3", "Long path ressource", "Should not exceed 64bytes"],
                             ["/query", "Ressource accepting query parameters", "Should not exceed 64bytes"],
                             ["/separate",
                              "Ressource which cannot be served immediately and which cannot be acknowledged in a piggy-backed way",
                              "Should not exceed 64bytes"],
                             ["/large", "Large resource (>1024 bytes)", "shall not exceed 2048bytes"],
                             ["/large_update", "Large resource that can be updated using PUT method (>1024 bytes)",
                              "shall not exceed 2048bytes"],
                             ["/large_create", "Large resource that can be  created using POST method (>1024 bytes)",
                              "shall not exceed 2048bytes"],
                             ["/obs", "Observable resource which changes every 5 seconds",
                              "shall not exceed 2048bytes"],
                             ["/.well-known/core", "CoRE Link Format", "may require usage of Block options"]
                             ]
438 439 440
    }


441 442 443 444 445 446 447
class MsgTestCaseStop(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI -> Testing Tool
    Message used for indicating the testing tool to stop the test case (the one running)
    """

448
    routing_key = 'control.testcoordination'
449 450 451 452 453 454 455 456 457 458 459 460

    _msg_data_template = {
        '_type': 'testcoordination.testcase.stop',
    }


class MsgTestCaseRestart(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI -> Testing Tool
    """

461
    routing_key = 'control.testcoordination'
462 463 464 465 466

    _msg_data_template = {
        '_type': 'testcoordination.testcase.restart',
    }

467 468 469 470 471 472 473 474 475 476 477 478

class MsgStepExecute(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    Used to indicate to the GUI (or automated-iut) which is the step to be executed by the user (or automated-IUT)
    """

    routing_key = 'control.testcoordination'

    _msg_data_template = {
479 480 481 482 483
        "_type":               "testcoordination.step.execute",
        "message":             "Next test step to be executed is TD_COAP_CORE_01_v01_step_01",
        "step_id":             "TD_COAP_CORE_01_v01_step_01",
        "step_type":           "stimuli",
        "step_info":           [
484 485 486 487
            "Client is requested to send a GET request with",
            "Type = 0(CON)",
            "Code = 1(GET)"
        ],
488 489
        "step_state":          "executing",
        "node":                "coap_client",
490
        "node_execution_mode": "user_assisted",
491 492
        "testcase_id":         "TBD",
        "testcase_ref":        "TBD"
493 494
    }

495 496 497 498 499 500 501

class MsgStimuliExecuted(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI (or automated-IUT)-> Testing Tool
    """

502
    routing_key = 'control.testcoordination'
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517

    _msg_data_template = {
        '_type': 'testcoordination.step.stimuli.executed',
    }


class MsgCheckResponse(Message):
    """
    Testing Tools'internal call.
    In the context of IUT to IUT test execution, this message is used for indicating that the previously executed
    messages (stimuli message and its reply) CHECK or comply to what is described in the Test Description.
    Testing tools' coordinator -> Testing Tool's analyzer (TAT)
    Not used in CoAP testing Tool (analysis of traces is done post mortem)
    """

518 519
    routing_key = 'control.testcoordination'

520
    _msg_data_template = {
521
        '_type':           'testcoordination.step.check.response',
522
        'partial_verdict': 'pass',
523
        'description':     'TAT says: step complies (checks) with specification'
524 525 526 527 528 529 530 531 532 533 534
    }


class MsgVerifyResponse(Message):
    """
    Testing Tool MUST-implement API endpoint
    Message provided by user declaring if the IUT VERIFY the step previously executed as described in the Test
    Description.
    GUI (or automated-IUT)-> Testing Tool
    """

535
    routing_key = 'control.testcoordination'
536 537

    _msg_data_template = {
538
        '_type':           'testcoordination.step.verify.response',
539
        'verify_response': True,
540
        'response_type':   'bool'
541 542
    }

543

544 545 546 547 548 549 550
class MsgTestCaseFinish(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI (or automated-IUT)-> Testing Tool
    Not used in CoAP Testing Tool (test coordinator deduces it automatically by using the testcase's step sequence)
    """

551
    routing_key = 'control.testcoordination'
552 553 554 555 556

    _msg_data_template = {
        '_type': 'testcoordination.testcase.finish',
    }

557

558 559 560 561 562 563 564 565 566 567 568
class MsgTestCaseFinished(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    This message is followed by a verdict
    """

    routing_key = 'control.testcoordination'

    _msg_data_template = {
569 570
        '_type':        'testcoordination.testcase.finished',
        'testcase_id':  'TD_COAP_CORE_01',
571
        "testcase_ref": "TBD",
572
        'message':      'Testcase finished'
573 574
    }

575

576 577 578 579
class MsgTestCaseSkip(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI (or automated-IUT)-> Testing Tool
580 581

    - testcase_id (optional) : if not provided then current tc is skipped
582 583
    """

584
    routing_key = 'control.testcoordination'
585 586

    _msg_data_template = {
587
        '_type':       'testcoordination.testcase.skip',
588 589 590 591 592 593 594 595 596 597
        'testcase_id': 'TD_COAP_CORE_02_v01',
    }


class MsgTestCaseSelect(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI (or automated-IUT)-> Testing Tool
    """

598
    routing_key = 'control.testcoordination'
599 600

    _msg_data_template = {
601
        '_type':       'testcoordination.testcase.select',
602 603 604
        'testcase_id': 'TD_COAP_CORE_03_v01',
    }

605

606 607 608 609 610 611
class MsgTestSuiteAbort(Message):
    """
    Testing Tool MUST-implement API endpoint
    GUI (or automated-IUT)-> Testing Tool
    """

612
    routing_key = 'control.testcoordination'
613 614 615 616 617

    _msg_data_template = {
        '_type': 'testcoordination.testsuite.abort',
    }

618

619 620
class MsgTestSuiteGetStatus(Message):
    """
621
    Testing Tool SHOULD-implement API endpoint
622 623 624 625 626 627
    Describes current state of the test suite.
    Format for the response not standardised.

    GUI -> Testing Tool
    """

628
    routing_key = 'control.testcoordination.service'
629 630 631 632 633

    _msg_data_template = {
        '_type': 'testcoordination.testsuite.getstatus',
    }

634

635
class MsgTestSuiteGetStatusReply(MsgReply):
636 637 638 639 640 641 642 643 644 645 646 647
    """
    Testing Tool SHOULD-implement API endpoint
    Describes current state of the test suite.
    Format for the response not standardised.

    Testing Tool -> GUI

    """

    routing_key = 'control.testcoordination.service.reply'

    _msg_data_template = {
648 649 650 651
        '_type':          'testcoordination.testsuite.getstatus.reply',
        'ok':             True,
        "started":        True,
        "testcase_id":    "TD_COAP_CORE_01_v01",
652
        "testcase_state": "executing",
653
        "step_id":        "TD_COAP_CORE_01_v01_step_01"
654

655 656
    }

657

658 659
class MsgTestSuiteGetTestCases(Message):
    """
660
    Testing Tool's MUST-implement API endpoint
661 662 663 664
    GUI -> Testing Tool
    GUI MUST implement
    """

665
    routing_key = 'control.testcoordination.service'
666 667 668 669 670

    _msg_data_template = {
        '_type': 'testcoordination.testsuite.gettestcases',
    }

671 672 673 674 675 676 677 678 679 680

class MsgTestSuiteGetTestCasesReply(MsgReply):
    """
    Testing Tool's MUST-implement API endpoint
    Testing Tool -> GUI
    """

    routing_key = 'control.testcoordination.service.reply'

    _msg_data_template = {
681 682
        '_type':   'testcoordination.testsuite.gettestcases.reply',
        'ok':      True,
683 684
        "tc_list": [
            {
685
                "testcase_id":  "TD_COAP_CORE_01_v01",
686
                "testcase_ref": "http://doc.f-interop.eu/tests/TD_COAP_CORE_01_v01",
687 688
                "objective":    "Perform GET transaction(CON mode)",
                "state":        None
689 690
            },
            {
691
                "testcase_id":  "TD_COAP_CORE_02_v01",
692
                "testcase_ref": "http://doc.f-interop.eu/tests/TD_COAP_CORE_02_v01",
693 694
                "objective":    "Perform DELETE transaction (CON mode)",
                "state":        None
695 696
            },
            {
697
                "testcase_id":  "TD_COAP_CORE_03_v01",
698
                "testcase_ref": "http://doc.f-interop.eu/tests/TD_COAP_CORE_03_v01",
699 700
                "objective":    "Perform PUT transaction (CON mode)",
                "state":        None
701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
            }
        ]
    }


class MsgTestCaseVerdict(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    Used to indicate to the GUI (or automated-iut) which is the final verdict of the testcase.
    """

    routing_key = 'control.testcoordination'

    _msg_data_template = {
717 718 719
        "_type":            "testcoordination.testcase.verdict",
        "verdict":          "pass",
        "description":      "No interoperability error was detected,",
720 721 722 723 724 725 726 727 728 729 730
        "partial_verdicts": [
            ["TD_COAP_CORE_01_v01_step_02", None, "CHECK postponed", ""],
            ["TD_COAP_CORE_01_v01_step_03", None, "CHECK postponed", ""],
            ["TD_COAP_CORE_01_v01_step_04", "pass",
             "VERIFY step: User informed that the information was displayed correclty on his/her IUT", ""],
            ["CHECK_1_post_mortem_analysis", "pass",
             "<Frame   3: [bbbb::1 -> bbbb::2] CoAP [CON 43211] GET /test> Match: CoAP(type=0, code=1)"],
            ["CHECK_2_post_mortem_analysis", "pass",
             "<Frame   4: [bbbb::2 -> bbbb::1] CoAP [ACK 43211] 2.05 Content > Match: CoAP(code=69, mid=0xa8cb, tok=b'', pl=Not(b''))"],
            ["CHECK_3_post_mortem_analysis", "pass",
             "<Frame   4: [bbbb::2 -> bbbb::1] CoAP [ACK 43211] 2.05 Content > Match: CoAP(opt=Opt(CoAPOptionContentFormat()))"]],
731 732 733
        "testcase_id":      "TD_COAP_CORE_01_v01",
        "testcase_ref":     "http://f-interop.paris.inria.fr/tests/TD_COAP_CORE_01_v01",
        "objective":        "Perform GET transaction(CON mode)", "state": "finished"
734 735 736 737 738 739 740 741 742 743 744 745 746 747
    }


class MsgTestSuiteReport(Message):
    """
    Testing Tool MUST-implement notification.
    Testing Tool -> GUI

    Used to indicate to the GUI (or automated-iut) the final results of the test session.
    """

    routing_key = 'control.testcoordination'

    _msg_data_template = {
748
        "_type": "testcoordination.testsuite.report",
749
        "TD_COAP_CORE_01_v01":
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
                 {
                     "verdict":     "pass",
                     "description": "No interoperability error was detected,",
                     "partial_verdicts":
                                    [
                                        ["TD_COAP_CORE_01_v01_step_02", None, "CHECK postponed", ""],
                                        ["TD_COAP_CORE_01_v01_step_03", None, "CHECK postponed", ""],
                                        ["TD_COAP_CORE_01_v01_step_04", "pass",
                                         "VERIFY step: User informed that the information was displayed correclty on his/her IUT",
                                         ""],
                                        ["CHECK_1_post_mortem_analysis", "pass",
                                         "<Frame   3: [bbbb::1 -> bbbb::2] CoAP [CON 43211] GET /test> Match: CoAP(type=0, code=1)"],
                                        ["CHECK_2_post_mortem_analysis", "pass",
                                         "<Frame   4: [bbbb::2 -> bbbb::1] CoAP [ACK 43211] 2.05 Content > Match: CoAP(code=69, mid=0xa8cb, tok=b'', pl=Not(b''))"],
                                        [
                                            "CHECK_3_post_mortem_analysis",
                                            "pass",
                                            "<Frame   4: [bbbb::2 -> bbbb::1] CoAP [ACK 43211] 2.05 Content > Match: CoAP(opt=Opt(CoAPOptionContentFormat()))"]
                                    ]
                 },
770 771

        "TD_COAP_CORE_02_v01":
772 773 774 775 776 777 778 779 780 781 782 783 784
                 {
                     "verdict":          "pass",
                     "description":      "No interoperability error was detected,",
                     "partial_verdicts": [
                         ["TD_COAP_CORE_02_v01_step_02", None, "CHECK postponed", ""],
                         ["TD_COAP_CORE_02_v01_step_03", None, "CHECK postponed", ""],
                         ["TD_COAP_CORE_02_v01_step_04", "pass",
                          "VERIFY step: User informed that the information was displayed correclty on his/her IUT",
                          ""], ["CHECK_1_post_mortem_analysis", "pass",
                                "<Frame   3: [bbbb::1 -> bbbb::2] CoAP [CON 43213] DELETE /test> Match: CoAP(type=0, code=4)"],
                         ["CHECK_2_post_mortem_analysis", "pass",
                          "<Frame   4: [bbbb::2 -> bbbb::1] CoAP [ACK 43213] 2.02 Deleted > Match: CoAP(code=66, mid=0xa8cd, tok=b'')"]]
                 }
785 786
    }

787

788
# # # # # # SNIFFING SERVICES REQUEST MESSAGES # # # # # #
789 790 791 792 793 794 795 796

class MsgSniffingStart(Message):
    """
    Testing Tools'internal call.
    Coordinator -> Sniffer
    Testing Tool SHOULD implement (design recommendation)
    """

797
    routing_key = 'control.sniffing.service'
798 799

    _msg_data_template = {
800 801 802
        '_type':        'sniffing.start',
        'capture_id':   'TD_COAP_CORE_01',
        'filter_if':    'tun0',
803 804 805
        'filter_proto': 'udp port 5683'
    }

806

807 808 809 810 811 812 813 814 815 816 817
class MsgSniffingStartReply(MsgReply):
    """
    Testing Tools'internal call.
    Sniffer -> Coordinator
    Testing Tool SHOULD implement (design recommendation)
    """

    routing_key = 'control.sniffing.service.reply'

    _msg_data_template = {
        '_type': 'sniffing.start.reply',
818
        'ok':    True
819 820
    }

821

822 823 824 825 826 827 828
class MsgSniffingStop(Message):
    """
    Testing Tools'internal call.
    Coordinator -> Sniffer
    Testing Tool SHOULD implement (design recommendation)
    """

829
    routing_key = 'control.sniffing.service'
830 831 832 833 834

    _msg_data_template = {
        '_type': 'sniffing.stop',
    }

835

836 837 838 839 840 841 842 843 844 845 846
class MsgSniffingStoptReply(MsgReply):
    """
    Testing Tools'internal call.
    Sniffer -> Coordinator
    Testing Tool SHOULD implement (design recommendation)
    """

    routing_key = 'control.sniffing.service.reply'

    _msg_data_template = {
        '_type': 'sniffing.stop.reply',
847
        'ok':    True
848 849
    }

850

851 852 853 854 855 856 857
class MsgSniffingGetCapture(Message):
    """
    Testing Tools'internal call.
    Coordinator -> Sniffer
    Testing Tool SHOULD implement (design recommendation)
    """

858
    routing_key = 'control.sniffing.service'
859 860

    _msg_data_template = {
861
        '_type':      'sniffing.getcapture',
862 863 864 865
        "capture_id": "TD_COAP_CORE_01",

    }

866

867
class MsgSniffingGetCaptureReply(MsgReply):
868 869 870
    routing_key = 'control.sniffing.service.reply'

    _msg_data_template = {
871 872
        '_type':    'sniffing.getcapture.reply',
        'ok':       True,
873 874
        'file_enc': 'pcap_base64',
        'filename': 'TD_COAP_CORE_01.pcap',
875
        'value':    '1MOyoQIABAAAAAAAAAAAAMgAAAAAAAAA',  # empty PCAP
876 877
    }

878

879 880 881 882 883 884 885
class MsgSniffingGetCaptureLast(Message):
    """
    Testing Tools'internal call.
    Coordinator -> Sniffer
    Testing Tool SHOULD implement (design recommendation)
    """

886
    routing_key = 'control.sniffing.service'
887 888 889 890

    _msg_data_template = {
        '_type': 'sniffing.getlastcapture',
    }
891

892

893
class MsgSniffingGetCaptureLastReply(MsgReply):
894 895 896
    routing_key = 'control.sniffing.service.reply'

    _msg_data_template = {
897 898
        '_type':    'sniffing.getlastcapture.reply',
        'ok':       True,
899 900
        'file_enc': 'pcap_base64',
        'filename': 'TD_COAP_CORE_01.pcap',
901
        'value':    '1MOyoQIABAAAAAAAAAAAAMgAAAAAAAAA',  # empty PCAP
902 903
    }

904

905
# # # # # # ANALYSIS MESSAGES # # # # # #
906

907
class MsgInteropTestCaseAnalyze(Message):
908 909
    """
    Testing Tools'internal call.
910 911 912 913 914 915

    Method to launch an analysis from a pcap file or a token if the pcap file has already been provided.
    # TODO token support

    The method need a token or a pcap_file but doesn't allow someone to provide both.

916
    Coordinator -> Analyzer
917

918 919 920 921 922
    Testing Tool SHOULD implement (design recommendation)
    """

    PCAP_empty_base64 = '1MOyoQIABAAAAAAAAAAAAMgAAAAAAAAA'

923
    routing_key = 'control.analysis.service'
924 925

    _msg_data_template = {
926 927
        '_type':        'analysis.interop.testcase.analyze',
        "testcase_id":  "TD_COAP_CORE_01",
928
        "testcase_ref": "http://doc.f-interop.eu/tests/TD_COAP_CORE_01_v01",
929 930 931
        "file_enc":     "pcap_base64",
        "filename":     "TD_COAP_CORE_01.pcap",
        "value":        PCAP_empty_base64,
932 933
    }

934

935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
class MsgInteropTestCaseAnalyzeReply(MsgReply):
    """
    Testing Tools'internal call.
    Analyzer -> Coordinator
    Testing Tool SHOULD implement (design recommendation)

    The recommended structure for the partial_verdicts field is a list of partial verdicts with the following
    requirements:
     - each one of those elements of the list correspond to one CHECK or VERIFY steps of the test description
     - first value of the list MUST be a "pass", "fail", "inconclusive" or eventually "error" partial verdict (string)
     - the second value MUST be a string with a description of partial verdict (intended for the user)
     - more values elements MAY be added to the list

    """

    _msg_data_template = {
951 952 953 954 955 956 957
        '_type':            'analysis.interop.testcase.analyze.reply',
        'ok':               True,
        'verdict':          'pass',
        'analysis_type':    'postmortem',
        'description':      'The test purpose has been verified without any fault detected',
        'review_frames':    [],
        'token':            '0lzzb_Bx30u8Gu-xkt1DFE1GmB4',
958 959 960
        "partial_verdicts": [
            [
                "pass", "<Frame   1: [127.0.0.1 -> 127.0.0.1] CoAP [CON 43521] GET /test> Match: CoAP(type=0, code=1)"
961
            ],
962 963 964 965 966

            [
                "pass",
                "<Frame   2: [127.0.0.1 -> 127.0.0.1] CoAP [ACK 43521] 2.05 Content > Match: CoAP(code=69, mid=0xaa01, \
                tok=b'b\\xda', pl=Not(b''))"
967
            ],
968 969 970 971
            [
                "pass",
                "<Frame   2: [127.0.0.1 -> 127.0.0.1] CoAP [ACK 43521] 2.05 Content > \
                Match: CoAP(opt=Opt(CoAPOptionContentFormat()))"
972
            ]
973
        ],
974 975
        "testcase_id":      "TD_COAP_CORE_01",
        "testcase_ref":     "http://doc.f-interop.eu/tests/TD_COAP_CORE_01_v01",
976 977
    }

978

979
# # # # # # DISSECTION MESSAGES # # # # # #
980

981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
class MsgDissectionDissectCapture(Message):
    """
    Testing Tools'internal call.
    Coordinator -> Dissector
    and
    Analyzer -> Dissector
    Testing Tool SHOULD implement (design recommendation)
    """

    PCAP_COAP_GET_OVER_TUN_INTERFACE_base64 = "1MOyoQIABAAAAAAAAAAAAMgAAABlAAAAqgl9WK8aBgA7AAAAOwAAAGADPxUAExFAu7s" \
                                              "AAAAAAAAAAAAAAAAAAbu7AAAAAAAAAAAAAAAAAALXvBYzABNZUEABcGO0dGVzdMECqg" \
                                              "l9WMcaBgCQAAAAkAAAAGAAAAAAaDr//oAAAAAAAAAAAAAAAAAAA7u7AAAAAAAAAAAAA" \
                                              "AAAAAGJAAcTAAAAALu7AAAAAAAAAAAAAAAAAAK7uwAAAAAAAAAAAAAAAAACBAgAAAAA" \
                                              "AABgAz8VABMRQLu7AAAAAAAAAAAAAAAAAAG7uwAAAAAAAAAAAAAAAAAC17wWMwATWVB" \
                                              "AAXBjtHRlc6oJfVjSGgYAOwAAADsAAABgAz8VABMRP7u7AAAAAAAAAAAAAAAAAAG7uw" \
                                              "AAAAAAAAAAAAAAAAAC17wWMwATWVBAAXBjtHRlc3TBAg=="

998
    routing_key = 'control.dissection.service'
999 1000

    _msg_data_template = {
1001 1002 1003 1004
        '_type':              'dissection.dissectcapture',
        "file_enc":           "pcap_base64",
        "filename":           "TD_COAP_CORE_01.pcap",
        "value":              PCAP_COAP_GET_OVER_TUN_INTERFACE_base64,
1005 1006 1007 1008
        "protocol_selection": 'coap',
    }


1009 1010 1011 1012 1013 1014 1015 1016 1017
class MsgDissectionDissectCaptureReply(MsgReply):
    """
    Testing Tools'internal call.
    Dissector -> Coordinator
    and
    Dissector -> Analyzer
    Testing Tool SHOULD implement (design recommendation)
    """

1018
    _frames_example = [
1019
        {
1020 1021 1022 1023
            "_type":          "frame",
            "id":             1,
            "timestamp":      1464858393.547275,
            "error":          None,
1024 1025
            "protocol_stack": [
                {
1026 1027 1028
                    "_type":          "protocol",
                    "_protocol":      "NullLoopback",
                    "AddressFamily":  "2",
1029 1030 1031
                    "ProtocolFamily": "0"
                },
                {
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
                    "_type":              "protocol",
                    "_protocol":          "IPv4",
                    "Version":            "4",
                    "HeaderLength":       "5",
                    "TypeOfService":      "0x00",
                    "TotalLength":        "41",
                    "Identification":     "0x71ac",
                    "Reserved":           "0",
                    "DontFragment":       "0",
                    "MoreFragments":      "0",
                    "FragmentOffset":     "0",
                    "TimeToLive":         "64",
                    "Protocol":           "17",
                    "HeaderChecksum":     "0x0000",
                    "SourceAddress":      "127.0.0.1",
1047
                    "DestinationAddress": "127.0.0.1",
1048
                    "Options":            "b''"
1049
                }
1050 1051 1052
            ]
        },
    ]
1053 1054

    _msg_data_template = {
1055 1056 1057
        '_type':  'dissection.dissectcapture.reply',
        'ok':     True,
        'token':  '0lzzb_Bx30u8Gu-xkt1DFE1GmB4',
1058
        'frames': _frames_example
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
    }


class MsgDissectionAutoDissect(Message):
    """
    Testing Tool's MUST-implement.
    Testing Tool -> GUI
    GUI MUST display this info during execution:
     - interop session
     - conformance session
     - performance ?
     - privacy?

    """
1073
    routing_key = 'control.dissection'
1074

1075
    _frames_example = MsgDissectionDissectCaptureReply._frames_example
1076 1077

    _msg_data_template = {
1078 1079 1080 1081
        '_type':        'dissection.autotriggered',
        'token':        '0lzzb_Bx30u8Gu-xkt1DFE1GmB4',
        'frames':       _frames_example,
        "testcase_id":  "TBD",
1082
        "testcase_ref": "TBD"
1083 1084
    }

1085

1086
# # # # # # PRIVACY TESTING TOOL MESSAGES # # # # # #
Luca Lamorte's avatar
Luca Lamorte committed
1087 1088 1089 1090 1091


class MsgPrivacyAnalyze(Message):
    """
        Testing Tool's MUST-implement.
1092
        Analyze PCAP File for Privacy checks.
Luca Lamorte's avatar
Luca Lamorte committed
1093 1094 1095 1096
    """
    routing_key = 'control.privacy.service'

    # TODO: This message should be update with a valuable privacy example
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
    # PCAP_COAP_GET_OVER_TUN_INTERFACE_base64 = "1MOyoQIABAAAAAAAAAAAAMgAAABlAAAAqgl9WK8aBgA7AAAAOwAAAGADPxUAExFAu7s" \
    #                                           "AAAAAAAAAAAAAAAAAAbu7AAAAAAAAAAAAAAAAAALXvBYzABNZUEABcGO0dGVzdMECqg" \
    #                                           "l9WMcaBgCQAAAAkAAAAGAAAAAAaDr//oAAAAAAAAAAAAAAAAAAA7u7AAAAAAAAAAAAA" \
    #                                           "AAAAAGJAAcTAAAAALu7AAAAAAAAAAAAAAAAAAK7uwAAAAAAAAAAAAAAAAACBAgAAAAA" \
    #                                           "AABgAz8VABMRQLu7AAAAAAAAAAAAAAAAAAG7uwAAAAAAAAAAAAAAAAAC17wWMwATWVB" \
    #                                           "AAXBjtHRlc6oJfVjSGgYAOwAAADsAAABgAz8VABMRP7u7AAAAAAAAAAAAAAAAAAG7uw" \
    #                                           "AAAAAAAAAAAAAAAAAC17wWMwATWVBAAXBjtHRlc3TBAg=="

    PCAP_COAP_GET_OVER_TUN_INTERFACE_base64 = "Cg0NCpgAAABNPCsaAQAAAP//////////AwAuAE1hYyBPUyBYIDEwLjEyLjQsIGJ1aWxk" \
                                              "IDE2RTE5NSAoRGFyd2luIDE2LjUuMCkAAAQAPQBEdW1wY2FwIChXaXJlc2hhcmspIDIu" \
                                              "Mi4wICh2Mi4yLjAtMC1nNTM2OGM1MCBmcm9tIG1hc3Rlci0yLjIpAAAAAAAAAJgAAAAB" \
                                              "AAAAXAAAAAAAAAAAAAQAAgAEAHR1bjAJAAEABgAAAAwALgBNYWMgT1MgWCAxMC4xMi40" \
                                              "LCBidWlsZCAxNkUxOTUgKERhcndpbiAxNi41LjApAAAAAAAAXAAAAAUAAABsAAAAAAAA" \
                                              "AIdOBQCsif6eAQAcAENvdW50ZXJzIHByb3ZpZGVkIGJ5IGR1bXBjYXACAAgAh04FAN2Z" \
                                              "ip4DAAgAh04FAKGJ/p4EAAgAAAAAAAAAAAAFAAgAAAAAAAAAAAAAAAAAbAAAAA=="
Luca Lamorte's avatar
Luca Lamorte committed
1112 1113

    _msg_data_template = {
1114 1115
        "_type":    "privacy.analyze",
        "value":    PCAP_COAP_GET_OVER_TUN_INTERFACE_base64,
Luca Lamorte's avatar
Luca Lamorte committed
1116 1117 1118 1119 1120
        "file_enc": "pcap_base64",
        "filename": "TD_PRIVACY_DEMO_01.pcap",
    }


1121 1122 1123 1124 1125 1126
class MsgPrivacyAnalyzeReply(MsgReply):
    """
            Testing Tool's MUST-implement.
            Response of Analyze request from GUI
    """

1127 1128 1129 1130 1131
    _privacy_empty_report = {'type':           'Anomalies Report',
                             'protocols':      ['coap'],
                             'conversation':   [],
                             'status':         'none',
                             'testing_tool':   'Privacy Testing Tool',
1132
                             'byte_exchanged': 0,
1133 1134 1135 1136
                             'timestamp':      1493798811.53124,
                             'is_final':       True,
                             'packets':        {},
                             'version':        '0.0.1'}
1137 1138

    _msg_data_template = {
1139 1140 1141
        '_type':       'privacy.analyze.reply',
        'ok':          True,
        'verdict':     _privacy_empty_report,
1142 1143 1144
        'testcase_id': 'TBD',
    }

1145

Luca Lamorte's avatar
Luca Lamorte committed
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
class MsgPrivacyGetConfiguration(Message):
    """
           Read Privacy configuration.
           GUI MUST display this info during setup
    """
    routing_key = 'control.privacy.service'

    _msg_data_template = {
        "_type": "privacy.configuration.get",
    }

1157

1158 1159 1160 1161 1162 1163 1164 1165
class MsgPrivacyGetConfigurationReply(MsgReply):
    """
           Read Privacy configuration.
           GUI MUST display this info during setup
    """
    routing_key = 'control.privacy.service.reply'

    _msg_data_template = {
1166 1167 1168
        "_type":         "privacy.configuration.get.reply",
        "configuration": {},
        "ok":            True,
1169 1170
    }

Luca Lamorte's avatar
Luca Lamorte committed
1171 1172 1173 1174 1175 1176 1177 1178

class MsgPrivacySetConfiguration(Message):
    """
        Write Privacy configuration.
        GUI MUST display this info during setup
    """
    routing_key = 'control.privacy.service'

1179
    CFG_EXAMPLE = dict()
Luca Lamorte's avatar
Luca Lamorte committed
1180 1181

    _msg_data_template = {
1182
        "_type":         "privacy.configuration.set",
Luca Lamorte's avatar
Luca Lamorte committed
1183 1184 1185 1186
        "configuration": CFG_EXAMPLE,
    }


1187 1188 1189 1190 1191 1192 1193 1194 1195
class MsgPrivacySetConfigurationReply(MsgReply):
    """
        Write Privacy configuration.
        GUI MUST display this info during setup
    """
    routing_key = 'control.privacy.service.reply'

    _msg_data_template = {
        "_type": "privacy.configuration.set.reply",
1196
        "ok":    True,
1197 1198 1199
    }


Luca Lamorte's avatar
Luca Lamorte committed
1200 1201 1202
class MsgPrivacyGetStatus(Message):
    """
    Testing Tool's MUST-implement.
1203
    GUI -> Testing Tool
Luca Lamorte's avatar
Luca Lamorte committed
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
    GUI MUST display this info during execution:
     - privacy?

    """
    routing_key = 'control.privacy.service'

    _msg_data_template = {
        "_type": "privacy.getstatus",
    }


1215
class MsgPrivacyGetStatusReply(MsgReply):
Luca Lamorte's avatar
Luca Lamorte committed
1216 1217
    """
    Testing Tool's MUST-implement.
1218
    GUI -> Testing Tool
Luca Lamorte's avatar
Luca Lamorte committed
1219 1220 1221 1222 1223 1224
    GUI MUST display this info during execution:
     - privacy?

    """

    REPORT_EXAMPLE = dict()
1225
    routing_key = 'control.privacy.service.reply'
Luca Lamorte's avatar
Luca Lamorte committed
1226 1227

    _msg_data_template = {
1228
        "_type":   "privacy.getstatus.reply",
Luca Lamorte's avatar
Luca Lamorte committed
1229
        "verdict": REPORT_EXAMPLE,
1230 1231
        "status":  "TBD",
        "ok":      True,
Luca Lamorte's avatar
Luca Lamorte committed
1232 1233 1234

    }

1235

1236 1237 1238
class MsgPrivacyIssue(Message):
    """
        Testing Tool's MUST-implement.
Federico Sismondi's avatar
Federico Sismondi committed
1239
        Testing tools -> GUI
1240 1241
        GUI MUST display this info during execution:
         - privacy
Luca Lamorte's avatar
Luca Lamorte committed
1242

1243
        """
1244
    routing_key = 'control.privacy'
Luca Lamorte's avatar
Luca Lamorte committed
1245 1246

    _msg_data_template = {
1247 1248
        "_type":   "privacy.issue",
        "verdict": json.dumps(MsgPrivacyAnalyzeReply._privacy_empty_report),
Luca Lamorte's avatar
Luca Lamorte committed
1249 1250
    }

1251 1252

message_types_dict = {
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
    "tun.start":                                     MsgAgentTunStart,  # TestingTool -> Agent
    "tun.started":                                   MsgAgentTunStarted,  # Agent -> TestingTool
    "testcoordination.testsuite.start":              MsgTestSuiteStart,  # GUI -> TestingTool
    "testcoordination.testsuite.finish":             MsgTestSuiteFinish,  # GUI -> TestingTool
    "testcoordination.testcase.ready":               MsgTestCaseReady,  # TestingTool -> GUI
    "testcoordination.testcase.start":               MsgTestCaseStart,  # GUI -> TestingTool
    "testcoordination.step.execute":                 MsgStepExecute,  # TestingTool -> GUI
    "testcoordination.testcase.configuration":       MsgTestCaseConfiguration,  # TestingTool -> GUI
    "testcoordination.testcase.stop":                MsgTestCaseStop,  # GUI -> TestingTool
    "testcoordination.testcase.restart":             MsgTestCaseRestart,  # GUI -> TestingTool
    "testcoordination.step.stimuli.executed":        MsgStimuliExecuted,  # GUI -> TestingTool
    "testcoordination.step.check.response":          MsgCheckResponse,  # GUI -> TestingTool
    "testcoordination.step.verify.response":         MsgVerifyResponse,  # GUI -> TestingTool
    "testcoordination.testcase.skip":                MsgTestCaseSkip,  # GUI -> TestingTool
    "testcoordination.testcase.select":              MsgTestCaseSelect,  # GUI -> TestingTool
    "testcoordination.testcase.finish":              MsgTestCaseFinish,  # GUI -> TestingTool
    "testcoordination.testcase.finished":            MsgTestCaseFinished,  # TestingTool -> GUI
    "testcoordination.testcase.verdict":             MsgTestCaseVerdict,  # TestingTool -> GUI
    "testcoordination.testsuite.abort":              MsgTestSuiteAbort,  # GUI -> TestingTool
    "testcoordination.testsuite.getstatus":          MsgTestSuiteGetStatus,  # GUI -> TestingTool
    "testcoordination.testsuite.getstatus.reply":    MsgTestSuiteGetStatusReply,  # TestingTool -> GUI (reply)
    "testcoordination.testsuite.gettestcases":       MsgTestSuiteGetTestCases,  # GUI -> TestingTool
1275
    "testcoordination.testsuite.gettestcases.reply": MsgTestSuiteGetTestCasesReply,  # TestingTool -> GUI (reply)
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
    "testcoordination.testsuite.report":             MsgTestSuiteReport,  # TestingTool -> GUI
    "sniffing.start":                                MsgSniffingStart,  # Testing Tool Internal
    "sniffing.stop":                                 MsgSniffingStop,  # Testing Tool Internal
    "sniffing.getcapture":                           MsgSniffingGetCapture,  # Testing Tool Internal
    "sniffing.getlastcapture":                       MsgSniffingGetCaptureLast,  # Testing Tool Internal
    "analysis.interop.testcase.analyze":             MsgInteropTestCaseAnalyze,  # Testing Tool Internal
    "analysis.interop.testcase.analyze.reply":       MsgInteropTestCaseAnalyzeReply,  # Testing Tool Internal
    "dissection.dissectcapture":                     MsgDissectionDissectCapture,  # Testing Tool Internal
    "dissection.dissectcapture.reply":               MsgDissectionDissectCaptureReply,  # Testing Tool Internal
    "dissection.autotriggered":                      MsgDissectionAutoDissect,  # TestingTool -> GUI
    "testingtool.component.ready":                   MsgTestingToolComponentReady,  # Testing Tool internal
    "testingtool.component.shutdown":                MsgTestingToolComponentShutdown,  # Testing Tool internal
    "testingtool.ready":                             MsgTestingToolReady,  # GUI Testing Tool -> GUI
    "testingtool.terminate":                         MsgTestingToolTerminate,  # GUI (or Orchestrator?) -> TestingTool
Luca Lamorte's avatar
Luca Lamorte committed
1290
    # PRIVACY TESTING TOOL -> Reference: Luca Lamorte (UL)
1291 1292 1293 1294 1295 1296 1297 1298 1299
    "privacy.analyze":                               MsgPrivacyAnalyze,  # TestingTool internal
    "privacy.analyze.reply":                         MsgPrivacyAnalyzeReply,  # TestingTool internal (reply)
    "privacy.getstatus":                             MsgPrivacyGetStatus,  # GUI -> TestingTool
    "privacy.getstatus.reply":                       MsgPrivacyGetStatusReply,  # GUI -> TestingTool (reply)
    "privacy.issue":                                 MsgPrivacyIssue,  # TestingTool -> GUI,
    "privacy.configuration.get":                     MsgPrivacyGetConfiguration,  # TestingTool -> GUI,
    "privacy.configuration.get.reply":               MsgPrivacyGetConfigurationReply,  # TestingTool -> GUI (reply),
    "privacy.configuration.set":                     MsgPrivacySetConfiguration,  # GUI -> TestingTool,
    "privacy.configuration.set.reply":               MsgPrivacySetConfigurationReply,  # GUI -> TestingTool (reply),
1300 1301 1302 1303 1304 1305 1306 1307 1308
}

if __name__ == '__main__':
    # m1=MsgTestCaseStart()
    # print(json.dumps(m1.to_dict()))
    # print(m1.routing_key)
    # print(m1.to_json())
    # print(m1)

1309
    m1 = MsgTestCaseStart(hola='verano')
1310
    m2 = MsgTestCaseStart()
1311
    # m2 = MsgTestCaseStart(routing_key = 'lolo', hola='verano')
1312 1313 1314

    print(m1)
    print(m1._msg_data)
1315 1316 1317 1318 1319
    j = m1.to_json()
    print(j)
    deco = Message.from_json(j)
    print(repr(deco))

1320 1321 1322
    print(m2)
    print(m2.to_json())
    print(m2._msg_data)
1323

1324
    m2 = MsgTestSuiteStart()
1325 1326 1327 1328 1329
    print(json.dumps(m2.to_dict()))
    print(m2.routing_key)
    print(m2.to_json())
    print(m2)

1330
    m3 = MsgTestCaseStop()
1331 1332 1333 1334
    print(json.dumps(m3.to_dict()))
    print(m3.routing_key)
    print(m3.to_json())
    print(m3)
1335 1336

    j = json.dumps({
1337 1338 1339
        '_type':              'dissection.dissectcapture',
        "file_enc":           "pcap_base64",
        "filename":           "TD_COAP_CORE_01.pcap",
1340 1341 1342 1343 1344 1345
        "protocol_selection": 'coap',
    })
    r = Message.from_json(j)
    print(type(r))
    print(r)

1346 1347 1348
    m = MsgTestCaseSkip()
    print(m)
    print(
1349 1350 1351
            m.routing_key,
            m.message_id,
            m.testcase_id,
1352
    )
1353
    m = MsgTestCaseSkip(testcase_id='TD_COAP_CORE_03_v01')
1354 1355 1356 1357
    print(
            m.testcase_id,
            m.to_json(),
    )
1358
    m = MsgTestSuiteStart()
1359