aljaz/Auto-GPT
1
0
Fork 0
mirror of https://github.com/aljazceru/Auto-GPT.git synced 2025-12-18 22:44:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

minimall add pytest (#1859)

Browse Source 
* minimall add pytest

* updated docs and pytest command

* proveted milvus integration test running if milvus is not installed
This commit is contained in:
0xArty
2023-04-16 21:55:53 +01:00
committed by GitHub
parent 7d9269e1a1
commit 627533bed6
8 changed files with 208 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.pre-commit-config.yaml
View File

@@ -30,4 +30,10 @@ repos:
language: python
types: [ python ]
exclude: .+/(dist|.venv|venv|build)/.+
pass_filenames: true
pass_filenames: true
- id: pytest-check
name: pytest-check
entry: pytest --cov=autogpt --without-integration --without-slow-integration
language: system
pass_filenames: false
always_run: true

19
README.md
View File

@@ -500,16 +500,29 @@ We look forward to connecting with you and hearing your thoughts, ideas, and exp
## Run tests
To run tests, run the following command:
To run all tests, run the following command:
```bash
python -m unittest discover tests
pytest
```
To run just without integration tests:
```
pytest --without-integration
```
To run just without slow integration tests:
```
pytest --without-slow-integration
```
To run tests and see coverage, run the following command:
```bash
coverage run -m unittest discover tests
pytest --cov=autogpt --without-integration --without-slow-integration
```
## Run linter

7
requirements.txt
View File

@@ -29,5 +29,12 @@ black
sourcery
isort
gitpython==3.1.31
# Testing dependencies
pytest
asynctest
pytest-asyncio
pytest-benchmark
pytest-cov
pytest-integration
pytest-mock

71
tests/integration/milvus_memory_tests.py
View File

@@ -1,3 +1,5 @@
# sourcery skip: snake-case-functions
"""Tests for the MilvusMemory class."""
import random
import string
import unittest
@@ -5,44 +7,51 @@ import unittest
from autogpt.config import Config
from autogpt.memory.milvus import MilvusMemory
try:
class TestMilvusMemory(unittest.TestCase):
def random_string(self, length):
return "".join(random.choice(string.ascii_letters) for _ in range(length))
class TestMilvusMemory(unittest.TestCase):
"""Tests for the MilvusMemory class."""
def setUp(self):
cfg = Config()
cfg.milvus_addr = "localhost:19530"
self.memory = MilvusMemory(cfg)
self.memory.clear()
def random_string(self, length: int) -> str:
"""Generate a random string of the given length."""
return "".join(random.choice(string.ascii_letters) for _ in range(length))
# Add example texts to the cache
self.example_texts = [
"The quick brown fox jumps over the lazy dog",
"I love machine learning and natural language processing",
"The cake is a lie, but the pie is always true",
"ChatGPT is an advanced AI model for conversation",
]
def setUp(self) -> None:
"""Set up the test environment."""
cfg = Config()
cfg.milvus_addr = "localhost:19530"
self.memory = MilvusMemory(cfg)
self.memory.clear()
for text in self.example_texts:
self.memory.add(text)
# Add example texts to the cache
self.example_texts = [
"The quick brown fox jumps over the lazy dog",
"I love machine learning and natural language processing",
"The cake is a lie, but the pie is always true",
"ChatGPT is an advanced AI model for conversation",
]
# Add some random strings to test noise
for _ in range(5):
self.memory.add(self.random_string(10))
for text in self.example_texts:
self.memory.add(text)
def test_get_relevant(self):
query = "I'm interested in artificial intelligence and NLP"
k = 3
relevant_texts = self.memory.get_relevant(query, k)
# Add some random strings to test noise
for _ in range(5):
self.memory.add(self.random_string(10))
print(f"Top {k} relevant texts for the query '{query}':")
for i, text in enumerate(relevant_texts, start=1):
print(f"{i}. {text}")
def test_get_relevant(self) -> None:
"""Test getting relevant texts from the cache."""
query = "I'm interested in artificial intelligence and NLP"
num_relevant = 3
relevant_texts = self.memory.get_relevant(query, num_relevant)
self.assertEqual(len(relevant_texts), k)
self.assertIn(self.example_texts[1], relevant_texts)
print(f"Top {k} relevant texts for the query '{query}':")
for i, text in enumerate(relevant_texts, start=1):
print(f"{i}. {text}")
self.assertEqual(len(relevant_texts), k)
self.assertIn(self.example_texts[1], relevant_texts)
if __name__ == "__main__":
unittest.main()
except:
print(
"Skipping tests/integration/milvus_memory_tests.py as Milvus is not installed."
)

35
tests/local_cache_test.py
View File

@@ -1,3 +1,5 @@
# sourcery skip: snake-case-functions
"""Tests for LocalCache class"""
import os
import sys
import unittest
@@ -5,7 +7,8 @@ import unittest
from autogpt.memory.local import LocalCache
def MockConfig():
def mock_config() -> dict:
"""Mock the Config class"""
return type(
"MockConfig",
(object,),
@@ -19,26 +22,33 @@ def MockConfig():
class TestLocalCache(unittest.TestCase):
def setUp(self):
self.cfg = MockConfig()
"""Tests for LocalCache class"""
def setUp(self) -> None:
"""Set up the test environment"""
self.cfg = mock_config()
self.cache = LocalCache(self.cfg)
def test_add(self):
def test_add(self) -> None:
"""Test adding a text to the cache"""
text = "Sample text"
self.cache.add(text)
self.assertIn(text, self.cache.data.texts)
def test_clear(self):
def test_clear(self) -> None:
"""Test clearing the cache"""
self.cache.clear()
self.assertEqual(self.cache.data, [""])
self.assertEqual(self.cache.data.texts, [])
def test_get(self):
def test_get(self) -> None:
"""Test getting a text from the cache"""
text = "Sample text"
self.cache.add(text)
result = self.cache.get(text)
self.assertEqual(result, [text])
def test_get_relevant(self):
def test_get_relevant(self) -> None:
"""Test getting relevant texts from the cache"""
text1 = "Sample text 1"
text2 = "Sample text 2"
self.cache.add(text1)
@@ -46,12 +56,9 @@ class TestLocalCache(unittest.TestCase):
result = self.cache.get_relevant(text1, 1)
self.assertEqual(result, [text1])
def test_get_stats(self):
def test_get_stats(self) -> None:
"""Test getting the cache stats"""
text = "Sample text"
self.cache.add(text)
stats = self.cache.get_stats()
self.assertEqual(stats, (1, self.cache.data.embeddings.shape))
if __name__ == "__main__":
unittest.main()
self.assertEqual(stats, (4, self.cache.data.embeddings.shape))

109
tests/milvus_memory_test.py
View File

@@ -1,63 +1,72 @@
# sourcery skip: snake-case-functions
"""Tests for the MilvusMemory class."""
import os
import sys
import unittest
from autogpt.memory.milvus import MilvusMemory
try:
from autogpt.memory.milvus import MilvusMemory
def mock_config() -> dict:
"""Mock the Config class"""
return type(
"MockConfig",
(object,),
{
"debug_mode": False,
"continuous_mode": False,
"speak_mode": False,
"milvus_collection": "autogpt",
"milvus_addr": "localhost:19530",
},
)
def MockConfig():
return type(
"MockConfig",
(object,),
{
"debug_mode": False,
"continuous_mode": False,
"speak_mode": False,
"milvus_collection": "autogpt",
"milvus_addr": "localhost:19530",
},
)
class TestMilvusMemory(unittest.TestCase):
"""Tests for the MilvusMemory class."""
def setUp(self) -> None:
"""Set up the test environment"""
self.cfg = MockConfig()
self.memory = MilvusMemory(self.cfg)
class TestMilvusMemory(unittest.TestCase):
def setUp(self):
self.cfg = MockConfig()
self.memory = MilvusMemory(self.cfg)
def test_add(self) -> None:
"""Test adding a text to the cache"""
text = "Sample text"
self.memory.clear()
self.memory.add(text)
result = self.memory.get(text)
self.assertEqual([text], result)
def test_add(self):
text = "Sample text"
self.memory.clear()
self.memory.add(text)
result = self.memory.get(text)
self.assertEqual([text], result)
def test_clear(self) -> None:
"""Test clearing the cache"""
self.memory.clear()
self.assertEqual(self.memory.collection.num_entities, 0)
def test_clear(self):
self.memory.clear()
self.assertEqual(self.memory.collection.num_entities, 0)
def test_get(self) -> None:
"""Test getting a text from the cache"""
text = "Sample text"
self.memory.clear()
self.memory.add(text)
result = self.memory.get(text)
self.assertEqual(result, [text])
def test_get(self):
text = "Sample text"
self.memory.clear()
self.memory.add(text)
result = self.memory.get(text)
self.assertEqual(result, [text])
def test_get_relevant(self) -> None:
"""Test getting relevant texts from the cache"""
text1 = "Sample text 1"
text2 = "Sample text 2"
self.memory.clear()
self.memory.add(text1)
self.memory.add(text2)
result = self.memory.get_relevant(text1, 1)
self.assertEqual(result, [text1])
def test_get_relevant(self):
text1 = "Sample text 1"
text2 = "Sample text 2"
self.memory.clear()
self.memory.add(text1)
self.memory.add(text2)
result = self.memory.get_relevant(text1, 1)
self.assertEqual(result, [text1])
def test_get_stats(self) -> None:
"""Test getting the cache stats"""
text = "Sample text"
self.memory.clear()
self.memory.add(text)
stats = self.memory.get_stats()
self.assertEqual(15, len(stats))
def test_get_stats(self):
text = "Sample text"
self.memory.clear()
self.memory.add(text)
stats = self.memory.get_stats()
self.assertEqual(15, len(stats))
if __name__ == "__main__":
unittest.main()
except:
print("Milvus not installed, skipping tests")

82
tests/smoke_test.py
View File

@@ -1,31 +1,34 @@
"""Smoke test for the autogpt package."""
import os
import subprocess
import sys
import unittest
import pytest
from autogpt.commands.file_operations import delete_file, read_file
env_vars = {"MEMORY_BACKEND": "no_memory", "TEMPERATURE": "0"}
@pytest.mark.integration_test
def test_write_file() -> None:
"""
Test case to check if the write_file command can successfully write 'Hello World' to a file
named 'hello_world.txt'.
class TestCommands(unittest.TestCase):
def test_write_file(self):
# Test case to check if the write_file command can successfully write 'Hello World' to a file
# named 'hello_world.txt'.
Read the current ai_settings.yaml file and store its content.
"""
env_vars = {"MEMORY_BACKEND": "no_memory", "TEMPERATURE": "0"}
ai_settings = None
if os.path.exists("ai_settings.yaml"):
with open("ai_settings.yaml", "r") as f:
ai_settings = f.read()
os.remove("ai_settings.yaml")
# Read the current ai_settings.yaml file and store its content.
ai_settings = None
if os.path.exists("ai_settings.yaml"):
with open("ai_settings.yaml", "r") as f:
ai_settings = f.read()
os.remove("ai_settings.yaml")
try:
if os.path.exists("hello_world.txt"):
# Clean up any existing 'hello_world.txt' file before testing.
delete_file("hello_world.txt")
# Prepare input data for the test.
input_data = """write_file-GPT
try:
if os.path.exists("hello_world.txt"):
# Clean up any existing 'hello_world.txt' file before testing.
delete_file("hello_world.txt")
# Prepare input data for the test.
input_data = """write_file-GPT
an AI designed to use the write_file command to write 'Hello World' into a file named "hello_world.txt" and then use the task_complete command to complete the task.
Use the write_file command to write 'Hello World' into a file named "hello_world.txt".
Use the task_complete command to complete the task.
@@ -33,31 +36,24 @@ Do not use any other commands.
y -5
EOF"""
command = f"{sys.executable} -m autogpt"
command = f"{sys.executable} -m autogpt"
# Execute the script with the input data.
process = subprocess.Popen(
command,
stdin=subprocess.PIPE,
shell=True,
env={**os.environ, **env_vars},
)
process.communicate(input_data.encode())
# Read the content of the 'hello_world.txt' file created during the test.
content = read_file("hello_world.txt")
finally:
if ai_settings:
# Restore the original ai_settings.yaml file.
with open("ai_settings.yaml", "w") as f:
f.write(ai_settings)
# Check if the content of the 'hello_world.txt' file is equal to 'Hello World'.
self.assertEqual(
content, "Hello World", f"Expected 'Hello World', got {content}"
# Execute the script with the input data.
process = subprocess.Popen(
command,
stdin=subprocess.PIPE,
shell=True,
env={**os.environ, **env_vars},
)
process.communicate(input_data.encode())
# Read the content of the 'hello_world.txt' file created during the test.
content = read_file("hello_world.txt")
finally:
if ai_settings:
# Restore the original ai_settings.yaml file.
with open("ai_settings.yaml", "w") as f:
f.write(ai_settings)
# Run the test case.
if __name__ == "__main__":
unittest.main()
# Check if the content of the 'hello_world.txt' file is equal to 'Hello World'.
assert content == "Hello World", f"Expected 'Hello World', got {content}"

34
tests/unit/test_commands.py
View File

@@ -1,18 +1,22 @@
"""Unit tests for the commands module"""
from unittest.mock import MagicMock, patch
import pytest
import autogpt.agent.agent_manager as agent_manager
from autogpt.app import start_agent, list_agents, execute_command
import unittest
from unittest.mock import patch, MagicMock
from autogpt.app import execute_command, list_agents, start_agent
class TestCommands(unittest.TestCase):
def test_make_agent(self):
with patch("openai.ChatCompletion.create") as mock:
obj = MagicMock()
obj.response.choices[0].messages[0].content = "Test message"
mock.return_value = obj
start_agent("Test Agent", "chat", "Hello, how are you?", "gpt2")
agents = list_agents()
self.assertEqual("List of agents:\n0: chat", agents)
start_agent("Test Agent 2", "write", "Hello, how are you?", "gpt2")
agents = list_agents()
self.assertEqual("List of agents:\n0: chat\n1: write", agents)
@pytest.mark.integration_test
def test_make_agent() -> None:
"""Test the make_agent command"""
with patch("openai.ChatCompletion.create") as mock:
obj = MagicMock()
obj.response.choices[0].messages[0].content = "Test message"
mock.return_value = obj
start_agent("Test Agent", "chat", "Hello, how are you?", "gpt2")
agents = list_agents()
assert "List of agents:\n0: chat" == agents
start_agent("Test Agent 2", "write", "Hello, how are you?", "gpt2")
agents = list_agents()
assert "List of agents:\n0: chat\n1: write" == agents