Add more test cases

Author: GustavoKatel

django_pymodsecurity/middleware.py

@@ -5,8 +5,6 @@
 
 import ModSecurity
 
-logger = logging.getLogger(__name__)
-
 SETTINGS_NAMES = {
     'rule_files': 'MODSECURITY_RULE_FILES',
     'rule_lines': 'MODSECURITY_RULES',
@@ -22,6 +20,8 @@ def __init__(self, get_response):
 
         :param callable get_response
         '''
+        self.logger = logging.getLogger(__name__)
+
         self.get_response = get_response
 
         self.modsecurity = ModSecurity.ModSecurity()
@@ -44,7 +44,7 @@ def __init__(self, get_response):
             self.load_rules(self.rule_lines)
 
     def modsecurity_log_callback(self, data, msg):
-        logger.info(msg)
+        self.logger.info(msg)
 
     @property
     def rules_count(self):
@@ -54,34 +54,43 @@ def load_rule_files(self, rule_files):
         '''
         Process a list of files (can be a list of globs) and loads into modsecurity
         :param list(str) rule_files
+        :rtype: int
+        :return the total rules that were loaded
         '''
+        before_count = self.rules_count
         import glob
         for pattern in rule_files:
             for rule_file in glob.glob(pattern, recursive=True):
                 rules_count = self.rules.loadFromUri(rule_file)
                 if rules_count < 0:
                     msg = '[ModSecurity] Error trying to load rule file %s. %s' % (
                         rule_file, self.rules.getParserError())
-                    logger.warning(msg)
+                    self.logger.warning(msg)
                 else:
                     self._rules_count += rules_count
 
+        return self.rules_count - before_count
+
     def load_rules(self, rules):
         '''
         Process rules
         :param str: rules
+        :rtype: int
+        :return the total rules that were loaded
         '''
         if rules is None or not len(rules) > 0:
-            return
+            return 0
 
         rules_count = self.rules.load(rules)
         if rules_count < 0:
             msg = '[ModSecurity] Error trying to load rules: %s' % self.rules.getParserError(
             )
-            logger.warning(msg)
+            self.logger.warning(msg)
         else:
             self._rules_count += rules_count
 
+        return rules_count
+
     def __call__(self, request):
         transaction = ModSecurity.Transaction(self.modsecurity, self.rules)
         response = self.process_request(request, transaction)
@@ -168,15 +177,17 @@ def process_intervention(self, transaction):
         :rtype HttpResponse:
         '''
         intervention = ModSecurity.ModSecurityIntervention()
+
+        if intervention is None:
+            return None
+
         if transaction.intervention(intervention):
-            if intervention is None:
-                return None
+            if intervention.log is not None:
+                self.logger.info(intervention.log)
 
             if not intervention.disruptive:
                 return None
 
-            # TODO process intervention logs
-
             if intervention.url is not None:
                 response = HttpResponseRedirect(intervention.url)
             else:

tests/test_main.py

@@ -117,3 +117,30 @@ def test_log(get_response, request_factory, mocker):
     assert obj == middleware
     assert data is None
     assert 'log test ok' in msg
+
+
+def test_log_when_load_rule_files_fail(middleware, mocker):
+    mocker.spy(middleware.logger, 'warning')
+
+    assert middleware.load_rule_files('tests/data/invalid-conf.conf') == 0
+
+    assert middleware.logger.warning.call_count > 0
+    msg = middleware.logger.warning.call_args_list[0][0][0]
+
+    assert '[ModSecurity] Error trying to load rule file' in msg
+
+
+def test_log_when_load_rules_fail(middleware, mocker):
+    mocker.spy(middleware.logger, 'warning')
+
+    assert middleware.load_rules('invalid sec rule here') < 0
+
+    assert middleware.logger.warning.call_count > 0
+    msg = middleware.logger.warning.call_args_list[0][0][0]
+
+    assert '[ModSecurity] Error trying to load rules' in msg
+
+
+@pytest.mark.parametrize('rules', [None, ''])
+def test_load_rules_params(middleware, rules):
+    assert middleware.load_rules(rules) == 0