Example #1
0
 def test_get_from_cache_prefix1(self):
     """Test case where we dont' have a matching prefix in cache"""
     ip = IP(self.IP)
     # clear out db to test specific function
     self.mock_cache.clear()
     self.assertFalse(ip.cached_prefix_found)
     self.assertEquals(ip.get_from_cached_prefix(), None)
 def test_get_from_cache_prefix1(self):
     """Test case where we dont' have a matching prefix in cache"""
     ip = IP(self.IP)
     # clear out db to test specific function
     self.db = {}
     self.assertFalse(ip.cached_prefix_found)
     self.assertEquals(ip.get_from_cached_prefix(), None)
Example #3
0
 def test_loopback6(self):
     """IPv6 loopback address"""
     det = IP("::1")
     self.assertEquals(det.asn, None)
     self.assertEquals(det.is_querable(), False)
     # no query to stat
     self.assertEquals(self.mock_get.call_count, 0)
     # no access to cache get
     self.assertEquals(self.mock_cache.get.call_count, 0)
 def test_loopback6(self):
     """IPv6 loopback address"""
     det = IP("::1")
     self.assertEquals(det.asn, None)
     self.assertEquals(det.is_querable(), False)
     # no query to stat
     self.assertEquals(self.mock_get.call_count, 0)
     # no access to cache get
     self.assertEquals(self.mock_cache.get.call_count, 0)
Example #5
0
 def test_get_from_cache_prefix(self):
     """Test case where we have a matching prefix in cache"""
     details = {'Prefix': '193.0.0.0/21', 'Holder': 'test', 'ASN': 'test'}
     self.mock_cache.set("IPDetailsPrefix:193.0.0.0/20", details, 1)
     ip = IP(self.IP)
     self.assertTrue(ip.cached_prefix_found)
     self.assertEquals(ip.asn, "test")
     self.assertEquals(ip.holder, "test")
     self.assertEquals(ip.get_from_cached_prefix(), details)
    def test_invalid_query_stat2(self):
        """Test case where stat returns exception"""
        self.mock_get.side_effect = requests.exceptions.RequestException
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        self.mock_get.return_value = FakeErrorResponse()
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
Example #7
0
 def test_valid_query_stat(self):
     """Test case for valid stat response"""
     ip = IP(self.IP)
     self.assertEqual(
         ip.query_stat(), {
             'Prefix': '193.0.0.0/21',
             'Holder':
             'RIPE-NCC-AS Reseaux IP Europeens Network Coordination Centre (RIPE NCC),NL',
             'ASN': '3333'
         })
 def test_valid_query_stat(self):
     """Test case for valid stat response"""
     ip = IP(self.IP)
     self.assertEqual(
         ip.query_stat(),
         {
             'Prefix': '193.0.0.0/21',
             'Holder': 'RIPE-NCC-AS Reseaux IP Europeens Network Coordination Centre (RIPE NCC),NL',
             'ASN': '3333'
         }
     )
Example #9
0
    def test_fakecache_sameip(self):
        """Fake cache, same IP"""
        det = IP(self.IP)
        det = IP(self.IP)

        self.assertEquals(det.asn, self.ASN)
        # query to stat
        self.assertEquals(self.mock_get.call_count, 1)
        # access to cache get
        self.assertEquals(self.mock_cache.get.call_count, 2)
        # access to cache set
        self.assertEquals(self.mock_cache.set.call_count, 2)
Example #10
0
    def test_fakecache_sameprefix(self):
        """Fake cache, same prefix"""
        det1 = IP(self.IP)
        det2 = IP(self.SAME_PREFIX_IP)

        self.assertEquals(det1.asn, self.ASN)
        self.assertEquals(det2.asn, det1.asn)
        # query to stat
        self.assertEquals(self.mock_get.call_count, 1)
        # access to cache get
        self.assertEquals(self.mock_cache.get.call_count, 3)
        # access to cache set
        self.assertEquals(self.mock_cache.set.call_count, 3)
 def test_get_from_cache_prefix(self):
     """Test case where we have a matching prefix in cache"""
     details = {
         'Prefix': '193.0.0.0/21',
         'Holder': 'test',
         'ASN': 'test'
     }
     self.mock_cache.set("IPDetailsPrefix:193.0.0.0/20", details, 1)
     ip = IP(self.IP)
     self.assertTrue(ip.cached_prefix_found)
     self.assertEquals(ip.asn, "test")
     self.assertEquals(ip.holder, "test")
     self.assertEquals(ip.get_from_cached_prefix(), details)
    def test_invalid_query_stat(self):
        """Test case where stat returns not ok status"""
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "notok"}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        self.mock_get.return_value = FakeResponse(
            json_return={}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
Example #13
0
    def test_fakecache_notannounced(self):
        """Fake cache, IP not announced"""
        self.mock_get.return_value = FakeResponse(
            json_return=self.MOCK_RESULTS[self.NOT_ANNOUNCED_IP])
        det = IP(self.NOT_ANNOUNCED_IP)

        self.assertEquals(det.asn, None)
        self.assertEquals(self.mock_get.call_count, 1)

        IP(self.NOT_ANNOUNCED_IP)

        # now it should be cached
        self.assertEquals(det.asn, None)
        self.assertEquals(self.mock_get.call_count, 2)
Example #14
0
    def test_fakecache_diffprefix(self):
        """Fake cache, same AS, different prefix"""
        self.mock_get.return_value = FakeResponse(
            json_return=self.MOCK_RESULTS[self.IP])
        det1 = IP(self.IP)
        self.mock_get.return_value = FakeResponse(
            json_return=self.MOCK_RESULTS[self.SAME_AS_DIFFERENT_PREFIX_IP])
        det2 = IP(self.SAME_AS_DIFFERENT_PREFIX_IP)

        self.assertEquals(det1.asn, self.ASN)
        self.assertEquals(det2.asn, det1.asn)
        self.assertEquals(self.mock_get.call_count, 2)
        # access to cache get
        self.assertEquals(self.mock_cache.get.call_count, 3)
        # access to cache set
        self.assertEquals(self.mock_cache.set.call_count, 4)
Example #15
0
    def test_nocache(self):
        """No cache"""
        det = IP(self.IP)

        self.assertEquals(det.asn, self.ASN)
        self.assertEquals(det.prefix, self.PREFIX)
        self.assertEquals(det.holder, self.HOLDER)
        # query to stat
        self.assertEquals(self.mock_get.call_count, 1)
        # access to cache get
        self.assertEquals(self.mock_cache.get.call_count, 1)
        # access to cache set
        self.assertEquals(self.mock_cache.set.call_count, 2)
 def test_update_cache1(self):
     """Test case where we store only address"""
     details = {
         'Prefix': '193.0.0.0/21',
         'Holder': 'RIPE-NCC-AS Reseaux IP Europeens Network Coordination Centre (RIPE NCC),NL',
         'ASN': '3333'
     }
     self.mock_cache.set("IPDetailsPrefix:193.0.0.0/21", details, 1)
     IP(self.IP)
     # we already called it above, so it should be 2 by bow
     self.assertEquals(self.mock_cache.set.call_count, 2)
     self.assertEquals(self.mock_cache.get("IPDetails:193.0.6.1"), details)
     self.assertEquals(self.mock_cache.get("IPDetailsPrefix:193.0.0.0/21"), details)
Example #17
0
 def test_update_cache(self):
     """Test case where we store both prefix/address"""
     details = {
         'Prefix': '193.0.0.0/21',
         'Holder':
         'RIPE-NCC-AS Reseaux IP Europeens Network Coordination Centre (RIPE NCC),NL',
         'ASN': '3333'
     }
     IP(self.IP)
     self.assertEquals(self.mock_cache.set.call_count, 2)
     self.assertEquals(self.mock_cache.get("IPDetails:193.0.6.1"), details)
     self.assertEquals(self.mock_cache.get("IPDetailsPrefix:193.0.0.0/21"),
                       details)
Example #18
0
    def test_invalid_query_stat2(self):
        """Test case where stat returns exception"""
        self.mock_get.side_effect = requests.exceptions.RequestException
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        self.mock_get.return_value = FakeErrorResponse()
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
    def test_invalid_query_stat1(self):
        """Test case where stat returns not valid data structure"""
        # no data at all
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "ok"}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # data is dict but no asns key
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "ok", "data": {"bla": "bla"}}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # data is not dict
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "ok", "data": [1, 2]}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # asns is not list
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "ok", "data": {"asns": {}}}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # asns is empty
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "ok", "data": {"asns": [{}]}}
        )
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
Example #20
0
    def test_invalid_query_stat(self):
        """Test case where stat returns not ok status"""
        self.mock_get.return_value = FakeResponse(
            json_return={"status": "notok"})
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        self.mock_get.return_value = FakeResponse(json_return={})
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
Example #21
0
 def test_is_querable1(self):
     """Test case where IP is not quearable"""
     ip = IP("127.0.0.1")
     self.assertFalse(ip.is_querable())
Example #22
0
 def test_is_querable(self):
     """Test case where IP is quearable"""
     ip = IP(self.IP)
     self.assertTrue(ip.is_querable())
 def test_is_querable(self):
     """Test case where IP is quearable"""
     ip = IP(self.IP)
     self.assertTrue(ip.is_querable())
Example #24
0
    def test_invalid_query_stat1(self):
        """Test case where stat returns not valid data structure"""
        # no data at all
        self.mock_get.return_value = FakeResponse(json_return={"status": "ok"})
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # data is dict but no asns key
        self.mock_get.return_value = FakeResponse(json_return={
            "status": "ok",
            "data": {
                "bla": "bla"
            }
        })
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # data is not dict
        self.mock_get.return_value = FakeResponse(json_return={
            "status": "ok",
            "data": [1, 2]
        })
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # asns is not list
        self.mock_get.return_value = FakeResponse(json_return={
            "status": "ok",
            "data": {
                "asns": {}
            }
        })
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})

        # asns is empty
        self.mock_get.return_value = FakeResponse(json_return={
            "status": "ok",
            "data": {
                "asns": [{}]
            }
        })
        ip = IP(self.IP)
        self.assertEqual(ip.query_stat(), {})
 def test_is_querable1(self):
     """Test case where IP is not quearable"""
     ip = IP("127.0.0.1")
     self.assertFalse(ip.is_querable())