diff --git a/tests/test_adaptors/test_adaptors_e2e.py b/tests/test_adaptors/test_adaptors_e2e.py
new file mode 100644
index 0000000..8732bb9
--- /dev/null
+++ b/tests/test_adaptors/test_adaptors_e2e.py
@@ -0,0 +1,555 @@
+#!/usr/bin/env python3
+"""
+End-to-End Tests for Multi-LLM Adaptors
+
+Tests complete workflows without real API uploads:
+- Scrape → Package → Verify for all platforms
+- Same scraped data works for all platforms
+- Package structure validation
+- Enhancement workflow (mocked)
+"""
+
+import unittest
+import tempfile
+import zipfile
+import tarfile
+import json
+from pathlib import Path
+
+from skill_seekers.cli.adaptors import get_adaptor, list_platforms
+from skill_seekers.cli.adaptors.base import SkillMetadata
+
+
+class TestAdaptorsE2E(unittest.TestCase):
+ """End-to-end tests for all platform adaptors"""
+
+ def setUp(self):
+ """Set up test environment with sample skill directory"""
+ self.temp_dir = tempfile.TemporaryDirectory()
+ self.skill_dir = Path(self.temp_dir.name) / "test-skill"
+ self.skill_dir.mkdir()
+
+ # Create realistic skill structure
+ self._create_sample_skill()
+
+ self.output_dir = Path(self.temp_dir.name) / "output"
+ self.output_dir.mkdir()
+
+ def tearDown(self):
+ """Clean up temporary directory"""
+ self.temp_dir.cleanup()
+
+ def _create_sample_skill(self):
+ """Create a sample skill directory with realistic content"""
+ # Create SKILL.md
+ skill_md_content = """# React Framework
+
+React is a JavaScript library for building user interfaces.
+
+## Quick Reference
+
+```javascript
+// Create a component
+function Welcome(props) {
+ return Hello, {props.name}
;
+}
+```
+
+## Key Concepts
+
+- Components
+- Props
+- State
+- Hooks
+"""
+ (self.skill_dir / "SKILL.md").write_text(skill_md_content)
+
+ # Create references directory
+ refs_dir = self.skill_dir / "references"
+ refs_dir.mkdir()
+
+ # Create sample reference files
+ (refs_dir / "getting_started.md").write_text("""# Getting Started
+
+Install React:
+
+```bash
+npm install react
+```
+
+Create your first component:
+
+```javascript
+function App() {
+ return Hello World
;
+}
+```
+""")
+
+ (refs_dir / "hooks.md").write_text("""# React Hooks
+
+## useState
+
+```javascript
+const [count, setCount] = useState(0);
+```
+
+## useEffect
+
+```javascript
+useEffect(() => {
+ document.title = `Count: ${count}`;
+}, [count]);
+```
+""")
+
+ (refs_dir / "components.md").write_text("""# Components
+
+## Functional Components
+
+```javascript
+function Greeting({ name }) {
+ return Hello {name}
;
+}
+```
+
+## Props
+
+Pass data to components:
+
+```javascript
+
+```
+""")
+
+ # Create empty scripts and assets directories
+ (self.skill_dir / "scripts").mkdir()
+ (self.skill_dir / "assets").mkdir()
+
+ def test_e2e_all_platforms_from_same_skill(self):
+ """Test that all platforms can package the same skill"""
+ platforms = ['claude', 'gemini', 'openai', 'markdown']
+ packages = {}
+
+ for platform in platforms:
+ adaptor = get_adaptor(platform)
+
+ # Package for this platform
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify package was created
+ self.assertTrue(package_path.exists(),
+ f"Package not created for {platform}")
+
+ # Store for later verification
+ packages[platform] = package_path
+
+ # Verify all packages were created
+ self.assertEqual(len(packages), 4)
+
+ # Verify correct extensions
+ self.assertTrue(str(packages['claude']).endswith('.zip'))
+ self.assertTrue(str(packages['gemini']).endswith('.tar.gz'))
+ self.assertTrue(str(packages['openai']).endswith('.zip'))
+ self.assertTrue(str(packages['markdown']).endswith('.zip'))
+
+ def test_e2e_claude_workflow(self):
+ """Test complete Claude workflow: package + verify structure"""
+ adaptor = get_adaptor('claude')
+
+ # Package
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify package
+ self.assertTrue(package_path.exists())
+ self.assertTrue(str(package_path).endswith('.zip'))
+
+ # Verify contents
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+
+ # Should have SKILL.md
+ self.assertIn('SKILL.md', names)
+
+ # Should have references
+ self.assertTrue(any('references/' in name for name in names))
+
+ # Verify SKILL.md content (should have YAML frontmatter)
+ skill_content = zf.read('SKILL.md').decode('utf-8')
+ # Claude uses YAML frontmatter (but current implementation doesn't add it in package)
+ # Just verify content exists
+ self.assertGreater(len(skill_content), 0)
+
+ def test_e2e_gemini_workflow(self):
+ """Test complete Gemini workflow: package + verify structure"""
+ adaptor = get_adaptor('gemini')
+
+ # Package
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify package
+ self.assertTrue(package_path.exists())
+ self.assertTrue(str(package_path).endswith('.tar.gz'))
+
+ # Verify contents
+ with tarfile.open(package_path, 'r:gz') as tar:
+ names = tar.getnames()
+
+ # Should have system_instructions.md (not SKILL.md)
+ self.assertIn('system_instructions.md', names)
+
+ # Should have references
+ self.assertTrue(any('references/' in name for name in names))
+
+ # Should have metadata
+ self.assertIn('gemini_metadata.json', names)
+
+ # Verify metadata content
+ metadata_member = tar.getmember('gemini_metadata.json')
+ metadata_file = tar.extractfile(metadata_member)
+ metadata = json.loads(metadata_file.read().decode('utf-8'))
+
+ self.assertEqual(metadata['platform'], 'gemini')
+ self.assertEqual(metadata['name'], 'test-skill')
+ self.assertIn('created_with', metadata)
+
+ def test_e2e_openai_workflow(self):
+ """Test complete OpenAI workflow: package + verify structure"""
+ adaptor = get_adaptor('openai')
+
+ # Package
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify package
+ self.assertTrue(package_path.exists())
+ self.assertTrue(str(package_path).endswith('.zip'))
+
+ # Verify contents
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+
+ # Should have assistant_instructions.txt
+ self.assertIn('assistant_instructions.txt', names)
+
+ # Should have vector store files
+ self.assertTrue(any('vector_store_files/' in name for name in names))
+
+ # Should have metadata
+ self.assertIn('openai_metadata.json', names)
+
+ # Verify metadata content
+ metadata_content = zf.read('openai_metadata.json').decode('utf-8')
+ metadata = json.loads(metadata_content)
+
+ self.assertEqual(metadata['platform'], 'openai')
+ self.assertEqual(metadata['name'], 'test-skill')
+ self.assertEqual(metadata['model'], 'gpt-4o')
+ self.assertIn('file_search', metadata['tools'])
+
+ def test_e2e_markdown_workflow(self):
+ """Test complete Markdown workflow: package + verify structure"""
+ adaptor = get_adaptor('markdown')
+
+ # Package
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify package
+ self.assertTrue(package_path.exists())
+ self.assertTrue(str(package_path).endswith('.zip'))
+
+ # Verify contents
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+
+ # Should have README.md
+ self.assertIn('README.md', names)
+
+ # Should have DOCUMENTATION.md (combined)
+ self.assertIn('DOCUMENTATION.md', names)
+
+ # Should have references
+ self.assertTrue(any('references/' in name for name in names))
+
+ # Should have metadata
+ self.assertIn('metadata.json', names)
+
+ # Verify combined documentation
+ doc_content = zf.read('DOCUMENTATION.md').decode('utf-8')
+
+ # Should contain content from all references
+ self.assertIn('Getting Started', doc_content)
+ self.assertIn('React Hooks', doc_content)
+ self.assertIn('Components', doc_content)
+
+ def test_e2e_package_format_validation(self):
+ """Test that each platform creates correct package format"""
+ test_cases = [
+ ('claude', '.zip'),
+ ('gemini', '.tar.gz'),
+ ('openai', '.zip'),
+ ('markdown', '.zip')
+ ]
+
+ for platform, expected_ext in test_cases:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify extension
+ if expected_ext == '.tar.gz':
+ self.assertTrue(str(package_path).endswith('.tar.gz'),
+ f"{platform} should create .tar.gz file")
+ else:
+ self.assertTrue(str(package_path).endswith('.zip'),
+ f"{platform} should create .zip file")
+
+ def test_e2e_package_filename_convention(self):
+ """Test that package filenames follow convention"""
+ test_cases = [
+ ('claude', 'test-skill.zip'),
+ ('gemini', 'test-skill-gemini.tar.gz'),
+ ('openai', 'test-skill-openai.zip'),
+ ('markdown', 'test-skill-markdown.zip')
+ ]
+
+ for platform, expected_name in test_cases:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Verify filename
+ self.assertEqual(package_path.name, expected_name,
+ f"{platform} package filename incorrect")
+
+ def test_e2e_all_platforms_preserve_references(self):
+ """Test that all platforms preserve reference files"""
+ ref_files = ['getting_started.md', 'hooks.md', 'components.md']
+
+ for platform in ['claude', 'gemini', 'openai', 'markdown']:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Check references are preserved
+ if platform == 'gemini':
+ with tarfile.open(package_path, 'r:gz') as tar:
+ names = tar.getnames()
+ for ref_file in ref_files:
+ self.assertTrue(
+ any(ref_file in name for name in names),
+ f"{platform}: {ref_file} not found in package"
+ )
+ else:
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+ for ref_file in ref_files:
+ # OpenAI moves to vector_store_files/
+ if platform == 'openai':
+ self.assertTrue(
+ any(f'vector_store_files/{ref_file}' in name for name in names),
+ f"{platform}: {ref_file} not found in vector_store_files/"
+ )
+ else:
+ self.assertTrue(
+ any(ref_file in name for name in names),
+ f"{platform}: {ref_file} not found in package"
+ )
+
+ def test_e2e_metadata_consistency(self):
+ """Test that metadata is consistent across platforms"""
+ platforms_with_metadata = ['gemini', 'openai', 'markdown']
+
+ for platform in platforms_with_metadata:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Extract and verify metadata
+ if platform == 'gemini':
+ with tarfile.open(package_path, 'r:gz') as tar:
+ metadata_member = tar.getmember('gemini_metadata.json')
+ metadata_file = tar.extractfile(metadata_member)
+ metadata = json.loads(metadata_file.read().decode('utf-8'))
+ else:
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ metadata_filename = f'{platform}_metadata.json' if platform == 'openai' else 'metadata.json'
+ metadata_content = zf.read(metadata_filename).decode('utf-8')
+ metadata = json.loads(metadata_content)
+
+ # Verify required fields
+ self.assertEqual(metadata['platform'], platform)
+ self.assertEqual(metadata['name'], 'test-skill')
+ self.assertIn('created_with', metadata)
+
+ def test_e2e_format_skill_md_differences(self):
+ """Test that each platform formats SKILL.md differently"""
+ metadata = SkillMetadata(
+ name="test-skill",
+ description="Test skill for E2E testing"
+ )
+
+ formats = {}
+ for platform in ['claude', 'gemini', 'openai', 'markdown']:
+ adaptor = get_adaptor(platform)
+ formatted = adaptor.format_skill_md(self.skill_dir, metadata)
+ formats[platform] = formatted
+
+ # Claude should have YAML frontmatter
+ self.assertTrue(formats['claude'].startswith('---'))
+
+ # Gemini and Markdown should NOT have YAML frontmatter
+ self.assertFalse(formats['gemini'].startswith('---'))
+ self.assertFalse(formats['markdown'].startswith('---'))
+
+ # All should contain content from existing SKILL.md (React Framework)
+ for platform, formatted in formats.items():
+ # Check for content from existing SKILL.md
+ self.assertIn('react', formatted.lower(),
+ f"{platform} should contain skill content")
+ # All should have non-empty content
+ self.assertGreater(len(formatted), 100,
+ f"{platform} should have substantial content")
+
+ def test_e2e_upload_without_api_key(self):
+ """Test upload behavior without API keys (should fail gracefully)"""
+ platforms_with_upload = ['claude', 'gemini', 'openai']
+
+ for platform in platforms_with_upload:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Try upload without API key
+ result = adaptor.upload(package_path, '')
+
+ # Should fail
+ self.assertFalse(result['success'],
+ f"{platform} should fail without API key")
+ self.assertIsNone(result['skill_id'])
+ self.assertIn('message', result)
+
+ def test_e2e_markdown_no_upload_support(self):
+ """Test that markdown adaptor doesn't support upload"""
+ adaptor = get_adaptor('markdown')
+ package_path = adaptor.package(self.skill_dir, self.output_dir)
+
+ # Try upload (should return informative message)
+ result = adaptor.upload(package_path, 'not-used')
+
+ # Should indicate no upload support
+ self.assertFalse(result['success'])
+ self.assertIsNone(result['skill_id'])
+ self.assertIn('not support', result['message'].lower())
+ # URL should point to local file
+ self.assertIn(str(package_path.absolute()), result['url'])
+
+
+class TestAdaptorsWorkflowIntegration(unittest.TestCase):
+ """Integration tests for common workflow patterns"""
+
+ def test_workflow_export_to_all_platforms(self):
+ """Test exporting same skill to all platforms"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "react"
+ skill_dir.mkdir()
+
+ # Create minimal skill
+ (skill_dir / "SKILL.md").write_text("# React\n\nReact documentation")
+ refs_dir = skill_dir / "references"
+ refs_dir.mkdir()
+ (refs_dir / "guide.md").write_text("# Guide\n\nContent")
+
+ output_dir = Path(temp_dir) / "output"
+ output_dir.mkdir()
+
+ # Export to all platforms
+ packages = {}
+ for platform in ['claude', 'gemini', 'openai', 'markdown']:
+ adaptor = get_adaptor(platform)
+ package_path = adaptor.package(skill_dir, output_dir)
+ packages[platform] = package_path
+
+ # Verify all packages exist and are distinct
+ self.assertEqual(len(packages), 4)
+ self.assertEqual(len(set(packages.values())), 4) # All unique
+
+ def test_workflow_package_to_custom_path(self):
+ """Test packaging to custom output paths"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "skill"
+ skill_dir.mkdir()
+ (skill_dir / "SKILL.md").write_text("# Test")
+ (skill_dir / "references").mkdir()
+
+ # Test custom output paths
+ custom_output = Path(temp_dir) / "custom" / "my-package.zip"
+
+ adaptor = get_adaptor('claude')
+ package_path = adaptor.package(skill_dir, custom_output)
+
+ # Should respect custom path
+ self.assertTrue(package_path.exists())
+ self.assertTrue('my-package' in package_path.name or package_path.parent.name == 'custom')
+
+ def test_workflow_api_key_validation(self):
+ """Test API key validation for each platform"""
+ test_cases = [
+ ('claude', 'sk-ant-test123', True),
+ ('claude', 'invalid-key', False),
+ ('gemini', 'AIzaSyTest123', True),
+ ('gemini', 'sk-ant-test', False),
+ ('openai', 'sk-proj-test123', True),
+ ('openai', 'sk-test123', True),
+ ('openai', 'AIzaSy123', False),
+ ('markdown', 'any-key', False), # Never uses keys
+ ]
+
+ for platform, api_key, expected in test_cases:
+ adaptor = get_adaptor(platform)
+ result = adaptor.validate_api_key(api_key)
+ self.assertEqual(result, expected,
+ f"{platform}: validate_api_key('{api_key}') should be {expected}")
+
+
+class TestAdaptorsErrorHandling(unittest.TestCase):
+ """Test error handling in adaptors"""
+
+ def test_error_invalid_skill_directory(self):
+ """Test packaging with invalid skill directory"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ # Empty directory (no SKILL.md)
+ empty_dir = Path(temp_dir) / "empty"
+ empty_dir.mkdir()
+
+ output_dir = Path(temp_dir) / "output"
+ output_dir.mkdir()
+
+ # Should handle gracefully (may create package but with empty content)
+ for platform in ['claude', 'gemini', 'openai', 'markdown']:
+ adaptor = get_adaptor(platform)
+ # Should not crash
+ try:
+ package_path = adaptor.package(empty_dir, output_dir)
+ # Package may be created but should exist
+ self.assertTrue(package_path.exists())
+ except Exception as e:
+ # If it raises, should be clear error
+ self.assertIn('SKILL.md', str(e).lower() or 'reference' in str(e).lower())
+
+ def test_error_upload_nonexistent_file(self):
+ """Test upload with nonexistent file"""
+ for platform in ['claude', 'gemini', 'openai']:
+ adaptor = get_adaptor(platform)
+ result = adaptor.upload(Path('/nonexistent/file.zip'), 'test-key')
+
+ self.assertFalse(result['success'])
+ self.assertIn('not found', result['message'].lower())
+
+ def test_error_upload_wrong_format(self):
+ """Test upload with wrong file format"""
+ with tempfile.NamedTemporaryFile(suffix='.txt') as tmp:
+ # Try uploading .txt file
+ for platform in ['claude', 'gemini', 'openai']:
+ adaptor = get_adaptor(platform)
+ result = adaptor.upload(Path(tmp.name), 'test-key')
+
+ self.assertFalse(result['success'])
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_adaptors/test_claude_adaptor.py b/tests/test_adaptors/test_claude_adaptor.py
new file mode 100644
index 0000000..840c906
--- /dev/null
+++ b/tests/test_adaptors/test_claude_adaptor.py
@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+Tests for Claude adaptor (refactored from existing code)
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+from pathlib import Path
+import tempfile
+import zipfile
+import json
+
+from skill_seekers.cli.adaptors import get_adaptor
+from skill_seekers.cli.adaptors.base import SkillMetadata
+
+
+class TestClaudeAdaptor(unittest.TestCase):
+ """Test Claude adaptor functionality"""
+
+ def setUp(self):
+ """Set up test adaptor"""
+ self.adaptor = get_adaptor('claude')
+
+ def test_platform_info(self):
+ """Test platform identifiers"""
+ self.assertEqual(self.adaptor.PLATFORM, 'claude')
+ self.assertIn('Claude', self.adaptor.PLATFORM_NAME)
+ self.assertIsNotNone(self.adaptor.DEFAULT_API_ENDPOINT)
+ self.assertIn('anthropic.com', self.adaptor.DEFAULT_API_ENDPOINT)
+
+ def test_validate_api_key_valid(self):
+ """Test valid Claude API keys"""
+ self.assertTrue(self.adaptor.validate_api_key('sk-ant-abc123'))
+ self.assertTrue(self.adaptor.validate_api_key('sk-ant-api03-test'))
+ self.assertTrue(self.adaptor.validate_api_key(' sk-ant-test ')) # with whitespace
+
+ def test_validate_api_key_invalid(self):
+ """Test invalid API keys"""
+ self.assertFalse(self.adaptor.validate_api_key('AIzaSyABC123')) # Gemini key
+ self.assertFalse(self.adaptor.validate_api_key('sk-proj-123')) # OpenAI key (proj)
+ self.assertFalse(self.adaptor.validate_api_key('invalid'))
+ self.assertFalse(self.adaptor.validate_api_key(''))
+ self.assertFalse(self.adaptor.validate_api_key('sk-test')) # Missing 'ant'
+
+ def test_get_env_var_name(self):
+ """Test environment variable name"""
+ self.assertEqual(self.adaptor.get_env_var_name(), 'ANTHROPIC_API_KEY')
+
+ def test_supports_enhancement(self):
+ """Test enhancement support"""
+ self.assertTrue(self.adaptor.supports_enhancement())
+
+ def test_format_skill_md_with_frontmatter(self):
+ """Test that Claude format includes YAML frontmatter"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir)
+
+ # Create minimal skill structure
+ (skill_dir / "references").mkdir()
+ (skill_dir / "references" / "test.md").write_text("# Test content")
+
+ metadata = SkillMetadata(
+ name="test-skill",
+ description="Test skill description",
+ version="1.0.0"
+ )
+
+ formatted = self.adaptor.format_skill_md(skill_dir, metadata)
+
+ # Should start with YAML frontmatter
+ self.assertTrue(formatted.startswith('---'))
+ # Should contain metadata fields
+ self.assertIn('name:', formatted)
+ self.assertIn('description:', formatted)
+ self.assertIn('version:', formatted)
+ # Should have closing delimiter
+ self.assertTrue('---' in formatted[3:]) # Second occurrence
+
+ def test_format_skill_md_with_existing_content(self):
+ """Test that existing SKILL.md content is preserved"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir)
+
+ # Create SKILL.md with existing content
+ existing_content = """# Existing Documentation
+
+This is existing skill content that should be preserved.
+
+## Features
+- Feature 1
+- Feature 2
+"""
+ (skill_dir / "SKILL.md").write_text(existing_content)
+ (skill_dir / "references").mkdir()
+
+ metadata = SkillMetadata(
+ name="test-skill",
+ description="Test description"
+ )
+
+ formatted = self.adaptor.format_skill_md(skill_dir, metadata)
+
+ # Should contain existing content
+ self.assertIn('Existing Documentation', formatted)
+ self.assertIn('Feature 1', formatted)
+
+ def test_package_creates_zip(self):
+ """Test that package creates ZIP file with correct structure"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "test-skill"
+ skill_dir.mkdir()
+
+ # Create minimal skill structure
+ (skill_dir / "SKILL.md").write_text("# Test Skill")
+ (skill_dir / "references").mkdir()
+ (skill_dir / "references" / "test.md").write_text("# Reference")
+ (skill_dir / "scripts").mkdir()
+ (skill_dir / "assets").mkdir()
+
+ output_dir = Path(temp_dir) / "output"
+ output_dir.mkdir()
+
+ # Package skill
+ package_path = self.adaptor.package(skill_dir, output_dir)
+
+ # Verify package was created
+ self.assertTrue(package_path.exists())
+ self.assertTrue(str(package_path).endswith('.zip'))
+ # Should NOT have platform suffix (Claude is default)
+ self.assertEqual(package_path.name, 'test-skill.zip')
+
+ # Verify package contents
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+ self.assertIn('SKILL.md', names)
+ self.assertTrue(any('references/' in name for name in names))
+
+ def test_package_excludes_backup_files(self):
+ """Test that backup files are excluded from package"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "test-skill"
+ skill_dir.mkdir()
+
+ # Create skill with backup file
+ (skill_dir / "SKILL.md").write_text("# Test")
+ (skill_dir / "SKILL.md.backup").write_text("# Old version")
+ (skill_dir / "references").mkdir()
+
+ output_dir = Path(temp_dir) / "output"
+ output_dir.mkdir()
+
+ package_path = self.adaptor.package(skill_dir, output_dir)
+
+ # Verify backup is excluded
+ with zipfile.ZipFile(package_path, 'r') as zf:
+ names = zf.namelist()
+ self.assertNotIn('SKILL.md.backup', names)
+
+ @patch('requests.post')
+ def test_upload_success(self, mock_post):
+ """Test successful upload to Claude"""
+ with tempfile.NamedTemporaryFile(suffix='.zip') as tmp:
+ # Mock successful response
+ mock_response = MagicMock()
+ mock_response.status_code = 200
+ mock_response.json.return_value = {'id': 'skill_abc123'}
+ mock_post.return_value = mock_response
+
+ result = self.adaptor.upload(Path(tmp.name), 'sk-ant-test123')
+
+ self.assertTrue(result['success'])
+ self.assertEqual(result['skill_id'], 'skill_abc123')
+ self.assertIn('claude.ai', result['url'])
+
+ # Verify correct API call
+ mock_post.assert_called_once()
+ call_args = mock_post.call_args
+ self.assertIn('anthropic.com', call_args[0][0])
+ self.assertEqual(call_args[1]['headers']['x-api-key'], 'sk-ant-test123')
+
+ @patch('requests.post')
+ def test_upload_failure(self, mock_post):
+ """Test failed upload to Claude"""
+ with tempfile.NamedTemporaryFile(suffix='.zip') as tmp:
+ # Mock failed response
+ mock_response = MagicMock()
+ mock_response.status_code = 400
+ mock_response.text = 'Invalid skill format'
+ mock_post.return_value = mock_response
+
+ result = self.adaptor.upload(Path(tmp.name), 'sk-ant-test123')
+
+ self.assertFalse(result['success'])
+ self.assertIsNone(result['skill_id'])
+ self.assertIn('Invalid skill format', result['message'])
+
+ def test_upload_invalid_file(self):
+ """Test upload with invalid file"""
+ result = self.adaptor.upload(Path('/nonexistent/file.zip'), 'sk-ant-test123')
+
+ self.assertFalse(result['success'])
+ self.assertIn('not found', result['message'].lower())
+
+ def test_upload_wrong_format(self):
+ """Test upload with wrong file format"""
+ with tempfile.NamedTemporaryFile(suffix='.tar.gz') as tmp:
+ result = self.adaptor.upload(Path(tmp.name), 'sk-ant-test123')
+
+ self.assertFalse(result['success'])
+ self.assertIn('not a zip', result['message'].lower())
+
+ @unittest.skip("Complex mocking - integration test needed with real API")
+ def test_enhance_success(self):
+ """Test successful enhancement - skipped (needs real API for integration test)"""
+ pass
+
+ def test_package_with_custom_output_path(self):
+ """Test packaging to custom output path"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "my-skill"
+ skill_dir.mkdir()
+ (skill_dir / "SKILL.md").write_text("# Test")
+ (skill_dir / "references").mkdir()
+
+ # Custom output path
+ custom_output = Path(temp_dir) / "custom" / "my-package.zip"
+
+ package_path = self.adaptor.package(skill_dir, custom_output)
+
+ self.assertTrue(package_path.exists())
+ # Should respect custom naming if provided
+ self.assertTrue('my-package' in package_path.name or package_path.parent.name == 'custom')
+
+ def test_package_to_directory(self):
+ """Test packaging to directory (should auto-name)"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir) / "react"
+ skill_dir.mkdir()
+ (skill_dir / "SKILL.md").write_text("# React")
+ (skill_dir / "references").mkdir()
+
+ output_dir = Path(temp_dir) / "output"
+ output_dir.mkdir()
+
+ # Pass directory as output
+ package_path = self.adaptor.package(skill_dir, output_dir)
+
+ self.assertTrue(package_path.exists())
+ self.assertEqual(package_path.name, 'react.zip')
+ self.assertEqual(package_path.parent, output_dir)
+
+
+class TestClaudeAdaptorEdgeCases(unittest.TestCase):
+ """Test edge cases and error handling"""
+
+ def setUp(self):
+ """Set up test adaptor"""
+ self.adaptor = get_adaptor('claude')
+
+ def test_format_with_minimal_metadata(self):
+ """Test formatting with only required metadata fields"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir)
+ (skill_dir / "references").mkdir()
+
+ metadata = SkillMetadata(
+ name="minimal",
+ description="Minimal skill"
+ # No version, author, tags
+ )
+
+ formatted = self.adaptor.format_skill_md(skill_dir, metadata)
+
+ # Should still create valid output
+ self.assertIn('---', formatted)
+ self.assertIn('minimal', formatted)
+
+ def test_format_with_special_characters_in_name(self):
+ """Test formatting with special characters in skill name"""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ skill_dir = Path(temp_dir)
+ (skill_dir / "references").mkdir()
+
+ metadata = SkillMetadata(
+ name="test-skill_v2.0",
+ description="Skill with special chars"
+ )
+
+ formatted = self.adaptor.format_skill_md(skill_dir, metadata)
+
+ # Should handle special characters
+ self.assertIn('test-skill_v2.0', formatted)
+
+ def test_api_key_validation_edge_cases(self):
+ """Test API key validation with edge cases"""
+ # Empty string
+ self.assertFalse(self.adaptor.validate_api_key(''))
+
+ # Only whitespace
+ self.assertFalse(self.adaptor.validate_api_key(' '))
+
+ # Correct prefix but very short
+ self.assertTrue(self.adaptor.validate_api_key('sk-ant-x'))
+
+ # Case sensitive
+ self.assertFalse(self.adaptor.validate_api_key('SK-ANT-TEST'))
+
+ def test_upload_with_network_error(self):
+ """Test upload with network errors"""
+ with tempfile.NamedTemporaryFile(suffix='.zip') as tmp:
+ with patch('requests.post') as mock_post:
+ # Simulate network error
+ mock_post.side_effect = Exception("Network error")
+
+ result = self.adaptor.upload(Path(tmp.name), 'sk-ant-test')
+
+ self.assertFalse(result['success'])
+ self.assertIn('Network error', result['message'])
+
+
+if __name__ == '__main__':
+ unittest.main()