Python Report.failed方法代碼示例

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
 def testFailureInSubReportEntry(self):
     entry_name = 'sub report'
     report = Report(self.report_name)
     subreport = Report(entry_name)
     report.add(entry_name, subreport)
     subreport.failed(self.failure_reason)
     self.assertEqual(report.get_status(), Report.FAILED)
     self.assertEqual(report.get('reason'), self.failure_reason)

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
 def testSuccess(self):
     '''
     .. note:: success was deprecated, and it only calls passed()
     '''
     report = Report(self.report_name)
     report.failed(self.failure_reason)
     self.assertEqual(report.get_status(), Report.FAILED)
     report.success()
     self.assertEqual(report.get_status(), Report.PASSED)

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
    def transmit(self, payload):
        '''
        Transmit single payload, and receive response, if expected.
        The actual implementation of the send/receive should be in
        ``_send_to_target`` and ``_receive_from_target``.

        :type payload: str
        :param payload: payload to send
        :rtype: str
        :return: the response (if received)
        '''
        response = None
        trans_report_name = 'transmission_0x%04x' % self.transmission_count
        trans_report = Report(trans_report_name)
        self.transmission_report = trans_report
        self.report.add(trans_report_name, trans_report)
        try:
            trans_report.add('request (hex)', payload.encode('hex'))
            trans_report.add('request (raw)', '%s' % payload)
            trans_report.add('request length', len(payload))
            trans_report.add('request time', time.time())

            request = payload.encode('hex')
            request = request if len(request) < 100 else (request[:100] + ' ...')
            self.logger.info('request(%d): %s' % (len(payload), request))
            self._send_to_target(payload)
            trans_report.success()

            if self.expect_response:
                try:
                    response = self._receive_from_target()
                    trans_report.add('response time', time.time())
                    trans_report.add('response (hex)', response.encode('hex'))
                    trans_report.add('response (raw)', '%s' % response)
                    trans_report.add('response length', len(response))
                    printed_response = response.encode('hex')
                    printed_response = printed_response if len(printed_response) < 100 else (printed_response[:100] + ' ...')
                    self.logger.info('response(%d): %s' % (len(response), printed_response))
                except Exception as ex2:
                    trans_report.failed('failed to receive response: %s' % ex2)
                    trans_report.add('traceback', traceback.format_exc())
                    self.logger.error('target.transmit - failure in receive (exception: %s)' % ex2)
                    self.logger.error(traceback.format_exc())
                    self.receive_failure = True
            else:
                response = ''
        except Exception as ex1:
            trans_report.failed('failed to send payload: %s' % ex1)
            trans_report.add('traceback', traceback.format_exc())
            self.logger.error('target.transmit - failure in send (exception: %s)' % ex1)
            self.logger.error(traceback.format_exc())
            self.send_failure = True
        self.transmission_count += 1
        return response

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
 def testClearRestoresStatusToDefaultPassed(self):
     report = Report(self.report_name)
     self.assertEqual(report.get_status(), Report.PASSED)
     report.failed('mock failure')
     report.clear()
     self.assertEqual(report.get_status(), Report.PASSED)

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
 def testPassed(self):
     report = Report(self.report_name)
     report.failed(self.failure_reason)
     self.assertEqual(report.get_status(), Report.FAILED)
     report.passed()
     self.assertEqual(report.get_status(), Report.PASSED)

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
 def testFailedWithoutReason(self):
     report = Report(self.report_name)
     self.assertEqual(report.get_status(), Report.PASSED)
     report.failed()
     self.assertEqual(report.get_status(), Report.FAILED)
     self.assertEqual(report.get('reason'), None)

# 需要導入模塊: from kitty.data.report import Report [as 別名]
# 或者: from kitty.data.report.Report import failed [as 別名]
class BaseTarget(KittyObject):
    '''
    BaseTarget contains the common logic and behaviour of all target.
    '''

    def __init__(self, name='BaseTarget', logger=None):
        super(BaseTarget, self).__init__(name, logger)
        self.controller = None
        self.monitors = []
        self.report = Report(name)
        self.test_number = None
        self.fuzzer = None

    def set_fuzzer(self, fuzzer):
        self.fuzzer = fuzzer

    def set_controller(self, controller):
        '''
        Set a controller
        '''
        self.controller = controller

    def add_monitor(self, monitor):
        '''
        Add a monitor
        '''
        self.monitors.append(monitor)

    def setup(self):
        '''
        Make sure the target is ready for fuzzing, including monitors and
        controllers
        '''
        if self.controller:
            self.controller.setup()
        for monitor in self.monitors:
            monitor.setup()

    def teardown(self):
        '''
        Clean up the target once all tests are completed
        '''
        if self.controller:
            self.controller.teardown()
        for monitor in self.monitors:
            monitor.teardown()

    def pre_test(self, test_num):
        '''
        Called when a test is started
        '''
        self.test_number = test_num
        self.report = Report(self.name)
        if self.controller:
            self.controller.pre_test(test_number=self.test_number)
        for monitor in self.monitors:
            monitor.pre_test(test_number=self.test_number)
        self.report.add('test_number', test_num)
        self.report.add('state', 'STARTED')

    def post_test(self, test_num):
        '''
        Called when test is completed, a report should be prepared now
        '''
        if self.controller:
            self.controller.post_test()
        for monitor in self.monitors:
            monitor.post_test()
        self.report.add('state', 'COMPLETED')
        if self.controller:
            controller_report = self.controller.get_report()
            self.report.add('controller', controller_report)
        for monitor in self.monitors:
            current_report = monitor.get_report()
            self.report.add(current_report.get('name'), current_report)
        if self.report.is_failed():
            self.report.failed()
        if self.report.is_failed():
            self.logger.warning('!!! Test %d failed !!!' % (test_num))

    def get_report(self):
        return self.report

    def get_session_data(self):
        '''
        Session related data dictionary to be used by data model.

        :return: dictionary (str, bytes)
        '''
        return {}