scrapling 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

scrapling-0.2.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+scrapling/__init__.py,sha256=x8S2Da-4KgUBzNYdM9ahYw3hDw5875KnpDliQWxQiGo,435
+scrapling/fetchers.py,sha256=_6mL7XSTZE1fHXBqbxE2bBHnlQP1lH-4MCiQHQd5hQs,16017
+scrapling/parser.py,sha256=VGbrARu2hxXyKLbUgtdtht_tljDYPT1jaWZWgoncv5U,53551
+scrapling/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+scrapling/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scrapling/core/_types.py,sha256=nD2ZY_fitLohx3MfDmqoKJ9ZShrnRhQ8-d1SU1zEGAY,552
+scrapling/core/custom_types.py,sha256=-gMNOiByewoAUqFVrDp822V51rcWNlWVUOB6yGUL648,8403
+scrapling/core/mixins.py,sha256=sozbpaGL1_O_x3U-ABM5aYWpnxpCLfdbcA9SG3P7weY,3532
+scrapling/core/storage_adaptors.py,sha256=Kbak0BOJX5e9I1PbUS_4sUJi2Wxw8Bv5XsaLHAu1l2Q,6218
+scrapling/core/translator.py,sha256=oU-dQCkNQOccZPrXbPW_VSgC5ll10Bb89C3ezW2lI0o,5228
+scrapling/core/utils.py,sha256=fXdANUgRBbVbOerJ94fRY9vi7n5zsbm8t3G4qQ-F3ak,3792
+scrapling/engines/__init__.py,sha256=zwMqcSdNGh-IX0d4zXazrgAeHrkqIN_v5Ia7RU1g8W0,267
+scrapling/engines/camo.py,sha256=P8kPxP0awgV-AGMibMNDJUaxZC9oYDP64Ei_dk9D3jA,7549
+scrapling/engines/constants.py,sha256=jSDA6lgbvEIB8z2m2SFzCKkvFEZnp28Mondy2__FpkM,3721
+scrapling/engines/pw.py,sha256=JKPdJkfz--8YyngLxFNwEyWF0O3_o5xR7zQCxF1D8Cs,12121
+scrapling/engines/static.py,sha256=dY1iLBe7YhzRJYd9MM8P7hbqF44cpwOgTJ6CkIVfaRA,7120
+scrapling/engines/toolbelt/__init__.py,sha256=BnBp34aDeohYgqdysEAAWnGZgA02YlExkc5FJLetMSo,367
+scrapling/engines/toolbelt/custom.py,sha256=XB_oINjmVnigODxfP9hl-teRy0BkJqfrEprWDAqO-Jo,7473
+scrapling/engines/toolbelt/fingerprints.py,sha256=kkVtZKSt2ukc0CV0g6QUvSWR0Yx5p8Mv8xiqACAsMBo,2917
+scrapling/engines/toolbelt/navigation.py,sha256=Tde5_6Wv7lOeWXMzs9D6TRaxAbJ3b-zIX6-4HggZbCQ,4017
+tests/__init__.py,sha256=YHFB5ftzgLQVh6gbPfbYcY4yOS9DOBp5dBa6I-qtm8U,32
+tests/fetchers/__init__.py,sha256=6H4NgARhyTcGGd3dNCKQJ8kUFdrAEMSScQL7Ga_vU3c,43
+tests/fetchers/test_camoufox.py,sha256=XPTCDZ9sj_GpCzXyvzKF_uZWhEYX6J_jh_BLeMEl8yY,2874
+tests/fetchers/test_httpx.py,sha256=UivOItR3-l-bXp9E6TP5Tvn2OrCdgiVkWsti-f9xdpU,3507
+tests/fetchers/test_playwright.py,sha256=YOWn89urd9NwoCHfTFj8fY4xYrRY2BeszTt5Q-TxUcs,3479
+tests/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/parser/test_automatch.py,sha256=BeeYJi3cYCghbiZmi57z4bqcGPaoUA8GAm7MALBBkkk,2486
+tests/parser/test_general.py,sha256=NfTuGLgAm-LH0dVV0pvbRcYSNI-wSu05rdnuRzmB0m4,11664
+scrapling-0.2.1.dist-info/LICENSE,sha256=XHgu8DRuT7_g3Hb9Q18YGg8eShp6axPBacbnQxT_WWQ,1499
+scrapling-0.2.1.dist-info/METADATA,sha256=aeExP8jl7VQxIUnfvvo4QxIeasqfziscacOrOoHOuXk,64155
+scrapling-0.2.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+scrapling-0.2.1.dist-info/top_level.txt,sha256=ub7FkOEXeYmmYTUxd4pCrwXfBfAMIpZ1sCGmXCc14tI,16
+scrapling-0.2.1.dist-info/RECORD,,

{scrapling-0.1.2.dist-info → scrapling-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{scrapling-0.1.2.dist-info → scrapling-0.2.1.dist-info}/top_level.txt

@@ -1 +1,2 @@
 scrapling
+tests

tests/__init__.py

@@ -0,0 +1 @@
+"""Package for test project."""

tests/fetchers/__init__.py

@@ -0,0 +1 @@
+# Because I'm too lazy to mock requests :)

tests/fetchers/test_camoufox.py

@@ -0,0 +1,62 @@
+import unittest
+import pytest_httpbin
+
+from scrapling import StealthyFetcher
+
+
+@pytest_httpbin.use_class_based_httpbin
+# @pytest_httpbin.use_class_based_httpbin_secure
+class TestStealthyFetcher(unittest.TestCase):
+    def setUp(self):
+        self.fetcher = StealthyFetcher(auto_match=False)
+        url = self.httpbin.url
+        self.status_200 = f'{url}/status/200'
+        self.status_404 = f'{url}/status/404'
+        self.status_501 = f'{url}/status/501'
+        self.basic_url = f'{url}/get'
+        self.html_url = f'{url}/html'
+        self.delayed_url = f'{url}/delay/10'  # 10 Seconds delay response
+        self.cookies_url = f"{url}/cookies/set/test/value"
+
+    def test_basic_fetch(self):
+        """Test doing basic fetch request with multiple statuses"""
+        self.assertEqual(self.fetcher.fetch(self.status_200).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.status_404).status, 404)
+        self.assertEqual(self.fetcher.fetch(self.status_501).status, 501)
+
+    def test_networkidle(self):
+        """Test if waiting for `networkidle` make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.basic_url, network_idle=True).status, 200)
+
+    def test_blocking_resources(self):
+        """Test if blocking resources make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.basic_url, block_images=True).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.basic_url, disable_resources=True).status, 200)
+
+    def test_waiting_selector(self):
+        """Test if waiting for a selector make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.html_url, wait_selector='h1').status, 200)
+
+    def test_cookies_loading(self):
+        """Test if cookies are set after the request"""
+        self.assertEqual(self.fetcher.fetch(self.cookies_url).cookies, {'test': 'value'})
+
+    def test_automation(self):
+        """Test if automation break the code or not"""
+        def scroll_page(page):
+            page.mouse.wheel(10, 0)
+            page.mouse.move(100, 400)
+            page.mouse.up()
+            return page
+
+        self.assertEqual(self.fetcher.fetch(self.html_url, page_action=scroll_page).status, 200)
+
+    def test_properties(self):
+        """Test if different arguments breaks the code or not"""
+        self.assertEqual(self.fetcher.fetch(self.html_url, block_webrtc=True, allow_webgl=True).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.html_url, block_webrtc=False, allow_webgl=True).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.html_url, block_webrtc=True, allow_webgl=False).status, 200)
+
+    def test_infinite_timeout(self):
+        """Test if infinite timeout breaks the code or not"""
+        self.assertEqual(self.fetcher.fetch(self.delayed_url, timeout=None).status, 200)

tests/fetchers/test_httpx.py

@@ -0,0 +1,67 @@
+import unittest
+import pytest_httpbin
+
+from scrapling import Fetcher
+
+
+@pytest_httpbin.use_class_based_httpbin
+class TestFetcher(unittest.TestCase):
+    def setUp(self):
+        self.fetcher = Fetcher(auto_match=False)
+        url = self.httpbin.url
+        self.status_200 = f'{url}/status/200'
+        self.status_404 = f'{url}/status/404'
+        self.status_501 = f'{url}/status/501'
+        self.basic_url = f'{url}/get'
+        self.post_url = f'{url}/post'
+        self.put_url = f'{url}/put'
+        self.delete_url = f'{url}/delete'
+        self.html_url = f'{url}/html'
+
+    def test_basic_get(self):
+        """Test doing basic get request with multiple statuses"""
+        self.assertEqual(self.fetcher.get(self.status_200).status, 200)
+        self.assertEqual(self.fetcher.get(self.status_404).status, 404)
+        self.assertEqual(self.fetcher.get(self.status_501).status, 501)
+
+    def test_get_properties(self):
+        """Test if different arguments with GET request breaks the code or not"""
+        self.assertEqual(self.fetcher.get(self.status_200, stealthy_headers=True).status, 200)
+        self.assertEqual(self.fetcher.get(self.status_200, follow_redirects=True).status, 200)
+        self.assertEqual(self.fetcher.get(self.status_200, timeout=None).status, 200)
+        self.assertEqual(
+            self.fetcher.get(self.status_200, stealthy_headers=True, follow_redirects=True, timeout=None).status,
+            200
+        )
+
+    def test_post_properties(self):
+        """Test if different arguments with POST request breaks the code or not"""
+        self.assertEqual(self.fetcher.post(self.post_url, data={'key': 'value'}).status, 200)
+        self.assertEqual(self.fetcher.post(self.post_url, data={'key': 'value'}, stealthy_headers=True).status, 200)
+        self.assertEqual(self.fetcher.post(self.post_url, data={'key': 'value'}, follow_redirects=True).status, 200)
+        self.assertEqual(self.fetcher.post(self.post_url, data={'key': 'value'}, timeout=None).status, 200)
+        self.assertEqual(
+            self.fetcher.post(self.post_url, data={'key': 'value'}, stealthy_headers=True, follow_redirects=True, timeout=None).status,
+            200
+        )
+
+    def test_put_properties(self):
+        """Test if different arguments with PUT request breaks the code or not"""
+        self.assertEqual(self.fetcher.put(self.put_url, data={'key': 'value'}).status, 200)
+        self.assertEqual(self.fetcher.put(self.put_url, data={'key': 'value'}, stealthy_headers=True).status, 200)
+        self.assertEqual(self.fetcher.put(self.put_url, data={'key': 'value'}, follow_redirects=True).status, 200)
+        self.assertEqual(self.fetcher.put(self.put_url, data={'key': 'value'}, timeout=None).status, 200)
+        self.assertEqual(
+            self.fetcher.put(self.put_url, data={'key': 'value'}, stealthy_headers=True, follow_redirects=True, timeout=None).status,
+            200
+        )
+
+    def test_delete_properties(self):
+        """Test if different arguments with DELETE request breaks the code or not"""
+        self.assertEqual(self.fetcher.delete(self.delete_url, stealthy_headers=True).status, 200)
+        self.assertEqual(self.fetcher.delete(self.delete_url, follow_redirects=True).status, 200)
+        self.assertEqual(self.fetcher.delete(self.delete_url, timeout=None).status, 200)
+        self.assertEqual(
+            self.fetcher.delete(self.delete_url, stealthy_headers=True, follow_redirects=True, timeout=None).status,
+            200
+        )

tests/fetchers/test_playwright.py

@@ -0,0 +1,74 @@
+import unittest
+import pytest_httpbin
+
+from scrapling import PlayWrightFetcher
+
+
+@pytest_httpbin.use_class_based_httpbin
+# @pytest_httpbin.use_class_based_httpbin_secure
+class TestPlayWrightFetcher(unittest.TestCase):
+    def setUp(self):
+        self.fetcher = PlayWrightFetcher(auto_match=False)
+        url = self.httpbin.url
+        self.status_200 = f'{url}/status/200'
+        self.status_404 = f'{url}/status/404'
+        self.status_501 = f'{url}/status/501'
+        self.basic_url = f'{url}/get'
+        self.html_url = f'{url}/html'
+        self.delayed_url = f'{url}/delay/10'  # 10 Seconds delay response
+        self.cookies_url = f"{url}/cookies/set/test/value"
+
+    def test_basic_fetch(self):
+        """Test doing basic fetch request with multiple statuses"""
+        self.assertEqual(self.fetcher.fetch(self.status_200).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.status_404).status, 404)
+        self.assertEqual(self.fetcher.fetch(self.status_501).status, 501)
+
+    def test_networkidle(self):
+        """Test if waiting for `networkidle` make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.basic_url, network_idle=True).status, 200)
+
+    def test_blocking_resources(self):
+        """Test if blocking resources make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.basic_url, disable_resources=True).status, 200)
+
+    def test_waiting_selector(self):
+        """Test if waiting for a selector make page does not finish loading or not"""
+        self.assertEqual(self.fetcher.fetch(self.html_url, wait_selector='h1').status, 200)
+
+    def test_cookies_loading(self):
+        """Test if cookies are set after the request"""
+        self.assertEqual(self.fetcher.fetch(self.cookies_url).cookies, {'test': 'value'})
+
+    def test_automation(self):
+        """Test if automation break the code or not"""
+        def scroll_page(page):
+            page.mouse.wheel(10, 0)
+            page.mouse.move(100, 400)
+            page.mouse.up()
+            return page
+
+        self.assertEqual(self.fetcher.fetch(self.html_url, page_action=scroll_page).status, 200)
+
+    def test_properties(self):
+        """Test if different arguments breaks the code or not"""
+        self.assertEqual(self.fetcher.fetch(self.html_url, disable_webgl=True, hide_canvas=False).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.html_url, disable_webgl=False, hide_canvas=True).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.html_url, stealth=True).status, 200)
+        self.assertEqual(self.fetcher.fetch(self.html_url, useragent='Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0').status, 200)
+
+    def test_cdp_url(self):
+        """Test if it's going to try to connect to cdp url or not"""
+        with self.assertRaises(ValueError):
+            _ = self.fetcher.fetch(self.html_url, cdp_url='blahblah')
+
+        with self.assertRaises(ValueError):
+            _ = self.fetcher.fetch(self.html_url, cdp_url='blahblah', nstbrowser_mode=True)
+
+        with self.assertRaises(Exception):
+            # There's no type for this error in PlayWright, it's just `Error`
+            _ = self.fetcher.fetch(self.html_url, cdp_url='ws://blahblah')
+
+    def test_infinite_timeout(self):
+        """Test if infinite timeout breaks the code or not"""
+        self.assertEqual(self.fetcher.fetch(self.delayed_url, timeout=None).status, 200)

tests/parser/test_automatch.py

@@ -0,0 +1,56 @@
+import unittest
+
+from scrapling import Adaptor
+
+
+class TestParserAutoMatch(unittest.TestCase):
+
+    def test_element_relocation(self):
+        """Test relocating element after structure change"""
+        original_html = '''
+                <div class="container">
+                    <section class="products">
+                        <article class="product" id="p1">
+                            <h3>Product 1</h3>
+                            <p class="description">Description 1</p>
+                        </article>
+                        <article class="product" id="p2">
+                            <h3>Product 2</h3>
+                            <p class="description">Description 2</p>
+                        </article>
+                    </section>
+                </div>
+                '''
+        changed_html = '''
+                <div class="new-container">
+                    <div class="product-wrapper">
+                        <section class="products">
+                            <article class="product new-class" data-id="p1">
+                                <div class="product-info">
+                                    <h3>Product 1</h3>
+                                    <p class="new-description">Description 1</p>
+                                </div>
+                            </article>
+                            <article class="product new-class" data-id="p2">
+                                <div class="product-info">
+                                    <h3>Product 2</h3>
+                                    <p class="new-description">Description 2</p>
+                                </div>
+                            </article>
+                        </section>
+                    </div>
+                </div>
+                '''
+
+        old_page = Adaptor(original_html, url='example.com', auto_match=True, debug=True)
+        new_page = Adaptor(changed_html, url='example.com', auto_match=True, debug=True)
+
+        # 'p1' was used as ID and now it's not and all the path elements have changes
+        # Also at the same time testing auto-match vs combined selectors
+        _ = old_page.css('#p1, #p2', auto_save=True)[0]
+        relocated = new_page.css('#p1', auto_match=True)
+
+        self.assertIsNotNone(relocated)
+        self.assertEqual(relocated[0].attrib['data-id'], 'p1')
+        self.assertTrue(relocated[0].has_class('new-class'))
+        self.assertEqual(relocated[0].css('.new-description')[0].text, 'Description 1')

tests/parser/test_general.py

@@ -0,0 +1,286 @@
+
+import pickle
+import unittest
+from scrapling import Adaptor
+from cssselect import SelectorError, SelectorSyntaxError
+
+
+class TestParser(unittest.TestCase):
+    def setUp(self):
+        self.html = '''
+        <html>
+        <head>
+            <title>Complex Web Page</title>
+            <style>
+                .hidden { display: none; }
+            </style>
+        </head>
+        <body>
+            <header>
+                <nav>
+                    <ul>
+                        <li><a href="#home">Home</a></li>
+                        <li><a href="#about">About</a></li>
+                        <li><a href="#contact">Contact</a></li>
+                    </ul>
+                </nav>
+            </header>
+            <main>
+                <section id="products" schema='{"jsonable": "data"}'>
+                    <h2>Products</h2>
+                    <div class="product-list">
+                        <article class="product" data-id="1">
+                            <h3>Product 1</h3>
+                            <p class="description">This is product 1</p>
+                            <span class="price">$10.99</span>
+                            <div class="hidden stock">In stock: 5</div>
+                        </article>
+                        <article class="product" data-id="2">
+                            <h3>Product 2</h3>
+                            <p class="description">This is product 2</p>
+                            <span class="price">$20.99</span>
+                            <div class="hidden stock">In stock: 3</div>
+                        </article>
+                        <article class="product" data-id="3">
+                            <h3>Product 3</h3>
+                            <p class="description">This is product 3</p>
+                            <span class="price">$15.99</span>
+                            <div class="hidden stock">Out of stock</div>
+                        </article>
+                    </div>
+                </section>
+                <section id="reviews">
+                    <h2>Customer Reviews</h2>
+                    <div class="review-list">
+                        <div class="review" data-rating="5">
+                            <p class="review-text">Great product!</p>
+                            <span class="reviewer">John Doe</span>
+                        </div>
+                        <div class="review" data-rating="4">
+                            <p class="review-text">Good value for money.</p>
+                            <span class="reviewer">Jane Smith</span>
+                        </div>
+                    </div>
+                </section>
+            </main>
+            <footer>
+                <p>&copy; 2024 Our Company</p>
+            </footer>
+            <script id="page-data" type="application/json">
+                {"lastUpdated": "2024-09-22T10:30:00Z", "totalProducts": 3}
+            </script>
+        </body>
+        </html>
+        '''
+        self.page = Adaptor(self.html, auto_match=False, debug=False)
+
+    def test_css_selector(self):
+        """Test Selecting elements with complex CSS selectors"""
+        elements = self.page.css('main #products .product-list article.product')
+        self.assertEqual(len(elements), 3)
+
+        in_stock_products = self.page.css(
+            'main #products .product-list article.product:not(:contains("Out of stock"))')
+        self.assertEqual(len(in_stock_products), 2)
+
+    def test_xpath_selector(self):
+        """Test Selecting elements with Complex XPath selectors"""
+        reviews = self.page.xpath(
+            '//section[@id="reviews"]//div[contains(@class, "review") and @data-rating >= 4]'
+        )
+        self.assertEqual(len(reviews), 2)
+
+        high_priced_products = self.page.xpath(
+            '//article[contains(@class, "product")]'
+            '[number(translate(substring-after(.//span[@class="price"], "$"), ",", "")) > 15]'
+        )
+        self.assertEqual(len(high_priced_products), 2)
+
+    def test_find_by_text(self):
+        """Test Selecting elements with Text matching"""
+        stock_info = self.page.find_by_regex(r'In stock: \d+', first_match=False)
+        self.assertEqual(len(stock_info), 2)
+
+        stock_info = self.page.find_by_regex(r'In stock: \d+', first_match=True, case_sensitive=True)
+        self.assertEqual(stock_info.text, 'In stock: 5')
+
+        stock_info = self.page.find_by_text(r'In stock:', partial=True, first_match=False)
+        self.assertEqual(len(stock_info), 2)
+
+        out_of_stock = self.page.find_by_text('Out of stock', partial=False, first_match=False)
+        self.assertEqual(len(out_of_stock), 1)
+
+    def test_find_similar_elements(self):
+        """Test Finding similar elements of an element"""
+        first_product = self.page.css_first('.product')
+        similar_products = first_product.find_similar()
+        self.assertEqual(len(similar_products), 2)
+
+        first_review = self.page.find('div', class_='review')
+        similar_high_rated_reviews = [
+            review
+            for review in first_review.find_similar()
+            if int(review.attrib.get('data-rating', 0)) >= 4
+        ]
+        self.assertEqual(len(similar_high_rated_reviews), 1)
+
+    def test_expected_errors(self):
+        """Test errors that should raised if it does"""
+        with self.assertRaises(ValueError):
+            _ = Adaptor(auto_match=False)
+
+        with self.assertRaises(TypeError):
+            _ = Adaptor(root="ayo", auto_match=False)
+
+        with self.assertRaises(TypeError):
+            _ = Adaptor(text=1, auto_match=False)
+
+        with self.assertRaises(TypeError):
+            _ = Adaptor(body=1, auto_match=False)
+
+        with self.assertRaises(ValueError):
+            _ = Adaptor(self.html, storage=object, auto_match=True)
+
+    def test_pickleable(self):
+        """Test that objects aren't pickleable"""
+        table = self.page.css('.product-list')[0]
+        with self.assertRaises(TypeError):  # Adaptors
+            pickle.dumps(table)
+
+        with self.assertRaises(TypeError):  # Adaptor
+            pickle.dumps(table[0])
+
+    def test_overridden(self):
+        """Test overridden functions"""
+        table = self.page.css('.product-list')[0]
+        self.assertTrue(issubclass(type(table.__str__()), str))
+        self.assertTrue(issubclass(type(table.__repr__()), str))
+        self.assertTrue(issubclass(type(table.attrib.__str__()), str))
+        self.assertTrue(issubclass(type(table.attrib.__repr__()), str))
+
+    def test_bad_selector(self):
+        """Test object can handle bad selector"""
+        with self.assertRaises((SelectorError, SelectorSyntaxError,)):
+            self.page.css('4 ayo')
+
+        with self.assertRaises((SelectorError, SelectorSyntaxError,)):
+            self.page.xpath('4 ayo')
+
+    def test_selectors_generation(self):
+        """Try to create selectors for all elements in the page"""
+        def _traverse(element: Adaptor):
+            self.assertTrue(type(element.generate_css_selector) is str)
+            self.assertTrue(type(element.generate_xpath_selector) is str)
+            for branch in element.children:
+                _traverse(branch)
+
+        _traverse(self.page)
+
+    def test_getting_all_text(self):
+        """Test getting all text"""
+        self.assertNotEqual(self.page.get_all_text(), '')
+
+    def test_element_navigation(self):
+        """Test moving in the page from selected element"""
+        table = self.page.css('.product-list')[0]
+
+        self.assertIsNot(table.path, [])
+        self.assertNotEqual(table.html_content, '')
+        self.assertNotEqual(table.prettify(), '')
+
+        parent = table.parent
+        self.assertEqual(parent.attrib['id'], 'products')
+
+        children = table.children
+        self.assertEqual(len(children), 3)
+
+        parent_siblings = parent.siblings
+        self.assertEqual(len(parent_siblings), 1)
+
+        child = table.find({'data-id': "1"})
+        next_element = child.next
+        self.assertEqual(next_element.attrib['data-id'], '2')
+
+        prev_element = next_element.previous
+        self.assertEqual(prev_element.tag, child.tag)
+
+        all_prices = self.page.css('.price')
+        products_with_prices = [
+            price.find_ancestor(lambda p: p.has_class('product'))
+            for price in all_prices
+        ]
+        self.assertEqual(len(products_with_prices), 3)
+
+    def test_empty_return(self):
+        """Test cases where functions shouldn't have results"""
+        test_html = """
+        <html>
+            <span id="a"><a></a><!--comment--></span>
+            <span id="b"><!--comment--><a></a></span>
+        </html>"""
+        soup = Adaptor(test_html, auto_match=False, keep_comments=False)
+        html_tag = soup.css('html')[0]
+        self.assertEqual(html_tag.path, [])
+        self.assertEqual(html_tag.siblings, [])
+        self.assertEqual(html_tag.parent, None)
+        self.assertEqual(html_tag.find_ancestor(lambda e: e), None)
+
+        self.assertEqual(soup.css('#a a')[0].next, None)
+        self.assertEqual(soup.css('#b a')[0].previous, None)
+
+    def test_text_to_json(self):
+        """Test converting text to json"""
+        script_content = self.page.css('#page-data::text')[0]
+        self.assertTrue(issubclass(type(script_content.sort()), str))
+        page_data = script_content.json()
+        self.assertEqual(page_data['totalProducts'], 3)
+        self.assertTrue('lastUpdated' in page_data)
+
+    def test_regex_on_text(self):
+        """Test doing regex on a selected text"""
+        element = self.page.css('[data-id="1"] .price')[0]
+        match = element.re_first(r'[\.\d]+')
+        self.assertEqual(match, '10.99')
+        match = element.text.re(r'(\d+)', replace_entities=False)
+        self.assertEqual(len(match), 2)
+
+    def test_attribute_operations(self):
+        """Test operations on elements attributes"""
+        products = self.page.css('.product')
+        product_ids = [product.attrib['data-id'] for product in products]
+        self.assertEqual(product_ids, ['1', '2', '3'])
+        self.assertTrue('data-id' in products[0].attrib)
+
+        reviews = self.page.css('.review')
+        review_ratings = [int(review.attrib['data-rating']) for review in reviews]
+        self.assertEqual(sum(review_ratings) / len(review_ratings), 4.5)
+
+        key_value = list(products[0].attrib.search_values('1', partial=False))
+        self.assertEqual(list(key_value[0].keys()), ['data-id'])
+
+        key_value = list(products[0].attrib.search_values('1', partial=True))
+        self.assertEqual(list(key_value[0].keys()), ['data-id'])
+
+        attr_json = self.page.css_first('#products').attrib['schema'].json()
+        self.assertEqual(attr_json, {'jsonable': 'data'})
+        self.assertEqual(type(self.page.css('#products')[0].attrib.json_string), bytes)
+
+    def test_performance(self):
+        """Test parsing and selecting speed"""
+        import time
+        large_html = '<html><body>' + '<div class="item">' * 5000 + '</div>' * 5000 + '</body></html>'
+
+        start_time = time.time()
+        parsed = Adaptor(large_html, auto_match=False, debug=False)
+        elements = parsed.css('.item')
+        end_time = time.time()
+
+        self.assertEqual(len(elements), 5000)
+        # Converting 5000 elements to a class and doing operations on them will take time
+        # Based on my tests with 100 runs, 1 loop each Scrapling (given the extra work/features) takes 10.4ms on average
+        self.assertLess(end_time - start_time, 0.1)
+
+
+# Use `coverage run -m unittest --verbose tests/test_parser_functions.py` instead for the coverage report
+# if __name__ == '__main__':
+#     unittest.main(verbosity=2)