Example #1
0
    def test_post(self):
        skiplist = SkipList(config=self.config)
        self.assertRaises(MissingArgumentError, skiplist.post)
        self.assertRaises(
            MissingArgumentError,
            skiplist.post,
            category='something'
        )
        self.assertRaises(
            MissingArgumentError,
            skiplist.post,
            rule='something'
        )

        # because of an integrity error since it already exists
        self.assertRaises(
            DatabaseError,
            skiplist.post,
            category='prefix', rule='CrashInJS'
        )

        self.assertTrue(
            skiplist.post(category='suffix', rule='Erik*tiny*font')
        )

        cursor = self.connection.cursor()
        cursor.execute("""
        select * from skiplist where category=%s and rule=%s
        """, ('suffix', 'Erik*tiny*font'))
        first, = cursor.fetchall()
        self.assertEqual(first[0], 'suffix')
        self.assertEqual(first[1], 'Erik*tiny*font')
Example #2
0
    def test_get(self):
        skiplist = SkipList(config=self.config)

        params = {
        }
        res_expected = {
            "hits": [
                # Note: sort is case-insensitive
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
                {
                    "category": "irrelevant",
                    "rule": "CxThrowException",
                },
                {
                    "category": "line_number",
                    "rule": "signatures_with_line_numbers_re",
                },
                {
                    "category": "prefix",
                    "rule": "arena_.*",
                },
                {
                    "category": "prefix",
                    "rule": "CrashInJS",
                },
            ],
            "total": 5
        }

        res = skiplist.get(**params)
        self.assertEqual(res, res_expected)
Example #3
0
    def test_get(self):
        skiplist = SkipList(config=self.config)

        params = {
        }
        res_expected = {
            "hits": [
                # Note: sort is case-insensitive
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
                {
                    "category": "irrelevant",
                    "rule": "CxThrowException",
                },
                {
                    "category": "line_number",
                    "rule": "signatures_with_line_numbers_re",
                },
                {
                    "category": "prefix",
                    "rule": "arena_.*",
                },
                {
                    "category": "prefix",
                    "rule": "CrashInJS",
                },
            ],
            "total": 5
        }

        res = skiplist.get(**params)
        eq_(res, res_expected)
Example #4
0
    def test_post(self):
        skiplist = SkipList(config=self.config)
        assert_raises(MissingArgumentError, skiplist.post)
        assert_raises(
            MissingArgumentError,
            skiplist.post,
            category='something'
        )
        assert_raises(
            MissingArgumentError,
            skiplist.post,
            rule='something'
        )

        # because of an integrity error since it already exists
        assert_raises(
            DatabaseError,
            skiplist.post,
            category='prefix', rule='CrashInJS'
        )

        ok_(
            skiplist.post(category='suffix', rule='Erik*tiny*font')
        )

        cursor = self.connection.cursor()
        cursor.execute("""
        select * from skiplist where category=%s and rule=%s
        """, ('suffix', 'Erik*tiny*font'))
        first, = cursor.fetchall()
        eq_(first[0], 'suffix')
        eq_(first[1], 'Erik*tiny*font')
Example #5
0
    def test_delete(self):
        skiplist = SkipList(config=self.config)
        self.assertRaises(MissingArgumentError, skiplist.delete)
        self.assertRaises(MissingArgumentError,
                          skiplist.delete,
                          category='something')
        self.assertRaises(MissingArgumentError,
                          skiplist.delete,
                          rule='something')

        cursor = self.connection.cursor()
        cursor.execute("select count(*) from skiplist")
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 5)

        self.assertTrue(skiplist.delete(category='irrelevant', rule='ashmem'))

        cursor.execute("select count(*) from skiplist")
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 4)

        cursor.execute(
            """
        select count(*) from skiplist
        where category=%s and rule=%s
        """, ('irrelevant', 'ashmem'))
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 0)

        self.assertTrue(not skiplist.delete(category='neverheard', rule='of'))
Example #6
0
    def test_get_with_optional_filtering(self):
        skiplist = SkipList(config=self.config)

        # filter by category
        params = {
            'category': 'irrelevant'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
                {
                    "category": "irrelevant",
                    "rule": "CxThrowException",
                },
            ],
            "total": 2
        }
        res = skiplist.get(**params)
        self.assertEqual(res, res_expected)

        # filter by rule
        params = {
            'rule': 'ashmem'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
            ],
            "total": 1
        }
        res = skiplist.get(**params)
        self.assertEqual(res, res_expected)

        # filter by both
        params = {
            'category': 'irrelevant',
            'rule': 'ashmem'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
            ],
            "total": 1
        }
        res = skiplist.get(**params)
        self.assertEqual(res, res_expected)
Example #7
0
    def test_get_with_optional_filtering(self):
        skiplist = SkipList(config=self.config)

        # filter by category
        params = {
            'category': 'irrelevant'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
                {
                    "category": "irrelevant",
                    "rule": "CxThrowException",
                },
            ],
            "total": 2
        }
        res = skiplist.get(**params)
        eq_(res, res_expected)

        # filter by rule
        params = {
            'rule': 'ashmem'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
            ],
            "total": 1
        }
        res = skiplist.get(**params)
        eq_(res, res_expected)

        # filter by both
        params = {
            'category': 'irrelevant',
            'rule': 'ashmem'
        }
        res_expected = {
            "hits": [
                {
                    "category": "irrelevant",
                    "rule": "ashmem",
                },
            ],
            "total": 1
        }
        res = skiplist.get(**params)
        eq_(res, res_expected)
Example #8
0
    def test_delete(self):
        skiplist = SkipList(config=self.config)
        self.assertRaises(MissingArgumentError, skiplist.delete)
        self.assertRaises(
            MissingArgumentError,
            skiplist.delete,
            category='something'
        )
        self.assertRaises(
            MissingArgumentError,
            skiplist.delete,
            rule='something'
        )

        cursor = self.connection.cursor()
        cursor.execute("select count(*) from skiplist")
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 5)

        self.assertTrue(skiplist.delete(category='irrelevant', rule='ashmem'))

        cursor.execute("select count(*) from skiplist")
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 4)

        cursor.execute("""
        select count(*) from skiplist
        where category=%s and rule=%s
        """, ('irrelevant', 'ashmem'))
        first, = cursor.fetchall()
        count = first[0]
        self.assertEqual(count, 0)

        self.assertTrue(not skiplist.delete(category='neverheard', rule='of'))