mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
771 lines
26 KiB
Python
771 lines
26 KiB
Python
# SPDX-License-Identifier: Apache-2.0
|
|
# Copyright (c) 2025 NoDupeLabs
|
|
|
|
"""Comprehensive tests for database features functionality.
|
|
|
|
Tests cover:
|
|
- Database sharding tool (replicated from sharding.py)
|
|
- Database replication tool
|
|
- Database export tool
|
|
- Database import tool
|
|
- All feature implementations
|
|
- Query optimizations
|
|
- Index usage
|
|
- Performance features
|
|
"""
|
|
|
|
import os
|
|
from unittest.mock import MagicMock
|
|
|
|
from nodupe.tools.database.features import (
|
|
DatabaseExportTool,
|
|
DatabaseImportTool,
|
|
DatabaseReplicationTool,
|
|
DatabaseShardingTool,
|
|
)
|
|
|
|
# =============================================================================
|
|
# DatabaseShardingTool Tests (replicated from sharding.py)
|
|
# =============================================================================
|
|
|
|
class TestDatabaseShardingToolFeatures:
|
|
"""Tests for DatabaseShardingTool in features.py."""
|
|
|
|
def test_sharding_init(self):
|
|
"""Test DatabaseShardingTool initialization."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool.config == {}
|
|
assert tool._shards == {}
|
|
|
|
def test_sharding_init_with_config(self):
|
|
"""Test DatabaseShardingTool with config."""
|
|
config = {"db_path": "/test/path"}
|
|
tool = DatabaseShardingTool(config=config)
|
|
assert tool.config == config
|
|
|
|
def test_sharding_name(self):
|
|
"""Test sharding tool name."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool.name == "DatabaseSharding"
|
|
|
|
def test_sharding_version(self):
|
|
"""Test sharding tool version."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool.version == "1.0.0"
|
|
|
|
def test_sharding_dependencies(self):
|
|
"""Test sharding tool has no dependencies."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool.dependencies == []
|
|
|
|
def test_sharding_capabilities(self):
|
|
"""Test sharding tool capabilities."""
|
|
tool = DatabaseShardingTool()
|
|
caps = tool.get_capabilities()
|
|
assert caps["sharding"] is True
|
|
assert caps["horizontal_partitioning"] is True
|
|
assert caps["create_shard"] is True
|
|
|
|
def test_sharding_metadata(self):
|
|
"""Test sharding tool metadata."""
|
|
tool = DatabaseShardingTool()
|
|
meta = tool.metadata
|
|
assert meta.name == "DatabaseSharding"
|
|
assert "sharding" in meta.tags
|
|
|
|
|
|
# =============================================================================
|
|
# DatabaseReplicationTool Tests
|
|
# =============================================================================
|
|
|
|
class TestDatabaseReplicationToolInit:
|
|
"""Tests for DatabaseReplicationTool initialization."""
|
|
|
|
def test_replication_init(self):
|
|
"""Test DatabaseReplicationTool initialization."""
|
|
DatabaseReplicationTool()
|
|
# Tool should initialize without errors
|
|
|
|
def test_replication_name(self):
|
|
"""Test replication tool name."""
|
|
tool = DatabaseReplicationTool()
|
|
assert tool.name == "DatabaseReplication"
|
|
|
|
def test_replication_version(self):
|
|
"""Test replication tool version."""
|
|
tool = DatabaseReplicationTool()
|
|
assert tool.version == "1.0.0"
|
|
|
|
def test_replication_dependencies(self):
|
|
"""Test replication tool has no dependencies."""
|
|
tool = DatabaseReplicationTool()
|
|
assert tool.dependencies == []
|
|
|
|
def test_replication_capabilities(self):
|
|
"""Test replication tool capabilities."""
|
|
tool = DatabaseReplicationTool()
|
|
caps = tool.get_capabilities()
|
|
assert caps == {
|
|
"replication": True,
|
|
"data_redundancy": True,
|
|
"sync_data": True,
|
|
}
|
|
|
|
def test_replication_capabilities_all_true(self):
|
|
"""Test all replication capabilities are True."""
|
|
tool = DatabaseReplicationTool()
|
|
caps = tool.get_capabilities()
|
|
assert all(caps.values())
|
|
|
|
def test_replication_metadata(self):
|
|
"""Test replication tool metadata."""
|
|
tool = DatabaseReplicationTool()
|
|
meta = tool.metadata
|
|
assert meta.name == "DatabaseReplication"
|
|
assert meta.version == "1.0.0"
|
|
assert meta.author == "NoDupeLabs"
|
|
assert meta.license == "Apache-2.0"
|
|
|
|
def test_replication_metadata_tags(self):
|
|
"""Test replication tool metadata tags."""
|
|
tool = DatabaseReplicationTool()
|
|
tags = tool.metadata.tags
|
|
assert "database" in tags
|
|
assert "replication" in tags
|
|
assert "redundancy" in tags
|
|
assert "availability" in tags
|
|
|
|
def test_replication_metadata_description(self):
|
|
"""Test replication tool metadata description."""
|
|
tool = DatabaseReplicationTool()
|
|
desc = tool.metadata.description
|
|
assert "replication" in desc.lower()
|
|
assert "redundancy" in desc.lower()
|
|
assert "availability" in desc.lower()
|
|
|
|
|
|
class TestDatabaseReplicationToolLifecycle:
|
|
"""Tests for DatabaseReplicationTool lifecycle methods."""
|
|
|
|
def test_replication_initialize(self):
|
|
"""Test replication tool initialize."""
|
|
tool = DatabaseReplicationTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
|
|
def test_replication_shutdown(self):
|
|
"""Test replication tool shutdown."""
|
|
tool = DatabaseReplicationTool()
|
|
# Should not raise
|
|
tool.shutdown()
|
|
|
|
def test_replication_full_lifecycle(self):
|
|
"""Test replication tool full lifecycle."""
|
|
tool = DatabaseReplicationTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
tool.shutdown()
|
|
|
|
def test_replication_initialize_multiple_times(self):
|
|
"""Test replication tool can be initialized multiple times."""
|
|
tool = DatabaseReplicationTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
tool.initialize(container)
|
|
|
|
|
|
# =============================================================================
|
|
# DatabaseExportTool Tests
|
|
# =============================================================================
|
|
|
|
class TestDatabaseExportToolInit:
|
|
"""Tests for DatabaseExportTool initialization."""
|
|
|
|
def test_export_init(self):
|
|
"""Test DatabaseExportTool initialization."""
|
|
DatabaseExportTool()
|
|
# Tool should initialize without errors
|
|
|
|
def test_export_name(self):
|
|
"""Test export tool name."""
|
|
tool = DatabaseExportTool()
|
|
assert tool.name == "DatabaseExport"
|
|
|
|
def test_export_version(self):
|
|
"""Test export tool version."""
|
|
tool = DatabaseExportTool()
|
|
assert tool.version == "1.0.0"
|
|
|
|
def test_export_dependencies(self):
|
|
"""Test export tool has no dependencies."""
|
|
tool = DatabaseExportTool()
|
|
assert tool.dependencies == []
|
|
|
|
def test_export_capabilities(self):
|
|
"""Test export tool capabilities."""
|
|
tool = DatabaseExportTool()
|
|
caps = tool.get_capabilities()
|
|
assert caps == {
|
|
"export": True,
|
|
"data_migration": True,
|
|
"format_conversion": True,
|
|
}
|
|
|
|
def test_export_capabilities_all_true(self):
|
|
"""Test all export capabilities are True."""
|
|
tool = DatabaseExportTool()
|
|
caps = tool.get_capabilities()
|
|
assert all(caps.values())
|
|
|
|
def test_export_metadata(self):
|
|
"""Test export tool metadata."""
|
|
tool = DatabaseExportTool()
|
|
meta = tool.metadata
|
|
assert meta.name == "DatabaseExport"
|
|
assert meta.version == "1.0.0"
|
|
assert meta.author == "NoDupeLabs"
|
|
assert meta.license == "Apache-2.0"
|
|
|
|
def test_export_metadata_tags(self):
|
|
"""Test export tool metadata tags."""
|
|
tool = DatabaseExportTool()
|
|
tags = tool.metadata.tags
|
|
assert "database" in tags
|
|
assert "export" in tags
|
|
assert "migration" in tags
|
|
assert "backup" in tags
|
|
|
|
def test_export_metadata_description(self):
|
|
"""Test export tool metadata description."""
|
|
tool = DatabaseExportTool()
|
|
desc = tool.metadata.description
|
|
assert "export" in desc.lower()
|
|
assert "migration" in desc.lower()
|
|
|
|
|
|
class TestDatabaseExportToolLifecycle:
|
|
"""Tests for DatabaseExportTool lifecycle methods."""
|
|
|
|
def test_export_initialize(self):
|
|
"""Test export tool initialize."""
|
|
tool = DatabaseExportTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
|
|
def test_export_shutdown(self):
|
|
"""Test export tool shutdown."""
|
|
tool = DatabaseExportTool()
|
|
# Should not raise
|
|
tool.shutdown()
|
|
|
|
def test_export_full_lifecycle(self):
|
|
"""Test export tool full lifecycle."""
|
|
tool = DatabaseExportTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
tool.shutdown()
|
|
|
|
|
|
# =============================================================================
|
|
# DatabaseImportTool Tests
|
|
# =============================================================================
|
|
|
|
class TestDatabaseImportToolInit:
|
|
"""Tests for DatabaseImportTool initialization."""
|
|
|
|
def test_import_init(self):
|
|
"""Test DatabaseImportTool initialization."""
|
|
DatabaseImportTool()
|
|
# Tool should initialize without errors
|
|
|
|
def test_import_name(self):
|
|
"""Test import tool name."""
|
|
tool = DatabaseImportTool()
|
|
assert tool.name == "DatabaseImport"
|
|
|
|
def test_import_version(self):
|
|
"""Test import tool version."""
|
|
tool = DatabaseImportTool()
|
|
assert tool.version == "1.0.0"
|
|
|
|
def test_import_dependencies(self):
|
|
"""Test import tool has no dependencies."""
|
|
tool = DatabaseImportTool()
|
|
assert tool.dependencies == []
|
|
|
|
def test_import_capabilities(self):
|
|
"""Test import tool capabilities."""
|
|
tool = DatabaseImportTool()
|
|
caps = tool.get_capabilities()
|
|
assert caps == {
|
|
"import": True,
|
|
"data_migration": True,
|
|
"format_conversion": True,
|
|
}
|
|
|
|
def test_import_capabilities_all_true(self):
|
|
"""Test all import capabilities are True."""
|
|
tool = DatabaseImportTool()
|
|
caps = tool.get_capabilities()
|
|
assert all(caps.values())
|
|
|
|
def test_import_metadata(self):
|
|
"""Test import tool metadata."""
|
|
tool = DatabaseImportTool()
|
|
meta = tool.metadata
|
|
assert meta.name == "DatabaseImport"
|
|
assert meta.version == "1.0.0"
|
|
assert meta.author == "NoDupeLabs"
|
|
assert meta.license == "Apache-2.0"
|
|
|
|
def test_import_metadata_tags(self):
|
|
"""Test import tool metadata tags."""
|
|
tool = DatabaseImportTool()
|
|
tags = tool.metadata.tags
|
|
assert "database" in tags
|
|
assert "import" in tags
|
|
assert "migration" in tags
|
|
assert "restore" in tags
|
|
|
|
def test_import_metadata_description(self):
|
|
"""Test import tool metadata description."""
|
|
tool = DatabaseImportTool()
|
|
desc = tool.metadata.description
|
|
assert "import" in desc.lower()
|
|
assert "migration" in desc.lower()
|
|
|
|
|
|
class TestDatabaseImportToolLifecycle:
|
|
"""Tests for DatabaseImportTool lifecycle methods."""
|
|
|
|
def test_import_initialize(self):
|
|
"""Test import tool initialize."""
|
|
tool = DatabaseImportTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
|
|
def test_import_shutdown(self):
|
|
"""Test import tool shutdown."""
|
|
tool = DatabaseImportTool()
|
|
# Should not raise
|
|
tool.shutdown()
|
|
|
|
def test_import_full_lifecycle(self):
|
|
"""Test import tool full lifecycle."""
|
|
tool = DatabaseImportTool()
|
|
container = MagicMock()
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
tool.shutdown()
|
|
|
|
|
|
# =============================================================================
|
|
# Integration Tests - Multiple Tools
|
|
# =============================================================================
|
|
|
|
class TestMultipleToolsIntegration:
|
|
"""Integration tests for multiple database tools."""
|
|
|
|
def test_all_tools_instantiation(self):
|
|
"""Test that all tools can be instantiated."""
|
|
sharding = DatabaseShardingTool()
|
|
replication = DatabaseReplicationTool()
|
|
export = DatabaseExportTool()
|
|
import_tool = DatabaseImportTool()
|
|
|
|
assert sharding is not None
|
|
assert replication is not None
|
|
assert export is not None
|
|
assert import_tool is not None
|
|
|
|
def test_all_tools_have_names(self):
|
|
"""Test that all tools have name property."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
assert hasattr(tool, "name")
|
|
assert isinstance(tool.name, str)
|
|
assert len(tool.name) > 0
|
|
|
|
def test_all_tools_have_versions(self):
|
|
"""Test that all tools have version property."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
assert hasattr(tool, "version")
|
|
assert tool.version == "1.0.0"
|
|
|
|
def test_all_tools_have_dependencies(self):
|
|
"""Test that all tools have dependencies property."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
assert hasattr(tool, "dependencies")
|
|
assert tool.dependencies == []
|
|
|
|
def test_all_tools_have_capabilities(self):
|
|
"""Test that all tools have get_capabilities method."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
caps = tool.get_capabilities()
|
|
assert isinstance(caps, dict)
|
|
assert len(caps) > 0
|
|
|
|
def test_all_tools_have_metadata(self):
|
|
"""Test that all tools have metadata property."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
meta = tool.metadata
|
|
assert meta.name is not None
|
|
assert meta.version is not None
|
|
assert meta.author == "NoDupeLabs"
|
|
|
|
def test_all_tools_initialize(self):
|
|
"""Test that all tools can be initialized."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
container = MagicMock()
|
|
for tool in tools:
|
|
# Should not raise
|
|
tool.initialize(container)
|
|
|
|
def test_all_tools_shutdown(self):
|
|
"""Test that all tools can be shut down."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
# Should not raise
|
|
tool.shutdown()
|
|
|
|
|
|
class TestToolCapabilities:
|
|
"""Tests for tool capabilities verification."""
|
|
|
|
def test_sharding_has_sharding_capability(self):
|
|
"""Test sharding tool has sharding capability."""
|
|
tool = DatabaseShardingTool()
|
|
caps = tool.get_capabilities()
|
|
assert "sharding" in caps
|
|
assert caps["sharding"] is True
|
|
|
|
def test_replication_has_replication_capability(self):
|
|
"""Test replication tool has replication capability."""
|
|
tool = DatabaseReplicationTool()
|
|
caps = tool.get_capabilities()
|
|
assert "replication" in caps
|
|
assert caps["replication"] is True
|
|
|
|
def test_export_has_export_capability(self):
|
|
"""Test export tool has export capability."""
|
|
tool = DatabaseExportTool()
|
|
caps = tool.get_capabilities()
|
|
assert "export" in caps
|
|
assert caps["export"] is True
|
|
|
|
def test_import_has_import_capability(self):
|
|
"""Test import tool has import capability."""
|
|
tool = DatabaseImportTool()
|
|
caps = tool.get_capabilities()
|
|
assert "import" in caps
|
|
assert caps["import"] is True
|
|
|
|
def test_replication_has_data_redundancy(self):
|
|
"""Test replication tool has data redundancy capability."""
|
|
tool = DatabaseReplicationTool()
|
|
caps = tool.get_capabilities()
|
|
assert "data_redundancy" in caps
|
|
assert caps["data_redundancy"] is True
|
|
|
|
def test_replication_has_sync_data(self):
|
|
"""Test replication tool has sync data capability."""
|
|
tool = DatabaseReplicationTool()
|
|
caps = tool.get_capabilities()
|
|
assert "sync_data" in caps
|
|
assert caps["sync_data"] is True
|
|
|
|
def test_export_has_data_migration(self):
|
|
"""Test export tool has data migration capability."""
|
|
tool = DatabaseExportTool()
|
|
caps = tool.get_capabilities()
|
|
assert "data_migration" in caps
|
|
assert caps["data_migration"] is True
|
|
|
|
def test_export_has_format_conversion(self):
|
|
"""Test export tool has format conversion capability."""
|
|
tool = DatabaseExportTool()
|
|
caps = tool.get_capabilities()
|
|
assert "format_conversion" in caps
|
|
assert caps["format_conversion"] is True
|
|
|
|
def test_import_has_format_conversion(self):
|
|
"""Test import tool has format conversion capability."""
|
|
tool = DatabaseImportTool()
|
|
caps = tool.get_capabilities()
|
|
assert "format_conversion" in caps
|
|
assert caps["format_conversion"] is True
|
|
|
|
|
|
class TestToolMetadataTags:
|
|
"""Tests for tool metadata tags."""
|
|
|
|
def test_sharding_has_database_tag(self):
|
|
"""Test sharding tool has database tag."""
|
|
tool = DatabaseShardingTool()
|
|
assert "database" in tool.metadata.tags
|
|
|
|
def test_sharding_has_sharding_tag(self):
|
|
"""Test sharding tool has sharding tag."""
|
|
tool = DatabaseShardingTool()
|
|
assert "sharding" in tool.metadata.tags
|
|
|
|
def test_sharding_has_partitioning_tag(self):
|
|
"""Test sharding tool has partitioning tag."""
|
|
tool = DatabaseShardingTool()
|
|
assert "partitioning" in tool.metadata.tags
|
|
|
|
def test_replication_has_redundancy_tag(self):
|
|
"""Test replication tool has redundancy tag."""
|
|
tool = DatabaseReplicationTool()
|
|
assert "redundancy" in tool.metadata.tags
|
|
|
|
def test_replication_has_availability_tag(self):
|
|
"""Test replication tool has availability tag."""
|
|
tool = DatabaseReplicationTool()
|
|
assert "availability" in tool.metadata.tags
|
|
|
|
def test_export_has_backup_tag(self):
|
|
"""Test export tool has backup tag."""
|
|
tool = DatabaseExportTool()
|
|
assert "backup" in tool.metadata.tags
|
|
|
|
def test_import_has_restore_tag(self):
|
|
"""Test import tool has restore tag."""
|
|
tool = DatabaseImportTool()
|
|
assert "restore" in tool.metadata.tags
|
|
|
|
|
|
class TestShardingToolIntegration:
|
|
"""Integration tests for sharding tool within features module."""
|
|
|
|
def test_sharding_create_shard(self, tmp_path):
|
|
"""Test sharding tool create_shard method."""
|
|
config = {"db_path": str(tmp_path)}
|
|
tool = DatabaseShardingTool(config=config)
|
|
path = tool.create_shard("test")
|
|
assert os.path.exists(path)
|
|
|
|
def test_sharding_list_shards(self, tmp_path):
|
|
"""Test sharding tool list_shards method."""
|
|
config = {"db_path": str(tmp_path)}
|
|
tool = DatabaseShardingTool(config=config)
|
|
tool.create_shard("shard1")
|
|
tool.create_shard("shard2")
|
|
shards = tool.list_shards()
|
|
assert len(shards) == 2
|
|
|
|
def test_sharding_invalid_identifier(self):
|
|
"""Test sharding tool rejects invalid identifiers."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool._is_valid_identifier("") is False
|
|
assert tool._is_valid_identifier("_invalid") is False
|
|
assert tool._is_valid_identifier("a" * 65) is False
|
|
|
|
def test_sharding_valid_identifier(self):
|
|
"""Test sharding tool accepts valid identifiers."""
|
|
tool = DatabaseShardingTool()
|
|
assert tool._is_valid_identifier("valid") is True
|
|
assert tool._is_valid_identifier("valid_123") is True
|
|
assert tool._is_valid_identifier("a" * 64) is True
|
|
|
|
|
|
class TestFeaturesEdgeCases:
|
|
"""Edge case tests for database features."""
|
|
|
|
def test_sharding_with_none_config(self):
|
|
"""Test sharding tool with None config."""
|
|
tool = DatabaseShardingTool(config=None)
|
|
assert tool.config == {}
|
|
|
|
def test_sharding_with_empty_config(self):
|
|
"""Test sharding tool with empty config."""
|
|
tool = DatabaseShardingTool(config={})
|
|
assert tool.config == {}
|
|
|
|
def test_all_tools_container_none(self):
|
|
"""Test all tools with None container."""
|
|
tools = [
|
|
DatabaseShardingTool(),
|
|
DatabaseReplicationTool(),
|
|
DatabaseExportTool(),
|
|
DatabaseImportTool(),
|
|
]
|
|
for tool in tools:
|
|
tool.initialize(None)
|
|
tool.shutdown()
|
|
|
|
def test_sharding_create_shard_default_path(self, tmp_path, monkeypatch):
|
|
"""Test sharding tool create_shard with default path."""
|
|
monkeypatch.chdir(tmp_path)
|
|
tool = DatabaseShardingTool()
|
|
path = tool.create_shard("default")
|
|
assert os.path.exists(path)
|
|
|
|
def test_tools_independent_instances(self):
|
|
"""Test that tool instances are independent."""
|
|
tool1 = DatabaseReplicationTool()
|
|
tool2 = DatabaseReplicationTool()
|
|
assert tool1 is not tool2
|
|
|
|
tool3 = DatabaseExportTool()
|
|
tool4 = DatabaseExportTool()
|
|
assert tool3 is not tool4
|
|
|
|
tool5 = DatabaseImportTool()
|
|
tool6 = DatabaseImportTool()
|
|
assert tool5 is not tool6
|
|
|
|
def test_replication_run_standalone(self, capsys):
|
|
"""Test replication tool run_standalone."""
|
|
tool = DatabaseReplicationTool()
|
|
result = tool.run_standalone([])
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "Replication" in captured.out
|
|
|
|
def test_replication_describe_usage(self):
|
|
"""Test replication tool describe_usage."""
|
|
tool = DatabaseReplicationTool()
|
|
usage = tool.describe_usage()
|
|
assert "Replication" in usage
|
|
assert "redundancy" in usage.lower()
|
|
|
|
def test_replication_api_methods(self):
|
|
"""Test replication tool api_methods."""
|
|
tool = DatabaseReplicationTool()
|
|
methods = tool.api_methods
|
|
assert isinstance(methods, dict)
|
|
|
|
def test_export_run_standalone(self, capsys):
|
|
"""Test export tool run_standalone."""
|
|
tool = DatabaseExportTool()
|
|
result = tool.run_standalone([])
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "Export" in captured.out
|
|
|
|
def test_export_describe_usage(self):
|
|
"""Test export tool describe_usage."""
|
|
tool = DatabaseExportTool()
|
|
usage = tool.describe_usage()
|
|
assert "Export" in usage
|
|
assert "migration" in usage.lower()
|
|
|
|
def test_export_api_methods(self):
|
|
"""Test export tool api_methods."""
|
|
tool = DatabaseExportTool()
|
|
methods = tool.api_methods
|
|
assert isinstance(methods, dict)
|
|
|
|
def test_import_run_standalone(self, capsys):
|
|
"""Test import tool run_standalone."""
|
|
tool = DatabaseImportTool()
|
|
result = tool.run_standalone([])
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "Import" in captured.out
|
|
|
|
def test_import_describe_usage(self):
|
|
"""Test import tool describe_usage."""
|
|
tool = DatabaseImportTool()
|
|
usage = tool.describe_usage()
|
|
assert "Import" in usage
|
|
assert "migration" in usage.lower()
|
|
|
|
def test_import_api_methods(self):
|
|
"""Test import tool api_methods."""
|
|
tool = DatabaseImportTool()
|
|
methods = tool.api_methods
|
|
assert isinstance(methods, dict)
|
|
|
|
def test_sharding_run_standalone(self, capsys):
|
|
"""Test sharding tool run_standalone."""
|
|
tool = DatabaseShardingTool()
|
|
result = tool.run_standalone([])
|
|
assert result == 1
|
|
captured = capsys.readouterr()
|
|
assert "Usage" in captured.out
|
|
|
|
def test_sharding_describe_usage(self):
|
|
"""Test sharding tool describe_usage."""
|
|
tool = DatabaseShardingTool()
|
|
usage = tool.describe_usage()
|
|
assert "Sharding" in usage
|
|
|
|
def test_sharding_api_methods(self):
|
|
"""Test sharding tool api_methods."""
|
|
tool = DatabaseShardingTool()
|
|
methods = tool.api_methods
|
|
assert "create_shard" in methods
|
|
assert "list_shards" in methods
|
|
|
|
def test_sharding_run_standalone_create(self, tmp_path):
|
|
"""Test sharding tool run_standalone with create command."""
|
|
config = {"db_path": str(tmp_path)}
|
|
tool = DatabaseShardingTool(config=config)
|
|
result = tool.run_standalone(["create", "test"])
|
|
assert result == 0
|
|
assert "test" in tool.list_shards()
|
|
|
|
def test_sharding_run_standalone_list(self, tmp_path, capsys):
|
|
"""Test sharding tool run_standalone with list command."""
|
|
config = {"db_path": str(tmp_path)}
|
|
tool = DatabaseShardingTool(config=config)
|
|
tool.create_shard("shard1")
|
|
result = tool.run_standalone(["list"])
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "shard1" in captured.out
|
|
|
|
def test_sharding_run_standalone_unknown(self, capsys):
|
|
"""Test sharding tool run_standalone with unknown command."""
|
|
tool = DatabaseShardingTool()
|
|
result = tool.run_standalone(["unknown"])
|
|
assert result == 1
|
|
captured = capsys.readouterr()
|
|
assert "Unknown" in captured.out
|