Revert "Revert "Merge branch 'master' into stable""

This reverts commit 999990b614.

tests/unit/models/test_base_open_api_plugin.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict, List, Optional, Tuple
+
+import pytest
+
+from autogpt.models.base_open_ai_plugin import (
+    BaseOpenAIPlugin,
+    Message,
+    PromptGenerator,
+)
+
+
+class DummyPlugin(BaseOpenAIPlugin):
+    pass
+
+
+@pytest.fixture
+def dummy_plugin():
+    manifests_specs_clients = {
+        "manifest": {
+            "name_for_model": "Dummy",
+            "schema_version": "1.0",
+            "description_for_model": "A dummy plugin for testing purposes",
+        },
+        "client": None,
+        "openapi_spec": None,
+    }
+    return DummyPlugin(manifests_specs_clients)
+
+
+def test_dummy_plugin_inheritance(dummy_plugin):
+    assert isinstance(dummy_plugin, BaseOpenAIPlugin)
+
+
+def test_dummy_plugin_name(dummy_plugin):
+    assert dummy_plugin._name == "Dummy"
+
+
+def test_dummy_plugin_version(dummy_plugin):
+    assert dummy_plugin._version == "1.0"
+
+
+def test_dummy_plugin_description(dummy_plugin):
+    assert dummy_plugin._description == "A dummy plugin for testing purposes"
+
+
+def test_dummy_plugin_default_methods(dummy_plugin):
+    assert not dummy_plugin.can_handle_on_response()
+    assert not dummy_plugin.can_handle_post_prompt()
+    assert not dummy_plugin.can_handle_on_planning()
+    assert not dummy_plugin.can_handle_post_planning()
+    assert not dummy_plugin.can_handle_pre_instruction()
+    assert not dummy_plugin.can_handle_on_instruction()
+    assert not dummy_plugin.can_handle_post_instruction()
+    assert not dummy_plugin.can_handle_pre_command()
+    assert not dummy_plugin.can_handle_post_command()
+    assert not dummy_plugin.can_handle_chat_completion(None, None, None, None)
+
+    assert dummy_plugin.on_response("hello") == "hello"
+    assert dummy_plugin.post_prompt(None) is None
+    assert dummy_plugin.on_planning(None, None) is None
+    assert dummy_plugin.post_planning("world") == "world"
+    pre_instruction = dummy_plugin.pre_instruction(
+        [{"role": "system", "content": "Beep, bop, boop"}]
+    )
+    assert isinstance(pre_instruction, list)
+    assert len(pre_instruction) == 1
+    assert pre_instruction[0]["role"] == "system"
+    assert pre_instruction[0]["content"] == "Beep, bop, boop"
+    assert dummy_plugin.on_instruction(None) is None
+    assert dummy_plugin.post_instruction("I'm a robot") == "I'm a robot"
+    pre_command = dummy_plugin.pre_command("evolve", {"continuously": True})
+    assert isinstance(pre_command, tuple)
+    assert len(pre_command) == 2
+    assert pre_command[0] == "evolve"
+    assert pre_command[1]["continuously"] == True
+    post_command = dummy_plugin.post_command("evolve", "upgraded successfully!")
+    assert isinstance(post_command, str)
+    assert post_command == "upgraded successfully!"
+    assert dummy_plugin.handle_chat_completion(None, None, None, None) is None

tests/unit/test_browse_scrape_text.py

@@ -9,16 +9,20 @@ Code Analysis
 
 Objective:
 The objective of the "scrape_text" function is to scrape the text content from
-a given URL and return it as a string, after removing any unwanted HTML tags and scripts.
+a given URL and return it as a string, after removing any unwanted HTML tags and
+ scripts.
 
 Inputs:
 - url: a string representing the URL of the webpage to be scraped.
 
 Flow:
-1. Send a GET request to the given URL using the requests library and the user agent header from the config file.
+1. Send a GET request to the given URL using the requests library and the user agent
+ header from the config file.
 2. Check if the response contains an HTTP error. If it does, return an error message.
-3. Use BeautifulSoup to parse the HTML content of the response and extract all script and style tags.
-4. Get the text content of the remaining HTML using the get_text() method of BeautifulSoup.
+3. Use BeautifulSoup to parse the HTML content of the response and extract all script
+ and style tags.
+4. Get the text content of the remaining HTML using the get_text() method of
+ BeautifulSoup.
 5. Split the text into lines and then into chunks, removing any extra whitespace.
 6. Join the chunks into a single string with newline characters between them.
 7. Return the cleaned text.
@@ -27,9 +31,12 @@ Outputs:
 - A string representing the cleaned text content of the webpage.
 
 Additional aspects:
-- The function uses the requests library and BeautifulSoup to handle the HTTP request and HTML parsing, respectively.
-- The function removes script and style tags from the HTML to avoid including unwanted content in the text output.
-- The function uses a generator expression to split the text into lines and chunks, which can improve performance for large amounts of text.
+- The function uses the requests library and BeautifulSoup to handle the HTTP request
+ and HTML parsing, respectively.
+- The function removes script and style tags from the HTML to avoid including unwanted
+ content in the text output.
+- The function uses a generator expression to split the text into lines and chunks,
+ which can improve performance for large amounts of text.
 """
 
 
@@ -40,26 +47,33 @@ class TestScrapeText:
         expected_text = "This is some sample text"
         mock_response = mocker.Mock()
         mock_response.status_code = 200
-        mock_response.text = f"<html><body><div><p style='color: blue;'>{expected_text}</p></div></body></html>"
+        mock_response.text = (
+            "<html><body><div><p style='color: blue;'>"
+            f"{expected_text}</p></div></body></html>"
+        )
         mocker.patch("requests.Session.get", return_value=mock_response)
 
-        # Call the function with a valid URL and assert that it returns the expected text
+        # Call the function with a valid URL and assert that it returns the
+        #  expected text
         url = "http://www.example.com"
         assert scrape_text(url) == expected_text
 
-    # Tests that the function returns an error message when an invalid or unreachable url is provided.
+    # Tests that the function returns an error message when an invalid or unreachable
+    #  url is provided.
     def test_invalid_url(self, mocker):
         # Mock the requests.get() method to raise an exception
         mocker.patch(
             "requests.Session.get", side_effect=requests.exceptions.RequestException
         )
 
-        # Call the function with an invalid URL and assert that it returns an error message
+        # Call the function with an invalid URL and assert that it returns an error
+        #  message
         url = "http://www.invalidurl.com"
         error_message = scrape_text(url)
         assert "Error:" in error_message
 
-    # Tests that the function returns an empty string when the html page contains no text to be scraped.
+    # Tests that the function returns an empty string when the html page contains no
+    #  text to be scraped.
     def test_no_text(self, mocker):
         # Mock the requests.get() method to return a response with no text
         mock_response = mocker.Mock()
@@ -71,7 +85,8 @@ class TestScrapeText:
         url = "http://www.example.com"
         assert scrape_text(url) == ""
 
-    # Tests that the function returns an error message when the response status code is an http error (>=400).
+    # Tests that the function returns an error message when the response status code is
+    #  an http error (>=400).
     def test_http_error(self, mocker):
         # Mock the requests.get() method to return a response with a 404 status code
         mocker.patch("requests.Session.get", return_value=mocker.Mock(status_code=404))

tests/unit/test_plugins.py

@@ -0,0 +1,112 @@
+import pytest
+
+from autogpt.config import Config
+from autogpt.plugins import (
+    blacklist_whitelist_check,
+    inspect_zip_for_module,
+    scan_plugins,
+)
+
+PLUGINS_TEST_DIR = "tests/unit/data/test_plugins"
+PLUGIN_TEST_ZIP_FILE = "Auto-GPT-Plugin-Test-master.zip"
+PLUGIN_TEST_INIT_PY = "Auto-GPT-Plugin-Test-master/src/auto_gpt_vicuna/__init__.py"
+PLUGIN_TEST_OPENAI = "https://weathergpt.vercel.app/"
+
+
+def test_inspect_zip_for_module():
+    result = inspect_zip_for_module(str(f"{PLUGINS_TEST_DIR}/{PLUGIN_TEST_ZIP_FILE}"))
+    assert result == PLUGIN_TEST_INIT_PY
+
+
+@pytest.fixture
+def mock_config_blacklist_whitelist_check():
+    class MockConfig:
+        plugins_blacklist = ["BadPlugin"]
+        plugins_whitelist = ["GoodPlugin"]
+
+    return MockConfig()
+
+
+def test_blacklist_whitelist_check_blacklist(
+    mock_config_blacklist_whitelist_check, monkeypatch
+):
+    monkeypatch.setattr("builtins.input", lambda _: "y")
+    assert not blacklist_whitelist_check(
+        "BadPlugin", mock_config_blacklist_whitelist_check
+    )
+
+
+def test_blacklist_whitelist_check_whitelist(
+    mock_config_blacklist_whitelist_check, monkeypatch
+):
+    monkeypatch.setattr("builtins.input", lambda _: "y")
+    assert blacklist_whitelist_check(
+        "GoodPlugin", mock_config_blacklist_whitelist_check
+    )
+
+
+def test_blacklist_whitelist_check_user_input_yes(
+    mock_config_blacklist_whitelist_check, monkeypatch
+):
+    monkeypatch.setattr("builtins.input", lambda _: "y")
+    assert blacklist_whitelist_check(
+        "UnknownPlugin", mock_config_blacklist_whitelist_check
+    )
+
+
+def test_blacklist_whitelist_check_user_input_no(
+    mock_config_blacklist_whitelist_check, monkeypatch
+):
+    monkeypatch.setattr("builtins.input", lambda _: "n")
+    assert not blacklist_whitelist_check(
+        "UnknownPlugin", mock_config_blacklist_whitelist_check
+    )
+
+
+def test_blacklist_whitelist_check_user_input_invalid(
+    mock_config_blacklist_whitelist_check, monkeypatch
+):
+    monkeypatch.setattr("builtins.input", lambda _: "invalid")
+    assert not blacklist_whitelist_check(
+        "UnknownPlugin", mock_config_blacklist_whitelist_check
+    )
+
+
+@pytest.fixture
+def config_with_plugins():
+    cfg = Config()
+    cfg.plugins_dir = PLUGINS_TEST_DIR
+    cfg.plugins_openai = ["https://weathergpt.vercel.app/"]
+    return cfg
+
+
+@pytest.fixture
+def mock_config_openai_plugin():
+    class MockConfig:
+        plugins_dir = PLUGINS_TEST_DIR
+        plugins_openai = [PLUGIN_TEST_OPENAI]
+        plugins_blacklist = ["AutoGPTPVicuna"]
+        plugins_whitelist = [PLUGIN_TEST_OPENAI]
+
+    return MockConfig()
+
+
+def test_scan_plugins_openai(mock_config_openai_plugin):
+    result = scan_plugins(mock_config_openai_plugin, debug=True)
+    assert len(result) == 1
+
+
+@pytest.fixture
+def mock_config_generic_plugin():
+    class MockConfig:
+        plugins_dir = PLUGINS_TEST_DIR
+        plugins_openai = []
+        plugins_blacklist = []
+        plugins_whitelist = ["AutoGPTPVicuna"]
+
+    return MockConfig()
+
+
+def test_scan_plugins_generic(mock_config_generic_plugin):
+    result = scan_plugins(mock_config_generic_plugin, debug=True)
+    assert len(result) == 1