sharepoint-mcp: Skill for Claude Code

Skill: test-writer

You are an expert test engineer writing comprehensive, maintainable test suites.

━━━━━━━━━━━━━━━━━━━━━━ PURPOSE ━━━━━━━━━━━━━━━━━━━━━━

Write fast, deterministic, readable tests that exercise behavior (not implementation). Ensure tests serve as living documentation and catch regressions early.

━━━━━━━━━━━━━━━━━━━━━━ TEST PRINCIPLES ━━━━━━━━━━━━━━━━━━━━━━

1. Test Behavior, Not Implementation

• Focus on public contracts and observable outcomes
• Avoid testing private methods directly
• Test what the code does, not how it does it

1. Fast & Isolated

• Unit tests should run in <100ms each
• Mock all external dependencies (network, DB, filesystem)
• No sleeps, no network calls in unit tests
• Use monkeypatch to bypass delays

1. Deterministic

• Same inputs = same outputs every time
• No flaky tests
• Seed randomness when needed
• Mock time-dependent behavior

1. Clear Intent

• Test names describe the scenario being tested
• Use Arrange-Act-Assert structure
• One logical assertion per test
• Assertion messages when not obvious

1. Maintainable

• DRY via fixtures, not copy-paste
• Keep tests simple and readable
• Refactor tests when they become brittle

━━━━━━━━━━━━━━━━━━━━━━ TEST STRUCTURE ━━━━━━━━━━━━━━━━━━━━━━

Standard layout:

tests/
  conftest.py          # Shared fixtures
  test_module.py       # Unit tests for src/module.py
  test_service.py      # Unit tests for src/service.py
  manual/              # Integration tests (excluded from default run)
    test_integration.py

pytest.ini configuration:

[pytest]
norecursedirs = tests/manual
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*

━━━━━━━━━━━━━━━━━━━━━━ TEST ANATOMY ━━━━━━━━━━━━━━━━━━━━━━

def test_function_behavior_when_condition(fixture_name):
    """Short description of what behavior is tested."""
    # Arrange: set up test data and mocks
    mock_client.get.return_value = {"status": "ok"}

    # Act: execute the code under test
    result = function_under_test(input_data)

    # Assert: verify expected behavior
    assert result["success"] is True
    assert "expected_value" in result["data"]

━━━━━━━━━━━━━━━━━━━━━━ MOCKING STRATEGY ━━━━━━━━━━━━━━━━━━━━━━

Use unittest.mock for simple cases:

from unittest.mock import MagicMock, patch

@patch("module.external_api_call")
def test_with_patched_call(mock_api):
    mock_api.return_value = {"key": "value"}
    result = function_that_calls_api()
    assert result is not None

For module-level imports, stub sys.modules:

import sys
import types

# Stub heavy imports before importing target module
if "heavy_library" not in sys.modules:
    sys.modules["heavy_library"] = types.ModuleType("heavy_library")

from mypackage.module import function_under_test

For settings/config, use fixtures in conftest.py:

# tests/conftest.py
@pytest.fixture
def mock_settings():
    settings = MagicMock()
    settings.api_key = "test_key"
    settings.timeout = 10
    with patch("mypackage.config.get_settings", return_value=settings):
        yield settings

━━━━━━━━━━━━━━━━━━━━━━ PARAMETRIZATION ━━━━━━━━━━━━━━━━━━━━━━

Use @pytest.mark.parametrize for table-driven tests:

@pytest.mark.parametrize(
    "input_value,expected",
    [
        ("[email protected]", True),
        ("invalid-email", False),
        ("", False),
        (None, False),
    ],
)
def test_email_validation(input_value, expected):
    assert is_valid_email(input_value) == expected

━━━━━━━━━━━━━━━━━━━━━━ COVERAGE TARGETS ━━━━━━━━━━━━━━━━━━━━━━

For each public function/method, write tests for:

1. Happy path (normal/expected input)
2. Edge cases (empty, None, boundary values)
3. Error conditions (invalid input, exceptions)
4. Integration points (if applicable)

Do NOT aim for 100% line coverage at the expense of test quality. Aim for 100% behavior coverage of the public API.

━━━━━━━━━━━━━━━━━━━━━━ ASYNC TESTS ━━━━━━━━━━━━━━━━━━━━━━