remove global config in the search/browser engine

tests/metagpt/actions/test_research.py

@@ -28,9 +28,9 @@ async def test_collect_links(mocker, search_engine_mocker, context):
             return "[1,2]"
 
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_llm_ask)
-    resp = await research.CollectLinks(search_engine=SearchEngine(SearchEngineType.DUCK_DUCK_GO), context=context).run(
-        "The application of MetaGPT"
-    )
+    resp = await research.CollectLinks(
+        search_engine=SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO), context=context
+    ).run("The application of MetaGPT")
     for i in ["MetaGPT use cases", "The roadmap of MetaGPT", "The function of MetaGPT", "What llm MetaGPT support"]:
         assert i in resp
 
@@ -50,7 +50,9 @@ async def test_collect_links_with_rank_func(mocker, search_engine_mocker, contex
 
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_collect_links_llm_ask)
     resp = await research.CollectLinks(
-        search_engine=SearchEngine(SearchEngineType.DUCK_DUCK_GO), rank_func=rank_func, context=context
+        search_engine=SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO),
+        rank_func=rank_func,
+        context=context,
     ).run("The application of MetaGPT")
     for x, y, z in zip(rank_before, rank_after, resp.values()):
         assert x[::-1] == y

tests/metagpt/learn/test_google_search.py

@@ -16,6 +16,6 @@ async def test_google_search(search_engine_mocker):
         result = await google_search(
             seed.input,
             engine=SearchEngineType.SERPER_GOOGLE,
-            serper_api_key="mock-serper-key",
+            api_key="mock-serper-key",
         )
         assert result != ""

tests/metagpt/roles/test_researcher.py

@@ -36,7 +36,7 @@ async def test_researcher(mocker, search_engine_mocker, context):
         role = researcher.Researcher(context=context)
         for i in role.actions:
             if isinstance(i, CollectLinks):
-                i.search_engine = SearchEngine(SearchEngineType.DUCK_DUCK_GO)
+                i.search_engine = SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO)
         await role.run(topic)
         assert (researcher.RESEARCH_PATH / f"{topic}.md").read_text().startswith("# Research Report")
 

tests/metagpt/tools/test_search_engine.py

@@ -12,6 +12,7 @@ from typing import Callable
 import pytest
 
 from metagpt.config2 import config
+from metagpt.configs.search_config import SearchConfig
 from metagpt.logs import logger
 from metagpt.tools import SearchEngineType
 from metagpt.tools.search_engine import SearchEngine
@@ -49,27 +50,34 @@ async def test_search_engine(
     search_engine_mocker,
 ):
     # Prerequisites
-    search_engine_config = {}
+    search_engine_config = {"engine": search_engine_type, "run_func": run_func}
 
     if search_engine_type is SearchEngineType.SERPAPI_GOOGLE:
         assert config.search
-        search_engine_config["serpapi_api_key"] = "mock-serpapi-key"
+        search_engine_config["api_key"] = "mock-serpapi-key"
     elif search_engine_type is SearchEngineType.DIRECT_GOOGLE:
         assert config.search
-        search_engine_config["google_api_key"] = "mock-google-key"
-        search_engine_config["google_cse_id"] = "mock-google-cse"
+        search_engine_config["api_key"] = "mock-google-key"
+        search_engine_config["cse_id"] = "mock-google-cse"
     elif search_engine_type is SearchEngineType.SERPER_GOOGLE:
         assert config.search
-        search_engine_config["serper_api_key"] = "mock-serper-key"
+        search_engine_config["api_key"] = "mock-serper-key"
 
-    search_engine = SearchEngine(search_engine_type, run_func, **search_engine_config)
-    rsp = await search_engine.run("metagpt", max_results, as_string)
-    logger.info(rsp)
-    if as_string:
-        assert isinstance(rsp, str)
-    else:
-        assert isinstance(rsp, list)
-        assert len(rsp) <= max_results
+    async def test(search_engine):
+        rsp = await search_engine.run("metagpt", max_results, as_string)
+        logger.info(rsp)
+        if as_string:
+            assert isinstance(rsp, str)
+        else:
+            assert isinstance(rsp, list)
+            assert len(rsp) <= max_results
+
+    await test(SearchEngine(**search_engine_config))
+    search_engine_config["api_type"] = search_engine_config.pop("engine")
+    if run_func:
+        await test(SearchEngine.from_search_func(run_func))
+        search_engine_config["search_func"] = search_engine_config.pop("run_func")
+    await test(SearchEngine.from_search_config(SearchConfig(**search_engine_config)))
 
 
 if __name__ == "__main__":

tests/metagpt/tools/test_web_browser_engine_playwright.py

@@ -3,7 +3,6 @@
 
 import pytest
 
-from metagpt.config2 import config
 from metagpt.tools import web_browser_engine_playwright
 from metagpt.utils.parse_html import WebPage
 
@@ -19,26 +18,22 @@ from metagpt.utils.parse_html import WebPage
     ids=["chromium-normal", "firefox-normal", "webkit-normal"],
 )
 async def test_scrape_web_page(browser_type, use_proxy, kwagrs, url, urls, proxy, capfd):
-    global_proxy = config.proxy
-    try:
-        if use_proxy:
-            server, proxy_url = await proxy()
-            config.proxy = proxy_url
-        browser = web_browser_engine_playwright.PlaywrightWrapper(browser_type=browser_type, **kwagrs)
-        result = await browser.run(url)
-        assert isinstance(result, WebPage)
-        assert "MetaGPT" in result.inner_text
+    proxy_url = None
+    if use_proxy:
+        server, proxy_url = await proxy()
+    browser = web_browser_engine_playwright.PlaywrightWrapper(browser_type=browser_type, proxy=proxy_url, **kwagrs)
+    result = await browser.run(url)
+    assert isinstance(result, WebPage)
+    assert "MetaGPT" in result.inner_text
 
-        if urls:
-            results = await browser.run(url, *urls)
-            assert isinstance(results, list)
-            assert len(results) == len(urls) + 1
-            assert all(("MetaGPT" in i.inner_text) for i in results)
-        if use_proxy:
-            server.close()
-            assert "Proxy:" in capfd.readouterr().out
-    finally:
-        config.proxy = global_proxy
+    if urls:
+        results = await browser.run(url, *urls)
+        assert isinstance(results, list)
+        assert len(results) == len(urls) + 1
+        assert all(("MetaGPT" in i.inner_text) for i in results)
+    if use_proxy:
+        server.close()
+        assert "Proxy:" in capfd.readouterr().out
 
 
 if __name__ == "__main__":

tests/metagpt/tools/test_web_browser_engine_selenium.py

@@ -4,7 +4,6 @@
 import browsers
 import pytest
 
-from metagpt.config2 import config
 from metagpt.tools import web_browser_engine_selenium
 from metagpt.utils.parse_html import WebPage
 
@@ -40,27 +39,22 @@ from metagpt.utils.parse_html import WebPage
 async def test_scrape_web_page(browser_type, use_proxy, url, urls, proxy, capfd):
     # Prerequisites
     # firefox, chrome, Microsoft Edge
+    proxy_url = None
+    if use_proxy:
+        server, proxy_url = await proxy()
+    browser = web_browser_engine_selenium.SeleniumWrapper(browser_type=browser_type, proxy=proxy_url)
+    result = await browser.run(url)
+    assert isinstance(result, WebPage)
+    assert "MetaGPT" in result.inner_text
 
-    global_proxy = config.proxy
-    try:
-        if use_proxy:
-            server, proxy_url = await proxy()
-            config.proxy = proxy_url
-        browser = web_browser_engine_selenium.SeleniumWrapper(browser_type=browser_type)
-        result = await browser.run(url)
-        assert isinstance(result, WebPage)
-        assert "MetaGPT" in result.inner_text
-
-        if urls:
-            results = await browser.run(url, *urls)
-            assert isinstance(results, list)
-            assert len(results) == len(urls) + 1
-            assert all(("MetaGPT" in i.inner_text) for i in results)
-        if use_proxy:
-            server.close()
-            assert "Proxy:" in capfd.readouterr().out
-    finally:
-        config.proxy = global_proxy
+    if urls:
+        results = await browser.run(url, *urls)
+        assert isinstance(results, list)
+        assert len(results) == len(urls) + 1
+        assert all(("MetaGPT" in i.inner_text) for i in results)
+    if use_proxy:
+        server.close()
+        assert "Proxy:" in capfd.readouterr().out
 
 
 if __name__ == "__main__":