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

This reverts commit 999990b614.

tests/mocks/mock_commands.py

@@ -0,0 +1,6 @@
+from autogpt.commands.command import command
+
+
+@command("function_based", "Function-based test command")
+def function_based(arg1: int, arg2: str) -> str:
+    return f"{arg1} - {arg2}"

tests/test_commands.py

@@ -0,0 +1,177 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+from autogpt.commands.command import Command, CommandRegistry
+
+
+class TestCommand:
+    @staticmethod
+    def example_function(arg1: int, arg2: str) -> str:
+        return f"{arg1} - {arg2}"
+
+    def test_command_creation(self):
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        assert cmd.name == "example"
+        assert cmd.description == "Example command"
+        assert cmd.method == self.example_function
+        assert cmd.signature == "(arg1: int, arg2: str) -> str"
+
+    def test_command_call(self):
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        result = cmd(arg1=1, arg2="test")
+        assert result == "1 - test"
+
+    def test_command_call_with_invalid_arguments(self):
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        with pytest.raises(TypeError):
+            cmd(arg1="invalid", does_not_exist="test")
+
+    def test_command_default_signature(self):
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        assert cmd.signature == "(arg1: int, arg2: str) -> str"
+
+    def test_command_custom_signature(self):
+        custom_signature = "custom_arg1: int, custom_arg2: str"
+        cmd = Command(
+            name="example",
+            description="Example command",
+            method=self.example_function,
+            signature=custom_signature,
+        )
+
+        assert cmd.signature == custom_signature
+
+
+class TestCommandRegistry:
+    @staticmethod
+    def example_function(arg1: int, arg2: str) -> str:
+        return f"{arg1} - {arg2}"
+
+    def test_register_command(self):
+        """Test that a command can be registered to the registry."""
+        registry = CommandRegistry()
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        registry.register(cmd)
+
+        assert cmd.name in registry.commands
+        assert registry.commands[cmd.name] == cmd
+
+    def test_unregister_command(self):
+        """Test that a command can be unregistered from the registry."""
+        registry = CommandRegistry()
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        registry.register(cmd)
+        registry.unregister(cmd.name)
+
+        assert cmd.name not in registry.commands
+
+    def test_get_command(self):
+        """Test that a command can be retrieved from the registry."""
+        registry = CommandRegistry()
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        registry.register(cmd)
+        retrieved_cmd = registry.get_command(cmd.name)
+
+        assert retrieved_cmd == cmd
+
+    def test_get_nonexistent_command(self):
+        """Test that attempting to get a nonexistent command raises a KeyError."""
+        registry = CommandRegistry()
+
+        with pytest.raises(KeyError):
+            registry.get_command("nonexistent_command")
+
+    def test_call_command(self):
+        """Test that a command can be called through the registry."""
+        registry = CommandRegistry()
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        registry.register(cmd)
+        result = registry.call("example", arg1=1, arg2="test")
+
+        assert result == "1 - test"
+
+    def test_call_nonexistent_command(self):
+        """Test that attempting to call a nonexistent command raises a KeyError."""
+        registry = CommandRegistry()
+
+        with pytest.raises(KeyError):
+            registry.call("nonexistent_command", arg1=1, arg2="test")
+
+    def test_get_command_prompt(self):
+        """Test that the command prompt is correctly formatted."""
+        registry = CommandRegistry()
+        cmd = Command(
+            name="example", description="Example command", method=self.example_function
+        )
+
+        registry.register(cmd)
+        command_prompt = registry.command_prompt()
+
+        assert f"(arg1: int, arg2: str)" in command_prompt
+
+    def test_import_mock_commands_module(self):
+        """Test that the registry can import a module with mock command plugins."""
+        registry = CommandRegistry()
+        mock_commands_module = "tests.mocks.mock_commands"
+
+        registry.import_commands(mock_commands_module)
+
+        assert "function_based" in registry.commands
+        assert registry.commands["function_based"].name == "function_based"
+        assert (
+            registry.commands["function_based"].description
+            == "Function-based test command"
+        )
+
+    def test_import_temp_command_file_module(self, tmp_path):
+        """Test that the registry can import a command plugins module from a temp file."""
+        registry = CommandRegistry()
+
+        # Create a temp command file
+        src = Path(os.getcwd()) / "tests/mocks/mock_commands.py"
+        temp_commands_file = tmp_path / "mock_commands.py"
+        shutil.copyfile(src, temp_commands_file)
+
+        # Add the temp directory to sys.path to make the module importable
+        sys.path.append(str(tmp_path))
+
+        temp_commands_module = "mock_commands"
+        registry.import_commands(temp_commands_module)
+
+        # Remove the temp directory from sys.path
+        sys.path.remove(str(tmp_path))
+
+        assert "function_based" in registry.commands
+        assert registry.commands["function_based"].name == "function_based"
+        assert (
+            registry.commands["function_based"].description
+            == "Function-based test command"
+        )

tests/test_prompt_generator.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from autogpt.promptgenerator import PromptGenerator
+from autogpt.prompts.generator import PromptGenerator
 
 
 class TestPromptGenerator(TestCase):
@@ -38,6 +38,7 @@ class TestPromptGenerator(TestCase):
             "label": command_label,
             "name": command_name,
             "args": args,
+            "function": None,
         }
         self.assertIn(command, self.generator.commands)
 

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