def test_failed_module_import(self): # test importing a bogus module user_rule_path = self.get_sample_path("user_rules/import_exception") # We don't check the entire error message because that is different based on the python version and underlying # operating system expected_msg = "Error while importing extra-path module 'invalid_python'" with self.assertRaisesRegex(UserRuleError, expected_msg): find_rule_classes(user_rule_path)
def test_assert_valid_rule_class_negative(self): # general test to make sure that incorrect rules will raise an exception user_rule_path = self.get_sample_path("user_rules/incorrect_linerule") with self.assertRaisesRegex( UserRuleError, "User-defined rule class 'MyUserLineRule' must have a 'validate' method" ): find_rule_classes(user_rule_path)
def extra_path(self, value): try: if self.extra_path: self._extra_path.set(value) else: self._extra_path = options.PathOption( 'extra-path', value, "Path to a directory or module with extra user-defined rules", type='both' ) # Make sure we unload any previously loaded extra-path rules for rule in self.rules: if hasattr(rule, 'user_defined') and rule.user_defined: del self._rules[rule.id] # Find rules in the new extra-path rule_classes = user_rules.find_rule_classes(self.extra_path) # Add the newly found rules to the existing rules for rule_class in rule_classes: rule_obj = rule_class() rule_obj.user_defined = True self._rules[rule_class.id] = rule_obj except (options.RuleOptionError, user_rules.UserRuleError) as e: raise LintConfigError(ustr(e))
def extra_path(self, value): try: if self.extra_path: self._extra_path.set(value) else: self._extra_path = options.DirectoryOption('extra-path', value, "Path to a directory with extra user-defined rules") # Make sure we unload any previously loaded extra-path rules for rule in self.rules: if hasattr(rule, 'user_defined') and rule.user_defined: del self._rules[rule.id] # Find rules in the new extra-path rule_classes = user_rules.find_rule_classes(self.extra_path) # Add the newly found rules to the existing rules for rule_class in rule_classes: rule_obj = rule_class() rule_obj.user_defined = True self._rules[rule_class.id] = rule_obj except options.RuleOptionError as e: raise LintConfigError(str(e)) except Exception as e: # TODO(joris.roovers): better error message raise e
def test_empty_user_classes(self): # Test that we don't find rules if we scan a different directory user_rule_path = self.get_sample_path("config") classes = find_rule_classes(user_rule_path) self.assertListEqual(classes, []) # Importantly, ensure that the directory is not added to the syspath as this happens only when we actually # find modules self.assertNotIn(user_rule_path, sys.path)
def test_extra_path_specified_by_file(self): # Test that find_rule_classes can handle an extra path given as a file name instead of a directory user_rule_path = self.get_sample_path("user_rules") user_rule_module = os.path.join(user_rule_path, "my_commit_rules.py") classes = find_rule_classes(user_rule_module) rule_class = classes[0]() violations = rule_class.validate("false-commit-object (ignored)") self.assertListEqual(violations, [ rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1) ])
def extra_path(self, value): try: self._extra_path.set(value) rule_classes = user_rules.find_rule_classes(self.extra_path) # Add the newly found rules to the existing rules for rule_class in rule_classes: self.rule_classes.append(rule_class) self._rules[rule_class.id] = rule_class() except options.RuleOptionError as e: raise LintConfigError(str(e)) except Exception as e: # TODO(joris.roovers): better error message raise e
def test_find_rule_classes(self): # Let's find some user classes! user_rule_path = self.get_sample_path("user_rules") classes = find_rule_classes(user_rule_path) # Compare string representations because we can't import MyUserCommitRule here since samples/user_rules is not # a proper python package # Note that the following check effectively asserts that: # - There is only 1 rule recognized and it is MyUserCommitRule # - Other non-python files in the directory are ignored # - Other members of the my_commit_rules module are ignored # (such as func_should_be_ignored, global_variable_should_be_ignored) # - Rules are loaded non-recursively (user_rules/import_exception directory is ignored) self.assertEqual("[<class 'my_commit_rules.MyUserCommitRule'>]", ustr(classes)) # Assert that we added the new user_rules directory to the system path and modules self.assertIn(user_rule_path, sys.path) self.assertIn("my_commit_rules", sys.modules) # # Do some basic asserts on our user rule self.assertEqual(classes[0].id, "UC1") self.assertEqual(classes[0].name, u"my-üser-commit-rule") expected_option = options.IntOption('violation-count', 1, u"Number of violåtions to return") self.assertListEqual(classes[0].options_spec, [expected_option]) self.assertTrue(hasattr(classes[0], "validate")) # Test that we can instantiate the class and can execute run the validate method and that it returns the # expected result rule_class = classes[0]() violations = rule_class.validate("false-commit-object (ignored)") self.assertListEqual(violations, [ rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1) ]) # Have it return more violations rule_class.options['violation-count'].value = 2 violations = rule_class.validate("false-commit-object (ignored)") self.assertListEqual(violations, [ rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1), rules.RuleViolation("UC1", u"Commit violåtion 2", u"Contënt 2", 2) ])
def test_find_rule_classes(self): # Let's find some user classes! user_rule_path = self.get_sample_path("user_rules") classes = find_rule_classes(user_rule_path) # Compare string representations because we can't import MyUserCommitRule here since samples/user_rules is not # a proper python package # Note that the following check effectively asserts that: # - There is only 1 rule recognized and it is MyUserCommitRule # - Other non-python files in the directory are ignored # - Other members of the my_commit_rules module are ignored # (such as func_should_be_ignored, global_variable_should_be_ignored) # - Rules are loaded non-recursively (user_rules/import_exception directory is ignored) self.assertEqual("[<class 'my_commit_rules.MyUserCommitRule'>]", str(classes)) # Assert that we added the new user_rules directory to the system path and modules self.assertIn(user_rule_path, sys.path) self.assertIn("my_commit_rules", sys.modules) # Do some basic asserts on our user rule self.assertEqual(classes[0].id, "TUC1") self.assertEqual(classes[0].name, "my-user-commit-rule") expected_option = options.IntOption('violation-count', 1, "Number of violations to return") self.assertListEqual(classes[0].options_spec, [expected_option]) self.assertTrue(hasattr(classes[0], "validate")) # Test that we can instantiate the class and can execute run the validate method and that it returns the # expected result rule_class = classes[0]() violations = rule_class.validate("false-commit-object (ignored)") self.assertListEqual(violations, [rules.RuleViolation("TUC1", "Commit violation 1", "Content 1", 1)]) # Have it return more violations rule_class.options['violation-count'].value = 2 violations = rule_class.validate("false-commit-object (ignored)") self.assertListEqual(violations, [rules.RuleViolation("TUC1", "Commit violation 1", "Content 1", 1), rules.RuleViolation("TUC1", "Commit violation 2", "Content 2", 2)])
def test_find_rule_classes_nonexisting_path(self): with self.assertRaisesRegex(UserRuleError, u"Invalid extra-path: föo/bar"): find_rule_classes(u"föo/bar")
def test_find_rule_classes_nonexisting_path(self): # When searching an non-existing path, we expect an OSError. That's fine because this case will be caught by # the CLI (you cannot specify a non-existing directory). What we do here is just assert that we indeed # get an OSError (so we guard against regressions). with self.assertRaisesRegex(OSError, "No such file or directory"): find_rule_classes(u"föo/bar")
def test_find_rule_classes_nonexisting_path(self): # When searching an non-existing path, we expect an OSError. That's fine because this case will be caught by # the CLI (you cannot specify a non-existing directory). What we do here is just assert that we indeed # get an OSError (so we guard against regressions). with self.assertRaisesRegex(OSError, "No such file or directory"): find_rule_classes("foo/bar")