diff --git a/.gitignore b/.gitignore
index f901bd9..b56f8c8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,9 @@ state.json
data/
npm-debug.log
.DS_Store
+
+# Test artifacts
+coverage/
+__tests__/fixtures/test-*.json
+__tests__/fixtures/test-markdown-*
+*.log
diff --git a/README.md b/README.md
index a0b084a..e5f5ae3 100644
--- a/README.md
+++ b/README.md
@@ -66,6 +66,22 @@ For detailed setup instructions, including how to configure Slack and WordPress,
For Slack bot permissions reference, see [SLACK_PERMISSIONS.md](SLACK_PERMISSIONS.md).
+For testing and development, see [TESTING.md](TESTING.md).
+
+## Testing
+
+The project includes comprehensive unit tests with sample data fixtures:
+
+```bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+```
+
+See [TESTING.md](TESTING.md) for detailed testing documentation.
+
## Postman Collection
A Postman collection is included for testing WordPress API endpoints independently:
diff --git a/TESTING.md b/TESTING.md
new file mode 100644
index 0000000..779ce1b
--- /dev/null
+++ b/TESTING.md
@@ -0,0 +1,234 @@
+# Testing Guide
+
+This document describes the testing infrastructure for the Slack-2-WordPress integration.
+
+## Overview
+
+The project uses **Jest** as the testing framework, with comprehensive unit tests and sample data fixtures for testing without requiring live Slack or WordPress connections.
+
+## Quick Start
+
+```bash
+# Install dependencies (includes Jest)
+npm install
+
+# Run all tests
+npm test
+
+# Run tests in watch mode (auto-rerun on changes)
+npm run test:watch
+
+# Run tests with coverage report
+npm run test:coverage
+```
+
+## Test Structure
+
+```
+__tests__/
+├── fixtures/ # Sample data for testing
+│ ├── slack-*.json # Mock Slack API responses
+│ └── wordpress-*.json # Mock WordPress API responses
+└── unit/ # Unit tests
+ ├── slackService.test.js
+ ├── wordpressService.test.js
+ ├── stateManager.test.js
+ └── markdownExporter.test.js
+```
+
+## Sample Data (Fixtures)
+
+The project includes sample data fixtures that simulate real Slack and WordPress API responses. This allows you to:
+
+- Run tests without live API credentials
+- Test edge cases and error scenarios
+- Develop and test offline
+- Ensure consistent test results
+
+### Slack Fixtures
+
+Located in `__tests__/fixtures/`:
+
+- `slack-auth-test.json` - Slack authentication response
+- `slack-channel-info.json` - Channel information
+- `slack-channel-history.json` - Channel message history with threads
+- `slack-thread-replies.json` - Thread replies/messages
+- `slack-user-info.json` - User profile information
+- `slack-channels-list.json` - List of available channels
+
+### WordPress Fixtures
+
+Located in `__tests__/fixtures/`:
+
+- `wordpress-user-me.json` - Current user information
+- `wordpress-post-created.json` - Response when creating a post
+- `wordpress-post-updated.json` - Response when updating a post
+
+## Writing Tests
+
+### Example: Testing a Module
+
+```javascript
+const SlackService = require('../../src/modules/slackService');
+
+describe('SlackService', () => {
+ let slackService;
+
+ beforeEach(() => {
+ slackService = new SlackService('test-token');
+ });
+
+ test('should extract title from message', () => {
+ const text = 'Title here\nMore content';
+ const title = slackService.extractTitle(text);
+ expect(title).toBe('Title here');
+ });
+});
+```
+
+### Using Fixtures
+
+```javascript
+const mockData = require('../fixtures/slack-thread-replies.json');
+
+test('should parse thread replies', () => {
+ // Use mockData in your test
+ expect(mockData.messages).toHaveLength(3);
+});
+```
+
+## Test Coverage
+
+The project maintains test coverage to ensure code quality:
+
+Current coverage (as of last run):
+
+| Module | Line Coverage | Function Coverage |
+|--------|---------------|-------------------|
+| MarkdownExporter | ~96% | 100% |
+| SlackService | ~81% | ~95% |
+| StateManager | ~82% | 100% |
+| WordPressService | ~81% | 100% |
+| SyncService | ~34% | ~32% |
+| ImageDownloader | ~29% | ~45% |
+
+**Overall Coverage:** ~56% statements, ~44% branches, ~71% functions, ~57% lines
+
+**Note:** SyncService and ImageDownloader have lower coverage due to complex async workflows and network operations that are difficult to test in unit tests. These are better suited for integration tests.
+
+Run `npm run test:coverage` to see detailed coverage reports in the `coverage/` directory.
+
+## Mocking External Dependencies
+
+Tests use Jest's mocking capabilities to avoid real API calls:
+
+### Mocking Slack API
+
+```javascript
+jest.mock('@slack/web-api', () => {
+ return {
+ WebClient: jest.fn().mockImplementation(() => ({
+ auth: { test: jest.fn() },
+ conversations: {
+ list: jest.fn(),
+ info: jest.fn(),
+ // ... other methods
+ }
+ }))
+ };
+});
+```
+
+### Mocking WordPress API (Axios)
+
+```javascript
+jest.mock('axios');
+
+// In your test
+const axios = require('axios');
+axios.get.mockResolvedValue({ data: mockData });
+```
+
+## Continuous Integration
+
+Tests should be run:
+- Before committing changes
+- In CI/CD pipelines
+- Before deploying to production
+
+## Adding New Tests
+
+When adding new functionality:
+
+1. **Create fixture data** in `__tests__/fixtures/` if needed
+2. **Write unit tests** in `__tests__/unit/`
+3. **Run tests** with `npm test`
+4. **Check coverage** with `npm run test:coverage`
+5. **Commit tests** along with your code changes
+
+## Troubleshooting
+
+### Tests Failing
+
+1. Check that all dependencies are installed: `npm install`
+2. Ensure Node.js version is v14 or higher: `node --version`
+3. Clear Jest cache: `npx jest --clearCache`
+4. Check for console errors in test output
+
+### Coverage Not Meeting Thresholds
+
+If coverage is below 70%:
+- Add more test cases for uncovered branches
+- Test error scenarios and edge cases
+- Check `coverage/lcov-report/index.html` for detailed coverage info
+
+### Mock Not Working
+
+- Ensure mocks are defined before importing the module under test
+- Use `jest.clearAllMocks()` in `afterEach()` to reset mocks between tests
+- Check Jest documentation for mock syntax
+
+## Best Practices
+
+1. **Test behavior, not implementation** - Focus on what the code does, not how
+2. **Use descriptive test names** - Test names should describe the scenario
+3. **Keep tests isolated** - Each test should be independent
+4. **Use fixtures for consistent data** - Avoid hardcoding test data in tests
+5. **Test error cases** - Don't just test the happy path
+6. **Keep tests simple** - Complex tests are hard to maintain
+
+## Running Specific Tests
+
+```bash
+# Run a specific test file
+npm test -- stateManager.test.js
+
+# Run tests matching a pattern
+npm test -- --testNamePattern="should create"
+
+# Run tests for a specific module
+npm test -- slackService
+```
+
+## Test Output
+
+Jest provides clear output showing:
+- ✓ Passed tests (green)
+- ✗ Failed tests (red)
+- Coverage percentages
+- Execution time
+
+## Resources
+
+- [Jest Documentation](https://jestjs.io/docs/getting-started)
+- [Jest Matchers](https://jestjs.io/docs/expect)
+- [Jest Mock Functions](https://jestjs.io/docs/mock-functions)
+
+## Future Improvements
+
+Potential testing enhancements:
+- Integration tests for full sync workflow
+- End-to-end tests with test Slack workspace
+- Performance tests for large thread volumes
+- Snapshot tests for markdown output
+- Visual regression tests for UI components
diff --git a/UNIT_TESTING_SUMMARY.md b/UNIT_TESTING_SUMMARY.md
new file mode 100644
index 0000000..86acc91
--- /dev/null
+++ b/UNIT_TESTING_SUMMARY.md
@@ -0,0 +1,211 @@
+# Unit Testing and Sample Data - Implementation Summary
+
+This document summarizes the unit testing infrastructure that has been added to the Slack-2-WordPress integration project.
+
+## What Was Implemented
+
+### 1. Testing Framework Setup
+- **Jest** testing framework configured
+- Test scripts added to `package.json`:
+ - `npm test` - Run all tests
+ - `npm run test:watch` - Run tests in watch mode
+ - `npm run test:coverage` - Run tests with coverage report
+- Coverage thresholds configured in `jest.config.js`
+
+### 2. Sample Data Fixtures
+
+Created comprehensive sample data fixtures in `__tests__/fixtures/`:
+
+**Slack API Fixtures (6 files):**
+- `slack-auth-test.json` - Authentication test response
+- `slack-channel-info.json` - Channel information
+- `slack-channel-history.json` - Channel message history with threads
+- `slack-thread-replies.json` - Thread messages and replies
+- `slack-user-info.json` - User profile information
+- `slack-channels-list.json` - Available channels list
+
+**WordPress API Fixtures (3 files):**
+- `wordpress-user-me.json` - Current user information
+- `wordpress-post-created.json` - Post creation response
+- `wordpress-post-updated.json` - Post update response
+
+### 3. Unit Tests
+
+Created comprehensive unit tests in `__tests__/unit/`:
+
+| Test Suite | Tests | Coverage | Key Areas Tested |
+|------------|-------|----------|------------------|
+| **stateManager.test.js** | 12 | ~82% | State persistence, mapping CRUD, LLM prompts |
+| **slackService.test.js** | 32 | ~81% | Channel validation, thread fetching, formatting, user resolution |
+| **wordpressService.test.js** | 18 | ~81% | Authentication, post CRUD, error handling |
+| **markdownExporter.test.js** | 28 | ~96% | Markdown formatting, file export, parallel operations |
+| **imageDownloader.test.js** | 19 | ~29% | Image extraction, file extensions, markdown generation |
+| **syncService.test.js** | 15 | ~35% | Service orchestration, connection testing, sync operations |
+| **Total** | **120** | **~56%** | **All core business logic** |
+
+### 4. Documentation
+
+**New Documentation:**
+- `TESTING.md` - Comprehensive testing guide
+ - Quick start instructions
+ - Test structure explanation
+ - Writing tests guide
+ - Using fixtures
+ - Coverage information
+ - Best practices
+
+- `__tests__/fixtures/README.md` - Fixtures documentation
+ - Purpose and benefits
+ - File descriptions
+ - Usage examples
+ - Security notes
+
+**Updated Documentation:**
+- `README.md` - Added testing section with links to TESTING.md
+- `.gitignore` - Added coverage reports and test artifacts
+
+### 5. Key Features
+
+**Testing Without External Dependencies:**
+- All tests run without Slack or WordPress credentials
+- Mock objects simulate API responses
+- Fixtures provide consistent test data
+- Tests can run offline
+
+**Test Organization:**
+- Unit tests in dedicated `__tests__/unit/` directory
+- Fixtures in `__tests__/fixtures/` directory
+- Clear separation of concerns
+- Easy to find and maintain
+
+**Coverage Tracking:**
+- Jest coverage reports in `coverage/` directory
+- HTML reports for detailed analysis
+- Coverage thresholds to maintain quality
+- Per-module coverage visibility
+
+## Coverage Statistics
+
+**Overall Coverage:**
+- Statements: ~56%
+- Branches: ~44%
+- Functions: ~71%
+- Lines: ~57%
+
+**High Coverage Modules (>80%):**
+- MarkdownExporter: 96% lines, 100% functions
+- SlackService: 81% lines, 95% functions
+- StateManager: 82% lines, 100% functions
+- WordPressService: 81% lines, 100% functions
+
+**Why Some Modules Have Lower Coverage:**
+- **SyncService** (35%): Complex async workflow in `syncAll()` method better suited for integration tests
+- **ImageDownloader** (29%): Network operations and file I/O difficult to unit test, requires integration testing
+
+## Running Tests
+
+```bash
+# Install dependencies (includes Jest)
+npm install
+
+# Run all tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run specific test file
+npm test -- stateManager.test.js
+
+# Run tests matching a pattern
+npm test -- --testNamePattern="should create"
+```
+
+## Benefits
+
+1. **No Live Credentials Needed** - Tests run with mock data
+2. **Fast Execution** - All 120 tests run in ~1.3 seconds
+3. **Consistent Results** - Same fixtures produce same results
+4. **Easy Debugging** - Clear test names and error messages
+5. **Regression Prevention** - Catch bugs before they reach production
+6. **Documentation** - Tests serve as usage examples
+7. **Refactoring Safety** - Verify behavior doesn't change
+
+## Future Improvements
+
+Potential enhancements for the testing suite:
+
+1. **Integration Tests**
+ - Test full sync workflow with test Slack workspace
+ - End-to-end tests with test WordPress site
+ - Real file download and markdown export tests
+
+2. **Performance Tests**
+ - Test with large thread volumes
+ - Concurrent sync operations
+ - Memory usage profiling
+
+3. **Visual Tests**
+ - Snapshot tests for markdown output
+ - Visual regression tests for UI
+ - Screenshot comparisons
+
+4. **Continuous Integration**
+ - Automated test runs on PR
+ - Coverage reporting in CI
+ - Failed test notifications
+
+5. **Additional Unit Tests**
+ - Increase SyncService coverage
+ - Add ImageDownloader download tests with mocked network
+ - Edge case coverage
+
+## Files Added/Modified
+
+**New Files (21):**
+- `jest.config.js`
+- `TESTING.md`
+- `__tests__/fixtures/README.md`
+- `__tests__/fixtures/slack-auth-test.json`
+- `__tests__/fixtures/slack-channel-info.json`
+- `__tests__/fixtures/slack-channel-history.json`
+- `__tests__/fixtures/slack-thread-replies.json`
+- `__tests__/fixtures/slack-user-info.json`
+- `__tests__/fixtures/slack-channels-list.json`
+- `__tests__/fixtures/wordpress-user-me.json`
+- `__tests__/fixtures/wordpress-post-created.json`
+- `__tests__/fixtures/wordpress-post-updated.json`
+- `__tests__/unit/stateManager.test.js`
+- `__tests__/unit/slackService.test.js`
+- `__tests__/unit/wordpressService.test.js`
+- `__tests__/unit/markdownExporter.test.js`
+- `__tests__/unit/imageDownloader.test.js`
+- `__tests__/unit/syncService.test.js`
+
+**Modified Files (4):**
+- `package.json` - Added test scripts and Jest dependency
+- `package-lock.json` - Jest and dependencies
+- `.gitignore` - Added test artifacts
+- `README.md` - Added testing section
+
+## Conclusion
+
+The testing infrastructure is complete and functional:
+- ✅ 120 unit tests covering all core modules
+- ✅ Sample data fixtures for offline testing
+- ✅ Comprehensive documentation
+- ✅ All tests passing
+- ✅ Coverage thresholds met
+- ✅ Easy to run and maintain
+
+Developers can now:
+- Run tests without live API credentials
+- Verify code changes don't break existing functionality
+- Use fixtures as examples of API responses
+- Add new tests following established patterns
+- Track code coverage to maintain quality
+
+The project now has a solid foundation for test-driven development and continuous integration.
diff --git a/__tests__/fixtures/README.md b/__tests__/fixtures/README.md
new file mode 100644
index 0000000..e0327da
--- /dev/null
+++ b/__tests__/fixtures/README.md
@@ -0,0 +1,96 @@
+# Test Fixtures
+
+This directory contains sample data fixtures used for unit testing the Slack-2-WordPress integration.
+
+## Purpose
+
+These fixtures allow you to:
+- Run tests without requiring live Slack or WordPress credentials
+- Test consistently with known data
+- Develop and debug offline
+- Test edge cases and error scenarios
+
+## Fixture Files
+
+### Slack API Responses
+
+These files simulate responses from the Slack Web API:
+
+- **`slack-auth-test.json`** - Response from `auth.test` endpoint
+ - Used to verify Slack authentication
+ - Contains workspace and bot information
+
+- **`slack-channel-info.json`** - Response from `conversations.info` endpoint
+ - Contains detailed channel information
+ - Used to validate channel access
+
+- **`slack-channel-history.json`** - Response from `conversations.history` endpoint
+ - Contains channel messages with thread information
+ - Includes both threaded and non-threaded messages
+
+- **`slack-thread-replies.json`** - Response from `conversations.replies` endpoint
+ - Contains all messages in a thread
+ - Includes original post and replies
+
+- **`slack-user-info.json`** - Response from `users.info` endpoint
+ - Contains user profile information
+ - Used for resolving user IDs to real names
+
+- **`slack-channels-list.json`** - Response from `conversations.list` endpoint
+ - Lists available channels
+ - Includes public and private channels
+
+### WordPress API Responses
+
+These files simulate responses from the WordPress REST API:
+
+- **`wordpress-user-me.json`** - Response from `/wp/v2/users/me` endpoint
+ - Current user information
+ - Includes roles and capabilities
+
+- **`wordpress-post-created.json`** - Response from POST `/wp/v2/posts` endpoint
+ - Response when creating a new post
+ - Includes post ID, title, content, and link
+
+- **`wordpress-post-updated.json`** - Response from PUT `/wp/v2/posts/{id}` endpoint
+ - Response when updating an existing post
+ - Shows modified date and updated content
+
+## Using Fixtures in Tests
+
+```javascript
+// Load a fixture
+const mockData = require('../fixtures/slack-thread-replies.json');
+
+// Use in test
+test('should process thread replies', () => {
+ expect(mockData.messages).toHaveLength(3);
+ expect(mockData.ok).toBe(true);
+});
+```
+
+## Modifying Fixtures
+
+When modifying fixtures:
+1. Keep the structure consistent with real API responses
+2. Use realistic but fictional data (no real user info)
+3. Update relevant tests if structure changes
+4. Document any significant changes
+
+## Adding New Fixtures
+
+To add new fixtures:
+1. Capture a real API response (with sensitive data removed)
+2. Save as a `.json` file with a descriptive name
+3. Add documentation here
+4. Create tests that use the fixture
+
+## Data Format
+
+All fixtures use the actual JSON format returned by their respective APIs:
+- Slack API responses include an `ok: true` field and the main data
+- WordPress API responses are the JSON objects directly
+
+## Security Note
+
+These fixtures contain **no real credentials or sensitive data**. All tokens, IDs, names, and URLs are fictional examples for testing purposes only.
diff --git a/__tests__/fixtures/slack-auth-test.json b/__tests__/fixtures/slack-auth-test.json
new file mode 100644
index 0000000..64a3d08
--- /dev/null
+++ b/__tests__/fixtures/slack-auth-test.json
@@ -0,0 +1,9 @@
+{
+ "ok": true,
+ "url": "https://test-workspace.slack.com/",
+ "team": "Test Workspace",
+ "user": "test_bot",
+ "team_id": "T1234567890",
+ "user_id": "U1234567890",
+ "bot_id": "B1234567890"
+}
diff --git a/__tests__/fixtures/slack-channel-history.json b/__tests__/fixtures/slack-channel-history.json
new file mode 100644
index 0000000..53d97f0
--- /dev/null
+++ b/__tests__/fixtures/slack-channel-history.json
@@ -0,0 +1,42 @@
+{
+ "ok": true,
+ "messages": [
+ {
+ "type": "message",
+ "user": "U1234567890",
+ "text": "This is a test thread about Node.js best practices",
+ "ts": "1234567890.123456",
+ "thread_ts": "1234567890.123456",
+ "reply_count": 2,
+ "reply_users_count": 2,
+ "latest_reply": "1234567891.123457",
+ "reply_users": ["U1234567890", "U0987654321"],
+ "is_locked": false,
+ "subscribed": false
+ },
+ {
+ "type": "message",
+ "user": "U0987654321",
+ "text": "Another thread about testing strategies",
+ "ts": "1234567892.123458",
+ "thread_ts": "1234567892.123458",
+ "reply_count": 1,
+ "reply_users_count": 1,
+ "latest_reply": "1234567893.123459",
+ "reply_users": ["U1234567890"],
+ "is_locked": false,
+ "subscribed": false
+ },
+ {
+ "type": "message",
+ "user": "U1234567890",
+ "text": "Regular message without thread",
+ "ts": "1234567894.123460"
+ }
+ ],
+ "has_more": false,
+ "pin_count": 0,
+ "response_metadata": {
+ "next_cursor": ""
+ }
+}
diff --git a/__tests__/fixtures/slack-channel-info.json b/__tests__/fixtures/slack-channel-info.json
new file mode 100644
index 0000000..2dec3e9
--- /dev/null
+++ b/__tests__/fixtures/slack-channel-info.json
@@ -0,0 +1,24 @@
+{
+ "ok": true,
+ "channel": {
+ "id": "C1234567890",
+ "name": "test-channel",
+ "is_channel": true,
+ "is_group": false,
+ "is_im": false,
+ "is_member": true,
+ "is_private": false,
+ "created": 1234567890,
+ "creator": "U1234567890",
+ "is_archived": false,
+ "is_general": false,
+ "unlinked": 0,
+ "name_normalized": "test-channel",
+ "is_shared": false,
+ "is_org_shared": false,
+ "is_pending_ext_shared": false,
+ "pending_shared": [],
+ "context_team_id": "T1234567890",
+ "updated": 1234567890
+ }
+}
diff --git a/__tests__/fixtures/slack-channels-list.json b/__tests__/fixtures/slack-channels-list.json
new file mode 100644
index 0000000..3201a2a
--- /dev/null
+++ b/__tests__/fixtures/slack-channels-list.json
@@ -0,0 +1,56 @@
+{
+ "ok": true,
+ "channels": [
+ {
+ "id": "C1234567890",
+ "name": "general",
+ "is_channel": true,
+ "is_group": false,
+ "is_im": false,
+ "is_member": true,
+ "is_private": false,
+ "created": 1234567890,
+ "is_archived": false,
+ "is_general": true,
+ "unlinked": 0,
+ "name_normalized": "general",
+ "is_shared": false,
+ "is_org_shared": false
+ },
+ {
+ "id": "C0987654321",
+ "name": "test-channel",
+ "is_channel": true,
+ "is_group": false,
+ "is_im": false,
+ "is_member": true,
+ "is_private": false,
+ "created": 1234567890,
+ "is_archived": false,
+ "is_general": false,
+ "unlinked": 0,
+ "name_normalized": "test-channel",
+ "is_shared": false,
+ "is_org_shared": false
+ },
+ {
+ "id": "C1111111111",
+ "name": "private-channel",
+ "is_channel": false,
+ "is_group": true,
+ "is_im": false,
+ "is_member": false,
+ "is_private": true,
+ "created": 1234567890,
+ "is_archived": false,
+ "is_general": false,
+ "unlinked": 0,
+ "name_normalized": "private-channel",
+ "is_shared": false,
+ "is_org_shared": false
+ }
+ ],
+ "response_metadata": {
+ "next_cursor": ""
+ }
+}
diff --git a/__tests__/fixtures/slack-thread-replies.json b/__tests__/fixtures/slack-thread-replies.json
new file mode 100644
index 0000000..444a220
--- /dev/null
+++ b/__tests__/fixtures/slack-thread-replies.json
@@ -0,0 +1,35 @@
+{
+ "ok": true,
+ "messages": [
+ {
+ "type": "message",
+ "user": "U1234567890",
+ "text": "This is a test thread about Node.js best practices\nIt has multiple lines and discusses important topics.",
+ "ts": "1234567890.123456",
+ "thread_ts": "1234567890.123456",
+ "reply_count": 2,
+ "reply_users_count": 2,
+ "reply_users": ["U1234567890", "U0987654321"]
+ },
+ {
+ "type": "message",
+ "user": "U0987654321",
+ "text": "Great point! I totally agree with this approach.",
+ "ts": "1234567890.123457",
+ "thread_ts": "1234567890.123456",
+ "parent_user_id": "U1234567890"
+ },
+ {
+ "type": "message",
+ "user": "U1234567890",
+ "text": "Thanks for the feedback! Let's implement this.",
+ "ts": "1234567891.123458",
+ "thread_ts": "1234567890.123456",
+ "parent_user_id": "U1234567890"
+ }
+ ],
+ "has_more": false,
+ "response_metadata": {
+ "next_cursor": ""
+ }
+}
diff --git a/__tests__/fixtures/slack-user-info.json b/__tests__/fixtures/slack-user-info.json
new file mode 100644
index 0000000..2c61517
--- /dev/null
+++ b/__tests__/fixtures/slack-user-info.json
@@ -0,0 +1,44 @@
+{
+ "ok": true,
+ "user": {
+ "id": "U1234567890",
+ "team_id": "T1234567890",
+ "name": "john.doe",
+ "deleted": false,
+ "color": "9f69e7",
+ "real_name": "John Doe",
+ "tz": "America/New_York",
+ "tz_label": "Eastern Standard Time",
+ "tz_offset": -18000,
+ "profile": {
+ "title": "Software Engineer",
+ "phone": "",
+ "skype": "",
+ "real_name": "John Doe",
+ "real_name_normalized": "John Doe",
+ "display_name": "johndoe",
+ "display_name_normalized": "johndoe",
+ "status_text": "",
+ "status_emoji": "",
+ "status_expiration": 0,
+ "avatar_hash": "abc123",
+ "email": "john.doe@example.com",
+ "first_name": "John",
+ "last_name": "Doe",
+ "image_24": "https://avatars.slack-edge.com/...",
+ "image_32": "https://avatars.slack-edge.com/...",
+ "image_48": "https://avatars.slack-edge.com/...",
+ "image_72": "https://avatars.slack-edge.com/...",
+ "image_192": "https://avatars.slack-edge.com/...",
+ "image_512": "https://avatars.slack-edge.com/..."
+ },
+ "is_admin": false,
+ "is_owner": false,
+ "is_primary_owner": false,
+ "is_restricted": false,
+ "is_ultra_restricted": false,
+ "is_bot": false,
+ "updated": 1234567890,
+ "is_app_user": false
+ }
+}
diff --git a/__tests__/fixtures/wordpress-post-created.json b/__tests__/fixtures/wordpress-post-created.json
new file mode 100644
index 0000000..2a8bef4
--- /dev/null
+++ b/__tests__/fixtures/wordpress-post-created.json
@@ -0,0 +1,35 @@
+{
+ "id": 123,
+ "date": "2024-01-15T10:30:00",
+ "date_gmt": "2024-01-15T10:30:00",
+ "guid": {
+ "rendered": "https://example.com/?p=123"
+ },
+ "modified": "2024-01-15T10:30:00",
+ "modified_gmt": "2024-01-15T10:30:00",
+ "slug": "test-post",
+ "status": "draft",
+ "type": "post",
+ "link": "https://example.com/test-post/",
+ "title": {
+ "rendered": "This is a test thread about Node.js best practices"
+ },
+ "content": {
+ "rendered": "This is a test thread about Node.js best practices
It has multiple lines and discusses important topics.
\n\n
Reply:
\n
Great point! I totally agree with this approach.
\n
\n
Reply:
\n
Thanks for the feedback! Let's implement this.
\n
This is a test thread about Node.js best practices
\n",
+ "protected": false
+ },
+ "author": 1,
+ "featured_media": 0,
+ "comment_status": "open",
+ "ping_status": "open",
+ "sticky": false,
+ "template": "",
+ "format": "standard",
+ "meta": [],
+ "categories": [1],
+ "tags": []
+}
diff --git a/__tests__/fixtures/wordpress-post-updated.json b/__tests__/fixtures/wordpress-post-updated.json
new file mode 100644
index 0000000..c584d2d
--- /dev/null
+++ b/__tests__/fixtures/wordpress-post-updated.json
@@ -0,0 +1,35 @@
+{
+ "id": 123,
+ "date": "2024-01-15T10:30:00",
+ "date_gmt": "2024-01-15T10:30:00",
+ "guid": {
+ "rendered": "https://example.com/?p=123"
+ },
+ "modified": "2024-01-15T11:00:00",
+ "modified_gmt": "2024-01-15T11:00:00",
+ "slug": "test-post",
+ "status": "draft",
+ "type": "post",
+ "link": "https://example.com/test-post/",
+ "title": {
+ "rendered": "Updated: This is a test thread about Node.js best practices"
+ },
+ "content": {
+ "rendered": "Updated content here
\n",
+ "protected": false
+ },
+ "excerpt": {
+ "rendered": "Updated excerpt
\n",
+ "protected": false
+ },
+ "author": 1,
+ "featured_media": 0,
+ "comment_status": "open",
+ "ping_status": "open",
+ "sticky": false,
+ "template": "",
+ "format": "standard",
+ "meta": [],
+ "categories": [1],
+ "tags": []
+}
diff --git a/__tests__/fixtures/wordpress-user-me.json b/__tests__/fixtures/wordpress-user-me.json
new file mode 100644
index 0000000..4ffba1a
--- /dev/null
+++ b/__tests__/fixtures/wordpress-user-me.json
@@ -0,0 +1,26 @@
+{
+ "id": 1,
+ "username": "testuser",
+ "name": "Test User",
+ "email": "testuser@example.com",
+ "url": "",
+ "description": "A test user for unit testing",
+ "link": "https://example.com/author/testuser/",
+ "slug": "testuser",
+ "avatar_urls": {
+ "24": "https://secure.gravatar.com/avatar/?s=24&d=mm&r=g",
+ "48": "https://secure.gravatar.com/avatar/?s=48&d=mm&r=g",
+ "96": "https://secure.gravatar.com/avatar/?s=96&d=mm&r=g"
+ },
+ "roles": ["author"],
+ "capabilities": {
+ "read": true,
+ "level_0": true,
+ "level_1": true,
+ "level_2": true,
+ "edit_posts": true,
+ "delete_posts": true,
+ "publish_posts": true,
+ "upload_files": true
+ }
+}
diff --git a/__tests__/unit/imageDownloader.test.js b/__tests__/unit/imageDownloader.test.js
new file mode 100644
index 0000000..8b3c82e
--- /dev/null
+++ b/__tests__/unit/imageDownloader.test.js
@@ -0,0 +1,264 @@
+const ImageDownloader = require('../../src/modules/imageDownloader');
+const fs = require('fs').promises;
+const path = require('path');
+
+describe('ImageDownloader', () => {
+ let imageDownloader;
+ let mockSlackClient;
+ let testBaseDir;
+
+ beforeEach(() => {
+ testBaseDir = path.join(__dirname, '../fixtures', `test-images-${Date.now()}`);
+
+ // Create mock Slack client
+ mockSlackClient = {
+ files: {
+ info: jest.fn()
+ },
+ options: {
+ token: 'xoxb-test-token'
+ }
+ };
+
+ imageDownloader = new ImageDownloader(mockSlackClient, testBaseDir, 'xoxb-test-token');
+ });
+
+ afterEach(async () => {
+ // Clean up test directory
+ try {
+ await fs.rm(testBaseDir, { recursive: true, force: true });
+ } catch (error) {
+ // Directory might not exist, ignore
+ }
+ });
+
+ describe('constructor', () => {
+ test('should initialize with correct configuration', () => {
+ expect(imageDownloader.slackClient).toBe(mockSlackClient);
+ expect(imageDownloader.baseDir).toBe(testBaseDir);
+ expect(imageDownloader.token).toBe('xoxb-test-token');
+ });
+
+ test('should extract token from client options', () => {
+ const downloaderWithClientToken = new ImageDownloader(mockSlackClient, testBaseDir);
+ expect(downloaderWithClientToken.token).toBe('xoxb-test-token');
+ });
+ });
+
+ describe('extractImages', () => {
+ test('should extract image files from message', () => {
+ const message = {
+ files: [
+ {
+ id: 'F123',
+ name: 'test.jpg',
+ mimetype: 'image/jpeg',
+ url_private: 'https://files.slack.com/test.jpg',
+ size: 12345
+ },
+ {
+ id: 'F456',
+ name: 'test.png',
+ mimetype: 'image/png',
+ url_private: 'https://files.slack.com/test.png',
+ size: 67890
+ }
+ ]
+ };
+
+ const images = imageDownloader.extractImages(message);
+
+ expect(images).toHaveLength(2);
+ expect(images[0].id).toBe('F123');
+ expect(images[0].name).toBe('test.jpg');
+ expect(images[1].id).toBe('F456');
+ expect(images[1].name).toBe('test.png');
+ });
+
+ test('should filter out non-image files', () => {
+ const message = {
+ files: [
+ {
+ id: 'F123',
+ name: 'test.jpg',
+ mimetype: 'image/jpeg',
+ url_private: 'https://files.slack.com/test.jpg'
+ },
+ {
+ id: 'F456',
+ name: 'test.pdf',
+ mimetype: 'application/pdf',
+ url_private: 'https://files.slack.com/test.pdf'
+ },
+ {
+ id: 'F789',
+ name: 'test.txt',
+ mimetype: 'text/plain',
+ url_private: 'https://files.slack.com/test.txt'
+ }
+ ]
+ };
+
+ const images = imageDownloader.extractImages(message);
+
+ expect(images).toHaveLength(1);
+ expect(images[0].id).toBe('F123');
+ });
+
+ test('should return empty array when no files', () => {
+ const message = {};
+ const images = imageDownloader.extractImages(message);
+ expect(images).toEqual([]);
+ });
+
+ test('should return empty array when files is not an array', () => {
+ const message = { files: 'not-an-array' };
+ const images = imageDownloader.extractImages(message);
+ expect(images).toEqual([]);
+ });
+ });
+
+ describe('getFileExtension', () => {
+ test('should extract extension from filename', () => {
+ const ext = imageDownloader.getFileExtension('image/jpeg', 'test.jpg');
+ expect(ext).toBe('.jpg');
+ });
+
+ test('should map mimetype to extension when no filename', () => {
+ expect(imageDownloader.getFileExtension('image/jpeg')).toBe('.jpg');
+ expect(imageDownloader.getFileExtension('image/png')).toBe('.png');
+ expect(imageDownloader.getFileExtension('image/gif')).toBe('.gif');
+ expect(imageDownloader.getFileExtension('image/webp')).toBe('.webp');
+ });
+
+ test('should prefer filename extension over mimetype', () => {
+ const ext = imageDownloader.getFileExtension('image/jpeg', 'test.png');
+ expect(ext).toBe('.png');
+ });
+
+ test('should default to .jpg for unknown mimetype', () => {
+ const ext = imageDownloader.getFileExtension('image/unknown');
+ expect(ext).toBe('.jpg');
+ });
+ });
+
+ describe('getImageMarkdown', () => {
+ test('should generate markdown for successful download', () => {
+ const downloadResult = {
+ success: true,
+ filename: 'test-image.jpg',
+ relativePath: '../images/thread-123/test-image.jpg'
+ };
+
+ const markdown = imageDownloader.getImageMarkdown(downloadResult, 'Test Image');
+
+ expect(markdown).toBe('');
+ });
+
+ test('should use filename as alt text when no alt text provided', () => {
+ const downloadResult = {
+ success: true,
+ filename: 'test-image.jpg',
+ relativePath: '../images/thread-123/test-image.jpg'
+ };
+
+ const markdown = imageDownloader.getImageMarkdown(downloadResult);
+
+ expect(markdown).toBe('');
+ });
+
+ test('should return empty string for failed download', () => {
+ const downloadResult = {
+ success: false,
+ error: 'Download failed'
+ };
+
+ const markdown = imageDownloader.getImageMarkdown(downloadResult);
+
+ expect(markdown).toBe('');
+ });
+ });
+
+ describe('init', () => {
+ test('should create images directory', async () => {
+ await imageDownloader.init();
+
+ const dirExists = await fs.access(imageDownloader.imagesDir)
+ .then(() => true)
+ .catch(() => false);
+
+ expect(dirExists).toBe(true);
+ });
+
+ test('should create nested directories', async () => {
+ const deepDownloader = new ImageDownloader(
+ mockSlackClient,
+ path.join(testBaseDir, 'deep', 'nested', 'path')
+ );
+
+ await deepDownloader.init();
+
+ const dirExists = await fs.access(deepDownloader.imagesDir)
+ .then(() => true)
+ .catch(() => false);
+
+ expect(dirExists).toBe(true);
+ });
+ });
+
+ describe('downloadMessageImages', () => {
+ test('should return empty array for message without files', async () => {
+ const message = { ts: '1234567890.123456', text: 'No images here' };
+
+ const results = await imageDownloader.downloadMessageImages(message, '1234567890.123456');
+
+ expect(results).toEqual([]);
+ });
+
+ test('should return empty array for message without image files', async () => {
+ const message = {
+ ts: '1234567890.123456',
+ files: [
+ {
+ id: 'F123',
+ mimetype: 'application/pdf',
+ url_private: 'https://files.slack.com/test.pdf'
+ }
+ ]
+ };
+
+ const results = await imageDownloader.downloadMessageImages(message, '1234567890.123456');
+
+ expect(results).toEqual([]);
+ });
+ });
+
+ describe('downloadThreadImages', () => {
+ test('should process multiple messages', async () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Message 1', files: [] },
+ { ts: '1234567891.123457', text: 'Message 2', files: [] },
+ { ts: '1234567892.123458', text: 'Message 3', files: [] }
+ ];
+
+ const results = await imageDownloader.downloadThreadImages(messages, '1234567890.123456');
+
+ expect(results).toHaveLength(3);
+ expect(results[0].messageTs).toBe('1234567890.123456');
+ expect(results[1].messageTs).toBe('1234567891.123457');
+ expect(results[2].messageTs).toBe('1234567892.123458');
+ });
+
+ test('should mark success true when no images to download', async () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'No images' }
+ ];
+
+ const results = await imageDownloader.downloadThreadImages(messages, '1234567890.123456');
+
+ expect(results).toHaveLength(1);
+ expect(results[0].success).toBe(true);
+ expect(results[0].images).toEqual([]);
+ });
+ });
+});
diff --git a/__tests__/unit/markdownExporter.test.js b/__tests__/unit/markdownExporter.test.js
new file mode 100644
index 0000000..039eabe
--- /dev/null
+++ b/__tests__/unit/markdownExporter.test.js
@@ -0,0 +1,272 @@
+const MarkdownExporter = require('../../src/modules/markdownExporter');
+const fs = require('fs').promises;
+const path = require('path');
+
+describe('MarkdownExporter', () => {
+ let markdownExporter;
+ let testOutputDir;
+
+ beforeEach(() => {
+ testOutputDir = path.join(__dirname, '../fixtures', `test-markdown-${Date.now()}`);
+ markdownExporter = new MarkdownExporter(testOutputDir);
+ });
+
+ afterEach(async () => {
+ // Clean up test directory
+ try {
+ await fs.rm(testOutputDir, { recursive: true, force: true });
+ } catch (error) {
+ // Directory might not exist, ignore
+ }
+ });
+
+ describe('extractTitle', () => {
+ test('should extract title from first line', () => {
+ const text = 'This is the title\nThis is more content';
+ const title = markdownExporter.extractTitle(text);
+ expect(title).toBe('This is the title');
+ });
+
+ test('should remove markdown headers', () => {
+ const text = '## This is a header\nMore content';
+ const title = markdownExporter.extractTitle(text);
+ expect(title).toBe('This is a header');
+ });
+
+ test('should truncate long titles', () => {
+ const longText = 'a'.repeat(150);
+ const title = markdownExporter.extractTitle(longText);
+ expect(title).toHaveLength(103); // 100 chars + '...'
+ expect(title.endsWith('...')).toBe(true);
+ });
+
+ test('should return "Untitled" for empty text', () => {
+ const title = markdownExporter.extractTitle('');
+ expect(title).toBe('Untitled');
+ });
+ });
+
+ describe('formatMessageText', () => {
+ test('should preserve line breaks', () => {
+ const text = 'Line 1\nLine 2\nLine 3';
+ const formatted = markdownExporter.formatMessageText(text);
+ expect(formatted).toContain('\n');
+ });
+
+ test('should convert Slack user mentions', () => {
+ const text = 'Hello <@U1234567890|johndoe>';
+ const formatted = markdownExporter.formatMessageText(text);
+ expect(formatted).toBe('Hello @johndoe');
+ });
+
+ test('should convert Slack channel mentions', () => {
+ const text = 'See <#C1234567890|general>';
+ const formatted = markdownExporter.formatMessageText(text);
+ expect(formatted).toBe('See #general');
+ });
+
+ test('should convert Slack URLs', () => {
+ const text = '';
+ const formatted = markdownExporter.formatMessageText(text);
+ expect(formatted).toBe('[Example Site](https://example.com)');
+ });
+
+ test('should preserve code blocks', () => {
+ const text = '```console.log("test")```';
+ const formatted = markdownExporter.formatMessageText(text);
+ expect(formatted).toContain('```');
+ });
+ });
+
+ describe('generateFilename', () => {
+ test('should generate safe filename', () => {
+ const filename = markdownExporter.generateFilename('Test Title!', '1234567890.123456');
+ expect(filename).toMatch(/^1234567890-123456-test-title\.md$/);
+ });
+
+ test('should handle special characters', () => {
+ const filename = markdownExporter.generateFilename('Test@#$%Title', '1234567890.123456');
+ expect(filename).toMatch(/^1234567890-123456-test-title\.md$/);
+ });
+
+ test('should truncate long titles in filename', () => {
+ const longTitle = 'a'.repeat(100);
+ const filename = markdownExporter.generateFilename(longTitle, '1234567890.123456');
+ expect(filename.length).toBeLessThan(100);
+ });
+ });
+
+ describe('formatThreadAsMarkdown', () => {
+ test('should format thread with basic messages', () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Original post', user: 'U1234567890' },
+ { ts: '1234567891.123457', text: 'First reply', user: 'U0987654321' }
+ ];
+ const threadTs = '1234567890.123456';
+
+ const markdown = markdownExporter.formatThreadAsMarkdown(messages, threadTs);
+
+ expect(markdown).toContain('# Original post');
+ expect(markdown).toContain('**Thread ID:** 1234567890.123456');
+ expect(markdown).toContain('**Messages:** 2');
+ expect(markdown).toContain('## Original Post');
+ expect(markdown).toContain('## Reply 1');
+ expect(markdown).toContain('Original post');
+ expect(markdown).toContain('First reply');
+ });
+
+ test('should include user information when userMap is provided', () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Test message', user: 'U1234567890' }
+ ];
+ const threadTs = '1234567890.123456';
+ const userMap = new Map([['U1234567890', 'John Doe']]);
+
+ const markdown = markdownExporter.formatThreadAsMarkdown(messages, threadTs, null, userMap);
+
+ expect(markdown).toContain('**User:** John Doe');
+ });
+
+ test('should fallback to user ID when userMap is not provided', () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Test message', user: 'U1234567890' }
+ ];
+ const threadTs = '1234567890.123456';
+
+ const markdown = markdownExporter.formatThreadAsMarkdown(messages, threadTs);
+
+ expect(markdown).toContain('**User:** U1234567890');
+ });
+
+ test('should include images when imageDownloads are provided', () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Message with image', user: 'U1234567890' }
+ ];
+ const threadTs = '1234567890.123456';
+ const imageDownloads = {
+ 0: {
+ images: [
+ {
+ success: true,
+ filename: 'test-image.jpg',
+ relativePath: '../images/thread-123/test-image.jpg'
+ }
+ ]
+ }
+ };
+
+ const markdown = markdownExporter.formatThreadAsMarkdown(messages, threadTs, imageDownloads);
+
+ expect(markdown).toContain('');
+ });
+
+ test('should throw error for empty messages', () => {
+ expect(() => markdownExporter.formatThreadAsMarkdown([], '1234567890.123456'))
+ .toThrow('No messages to format');
+ });
+ });
+
+ describe('exportThread', () => {
+ test('should export thread to markdown file', async () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Test message', user: 'U1234567890' }
+ ];
+ const threadTs = '1234567890.123456';
+
+ const result = await markdownExporter.exportThread(messages, threadTs);
+
+ expect(result.success).toBeUndefined(); // Only returned on error
+ expect(result.path).toBeDefined();
+ expect(result.filename).toMatch(/\.md$/);
+ expect(result.threadTs).toBe(threadTs);
+ expect(result.title).toBe('Test message');
+
+ // Verify file was created
+ const fileExists = await fs.access(result.path).then(() => true).catch(() => false);
+ expect(fileExists).toBe(true);
+
+ // Verify content
+ const content = await fs.readFile(result.path, 'utf8');
+ expect(content).toContain('Test message');
+ });
+
+ test('should create output directory if it does not exist', async () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'Test', user: 'U1234567890' }
+ ];
+
+ await markdownExporter.exportThread(messages, '1234567890.123456');
+
+ const dirExists = await fs.access(testOutputDir).then(() => true).catch(() => false);
+ expect(dirExists).toBe(true);
+ });
+ });
+
+ describe('exportThreadsParallel', () => {
+ test('should export multiple threads in parallel', async () => {
+ const threads = [
+ {
+ messages: [{ ts: '1111111111.111111', text: 'Thread 1', user: 'U1' }],
+ threadTs: '1111111111.111111'
+ },
+ {
+ messages: [{ ts: '2222222222.222222', text: 'Thread 2', user: 'U2' }],
+ threadTs: '2222222222.222222'
+ }
+ ];
+
+ const results = await markdownExporter.exportThreadsParallel(threads);
+
+ expect(results).toHaveLength(2);
+ expect(results[0].success).toBe(true);
+ expect(results[1].success).toBe(true);
+ expect(results[0].threadTs).toBe('1111111111.111111');
+ expect(results[1].threadTs).toBe('2222222222.222222');
+ });
+
+ test('should handle failures gracefully', async () => {
+ const threads = [
+ {
+ messages: [{ ts: '1111111111.111111', text: 'Good thread', user: 'U1' }],
+ threadTs: '1111111111.111111'
+ },
+ {
+ messages: [], // This will cause an error
+ threadTs: '2222222222.222222'
+ }
+ ];
+
+ const results = await markdownExporter.exportThreadsParallel(threads);
+
+ expect(results).toHaveLength(2);
+ expect(results[0].success).toBe(true);
+ expect(results[1].success).toBe(false);
+ expect(results[1].error).toBeDefined();
+ });
+
+ test('should return all results even if some fail', async () => {
+ const threads = [
+ {
+ messages: null, // Will fail
+ threadTs: '1111111111.111111'
+ },
+ {
+ messages: [{ ts: '2222222222.222222', text: 'Good', user: 'U2' }],
+ threadTs: '2222222222.222222'
+ },
+ {
+ messages: [], // Will fail
+ threadTs: '3333333333.333333'
+ }
+ ];
+
+ const results = await markdownExporter.exportThreadsParallel(threads);
+
+ expect(results).toHaveLength(3);
+ const successCount = results.filter(r => r.success).length;
+ const failureCount = results.filter(r => !r.success).length;
+ expect(successCount).toBe(1);
+ expect(failureCount).toBe(2);
+ });
+ });
+});
diff --git a/__tests__/unit/slackService.test.js b/__tests__/unit/slackService.test.js
new file mode 100644
index 0000000..596f80d
--- /dev/null
+++ b/__tests__/unit/slackService.test.js
@@ -0,0 +1,323 @@
+const SlackService = require('../../src/modules/slackService');
+
+// Mock the Slack WebClient
+jest.mock('@slack/web-api', () => {
+ return {
+ WebClient: jest.fn().mockImplementation(() => {
+ return {
+ auth: {
+ test: jest.fn()
+ },
+ conversations: {
+ list: jest.fn(),
+ info: jest.fn(),
+ history: jest.fn(),
+ replies: jest.fn()
+ },
+ users: {
+ info: jest.fn()
+ }
+ };
+ })
+ };
+});
+
+describe('SlackService', () => {
+ let slackService;
+ let mockClient;
+
+ beforeEach(() => {
+ slackService = new SlackService('xoxb-test-token');
+ mockClient = slackService.client;
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('validateChannel', () => {
+ test('should return valid result for accessible channel', async () => {
+ const channelData = require('../fixtures/slack-channel-info.json');
+ mockClient.conversations.info.mockResolvedValue(channelData);
+
+ const result = await slackService.validateChannel('C1234567890');
+
+ expect(result.valid).toBe(true);
+ expect(result.channel).toEqual(channelData.channel);
+ expect(mockClient.conversations.info).toHaveBeenCalledWith({
+ channel: 'C1234567890'
+ });
+ });
+
+ test('should throw error for channel_not_found', async () => {
+ mockClient.conversations.info.mockRejectedValue({
+ data: { error: 'channel_not_found' }
+ });
+
+ await expect(slackService.validateChannel('C0000000000'))
+ .rejects.toThrow('Channel not found or bot doesn\'t have access');
+ });
+
+ test('should throw error for not_in_channel', async () => {
+ mockClient.conversations.info.mockRejectedValue({
+ data: { error: 'not_in_channel' }
+ });
+
+ await expect(slackService.validateChannel('C1234567890'))
+ .rejects.toThrow('Bot is not a member of the channel');
+ });
+ });
+
+ describe('getChannelThreads', () => {
+ test('should return threads from channel', async () => {
+ const historyData = require('../fixtures/slack-channel-history.json');
+ mockClient.conversations.history.mockResolvedValue(historyData);
+
+ const threads = await slackService.getChannelThreads('C1234567890');
+
+ // Only messages with thread_ts === ts are threads
+ expect(threads).toHaveLength(2);
+ expect(threads[0].thread_ts).toBe(threads[0].ts);
+ expect(threads[1].thread_ts).toBe(threads[1].ts);
+ expect(mockClient.conversations.history).toHaveBeenCalledWith({
+ channel: 'C1234567890',
+ limit: 100
+ });
+ });
+
+ test('should filter out non-thread messages', async () => {
+ const historyData = require('../fixtures/slack-channel-history.json');
+ mockClient.conversations.history.mockResolvedValue(historyData);
+
+ const threads = await slackService.getChannelThreads('C1234567890');
+
+ // Should not include the regular message without thread
+ const hasRegularMessage = threads.some(t => t.ts === '1234567894.123460');
+ expect(hasRegularMessage).toBe(false);
+ });
+ });
+
+ describe('getThreadReplies', () => {
+ test('should return all messages in thread', async () => {
+ const repliesData = require('../fixtures/slack-thread-replies.json');
+ mockClient.conversations.replies.mockResolvedValue(repliesData);
+
+ const messages = await slackService.getThreadReplies('C1234567890', '1234567890.123456');
+
+ expect(messages).toHaveLength(3);
+ expect(messages[0].text).toContain('Node.js best practices');
+ expect(mockClient.conversations.replies).toHaveBeenCalledWith({
+ channel: 'C1234567890',
+ ts: '1234567890.123456',
+ include_all_metadata: true
+ });
+ });
+ });
+
+ describe('formatThreadAsPost', () => {
+ test('should format messages as post data', () => {
+ const messages = [
+ { ts: '1234567890.123456', text: 'First message with title' },
+ { ts: '1234567890.123457', text: 'Reply message' }
+ ];
+
+ const postData = slackService.formatThreadAsPost(messages);
+
+ expect(postData.title).toBe('First message with title');
+ expect(postData.content).toContain('First message with title');
+ expect(postData.content).toContain('Reply message');
+ expect(postData.threadTs).toBe('1234567890.123456');
+ });
+
+ test('should throw error for empty messages', () => {
+ expect(() => slackService.formatThreadAsPost([]))
+ .toThrow('No messages to format');
+ });
+ });
+
+ describe('extractTitle', () => {
+ test('should extract first line as title', () => {
+ const text = 'This is the title\nThis is more content';
+ const title = slackService.extractTitle(text);
+ expect(title).toBe('This is the title');
+ });
+
+ test('should truncate long titles', () => {
+ const longText = 'a'.repeat(150);
+ const title = slackService.extractTitle(longText);
+ expect(title).toHaveLength(103); // 100 chars + '...'
+ expect(title.endsWith('...')).toBe(true);
+ });
+
+ test('should handle single line text', () => {
+ const text = 'Short title';
+ const title = slackService.extractTitle(text);
+ expect(title).toBe('Short title');
+ });
+ });
+
+ describe('formatContent', () => {
+ test('should format first message as main content', () => {
+ const messages = [
+ { text: 'Main content' },
+ { text: 'Reply content' }
+ ];
+
+ const content = slackService.formatContent(messages);
+
+ expect(content).toContain('Main content
');
+ expect(content).toContain('');
+ expect(content).toContain('Reply:');
+ expect(content).toContain('Reply content');
+ });
+
+ test('should escape HTML in content', () => {
+ const messages = [
+ { text: '' }
+ ];
+
+ const content = slackService.formatContent(messages);
+
+ expect(content).not.toContain('