def test_verifyFailIfDiscoveryRedirects(self): realm = 'http://*.example.com/' return_to = 'http://www.example.com/foo' def vrfy(disco_url): raise trustroot.RealmVerificationRedirected( disco_url, "http://redirected.invalid") with LogCapture() as logbook: self.assertFalse(trustroot.verifyReturnTo(realm, return_to, _vrfy=vrfy)) logbook.check(('openid.server.trustroot', 'INFO', StringComparison('Attempting to verify .*')))
def test_get_file_dict_allow_raw_file(self): log_printer = ListLogPrinter() with LogCapture() as capture: file_dict = get_file_dict([self.unreadable_path], log_printer, True) self.assertNotEqual(file_dict, {}) self.assertEqual(file_dict[self.unreadable_path], None) capture.check( ('root', 'DEBUG', StringComparison(r'(?s).*Files that will be ' r'checked(?s).*')) )
def testBadResponse(self): self.consumer.return_messages = [ Message(self.endpoint.preferredNamespace()) ] with LogCapture() as logbook: self.assertIsNone( self.consumer._negotiateAssociation(self.endpoint)) logbook.check( ('openid.consumer.consumer', 'ERROR', StringComparison('Server error when requesting an association .*') ))
def match_regex(self, regex_pattern, name=None, level=None): matches = [] for r in self.records: if name and r.name != name: continue if level and r.levelname != level: continue if r.getMessage() != StringComparison(regex_pattern): continue matches.append(r) return matches
def test_exeption(self): mltprsm = MultiprocessingManager() mltprsm.append(exeption_raising_func, {'arg': 0}) exp = IOError(StringComparison( "The function 'exeption_raising_func' of " "'slidelint.tests.modules.linter.test_modules' module" " raised an Exception:\n" "integer division or modulo by zero\n" ".*")) with ShouldRaise(exp): [i for i in mltprsm]
def test_verifyFailWithDiscoveryCalled(self): realm = 'http://*.example.com/' return_to = 'http://www.example.com/foo' def vrfy(disco_url): self.assertEqual(disco_url, 'http://www.example.com/') return ['http://something-else.invalid/'] with LogCapture() as logbook: self.assertFalse(trustroot.verifyReturnTo(realm, return_to, _vrfy=vrfy)) logbook.check(('openid.server.trustroot', 'INFO', StringComparison('Failed to validate return_to .*')))
def test_untrimmed(self): """Should not trim""" req = '{"jsonrpc": "2.0", "method": "go", "params": {"foo": "%s"}}' % ( "foo" * 100, ) with LogCapture() as capture: DummyClient().log_request(req, trim_log_values=False) capture.check(( "jsonrpcclient.client.request", "INFO", StringComparison(r".*" + "foo" * 100 + ".*"), ))
def test_bad_args(self): mltprsm = MultiprocessingManager() mltprsm.append(exeption_raising_func, {'x': 0}) exp = IOError(StringComparison( "The function 'exeption_raising_func' of " "'slidelint.tests.modules.linter.test_modules' module" " raised an Exception:\n" "exeption_raising_func\(\) got an unexpected keyword" " argument 'x'\n" ".*")) with ShouldRaise(exp): [i for i in mltprsm]
def testEmptySessionType(self): msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'new-assoc-type') # not set: msg.setArg(OPENID_NS, 'session_type', None) self.consumer.return_messages = [msg] with LogCapture() as logbook: self.assertIsNone(self.consumer._negotiateAssociation(self.endpoint)) logbook.check( ('openid.consumer.consumer', 'ERROR', StringComparison('Server error when requesting an association .*')))
def test_register_alerting_configured(self, mock_import, mock_add): manager = self._init_tool(['check', 'config_path', '-v']) manager.settings['alerting'] = { 'monitoring1': { 'module': 'monitoring1', 'class': 'TestMonitoringPlugin', 'config': { 'k1': 'v1', 'k2': 'v2' } }, 'dummy': { 'module': 'test', 'class': 'DummyAlertingPlugin' } } with LogCapture() as log: manager._register_alerting() mock_import.assert_has_calls([ mock.call('ipamanager.alerting.monitoring1'), mock.call('ipamanager.alerting.test') ], any_order=True) plugin1 = mock_import( 'ipamanager.alerting.monitoring1').TestMonitoringPlugin plugin1.assert_called_with({'k1': 'v1', 'k2': 'v2'}) plugin2 = mock_import('ipamanager.alerting.test').DummyAlertingPlugin plugin2.assert_called_with({}) instances = {p.return_value for p in (plugin1, plugin2)} mock_add.assert_has_calls([mock.call(i) for i in instances], any_order=True) assert set(manager.alerting_plugins) == instances log.check_present( ('FreeIPAManager', 'DEBUG', 'Registering 2 alerting plugins'), ('FreeIPAManager', 'DEBUG', StringComparison("Registered plugin .*TestMonitoringPlugin.*")), ('FreeIPAManager', 'DEBUG', StringComparison("Registered plugin .*DummyAlertingPlugin.*")), order_matters=False)
def test_sane_repr(self): self.assertEqual(sane_repr(None, 1024), str("None")) self.assertEqual(sane_repr(10562, 1024), str("10562")) self.assertEqual(sane_repr('short', 1024), StringComparison("u?'short'")) self.assertEqual(sane_repr(ValueError('A message'), 1024), StringComparison(r"ValueError\(u?'A message',?\)")) # Letter "g" on the end is present if unicode prefix is absent self.assertEqual(sane_repr('something longer', 10), StringComparison(r"u?'something? \[truncated\]...")) self.assertEqual( sane_repr('ěščřž'.encode('utf-8'), 1024), StringComparison( "b?'\\\\xc4\\\\x9b\\\\xc5\\\\xa1\\\\xc4\\\\x8d\\\\xc5\\\\x99\\\\xc5\\\\xbe'" )) if six.PY2: # pragma: no cover self.assertEqual(sane_repr('ěščřž', 1024), str("u'\\u011b\\u0161\\u010d\\u0159\\u017e'")) else: # pragma: no cover self.assertEqual(sane_repr('ěščřž', 1024), str("'ěščřž'"))
def test_model_pedantic(self): stan_file = os.path.join(DATAFILES_PATH, 'bernoulli_pedantic.stan') with LogCapture(level=logging.WARNING) as log: logging.getLogger() model = CmdStanModel(model_name='bern', stan_file=stan_file) model.compile(force=True, stanc_options={'warn-pedantic': True}) log.check_present( ( 'cmdstanpy', 'WARNING', StringComparison(r'(?s).*The parameter theta has no priors.*'), ) )
def test_entity_mention_tokenization(): comm = read_test_comm() assert validate_communication(comm) assert validate_entity_mention_ids(comm) comm.entityMentionSetList[0].mentionList[0].tokens.tokenizationId = ( concrete.UUID(uuidString='BAD_TOKENIZATION_UUID')) with LogCapture() as log_capture: assert not validate_entity_mention_tokenization_ids(comm) log_capture.check( ('root', 'ERROR', StringComparison(r'.*invalid tokenizationId.*BAD_TOKENIZATION_UUID')))
def test_get_file_dict_forbid_raw_file(self): log_printer = ListLogPrinter() with LogCapture() as capture: file_dict = get_file_dict([self.unreadable_path], log_printer, False) self.assertEqual(file_dict, {}) capture.check(('root', 'WARNING', "Failed to read file '{}'. It seems to contain " 'non-unicode characters. Leaving it out.'.format( self.unreadable_path)), ('root', 'DEBUG', StringComparison(r'(?s).*Files that will be ' r'checked(?s).*')))
def test_connection(self): """ Run a unit test on the connection method Note: a valid configuration file is required. Specify the path to the file in the environment variable POSTGRES_CFG. """ db = self.get_test_database() valid_cfg = db.get_configuration() # test valid config self.assertFalse(db.is_connected()) connection = db.get_connection() self.assertIsNotNone(connection) self.assertTrue(db.is_connected()) db.close_connection() self.assertFalse(db.is_connected()) # test erroneous connection config one argument at a time with LogCapture() as log_cap: for idx in list(range(len(PostgresDb.KEYS))): if idx == port_idx: # TODO figure out way to test connection timeout, skip for now continue db[PostgresDb.KEYS[idx]] = values[idx] connection = db.get_connection() self.assertIsNone(connection) db[PostgresDb.KEYS[idx]] = valid_cfg[PostgresDb.KEYS[idx]] auth_failed_regex = r'.*password authentication failed for user.*' log_cap.check( ('root', 'WARNING', StringComparison(auth_failed_regex)), ('root', 'WARNING', StringComparison(auth_failed_regex)), ('root', 'WARNING', StringComparison(r'.*does not exist.*')), ('root', 'WARNING', StringComparison(r'could not translate host name.*')))
def testNotAllowed(self): """ Test the case where an unsupported-type response specifies a preferred (assoc_type, session_type) combination that is not allowed by the consumer's SessionNegotiator. """ allowed_types = [] negotiator = association.SessionNegotiator(allowed_types) self.consumer.negotiator = negotiator msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'not-allowed') msg.setArg(OPENID_NS, 'session_type', 'not-allowed') self.consumer.return_messages = [msg] with LogCapture() as logbook: self.assertIsNone(self.consumer._negotiateAssociation(self.endpoint)) unsupported_msg = StringComparison('Server sent unsupported session/association type: .*') logbook.check(('openid.consumer.consumer', 'WARNING', StringComparison('Unsupported association type .*')), ('openid.consumer.consumer', 'WARNING', unsupported_msg))
def test_entity_mention_ids(): comm = read_test_comm() assert validate_communication(comm) assert validate_entity_mention_ids(comm) comm.entitySetList[0].entityList[0].mentionIdList[0] = concrete.UUID( uuidString='BAD_ENTITY_MENTION_UUID') with LogCapture() as log_capture: assert not validate_entity_mention_ids(comm) log_capture.check( ('root', 'ERROR', StringComparison( r'.*invalid entityMentionId.*BAD_ENTITY_MENTION_UUID')))
def assertEmailNotSent(self, function, reason): with LogCapture(emails.logger.name) as log_capture: function(self.course_run) assert len(mail.outbox) == 0 if reason: log_capture.check(( emails.logger.name, 'INFO', StringComparison( 'Not sending notification email for template course_metadata/email/.* because ' + reason), ))
def testUnsupportedWithRetryAndFail(self): """ Test the case where an unsupported-typ response triggers a retry, but the retry fails and None is returned instead. """ msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'HMAC-SHA1') msg.setArg(OPENID_NS, 'session_type', 'DH-SHA1') self.consumer.return_messages = [ msg, Message(self.endpoint.preferredNamespace()) ] with LogCapture() as logbook: self.assertIsNone( self.consumer._negotiateAssociation(self.endpoint)) refused_msg = StringComparison('Server %s refused its .*' % self.endpoint.server_url) logbook.check(('openid.consumer.consumer', 'ERROR', StringComparison('Unsupported association type .*')), ('openid.consumer.consumer', 'ERROR', refused_msg))
def testUnsupportedWithRetry(self): msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'HMAC-SHA1') msg.setArg(OPENID_NS, 'session_type', 'DH-SHA1') assoc = association.Association('handle', b'secret', 'issued', 10000, 'HMAC-SHA1') self.consumer.return_messages = [msg, assoc] with LogCapture() as logbook: self.assertIsNone(self.consumer._negotiateAssociation(self.endpoint)) logbook.check( ('openid.consumer.consumer', 'ERROR', StringComparison('Server error when requesting an association .*')))
def testBadResponse(self): """ Test the case where the response to an associate request is a server error or is otherwise undecipherable. """ self.consumer.return_messages = [ Message(self.endpoint.preferredNamespace()) ] with LogCapture() as logbook: self.assertEqual( self.consumer._negotiateAssociation(self.endpoint), None) logbook.check( ('openid.consumer.consumer', 'ERROR', StringComparison('Server error when requesting an association .*') ))
def test_fetch_from_properties_lemma_not_found(self): self.page_mock.title_str = "RE:Aas" self.page_mock.text = """{{REDaten |BAND=I,1 |WP=Aal_wp_link |WS=Aal_ws_link }} text. {{REAutor|OFF}}""" task = SCANTask(None, self.logger) task.re_page = RePage(self.page_mock) with LogCapture() as log_catcher: task._process_from_article_list() log_catcher.check(mock.ANY, ("Test", "ERROR", StringComparison("No available Lemma in Registers for issue I,1 " ".* Reason is:.*")))
def test_handle_pass(self, mock_response): """ Test using mock response from setup, using threshold it will clear""" mock_response.return_value = self.test_response with LogCapture(self.LOGGER_NAME) as log: call_command('populate_sdn_fallback_data_and_metadata', '--threshold=0.0001') log.check(( self.LOGGER_NAME, 'INFO', StringComparison( r'(?s)SDNFallback: IMPORT SUCCESS: Imported SDN CSV\. Metadata id.*' ) ), (self.LOGGER_NAME, 'INFO', "SDNFallback: DOWNLOAD SUCCESS: Successfully downloaded the SDN CSV." ))
def testEmptySessionType(self): """ Test the case where the session type (session_type) returned in an unsupported-type response is absent. """ msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'new-assoc-type') # not set: msg.setArg(OPENID_NS, 'session_type', None) self.consumer.return_messages = [msg] with LogCapture() as logbook: self.assertIsNone(self.consumer._negotiateAssociation(self.endpoint)) no_fallback_msg = 'Server responded with unsupported association session but did not supply a fallback.' logbook.check(('openid.consumer.consumer', 'WARNING', StringComparison('Unsupported association type .*')), ('openid.consumer.consumer', 'WARNING', no_fallback_msg))
def testUnsupportedWithRetry(self): """ Test the case where an unsupported-type response triggers a retry to get an association with the new preferred type. """ msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'HMAC-SHA1') msg.setArg(OPENID_NS, 'session_type', 'DH-SHA1') assoc = association.Association('handle', b'secret', 'issued', 10000, 'HMAC-SHA1') self.consumer.return_messages = [msg, assoc] with LogCapture() as logbook: self.assertEqual(self.consumer._negotiateAssociation(self.endpoint), assoc) logbook.check(('openid.consumer.consumer', 'WARNING', StringComparison('Unsupported association type .*')))
def testNotAllowed(self): allowed_types = [] negotiator = association.SessionNegotiator(allowed_types) self.consumer.negotiator = negotiator msg = Message(self.endpoint.preferredNamespace()) msg.setArg(OPENID_NS, 'error', 'Unsupported type') msg.setArg(OPENID_NS, 'error_code', 'unsupported-type') msg.setArg(OPENID_NS, 'assoc_type', 'not-allowed') msg.setArg(OPENID_NS, 'session_type', 'not-allowed') self.consumer.return_messages = [msg] with LogCapture() as logbook: self.assertIsNone(self.consumer._negotiateAssociation(self.endpoint)) logbook.check( ('openid.consumer.consumer', 'ERROR', StringComparison('Server error when requesting an association .*')))
def test_read_csv(): """ Tests whether the monkey patching of ('pandas.io.parsers', 'read_csv') works """ test_code = cleandoc(""" import os import pandas as pd from mlinspect.utils import get_project_root train_file = os.path.join(str(get_project_root()), "example_pipelines", "adult_complex", "adult_train.csv") raw_data = pd.read_csv(train_file, na_values='?', index_col=0) assert len(raw_data) == 22792 """) inspector_result = _pipeline_executor.singleton.run(python_code=test_code, track_code_references=True, inspections=[RowLineage(2)]) extracted_node: DagNode = list(inspector_result.dag.nodes)[0] expected_node = DagNode(0, BasicCodeLocation("<string-source>", 6), OperatorContext(OperatorType.DATA_SOURCE, FunctionInfo('pandas.io.parsers', 'read_csv')), DagNodeDetails(StringComparison(r".*\.csv"), ['age', 'workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country', 'income-per-year']), OptionalCodeInfo(CodeReference(6, 11, 6, 62), "pd.read_csv(train_file, na_values='?', index_col=0)")) compare(extracted_node, expected_node) inspection_results_data_source = inspector_result.dag_node_to_inspection_results[extracted_node] lineage_output = inspection_results_data_source[RowLineage(2)] expected_lineage_df = DataFrame([[46, 'Private', 128645, 'Some-college', 10, 'Divorced', 'Prof-specialty', 'Not-in-family', 'White', 'Female', 0, 0, 40, 'United-States', '<=50K', {LineageId(0, 0)}], [29, 'Local-gov', 115585, 'Some-college', 10, 'Never-married', 'Handlers-cleaners', 'Not-in-family', 'White', 'Male', 0, 0, 50, 'United-States', '<=50K', {LineageId(0, 1)}]], columns=['age', 'workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country', 'income-per-year', 'mlinspect_lineage']) pandas.testing.assert_frame_equal(lineage_output.reset_index(drop=True), expected_lineage_df.reset_index(drop=True))
def run_command(self, courses=None, orgs=None, allow_for=None, commit=True, fails=None, log=None): command_args = ['--partner=' + self.partner.short_code] if commit: command_args.append('--commit') if courses is None and orgs is None: courses = [self.course] if courses: command_args += ['--course=' + str(c.uuid) for c in courses] if orgs: command_args += ['--org=' + str(o.key) for o in orgs] if allow_for: command_args += [ '--allow-for=' + type_slug_run_slug_tuple for type_slug_run_slug_tuple in allow_for ] with LogCapture(logger.name) as log_capture: if fails: fails = fails if isinstance(fails, list) else [fails] keys = sorted('{key} ({id})'.format(key=fail.key, id=fail.id) for fail in fails) msg = 'Could not backpopulate a course type for the following courses: {course_keys}'.format( course_keys=', '.join(keys)) with self.assertRaisesMessage(CommandError, msg): self.call_command(*command_args) else: self.call_command(*command_args) if log: log_capture.check_present( (logger.name, 'INFO', StringComparison(log))) # As a convenience, refresh our built in courses and runs for obj in (self.course, self.audit_run, self.verified_run, self.course2, self.c2_audit_run): if obj.id: obj.refresh_from_db()
def test_openID2MismatchedDoesDisco(self): mismatched = discover.OpenIDServiceEndpoint() mismatched.identity = 'nothing special, but different' mismatched.local_id = 'green cheese' op_endpoint = 'Phone Home' sentinel = discover.OpenIDServiceEndpoint() sentinel.claimed_id = 'monkeysoft' self.consumer._discoverAndVerify = const(sentinel) msg = message.Message.fromOpenIDArgs( {'ns': message.OPENID2_NS, 'identity': 'sour grapes', 'claimed_id': 'monkeysoft', 'op_endpoint': op_endpoint}) with LogCapture() as logbook: result = self.consumer._verifyDiscoveryResults(msg, mismatched) self.assertEqual(result, sentinel) logbook.check(('openid.consumer.consumer', 'ERROR', StringComparison('Error attempting to use .*')), ('openid.consumer.consumer', 'INFO', 'Attempting discovery to verify endpoint'))
def test_failing_action(self): class FailingTestAction(ResultAction): def apply(self, *args, **kwargs): raise RuntimeError("YEAH THAT'S A FAILING BEAR") ACTIONS.append(FailingTestAction) self.section.append( Setting('default_actions', 'YBear: FailingTestAction')) with LogCapture() as capture: ret = autoapply_actions(self.results, {}, {}, self.section, self.log_printer) self.assertEqual(ret, self.results) capture.check( ('root', 'ERROR', "Failed to execute action 'FailingTestAction' " "with error: YEAH THAT'S A FAILING BEAR."), ('root', 'INFO', StringComparison(r"(?s).*YEAH THAT'S A FAILING BEAR.*")), ('root', 'DEBUG', '-> for result ' + repr(self.resultY) + '.')) ACTIONS.pop()