Python TestCase.assertIsNotNone方法代码示例

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
 def _apply(self,
            put: unittest.TestCase,
            value: Any,
            message_builder: MessageBuilder):
     msg = message_builder.apply('')
     put.assertIsNotNone(value, msg)
     put.assertIsInstance(value, self.expected_type, msg)
     self.value_assertion.apply(put, value, message_builder)

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
 def _assertions(self,
                 unittest_case: unittest.TestCase,
                 actual: FailureInfo):
     unittest_case.assertIsNotNone(actual,
                                   'Failure info should be present')
     unittest_case.assertIsInstance(actual, PhaseFailureInfo,
                                    'The failure is expected to be a {}'.format(str(PhaseFailureInfo)))
     assert isinstance(actual, PhaseFailureInfo)
     self.assertions_(unittest_case,
                      actual.phase_step.simple,
                      actual.failure_details)

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
def create_app(test: unittest.TestCase) -> App:
    """
    Create an :py:class:`App <arobito.controlinterface.ControllerBackend.App>` instance

    :param test: The currently running unit test case
    :return: An instance of App
    """

    app = App()
    test.assertIsNotNone(app)
    test.assertIsInstance(app, App)
    return app

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
def check_result(put: unittest.TestCase,
                 environment: InstructionEnvironmentForPostSdsStep,
                 expected_matcher_result: Optional[ValueAssertion[str]],
                 actual_result: Optional[ErrorMessageResolver]):
    if expected_matcher_result is None:
        put.assertIsNone(actual_result,
                         'result from main')
    else:
        put.assertIsNotNone(actual_result,
                            'result from main')
        err_msg_env = ErrorMessageResolvingEnvironment(environment.home_and_sds,
                                                       environment.symbols)
        err_msg = actual_result.resolve(err_msg_env)
        expected_matcher_result.apply_with_message(put, err_msg,
                                                   'error result of main')

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
 def _assertions(self,
                 unittest_case: unittest.TestCase,
                 return_value: Failure):
     if self._status is PartialExeResultStatus.PASS:
         unittest_case.assertIsNone(return_value,
                                    'Return value must be None (representing success)')
     else:
         unittest_case.assertIsNotNone(return_value,
                                       'Return value must not be None (representing failure)')
         unittest_case.assertEqual(self._status,
                                   return_value.status,
                                   'Status')
         self._line.apply_with_message(unittest_case,
                                       return_value.source_location,
                                       'source location path')
         unittest_case.assertIsNotNone(return_value.failure_details,
                                       'failure_details must be present')
         self._failure_details.apply_with_message(unittest_case,
                                                  return_value.failure_details,
                                                  'failure_details')

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
def get_valid_key(test: unittest.TestCase, app: App=None) -> str:
    """
    Produce a valid key by using the arobito default credentials against the :py:meth:`App.auth
    <arobito.controlinterface.ControllerBackend.App.auth>` method

    :param test: The currently running unit test case
    :return: A valid key
    """
    if app is None:
        app = create_app(test)

    request_valid = dict(username='arobito', password='arobito')
    response = app.auth(request_valid)
    test.assertIsNotNone(response, 'Response is none')
    test.assertIsInstance(response, dict, 'Response is not a dict')
    test.assertIn('auth', response, 'Response does not contain an auth element')
    auth = response['auth']
    test.assertIn('key', auth, 'Auth object does not contain a key')
    key = auth['key']
    test.assertIsNotNone(key, 'Key is None')
    test.assertIsInstance(key, str, 'Key is not a String')
    test.assertRegex(key, '^[a-zA-Z0-9]{64}$', 'Key looks not like expected')
    return key

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
def assert_velocity_properties(test_case: unittest.TestCase, data: SeismicData,
                               velocity_prop: VelocityProperties) -> None:
    test_case.assertIsNotNone(data)
    test_case.assertIsNotNone(data.velocity_properties)
    test_case.assertIsNotNone(velocity_prop)

    for prop in dir(data.velocity_properties):
        if "_" in prop[0:1] or prop == "count" or prop == "index":
            continue

        if getattr(data.velocity_properties, prop) is None:
            test_case.assertIsNone(getattr(velocity_prop, prop))
        else:
            try:
                float(getattr(data.velocity_properties, prop))
                test_case.assertAlmostEqual(getattr(data.velocity_properties, prop),
                                            getattr(velocity_prop, prop), 3)
            except ValueError:
                test_case.assertEqual(getattr(data.velocity_properties, prop),
                                      getattr(velocity_prop, prop))

# 需要导入模块: from unittest import TestCase [as 别名]
# 或者: from unittest.TestCase import assertIsNotNone [as 别名]
    def assertIsNotNone(self, obj, msg=None):
        if hasattr(TestCase, 'assertIsNotNone'):
            return TestCase.assertIsNotNone(self, obj, msg)

        return self.assertTrue(obj is not None)