testing-strategies

Enforce a NO MOCKING 3-tier testing strategy for Kailash applications.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/Integrum-Global/new_project_template --skill testing-strategies
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: testing-strategies
Source: https://github.com/Integrum-Global/new_project_template/tree/main/.claude/skills/12-testing-strategies
Command: npx skills add https://github.com/Integrum-Global/new_project_template --skill testing-strategies

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires kailash, pytest.

What problem does it solve?

Ensuring the reliability and quality of complex applications requires a robust testing strategy. This Skill provides a comprehensive guide to Kailash SDK's 3-tier testing approach (Unit, Integration, E2E), emphasizing test organization and the critical "NO MOCKING" policy for integration tests, guaranteeing production-ready code.

Core Features & Use Cases

  • 3-Tier Testing: Learn to implement unit tests for individual components, integration tests with real infrastructure, and end-to-end tests for full user journeys.
  • Test Organization: Best practices for structuring your test suite for maintainability and efficiency.
  • NO MOCKING Policy: Understand why and how to avoid mocks in integration tests to catch real-world issues.
  • Use Case: You're developing a critical workflow and need to ensure its reliability. This Skill guides you through setting up unit tests for each node, integration tests with a real database, and end-to-end tests simulating a complete user interaction.

Quick Start

Example: Unit Test

import pytest from kailash.nodes.code import PythonCodeNode def test_python_code_node_execution(): node = PythonCodeNode("test_node", {"code": "result = input_value * 2"}) result = node.execute({"input_value": 10}) assert result["result"]["value"] == 20

Frequently Asked Questions about testing-strategies

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a 3-tier testing strategy for Kailash applications?

A 3-tier testing strategy structures tests into unit tests for individual components, integration tests with real infrastructure, and end-to-end tests for complete user journeys. Unit tests use mocking allowance, while integration and E2E tiers enforce NO MOCKING, running against real databases, live APIs, and cached LLM calls to catch production-ready issues.

Why should I avoid mocking in integration tests?

Mocking hides real-world failures that occur between components and external services. The NO MOCKING policy for integration tests enforces testing against actual databases, APIs, and LLM calls, ensuring your code handles real infrastructure behavior and catches integration bugs before production.

How do I set up integration tests with real databases and APIs in Kailash?

Integration tests use Dockerized test databases and live API calls with cached LLM responses, eliminating mocks to validate actual component interaction. This approach simulates production conditions within CI/CD workflows, catching real-world integration issues without requiring full end-to-end test overhead.

What's the difference between unit, integration, and end-to-end tests in Kailash?

Unit tests isolate individual components with allowed mocking for dependencies. Integration tests validate component interaction using real infrastructure without mocks. End-to-end tests simulate complete user journeys across the full application stack, ensuring entire workflows function correctly.

Can I use pytest with Kailash's testing strategy?

Yes, pytest is a core dependency for Kailash testing. It runs all three test tiers—unit tests with fixtures, integration tests against Dockerized databases and live APIs, and end-to-end tests—supporting the complete NO MOCKING 3-tier strategy within CI/CD pipelines.

How should I organize my test suite for a complex Kailash workflow?

Structure tests by tier: unit tests for individual nodes with fixtures, integration tests validating database and API interactions, and end-to-end tests simulating full user interactions. This organization ensures maintainability, efficient execution, and clear coverage across all reliability layers.