mini-search-engine 1.0.0__tar.gz

mini_search_engine-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jules
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mini_search_engine-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include requirements.txt
+include LICENSE

mini_search_engine-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: mini_search_engine
+Version: 1.0.0
+Summary: A simple search engine library scraping Google and DuckDuckGo.
+Home-page: https://github.com/yourusername/mini-search-engine
+Author: Jules
+Author-email: jules@example.com
+Project-URL: Bug Reports, https://github.com/yourusername/mini-search-engine/issues
+Project-URL: Source, https://github.com/yourusername/mini-search-engine
+Keywords: search,google,duckduckgo,scraping,crawler
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: lxml
+Requires-Dist: certifi
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Mini Search Engine
+
+A flexible Python library that scrapes Google and DuckDuckGo for search results. It supports extensive search features including pagination, safe search, and time filtering.
+
+## Features
+
+-   **Multi-Engine Support**: Search via Google or DuckDuckGo.
+-   **Smart Fallback**: Automatically tries the next available engine if the primary one is blocked (e.g., falls back to DuckDuckGo if Google blocks).
+-   **Pagination**: Retrieve as many results as you need.
+-   **Safe Search**: Control safe search strictness (`strict`, `moderate`, `off`).
+-   **Time Filtering**: Filter results by day, week, month, or year.
+-   **No API Key Needed**: Uses direct web scraping.
+
+## Installation
+
+You can install the package directly from PyPI:
+
+```bash
+pip install mini-search-engine
+```
+
+Or install locally from source:
+
+```bash
+git clone https://github.com/yourusername/mini-search-engine.git
+cd mini-search-engine
+pip install .
+```
+
+## Usage
+
+```python
+from mini_search_engine import SearchEngine
+import logging
+
+# Optional: Enable logging to see what's happening under the hood
+logging.basicConfig(level=logging.INFO)
+
+engine = SearchEngine()
+
+# Simple Search
+results = engine.search("python programming")
+for res in results:
+    print(res['title'], res['link'])
+
+# Advanced Search with Filters
+results = engine.search(
+    "latest python news",
+    engine="auto",       # Try Google, then DDG
+    limit=20,            # Get 20 results (handles pagination automatically)
+    safe="strict",       # Strict safe search
+    time_range="w"       # Past week
+)
+
+print(f"\nFound {len(results)} results:")
+for i, res in enumerate(results):
+    print(f"#{i+1} [{res['source']}] {res['title']}")
+    print(f"Link: {res['link']}")
+    print(f"Snippet: {res['snippet']}")
+    print("-" * 30)
+```
+
+## API Reference
+
+### `search(query, engine="auto", limit=10, safe="moderate", time_range=None)`
+
+-   `query` (str): The search query.
+-   `engine` (str): `'google'`, `'ddg'`, or `'auto'`. Defaults to `'auto'`.
+-   `limit` (int): Number of results to return. Defaults to `10`.
+-   `safe` (str): Safe search level: `'strict'`, `'moderate'`, `'off'`. Defaults to `'moderate'`.
+-   `time_range` (str): `'d'` (day), `'w'` (week), `'m'` (month), `'y'` (year). Defaults to `None` (any time).
+
+## License
+
+MIT License

mini_search_engine-1.0.0/README.md

@@ -0,0 +1,75 @@
+# Mini Search Engine
+
+A flexible Python library that scrapes Google and DuckDuckGo for search results. It supports extensive search features including pagination, safe search, and time filtering.
+
+## Features
+
+-   **Multi-Engine Support**: Search via Google or DuckDuckGo.
+-   **Smart Fallback**: Automatically tries the next available engine if the primary one is blocked (e.g., falls back to DuckDuckGo if Google blocks).
+-   **Pagination**: Retrieve as many results as you need.
+-   **Safe Search**: Control safe search strictness (`strict`, `moderate`, `off`).
+-   **Time Filtering**: Filter results by day, week, month, or year.
+-   **No API Key Needed**: Uses direct web scraping.
+
+## Installation
+
+You can install the package directly from PyPI:
+
+```bash
+pip install mini-search-engine
+```
+
+Or install locally from source:
+
+```bash
+git clone https://github.com/yourusername/mini-search-engine.git
+cd mini-search-engine
+pip install .
+```
+
+## Usage
+
+```python
+from mini_search_engine import SearchEngine
+import logging
+
+# Optional: Enable logging to see what's happening under the hood
+logging.basicConfig(level=logging.INFO)
+
+engine = SearchEngine()
+
+# Simple Search
+results = engine.search("python programming")
+for res in results:
+    print(res['title'], res['link'])
+
+# Advanced Search with Filters
+results = engine.search(
+    "latest python news",
+    engine="auto",       # Try Google, then DDG
+    limit=20,            # Get 20 results (handles pagination automatically)
+    safe="strict",       # Strict safe search
+    time_range="w"       # Past week
+)
+
+print(f"\nFound {len(results)} results:")
+for i, res in enumerate(results):
+    print(f"#{i+1} [{res['source']}] {res['title']}")
+    print(f"Link: {res['link']}")
+    print(f"Snippet: {res['snippet']}")
+    print("-" * 30)
+```
+
+## API Reference
+
+### `search(query, engine="auto", limit=10, safe="moderate", time_range=None)`
+
+-   `query` (str): The search query.
+-   `engine` (str): `'google'`, `'ddg'`, or `'auto'`. Defaults to `'auto'`.
+-   `limit` (int): Number of results to return. Defaults to `10`.
+-   `safe` (str): Safe search level: `'strict'`, `'moderate'`, `'off'`. Defaults to `'moderate'`.
+-   `time_range` (str): `'d'` (day), `'w'` (week), `'m'` (month), `'y'` (year). Defaults to `None` (any time).
+
+## License
+
+MIT License

mini_search_engine-1.0.0/mini_search_engine/__init__.py

@@ -0,0 +1,3 @@
+from .engine import SearchEngine
+
+__all__ = ['SearchEngine']

mini_search_engine-1.0.0/mini_search_engine/engine.py

@@ -0,0 +1,267 @@
+import requests
+from bs4 import BeautifulSoup
+import logging
+import time
+import random
+import urllib.parse
+
+# Configure logger
+logger = logging.getLogger(__name__)
+
+class SearchEngine:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        })
+
+    def build_db(self, start_urls=None, max_pages=50, max_workers=10, timeout=None):
+        """
+        Deprecated: This method is no longer needed as the search engine
+        now queries the web directly. Kept for compatibility.
+        """
+        print("Note: build_db() is deprecated and does nothing. The engine searches the live web now.")
+        logger.warning("build_db() called but is deprecated.")
+
+    def search(self, query, engine="auto", limit=10, safe="moderate", time_range=None):
+        """
+        Searches the web for the query with extensive control.
+
+        Args:
+            query (str): The search query.
+            engine (str): 'google', 'ddg', or 'auto'. Defaults to 'auto'.
+                          If the specified engine fails, it will attempt the other one.
+            limit (int): Approximate number of results to return. Defaults to 10.
+            safe (str): Safe search level. 'strict', 'moderate', or 'off'.
+                        Defaults to 'moderate'.
+            time_range (str): 'd' (day), 'w' (week), 'm' (month), 'y' (year).
+                              Defaults to None (any time).
+
+        Returns:
+            list: A list of result dictionaries.
+        """
+        print(f"Searching for: '{query}' (Engine: {engine}, Limit: {limit}, Safe: {safe}, Time: {time_range})")
+
+        # Determine execution order
+        engines_to_try = []
+        if engine.lower() == 'google':
+            engines_to_try = ['google', 'ddg']
+        elif engine.lower() == 'ddg' or engine.lower() == 'duckduckgo':
+            engines_to_try = ['ddg', 'google']
+        else:
+            engines_to_try = ['google', 'ddg'] # Default preference
+
+        for eng in engines_to_try:
+            results = []
+            if eng == 'google':
+                results = self._search_google(query, limit, safe, time_range)
+            elif eng == 'ddg':
+                results = self._search_duckduckgo(query, limit, safe, time_range)
+
+            if results:
+                return results[:limit]
+
+            print(f"{eng.capitalize()} returned no results or failed. Trying next available engine...")
+
+        print("All engines failed to return results.")
+        return []
+
+    def _search_google(self, query, limit, safe, time_range):
+        base_url = "https://www.google.com/search"
+        results = []
+        start = 0
+
+        # Map parameters
+        params = {
+            "q": query,
+            "hl": "en"
+        }
+
+        # Safe Search
+        if safe == 'strict':
+            params['safe'] = 'active'
+        elif safe == 'off':
+            params['safe'] = 'images' # 'off' isn't explicitly 'off' in url, but omitting often defaults to moderate. 'images' is a trick or just omit.
+            # Actually, omitting 'safe' is usually moderate. explicit 'safe=active' is strict.
+            # To turn OFF, sometimes 'safe=off' works or 'safe=undefined'.
+            # We'll just omit it for 'off' and 'moderate', and use 'active' for strict.
+            if 'safe' in params: del params['safe']
+
+        # Time Range
+        if time_range:
+            # Map d, w, m, y to qdr:d, qdr:w, etc.
+            tr_map = {'d': 'd', 'w': 'w', 'm': 'm', 'y': 'y'}
+            if time_range in tr_map:
+                params['tbs'] = f"qdr:{tr_map[time_range]}"
+
+        while len(results) < limit:
+            # Use a copy of params to avoid mutation issues in mocks/retries
+            current_params = params.copy()
+            current_params['start'] = start
+
+            try:
+                # Add random delay if paging
+                if start > 0:
+                    time.sleep(random.uniform(1.0, 2.5))
+
+                response = self.session.get(base_url, params=current_params, timeout=10)
+                response.raise_for_status()
+
+                if "systems have detected unusual traffic" in response.text or "recaptcha" in response.text.lower():
+                    logger.warning("Google blocked the request.")
+                    break
+
+                soup = BeautifulSoup(response.text, "lxml")
+                current_page_results = []
+
+                for g in soup.select("div.g"):
+                    title_elem = g.select_one("h3")
+                    link_elem = g.select_one("a")
+
+                    if title_elem and link_elem:
+                        title = title_elem.get_text()
+                        link = link_elem["href"]
+
+                        if "/url?q=" in link:
+                            raw_link = link.split("/url?q=")[1].split("&")[0]
+                            link = urllib.parse.unquote(raw_link)
+
+                        snippet = "No snippet"
+                        snippet_div = g.select_one("div.VwiC3b, div.IsZvec, span.aCOpRe")
+                        if snippet_div:
+                            snippet = snippet_div.get_text()
+
+                        res = {
+                            "title": title,
+                            "link": link,
+                            "snippet": snippet,
+                            "score": 1.0,
+                            "source": "google"
+                        }
+                        current_page_results.append(res)
+                        results.append(res)
+
+                        if len(results) >= limit:
+                            break
+
+                if not current_page_results:
+                    # No more results on this page
+                    break
+
+                start += 10
+
+            except Exception as e:
+                logger.error(f"Google search failed: {e}")
+                break
+
+        return results
+
+    def _search_duckduckgo(self, query, limit, safe, time_range):
+        url = "https://html.duckduckgo.com/html/"
+        results = []
+
+        # Initial Params
+        data = {
+            "q": query,
+            "kl": "us-en" # Default region
+        }
+
+        # Safe Search
+        # kp: -2 (strict), -1 (off), 1 (moderate)?
+        # Checking online: kp=-2 is strict, kp=-1 is off. kp=1 is moderate.
+        if safe == 'strict':
+            data['kp'] = '-2'
+        elif safe == 'off':
+            data['kp'] = '-1'
+        else:
+            data['kp'] = '1' # moderate
+
+        # Time Range
+        if time_range:
+            tr_map = {'d': 'd', 'w': 'w', 'm': 'm', 'y': 'y'}
+            if time_range in tr_map:
+                data['df'] = tr_map[time_range]
+
+        while len(results) < limit:
+            try:
+                # Add random delay if paging
+                if len(results) > 0:
+                    time.sleep(random.uniform(0.5, 1.5))
+
+                response = self.session.post(url, data=data, timeout=10)
+                response.raise_for_status()
+
+                soup = BeautifulSoup(response.text, "html.parser")
+                current_page_results = []
+
+                # Parse Results
+                for result in soup.select(".result"):
+                    if "result--ad" in result.get("class", []):
+                        continue
+
+                    title_elem = result.select_one(".result__a")
+                    snippet_elem = result.select_one(".result__snippet")
+
+                    if title_elem:
+                        title = title_elem.get_text(strip=True)
+                        raw_link = title_elem["href"]
+                        link = raw_link
+
+                        # Decode DDG redirection
+                        if "uddg=" in raw_link:
+                            try:
+                                parsed = urllib.parse.urlparse(raw_link)
+                                qs = urllib.parse.parse_qs(parsed.query)
+                                if 'uddg' in qs:
+                                    link = qs['uddg'][0]
+                            except Exception:
+                                pass
+
+                        snippet = snippet_elem.get_text(strip=True) if snippet_elem else "No snippet"
+
+                        res = {
+                            "title": title,
+                            "link": link,
+                            "snippet": snippet,
+                            "score": 1.0,
+                            "source": "duckduckgo"
+                        }
+                        current_page_results.append(res)
+                        results.append(res)
+
+                        if len(results) >= limit:
+                            break
+
+                if not current_page_results:
+                    break
+
+                # Check for limit
+                if len(results) >= limit:
+                    break
+
+                # Pagination: Find the "Next" form
+                # Usually a form with action="/html/" and input value="Next"
+                next_form = None
+                for form in soup.select("form[action='/html/']"):
+                    if form.select_one("input[value='Next']"):
+                        next_form = form
+                        break
+
+                if next_form:
+                    # Extract inputs for the next request
+                    new_data = {}
+                    for inp in next_form.select("input"):
+                        name = inp.get("name")
+                        value = inp.get("value")
+                        if name:
+                            new_data[name] = value
+                    data = new_data
+                else:
+                    # No next page
+                    break
+
+            except Exception as e:
+                logger.error(f"DuckDuckGo search failed: {e}")
+                break
+
+        return results

mini_search_engine-1.0.0/mini_search_engine.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: mini_search_engine
+Version: 1.0.0
+Summary: A simple search engine library scraping Google and DuckDuckGo.
+Home-page: https://github.com/yourusername/mini-search-engine
+Author: Jules
+Author-email: jules@example.com
+Project-URL: Bug Reports, https://github.com/yourusername/mini-search-engine/issues
+Project-URL: Source, https://github.com/yourusername/mini-search-engine
+Keywords: search,google,duckduckgo,scraping,crawler
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: lxml
+Requires-Dist: certifi
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Mini Search Engine
+
+A flexible Python library that scrapes Google and DuckDuckGo for search results. It supports extensive search features including pagination, safe search, and time filtering.
+
+## Features
+
+-   **Multi-Engine Support**: Search via Google or DuckDuckGo.
+-   **Smart Fallback**: Automatically tries the next available engine if the primary one is blocked (e.g., falls back to DuckDuckGo if Google blocks).
+-   **Pagination**: Retrieve as many results as you need.
+-   **Safe Search**: Control safe search strictness (`strict`, `moderate`, `off`).
+-   **Time Filtering**: Filter results by day, week, month, or year.
+-   **No API Key Needed**: Uses direct web scraping.
+
+## Installation
+
+You can install the package directly from PyPI:
+
+```bash
+pip install mini-search-engine
+```
+
+Or install locally from source:
+
+```bash
+git clone https://github.com/yourusername/mini-search-engine.git
+cd mini-search-engine
+pip install .
+```
+
+## Usage
+
+```python
+from mini_search_engine import SearchEngine
+import logging
+
+# Optional: Enable logging to see what's happening under the hood
+logging.basicConfig(level=logging.INFO)
+
+engine = SearchEngine()
+
+# Simple Search
+results = engine.search("python programming")
+for res in results:
+    print(res['title'], res['link'])
+
+# Advanced Search with Filters
+results = engine.search(
+    "latest python news",
+    engine="auto",       # Try Google, then DDG
+    limit=20,            # Get 20 results (handles pagination automatically)
+    safe="strict",       # Strict safe search
+    time_range="w"       # Past week
+)
+
+print(f"\nFound {len(results)} results:")
+for i, res in enumerate(results):
+    print(f"#{i+1} [{res['source']}] {res['title']}")
+    print(f"Link: {res['link']}")
+    print(f"Snippet: {res['snippet']}")
+    print("-" * 30)
+```
+
+## API Reference
+
+### `search(query, engine="auto", limit=10, safe="moderate", time_range=None)`
+
+-   `query` (str): The search query.
+-   `engine` (str): `'google'`, `'ddg'`, or `'auto'`. Defaults to `'auto'`.
+-   `limit` (int): Number of results to return. Defaults to `10`.
+-   `safe` (str): Safe search level: `'strict'`, `'moderate'`, `'off'`. Defaults to `'moderate'`.
+-   `time_range` (str): `'d'` (day), `'w'` (week), `'m'` (month), `'y'` (year). Defaults to `None` (any time).
+
+## License
+
+MIT License

mini_search_engine-1.0.0/mini_search_engine.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+mini_search_engine/__init__.py
+mini_search_engine/engine.py
+mini_search_engine.egg-info/PKG-INFO
+mini_search_engine.egg-info/SOURCES.txt
+mini_search_engine.egg-info/dependency_links.txt
+mini_search_engine.egg-info/requires.txt
+mini_search_engine.egg-info/top_level.txt
+tests/test_engine.py

mini_search_engine-1.0.0/mini_search_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mini_search_engine-1.0.0/mini_search_engine.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests
+beautifulsoup4
+lxml
+certifi

mini_search_engine-1.0.0/mini_search_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+mini_search_engine

mini_search_engine-1.0.0/requirements.txt

@@ -0,0 +1,4 @@
+beautifulsoup4>=4.0.0
+requests>=2.0.0
+lxml>=4.6.0
+certifi>=2020.0.0

mini_search_engine-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mini_search_engine-1.0.0/setup.py

@@ -0,0 +1,43 @@
+from setuptools import setup, find_packages
+import pathlib
+
+# Read the contents of your README file
+here = pathlib.Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="mini_search_engine",
+    version="1.0.0",
+    description="A simple search engine library scraping Google and DuckDuckGo.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/mini-search-engine",
+    author="Jules",
+    author_email="jules@example.com",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Operating System :: OS Independent",
+    ],
+    keywords="search, google, duckduckgo, scraping, crawler",
+    packages=find_packages(),
+    python_requires=">=3.6",
+    install_requires=[
+        "requests",
+        "beautifulsoup4",
+        "lxml",
+        "certifi"
+    ],
+    project_urls={
+        "Bug Reports": "https://github.com/yourusername/mini-search-engine/issues",
+        "Source": "https://github.com/yourusername/mini-search-engine",
+    },
+)

mini_search_engine-1.0.0/tests/test_engine.py

@@ -0,0 +1,125 @@
+import unittest
+from unittest.mock import patch, Mock
+import os
+import sys
+
+# Add the parent directory to the path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from mini_search_engine.engine import SearchEngine
+
+class TestMiniSearchEngine(unittest.TestCase):
+
+    def setUp(self):
+        self.engine = SearchEngine()
+
+    @patch('mini_search_engine.engine.requests.Session.get')
+    def test_search_google_basic(self, mock_get):
+        # Mock Google response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = """
+        <html><body>
+            <div class="g">
+                <h3>Google Result</h3>
+                <a href="/url?q=http://google.com/res">Link</a>
+                <div class="VwiC3b">Snippet</div>
+            </div>
+        </body></html>
+        """
+        mock_get.return_value = mock_response
+
+        # Set limit=1 to avoid looping endlessly with the same mock response
+        results = self.engine.search("test", engine="google", limit=1)
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]['source'], "google")
+
+        # Verify params
+        args, kwargs = mock_get.call_args
+        self.assertEqual(kwargs['params']['q'], "test")
+
+    @patch('mini_search_engine.engine.requests.Session.post')
+    def test_search_ddg_basic(self, mock_post):
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = """
+        <html><body>
+            <div class="result">
+                <a class="result__a" href="//duckduckgo.com/l/?uddg=http://ddg.com/res">DDG Result</a>
+                <div class="result__snippet">Snippet</div>
+            </div>
+        </body></html>
+        """
+        mock_post.return_value = mock_response
+
+        results = self.engine.search("test", engine="ddg")
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]['source'], "duckduckgo")
+        self.assertEqual(results[0]['link'], "http://ddg.com/res")
+
+    @patch('mini_search_engine.engine.requests.Session.get')
+    @patch('mini_search_engine.engine.requests.Session.post')
+    def test_fallback_logic(self, mock_post, mock_get):
+        # Google fails (blocked)
+        mock_google = Mock()
+        mock_google.status_code = 200
+        mock_google.text = "systems have detected unusual traffic"
+        mock_get.return_value = mock_google
+
+        # DDG succeeds
+        mock_ddg = Mock()
+        mock_ddg.status_code = 200
+        mock_ddg.text = """
+        <html><body>
+            <div class="result">
+                <a class="result__a" href="http://res.com">Res</a>
+            </div>
+        </body></html>
+        """
+        mock_post.return_value = mock_ddg
+
+        # Request 'auto' (defaults to Google -> DDG)
+        results = self.engine.search("test", engine="auto")
+
+        self.assertTrue(mock_get.called)
+        self.assertTrue(mock_post.called)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]['source'], "duckduckgo")
+
+    @patch('mini_search_engine.engine.requests.Session.get')
+    def test_google_pagination_and_limit(self, mock_get):
+        # Mock 2 pages
+        page1 = Mock()
+        page1.status_code = 200
+        page1.text = """
+        <div class="g"><h3>R1</h3><a href="l1">L</a></div>
+        <div class="g"><h3>R2</h3><a href="l2">L</a></div>
+        """
+
+        page2 = Mock()
+        page2.status_code = 200
+        page2.text = """
+        <div class="g"><h3>R3</h3><a href="l3">L</a></div>
+        """
+
+        mock_get.side_effect = [page1, page2]
+
+        # Limit 3 results
+        results = self.engine.search("test", engine="google", limit=3)
+
+        self.assertEqual(len(results), 3)
+        self.assertEqual(results[0]['title'], "R1")
+        self.assertEqual(results[2]['title'], "R3")
+
+        # Verify calls
+        self.assertEqual(mock_get.call_count, 2)
+        # Check start params
+        args1, kwargs1 = mock_get.call_args_list[0]
+        self.assertEqual(kwargs1['params']['start'], 0)
+        args2, kwargs2 = mock_get.call_args_list[1]
+        self.assertEqual(kwargs2['params']['start'], 10)
+
+if __name__ == '__main__':
+    unittest.main()