[ci] Add mix of unit tests to raise tests coverage

Author: evilaliv3

backend/globaleaks/handlers/admin/network.py

@@ -28,7 +28,7 @@ def db_update_network(session, tid, user_session, request):
     :param request: The request data
     :return: Return the serialized configuration for the specified tenant
     """
-    # Validate that IP addresses/ranges we're getting are good
+    # Validate the IP addresses/ranges
     for k in ['admin', 'analyst', 'custodian', 'receiver']:
         if 'ip_filter_' + k in request and request['ip_filter_' + k + '_enable'] and request['ip_filter_' + k]:
             parse_csv_ip_ranges_to_ip_networks(request['ip_filter_' + k])

backend/globaleaks/tests/handlers/admin/test_network.py

@@ -1,3 +1,5 @@
+import copy
+
 from twisted.internet.defer import inlineCallbacks
 
 from globaleaks.handlers.admin import network
@@ -7,6 +9,7 @@
 class TestNetworkInstance(helpers.TestHandlerWithPopulatedDB):
     _handler = network.NetworkInstance
 
+
     @inlineCallbacks
     def test_get(self):
         handler = self.request(role='admin')
@@ -18,9 +21,12 @@ def test_get(self):
 
     @inlineCallbacks
     def test_put(self):
-        self.dummyNetwork['anonymize_outgoing_connection'] = True
+        config = copy.deepcopy(self.dummyNetwork)
+        config['ip_filter_custodian_enable'] = True
+        config['ip_filter_custodian'] = '10.0.0.0/24'
+        config['anonymize_outgoing_connection'] = True
 
-        handler = self.request(self.dummyNetwork, role='admin')
+        handler = self.request(config, role='admin')
         response = yield handler.put()
 
         self.assertTrue(isinstance(response, dict))

backend/globaleaks/tests/handlers/admin/test_operation.py

@@ -58,7 +58,7 @@ def _test_operation_handler(self, operation, args={}):
 
         return handler.put()
 
-    def atest_admin_test_set_hostname(self):
+    def test_admin_test_set_hostname(self):
         return self._test_operation_handler('set_hostname',
                                            {'value': 'www.nsa.gov'})
 

backend/globaleaks/tests/handlers/admin/test_redirect.py

@@ -5,13 +5,6 @@
 from globaleaks.orm import tw
 from globaleaks.tests import helpers
 
-def get_dummy_redirect_desc():
-    return {
-        'path1': '/old',
-        'path2': '/new'
-    }
-
-
 class TestRedirectCollection(helpers.TestHandlerWithPopulatedDB):
     _handler = RedirectCollection
 
@@ -29,15 +22,15 @@ def test_get(self):
 
     @inlineCallbacks
     def test_post(self):
-        handler = self.request(get_dummy_redirect_desc(), role='admin')
+        handler = self.request(self.get_dummy_redirect(), role='admin')
         redirect = yield handler.post()
 
         self.assertEqual(redirect['path1'], '/old')
         self.assertEqual(redirect['path2'], '/new')
 
     @inlineCallbacks
     def _create_redirect(self):
-        handler = self.request(get_dummy_redirect_desc(), role='admin')
+        handler = self.request(self.get_dummy_redirect(), role='admin')
         return (yield handler.post())
 
 

backend/globaleaks/tests/helpers.py

@@ -505,11 +505,7 @@ def isSecure():
     request.isSecure = isSecure
 
     def getResponseBody():
-        # Ugh, hack. Twisted returns this all as bytes, and we want it as str
-        if isinstance(request.written[0], bytes):
-            return b''.join(request.written)
-        else:
-            return ''.join(request.written)
+        return b''.join(request.written) if isinstance(request.written[0], bytes) else ''.join(request.written)
 
     request.getResponseBody = getResponseBody
 
@@ -715,8 +711,8 @@ def get_dummy_attachment(self, name=None, content=None):
 
     def get_dummy_redirect(self, x=''):
         return {
-            'path1': '/path1-' + x,
-            'path2': '/path2-' + x
+            'path1': '/old' + x,
+            'path2': '/new' + x
         }
 
     def emulate_file_upload(self, session, n):
@@ -939,10 +935,6 @@ def set_itips_near_to_expire(self, session):
         date = datetime_now() + timedelta(hours=self.state.tenants[1].cache.notification.tip_expiration_threshold - 1)
         session.query(models.InternalTip).update({'expiration_date': date})
 
-    @transact
-    def set_contexts_timetolive(self, session, ttl):
-        session.query(models.Context).update({'tip_timetolive': ttl})
-
 
 class TestHandler(TestGLWithPopulatedDB):
     """
@@ -1038,12 +1030,6 @@ def request(self, body='', uri=b'https://www.globaleaks.org/',
 
         return handler
 
-    def ss_serial_desc(self, safe_set, request_desc):
-        """
-        Constructs a request_dec parser of a handler that uses a safe_set in its serialization
-        """
-        return {k: v for k, v in request_desc.items() if k in safe_set}
-
     def get_dummy_request(self):
         return self._test_desc['model']().dict(u'en')
 

backend/globaleaks/tests/rest/test_decorators.py

@@ -38,8 +38,7 @@ def setUp(self):
     @defer.inlineCallbacks
     def test_decorator_rate_limit(self, mock_sleep):
         @decorator_rate_limit
-        def test_func(self):
-            return defer.succeed("Allowed")
+        def test_func(self): return defer.succeed("Allowed")
 
         self.session.role = "whistleblower"
 
@@ -59,8 +58,7 @@ def test_func(self):
 
     def test_decorator_require_session_or_token(self):
         @decorator_require_session_or_token
-        def test_func(self):
-            return "Authenticated"
+        def test_func(self): return "Authenticated"
 
         self.session = None
         self.request.token = None

backend/globaleaks/tests/utils/test_ip.py

@@ -1,10 +1,10 @@
 from twisted.trial import unittest
-
+import ipaddress
 from globaleaks.utils import ip
 
 
 class TestIPUtils(unittest.TestCase):
-    def test_parse_csv_ip_ranges_to_ip_networks(self):
+    def test_check_ip(self):
         ip_str = "192.168.1.1,10.0.0.0/8,::1,2001:db8::/32"
         self.assertTrue(ip.check_ip("192.168.1.1", ip_str))
 
@@ -16,3 +16,51 @@ def test_parse_csv_ip_ranges_to_ip_networks(self):
 
         ip_str = "192.168.1.2, 10.0.0.0/8, ::1,2001:db8::/32"
         self.assertTrue(ip.check_ip("2001:db8::2", ip_str))
+
+    def test_check_ip_invalid_ip(self):
+        """Test with an invalid IP address."""
+        ip_str = "192.168.1.1,10.0.0.0/8"
+        self.assertFalse(ip.check_ip("999.999.999.999", ip_str))
+
+    def test_check_ip_invalid_filter(self):
+        """Test with an invalid IP filter."""
+        ip_str = "invalid_data"
+        self.assertFalse(ip.check_ip("10.0.0.1", ip_str))
+
+    def test_check_ip_empty_filter(self):
+        """Test with an empty IP filter."""
+        ip_str = ""
+        self.assertFalse(ip.check_ip("10.0.0.1", ip_str))
+
+    def test_check_ip_bytes_input(self):
+        """Test with client IP as bytes."""
+        ip_str = "10.0.0.0/8"
+        self.assertTrue(ip.check_ip(b"10.0.0.1", ip_str))
+
+    def test_check_ip_ipv6(self):
+        """Test with IPv6 addresses."""
+        ip_str = "::1,2001:db8::/32"
+        self.assertTrue(ip.check_ip("2001:db8::2", ip_str))
+        self.assertFalse(ip.check_ip("2001:dead::1", ip_str))
+
+    def test_parse_csv_ip_ranges_to_ip_networks(self):
+        """Test parsing valid IP and CIDR ranges."""
+        ip_str = "192.168.1.1,10.0.0.0/8,::1,2001:db8::/32"
+        expected = [
+            ipaddress.ip_network("192.168.1.1/32"),
+            ipaddress.ip_network("10.0.0.0/8"),
+            ipaddress.ip_network("::1/128"),
+            ipaddress.ip_network("2001:db8::/32")
+        ]
+
+        self.assertEqual(ip.parse_csv_ip_ranges_to_ip_networks(ip_str), expected)
+
+    def test_parse_csv_ip_ranges_invalid_entries(self):
+        """Test parsing invalid IPs and CIDR ranges."""
+        invalid_ip_str = "invalid,300.300.300.300,10.0.0.1/33"
+        with self.assertRaises(ValueError):
+            ip.parse_csv_ip_ranges_to_ip_networks(invalid_ip_str)
+
+    def test_parse_csv_ip_ranges_empty(self):
+        """Test parsing an empty input."""
+        self.assertEqual(ip.parse_csv_ip_ranges_to_ip_networks(""), [])

backend/globaleaks/utils/crypto.py

@@ -64,9 +64,6 @@ def generateRandomPassword(N: int) -> str:
        Contains at least an uppercase ascii letter
        Contains at least a symbol in a selction of 10 common and accessible symbols
     """
-    if N < 10:
-        N = 10
-
     accessible_special_symbols = "!?@#+-/*="
     accessible_symbols_set = string.ascii_letters + string.digits + accessible_special_symbols
 

backend/globaleaks/utils/ip.py

@@ -7,6 +7,10 @@ def parse_csv_ip_ranges_to_ip_networks(ip_str):
     :param ip_str: the string of comma separated IP
     :return: the list of parsed IPs
     """
+    # Handle empty input
+    if not ip_str:
+        return []
+
     # strip all white spaces
     ip_str = "".join(ip_str.split())