tavily-python 0.7.5__tar.gz → 0.7.7__tar.gz

{tavily_python-0.7.5 → tavily_python-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tavily-python
-Version: 0.7.5
+Version: 0.7.7
 Summary: Python wrapper for the Tavily API
 Home-page: https://github.com/tavily-ai/tavily-python
 Author: Tavily AI

{tavily_python-0.7.5 → tavily_python-0.7.7}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='tavily-python',
-    version='0.7.5',
+    version='0.7.7',
     url='https://github.com/tavily-ai/tavily-python',
     author='Tavily AI',
     author_email='support@tavily.com',

{tavily_python-0.7.5 → tavily_python-0.7.7}/tavily/async_tavily.py

@@ -42,7 +42,8 @@ class AsyncTavilyClient:
         self._client_creator = lambda: httpx.AsyncClient(
             headers={
                 "Content-Type": "application/json",
-                "Authorization": f"Bearer {api_key}"
+                "Authorization": f"Bearer {api_key}",
+                "X-Client-Source": "tavily-python"
             },
             base_url="https://api.tavily.com",
             mounts=proxy_mounts
@@ -52,16 +53,16 @@ class AsyncTavilyClient:
     async def _search(
             self,
             query: str,
-            search_depth: Literal["basic", "advanced"] = "basic",
-            topic: Literal["general", "news", "finance"] = "general",
+            search_depth: Literal["basic", "advanced"] = None,
+            topic: Literal["general", "news", "finance"] = None,
             time_range: Literal["day", "week", "month", "year"] = None,
-            days: int = 7,
-            max_results: int = 5,
+            days: int = None,
+            max_results: int = None,
             include_domains: Sequence[str] = None,
             exclude_domains: Sequence[str] = None,
-            include_answer: Union[bool, Literal["basic", "advanced"]] = False,
-            include_raw_content: Union[bool, Literal["markdown", "text"]] = False,
-            include_images: bool = False,
+            include_answer: Union[bool, Literal["basic", "advanced"]] = None,
+            include_raw_content: Union[bool, Literal["markdown", "text"]] = None,
+            include_images: bool = None,
             timeout: int = 60,
             country: str = None,
             **kwargs,
@@ -84,6 +85,8 @@ class AsyncTavilyClient:
             "country": country,
         }
 
+        data = {k: v for k, v in data.items() if v is not None}
+
         if kwargs:
             data.update(kwargs)
 
@@ -117,16 +120,16 @@ class AsyncTavilyClient:
 
     async def search(self,
                      query: str,
-                     search_depth: Literal["basic", "advanced"] = "basic",
-                     topic: Literal["general", "news", "finance"] = "general",
+                     search_depth: Literal["basic", "advanced"] = None,
+                     topic: Literal["general", "news", "finance"] = None,
                      time_range: Literal["day", "week", "month", "year"] = None,
-                     days: int = 7,
-                     max_results: int = 5,
+                     days: int = None,
+                     max_results: int = None,
                      include_domains: Sequence[str] = None,
                      exclude_domains: Sequence[str] = None,
-                     include_answer: Union[bool, Literal["basic", "advanced"]] = False,
-                     include_raw_content: Union[bool, Literal["markdown", "text"]] = False,
-                     include_images: bool = False,
+                     include_answer: Union[bool, Literal["basic", "advanced"]] = None,
+                     include_raw_content: Union[bool, Literal["markdown", "text"]] = None,
+                     include_images: bool = None,
                      timeout: int = 60,
                      country: str = None,
                      **kwargs,  # Accept custom arguments
@@ -160,9 +163,9 @@ class AsyncTavilyClient:
     async def _extract(
             self,
             urls: Union[List[str], str],
-            include_images: bool = False,
-            extract_depth: Literal["basic", "advanced"] = "basic",
-            format: Literal["markdown", "text"] = "markdown",
+            include_images: bool = None,
+            extract_depth: Literal["basic", "advanced"] = None,
+            format: Literal["markdown", "text"] = None,
             timeout: int = 60,
             **kwargs
     ) -> dict:
@@ -175,6 +178,9 @@ class AsyncTavilyClient:
             "extract_depth": extract_depth,
             "format": format,
         }
+
+        data = {k: v for k, v in data.items() if v is not None}
+
         if kwargs:
             data.update(kwargs)
 
@@ -209,9 +215,9 @@ class AsyncTavilyClient:
 
     async def extract(self,
                       urls: Union[List[str], str],  # Accept a list of URLs or a single URL
-                      include_images: bool = False,
-                      extract_depth: Literal["basic", "advanced"] = "basic",
-                      format: Literal["markdown", "text"] = "markdown",
+                      include_images: bool = None,
+                      extract_depth: Literal["basic", "advanced"] = None,
+                      format: Literal["markdown", "text"] = None,
                       timeout: int = 60,
                       **kwargs,  # Accept custom arguments
                       ) -> dict:

{tavily_python-0.7.5 → tavily_python-0.7.7}/tavily/tavily.py

@@ -32,21 +32,22 @@ class TavilyClient:
         self.proxies = resolved_proxies
         self.headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key}"
+            "Authorization": f"Bearer {self.api_key}",
+            "X-Client-Source": "tavily-python"
         }
 
     def _search(self,
                 query: str,
-                search_depth: Literal["basic", "advanced"] = "basic",
-                topic: Literal["general", "news", "finance"] = "general",
+                search_depth: Literal["basic", "advanced"] = None,
+                topic: Literal["general", "news", "finance"] = None,
                 time_range: Literal["day", "week", "month", "year"] = None,
-                days: int = 7,
-                max_results: int = 5,
+                days: int = None,
+                max_results: int = None,
                 include_domains: Sequence[str] = None,
                 exclude_domains: Sequence[str] = None,
-                include_answer: Union[bool, Literal["basic", "advanced"]] = False,
-                include_raw_content: Union[bool, Literal["markdown", "text"]] = False,
-                include_images: bool = False,
+                include_answer: Union[bool, Literal["basic", "advanced"]] = None,
+                include_raw_content: Union[bool, Literal["markdown", "text"]] = None,
+                include_images: bool = None,
                 timeout: int = 60,
                 country: str = None,
                 **kwargs
@@ -70,6 +71,8 @@ class TavilyClient:
             "country": country,
         }
 
+        data = {k: v for k, v in data.items() if v is not None}
+
         if kwargs:
             data.update(kwargs)
 
@@ -104,16 +107,16 @@ class TavilyClient:
 
     def search(self,
                query: str,
-               search_depth: Literal["basic", "advanced"] = "basic",
-               topic: Literal["general", "news", "finance" ] = "general",
+               search_depth: Literal["basic", "advanced"] = None,
+               topic: Literal["general", "news", "finance" ] = None,
                time_range: Literal["day", "week", "month", "year"] = None,
-               days: int = 7,
-               max_results: int = 5,
+               days: int = None,
+               max_results: int = None,
                include_domains: Sequence[str] = None,
                exclude_domains: Sequence[str] = None,
-               include_answer: Union[bool, Literal["basic", "advanced"]] = False,
-               include_raw_content: Union[bool, Literal["markdown", "text"]] = False,
-               include_images: bool = False,
+               include_answer: Union[bool, Literal["basic", "advanced"]] = None,
+               include_raw_content: Union[bool, Literal["markdown", "text"]] = None,
+               include_images: bool = None,
                timeout: int = 60,
                country: str = None,
                **kwargs,  # Accept custom arguments
@@ -146,9 +149,9 @@ class TavilyClient:
 
     def _extract(self,
                  urls: Union[List[str], str],
-                 include_images: bool = False,
-                 extract_depth: Literal["basic", "advanced"] = "basic",
-                 format: Literal["markdown", "text"] = "markdown",
+                 include_images: bool = None,
+                 extract_depth: Literal["basic", "advanced"] = None,
+                 format: Literal["markdown", "text"] = None,
                  timeout: int = 60,
                  **kwargs
                  ) -> dict:
@@ -161,6 +164,9 @@ class TavilyClient:
             "extract_depth": extract_depth,
             "format": format,
         }
+
+        data = {k: v for k, v in data.items() if v is not None}
+
         if kwargs:
             data.update(kwargs)
 
@@ -193,9 +199,9 @@ class TavilyClient:
 
     def extract(self,
                 urls: Union[List[str], str],  # Accept a list of URLs or a single URL
-                include_images: bool = False,
-                extract_depth: Literal["basic", "advanced"] = "basic",
-                format: Literal["markdown", "text"] = "markdown",
+                include_images: bool = None,
+                extract_depth: Literal["basic", "advanced"] = None,
+                format: Literal["markdown", "text"] = None,
                 timeout: int = 60,
                 **kwargs,  # Accept custom arguments
                 ) -> dict:

{tavily_python-0.7.5 → tavily_python-0.7.7}/tavily_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tavily-python
-Version: 0.7.5
+Version: 0.7.7
 Summary: Python wrapper for the Tavily API
 Home-page: https://github.com/tavily-ai/tavily-python
 Author: Tavily AI

{tavily_python-0.7.5 → tavily_python-0.7.7}/tavily_python.egg-info/SOURCES.txt

@@ -14,7 +14,9 @@ tavily_python.egg-info/SOURCES.txt
 tavily_python.egg-info/dependency_links.txt
 tavily_python.egg-info/requires.txt
 tavily_python.egg-info/top_level.txt
+tests/test_async_search.py
 tests/test_crawl.py
 tests/test_errors.py
 tests/test_map.py
-tests/test_search.py
+tests/test_search.py
+tests/test_sync_search.py

tavily_python-0.7.7/tests/test_async_search.py

@@ -0,0 +1,219 @@
+import unittest
+import os
+from tavily import AsyncTavilyClient, MissingAPIKeyError, InvalidAPIKeyError
+from urllib.parse import urlparse
+import asyncio
+
+from unit_tests import cases
+class SearchTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        self.tavily_client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # Every single search result should have these properties
+    def common_search_result_properties(self, result) -> None:
+        self.assertIsInstance(result, dict)
+        self.assertIn("title", result)
+        self.assertIn("url", result)
+        self.assertIn("content", result)
+        self.assertIn("score", result)
+
+    # General search results should have these properties
+    def general_search_result_properties(self, result) -> None:
+        self.common_search_result_properties(result)
+        self.assertIn("raw_content", result)
+
+    # News search results should have these properties
+    def news_search_result_properties(self, result) -> None:
+        self.common_search_result_properties(result)
+        self.assertIn("published_date", result)
+
+    # Topic-specific properties
+    def topic_specific_properties(self, result, **params) -> None:
+        if params.get("topic", "general") == "general":
+            self.assertIn("raw_content", result)
+        elif params.get("topic", "general") == "news":
+            self.assertIn("published_date", result)
+
+    # Domain inclusion/exclusion-dependent properties
+    def domain_dependent_properties(self, response, **params) -> None:
+        if params.get("topic", "general") != "general":
+            return
+
+        if params.get("include_domains", False) and len(params["include_domains"]) > 0:
+            for result in response["results"]:
+                self.assertTrue(any(domain in urlparse(result["url"]).netloc for domain in params["include_domains"]))
+
+        if params.get("exclude_domains", False) and len(params["exclude_domains"]) > 0:
+            for result in response["results"]:
+                self.assertFalse(any(domain in urlparse(result["url"]).netloc for domain in params["exclude_domains"]))
+
+    # Image-dependent properties
+    def image_properties(self, response, **params) -> None:
+        if params.get("topic", "general") == "general" and params.get("include_images", False):
+            self.assertIsNotNone(response["images"])
+            self.assertIsInstance(response["images"], list)
+            for image in response["images"]:
+                self.assertIsInstance(image, str)
+
+    # Answer-dependent properties
+    def answer_properties(self, response, **params) -> None:
+        if params.get("include_answer", False):
+            self.assertIn("answer", response)
+            self.assertIsInstance(response["answer"], str)
+
+
+    # Every single search response should have these properties
+    def common_response_properties(self, response) -> None:
+        self.assertIsNotNone(response)
+        self.assertIsInstance(response, dict)
+        self.assertIn("answer", response)
+        self.assertIn("query", response)
+        self.assertIn("results", response)
+        self.assertIn("images", response)
+        self.assertIn("response_time", response)
+        self.assertIn("follow_up_questions", response)
+
+        self.assertIsNotNone(response["query"])
+        self.assertIsNotNone(response["results"])
+        self.assertIsNotNone(response["response_time"])
+        self.assertIsNotNone(response["images"])
+
+        self.assertIsInstance(response["query"], str)
+        self.assertIsInstance(response["results"], list)
+        self.assertIsInstance(response["response_time"], float)
+        self.assertIsInstance(response["images"], list)
+
+    # Search responses also have properties that depend on the request params
+    def custom_response_properties(self, response, **params) -> None:
+        self.domain_dependent_properties(response, **params)
+        self.image_properties(response, **params)
+        self.answer_properties(response, **params)
+        for result in response["results"]:
+            self.topic_specific_properties(result, **params)
+
+    def test_internal_search(self) -> None:
+        for test_case in cases:
+            with self.subTest(msg=test_case["name"]):
+                response = asyncio.run(self.tavily_client._search(**test_case["params"]))
+                self.common_response_properties(response)
+                if test_case["params"].get("topic", "general") == "general":
+                    for search_result in response["results"]:
+                        self.general_search_result_properties(search_result)
+                elif test_case["params"].get("topic", "general") == "news":
+                    for search_result in response["results"]:
+                        self.news_search_result_properties(search_result)
+                self.custom_response_properties(response, **test_case["params"])
+
+    def test_external_search(self) -> None:
+        for test_case in cases:
+            with self.subTest(msg=test_case["name"]):
+                response = asyncio.run(self.tavily_client.search(**test_case["params"]))
+                self.common_response_properties(response)
+                if test_case["params"].get("topic", "general") == "general":
+                    for search_result in response["results"]:
+                        self.general_search_result_properties(search_result)
+                elif test_case["params"].get("topic", "general") == "news":
+                    for search_result in response["results"]:
+                        self.news_search_result_properties(search_result)
+                self.custom_response_properties(response, **test_case["params"])
+
+class QNASearchTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        self.tavily_client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    def test_qna_search(self) -> None:
+        for test_case in cases:
+            if "include_answer" in test_case["params"]:
+                del test_case["params"]["include_answer"]
+            if "include_raw_content" in test_case["params"]:
+                del test_case["params"]["include_raw_content"]
+            if "include_images" in test_case["params"]:
+                del test_case["params"]["include_images"]
+            with self.subTest(msg=test_case["name"]):
+                response = asyncio.run(self.tavily_client.qna_search(**test_case["params"]))
+                self.assertIsNotNone(response)
+                self.assertIsInstance(response, str)
+                self.assertTrue(len(response) > 0)
+
+class CompanyInfoSearchTest(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.tavily_client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # Every single search result should have these properties
+    def common_search_result_properties(self, result) -> None:
+        self.assertIsInstance(result, dict)
+        self.assertIn("title", result)
+        self.assertIn("url", result)
+        self.assertIn("content", result)
+        self.assertIn("score", result)
+    
+    def test_company_info_search(self) -> None:
+        for test_case in cases:
+            if "topic" in test_case["params"]:
+                del test_case["params"]["topic"]
+            if "include_domains" in test_case["params"]:
+                del test_case["params"]["include_domains"]
+            if "exclude_domains" in test_case["params"]:
+                del test_case["params"]["exclude_domains"]
+            if "include_raw_content" in test_case["params"]:
+                del test_case["params"]["include_raw_content"]
+            if "include_images" in test_case["params"]:
+                del test_case["params"]["include_images"]
+            if "include_answer" in test_case["params"]:
+                del test_case["params"]["include_answer"]
+            if "use_cache" in test_case["params"]:
+                del test_case["params"]["use_cache"]
+            with self.subTest(msg=test_case["name"]):
+                response = asyncio.run(self.tavily_client.get_company_info(**test_case["params"]))
+                self.assertIsNotNone(response)
+                self.assertIsInstance(response, list)
+                self.assertTrue(len(response) > 0)
+                for search_result in response:
+                    self.common_search_result_properties(search_result)
+            
+class ErrorTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # This test is here to ensure that no MissingAPIKeyError is raised when the API key is in the environment
+    def test_load_key_from_env(self) -> None:
+        self.assertIn('results', asyncio.run(AsyncTavilyClient().search("Why is Tavily the best search API?")))
+    
+    def test_missing_api_key(self) -> None:
+        with self.assertRaises(MissingAPIKeyError):
+            AsyncTavilyClient(api_key='')
+        
+        old_key = os.getenv("TAVILY_API_KEY")
+        del os.environ["TAVILY_API_KEY"]
+        with self.assertRaises(MissingAPIKeyError):
+            AsyncTavilyClient()
+            
+        os.environ["TAVILY_API_KEY"] = old_key
+
+
+    def test_invalid_api_key(self) -> None:
+        with self.assertRaises(InvalidAPIKeyError):
+            asyncio.run(AsyncTavilyClient(api_key="invalid_api_key").search("Why is Tavily the best search API?"))
+
+if __name__ == "__main__":
+
+    unittest.main()

{tavily_python-0.7.5 → tavily_python-0.7.7}/tests/test_crawl.py

@@ -16,6 +16,7 @@ def validate_default(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/crawl"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.json().get('url') == "https://tavily.com"
     assert response == dummy_response
 
@@ -23,6 +24,7 @@ def validate_specific(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/crawl"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.timeout == 10
     
     request_json = request.json()

{tavily_python-0.7.5 → tavily_python-0.7.7}/tests/test_map.py

@@ -15,6 +15,7 @@ def validate_default(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/map"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.json().get('url') == "https://tavily.com"
     assert response == dummy_response
 
@@ -22,6 +23,7 @@ def validate_specific(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/map"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.timeout == 10
     
     request_json = request.json()

{tavily_python-0.7.5 → tavily_python-0.7.7}/tests/test_search.py

@@ -22,6 +22,7 @@ def validate_default(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/search"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.json().get('query') == "What is Tavily?"
     assert response == dummy_response
 
@@ -29,6 +30,7 @@ def validate_specific(request, response):
     assert request.method == "POST"
     assert request.url == "https://api.tavily.com/search"
     assert request.headers["Authorization"] == "Bearer tvly-test"
+    assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.timeout == 10
     
     request_json = request.json()

tavily_python-0.7.7/tests/test_sync_search.py

@@ -0,0 +1,219 @@
+import unittest
+import os
+from tavily import TavilyClient, InvalidAPIKeyError, MissingAPIKeyError
+from urllib.parse import urlparse
+
+from unit_tests import cases
+
+class SearchTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        self.tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # Every single search result should have these properties
+    def common_search_result_properties(self, result) -> None:
+        self.assertIsInstance(result, dict)
+        self.assertIn("title", result)
+        self.assertIn("url", result)
+        self.assertIn("content", result)
+        self.assertIn("score", result)
+
+    # General search results should have these properties
+    def general_search_result_properties(self, result) -> None:
+        self.common_search_result_properties(result)
+        self.assertIn("raw_content", result)
+
+    # News search results should have these properties
+    def news_search_result_properties(self, result) -> None:
+        self.common_search_result_properties(result)
+        self.assertIn("published_date", result)
+
+    # Topic-specific properties
+    def topic_specific_properties(self, result, **params) -> None:
+        if params.get("topic", "general") == "general":
+            self.assertIn("raw_content", result)
+        elif params.get("topic", "general") == "news":
+            self.assertIn("published_date", result)
+
+    # Domain inclusion/exclusion-dependent properties
+    def domain_dependent_properties(self, response, **params) -> None:
+        if params.get("topic", "general") != "general":
+            return
+
+        if params.get("include_domains", False) and len(params["include_domains"]) > 0:
+            for result in response["results"]:
+                self.assertTrue(any(domain in urlparse(result["url"]).netloc for domain in params["include_domains"]))
+
+        if params.get("exclude_domains", False) and len(params["exclude_domains"]) > 0:
+            for result in response["results"]:
+                self.assertFalse(any(domain in urlparse(result["url"]).netloc for domain in params["exclude_domains"]))
+
+    # Image-dependent properties
+    def image_properties(self, response, **params) -> None:
+        if params.get("topic", "general") == "general" and params.get("include_images", False):
+            self.assertIsNotNone(response["images"])
+            self.assertIsInstance(response["images"], list)
+            for image in response["images"]:
+                self.assertIsInstance(image, str)
+
+    # Answer-dependent properties
+    def answer_properties(self, response, **params) -> None:
+        if params.get("include_answer", False):
+            self.assertIn("answer", response)
+            self.assertIsInstance(response["answer"], str)
+
+
+    # Every single search response should have these properties
+    def common_response_properties(self, response) -> None:
+        self.assertIsNotNone(response)
+        self.assertIsInstance(response, dict)
+        self.assertIn("answer", response)
+        self.assertIn("query", response)
+        self.assertIn("results", response)
+        self.assertIn("images", response)
+        self.assertIn("response_time", response)
+        self.assertIn("follow_up_questions", response)
+
+        self.assertIsNotNone(response["query"])
+        self.assertIsNotNone(response["results"])
+        self.assertIsNotNone(response["response_time"])
+        self.assertIsNotNone(response["images"])
+
+        self.assertIsInstance(response["query"], str)
+        self.assertIsInstance(response["results"], list)
+        self.assertIsInstance(response["response_time"], float)
+        self.assertIsInstance(response["images"], list)
+
+    # Search responses also have properties that depend on the request params
+    def custom_response_properties(self, response, **params) -> None:
+        self.domain_dependent_properties(response, **params)
+        self.image_properties(response, **params)
+        self.answer_properties(response, **params)
+        for result in response["results"]:
+            self.topic_specific_properties(result, **params)
+
+    def test_internal_search(self) -> None:
+        for test_case in cases:
+            with self.subTest(msg=test_case["name"]):
+                result = self.tavily_client._search(**test_case["params"])
+                self.common_response_properties(result)
+                if test_case["params"].get("topic", "general") == "general":
+                    for search_result in result["results"]:
+                        self.general_search_result_properties(search_result)
+                elif test_case["params"].get("topic", "general") == "news":
+                    for search_result in result["results"]:
+                        self.news_search_result_properties(search_result)
+                self.custom_response_properties(result, **test_case["params"])
+
+    def test_external_search(self) -> None:
+        for test_case in cases:
+            with self.subTest(msg=test_case["name"]):
+                response = self.tavily_client._search(**test_case["params"])
+                self.common_response_properties(response)
+                if test_case["params"].get("topic", "general") == "general":
+                    for search_result in response["results"]:
+                        self.general_search_result_properties(search_result)
+                elif test_case["params"].get("topic", "general") == "news":
+                    for search_result in response["results"]:
+                        self.news_search_result_properties(search_result)
+                self.custom_response_properties(response, **test_case["params"])
+
+class QNASearchTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        self.tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    def test_qna_search(self) -> None:
+        for test_case in cases:
+            if "include_answer" in test_case["params"]:
+                del test_case["params"]["include_answer"]
+            if "include_raw_content" in test_case["params"]:
+                del test_case["params"]["include_raw_content"]
+            if "include_images" in test_case["params"]:
+                del test_case["params"]["include_images"]
+            with self.subTest(msg=test_case["name"]):
+                response = self.tavily_client.qna_search(**test_case["params"])
+                self.assertIsNotNone(response)
+                self.assertIsInstance(response, str)
+                self.assertTrue(len(response) > 0)
+
+class CompanyInfoSearchTest(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # Every single search result should have these properties
+    def common_search_result_properties(self, result) -> None:
+        self.assertIsInstance(result, dict)
+        self.assertIn("title", result)
+        self.assertIn("url", result)
+        self.assertIn("content", result)
+        self.assertIn("score", result)
+    
+    def test_company_info_search(self) -> None:
+        for test_case in cases:
+            if "topic" in test_case["params"]:
+                del test_case["params"]["topic"]
+            if "include_domains" in test_case["params"]:
+                del test_case["params"]["include_domains"]
+            if "exclude_domains" in test_case["params"]:
+                del test_case["params"]["exclude_domains"]
+            if "include_raw_content" in test_case["params"]:
+                del test_case["params"]["include_raw_content"]
+            if "include_images" in test_case["params"]:
+                del test_case["params"]["include_images"]
+            if "include_answer" in test_case["params"]:
+                del test_case["params"]["include_answer"]
+            if "use_cache" in test_case["params"]:
+                del test_case["params"]["use_cache"]
+            with self.subTest(msg=test_case["name"]):
+                response = self.tavily_client.get_company_info(**test_case["params"])
+                self.assertIsNotNone(response)
+                self.assertIsInstance(response, list)
+                self.assertTrue(len(response) > 0)
+                for search_result in response:
+                    self.common_search_result_properties(search_result)
+            
+class ErrorTest(unittest.TestCase):
+    
+    def setUp(self) -> None:
+        return super().setUp()
+    
+    def tearDown(self) -> None:
+        return super().tearDown()
+    
+    # This test is here to ensure that no MissingAPIKeyError is raised when the API key is in the environment
+    def test_load_key_from_env(self) -> None:
+        self.assertIn('results', TavilyClient().search("Why is Tavily the best search API?"))
+    
+    def test_missing_api_key(self) -> None:
+        with self.assertRaises(MissingAPIKeyError):
+            TavilyClient(api_key='')
+        
+        old_key = os.getenv("TAVILY_API_KEY")
+        del os.environ["TAVILY_API_KEY"]
+        with self.assertRaises(MissingAPIKeyError):
+            TavilyClient()
+            
+        os.environ["TAVILY_API_KEY"] = old_key
+
+
+    def test_invalid_api_key(self) -> None:
+        with self.assertRaises(InvalidAPIKeyError):
+            TavilyClient(api_key="invalid_api_key").search("Why is Tavily the best search API?")
+
+if __name__ == "__main__":
+
+    unittest.main()