@freshworks/shiftleft-tools 1.1.8

package/templates/rules/local-test-setup.mdc

@@ -0,0 +1,420 @@
+---
+description: Local test environment setup - H2, WireMock, mocking dependencies
+globs:
+  - "**/application-integration.properties"
+  - "**/application-integration.yml"
+  - "**/application-test.properties"
+  - "**/application-test.yml"
+  - "**/*IntegrationTest.java"
+  - "**/wiremock/**"
+  - "**/src/test/resources/**"
+---
+
+# Local Test Environment Setup - MANDATORY (Java / Spring Boot)
+
+For Postman/Newman tests to run locally on **Java** services, you MUST set up H2, WireMock, and mock all external dependencies.
+
+> **Node.js services:** use in-process nock mocks (`postman/scripts/setup-mocks.js`) instead of WireMock. See `setup-api-tests` SKILL-node.md.
+
+## CRITICAL: Explore Codebase First
+
+**Before creating any files, explore the project structure:**
+
+1. Read `application.properties` → get server.port, context-path, Feign base URLs
+2. Find all `@FeignClient` interfaces → these need WireMock stubs
+3. Read `db/migration/*.sql` → check for H2-incompatible syntax
+4. Check if `application-integration.properties` exists already
+
+**Adapt all templates below based on what you find in the project.**
+
+## H2 Database Configuration
+
+### Spring Profile for Integration Tests
+
+Create `src/main/resources/application-integration.properties`:
+
+```properties
+# =============================================================================
+# H2 Database Configuration for Local Integration Tests
+# =============================================================================
+
+# H2 in-memory database with MySQL compatibility mode
+spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;DATABASE_TO_LOWER=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE
+spring.datasource.driver-class-name=org.h2.Driver
+spring.datasource.username=sa
+spring.datasource.password=
+
+# JPA/Hibernate settings
+spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
+spring.jpa.hibernate.ddl-auto=none
+spring.jpa.show-sql=false
+
+# Flyway configuration
+spring.flyway.enabled=true
+spring.flyway.locations=classpath:db/migration,classpath:db/testdata
+spring.flyway.baseline-on-migrate=true
+spring.flyway.validate-on-migrate=false
+
+# H2 Console (optional, for debugging)
+spring.h2.console.enabled=true
+spring.h2.console.path=/h2-console
+
+# Disable features not needed for local tests
+spring.cache.type=none
+spring.redis.enabled=false
+```
+
+### H2 Maven Dependency
+
+Ensure `pom.xml` has H2 as test dependency:
+
+```xml
+<dependency>
+    <groupId>com.h2database</groupId>
+    <artifactId>h2</artifactId>
+    <scope>test</scope>
+</dependency>
+```
+
+## Flyway Migrations - H2 Compatibility
+
+### CRITICAL: MySQL vs H2 Syntax Differences
+
+| MySQL Syntax | H2 Compatible Alternative |
+|-------------|---------------------------|
+| `DATETIME` | `TIMESTAMP` |
+| `TINYINT(1)` | `BOOLEAN` |
+| `AUTO_INCREMENT` | `AUTO_INCREMENT` (same) |
+| `ENGINE=InnoDB` | Remove (not supported) |
+| `CHARSET=utf8mb4` | Remove (not supported) |
+| `ON UPDATE CURRENT_TIMESTAMP` | Remove (use `@PreUpdate` instead) |
+| `JSON` | `CLOB` or `VARCHAR(MAX)` |
+
+### Migration File Strategy
+
+**Option 1: H2-Compatible MySQL Migrations (Recommended)**
+
+Write migrations that work in both MySQL and H2:
+
+```sql
+-- V20240224120000__create_apps_table.sql
+CREATE TABLE IF NOT EXISTS apps (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    external_id VARCHAR(255) NOT NULL UNIQUE,
+    name VARCHAR(255) NOT NULL,
+    type VARCHAR(50) NOT NULL,
+    status VARCHAR(50) NOT NULL DEFAULT 'ACTIVE',
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP NULL
+);
+
+CREATE INDEX idx_apps_external_id ON apps(external_id);
+CREATE INDEX idx_apps_type ON apps(type);
+```
+
+**Option 2: Separate H2 Migrations**
+
+For complex cases, create H2-specific migrations:
+
+```
+src/main/resources/
+├── db/migration/           # MySQL migrations (production)
+│   └── V1__create_tables.sql
+└── db/h2/                  # H2 overrides (test only)
+    └── V1__create_tables.sql
+```
+
+Then configure Flyway per profile:
+```properties
+# application-integration.properties
+spring.flyway.locations=classpath:db/h2
+```
+
+### Test Data Seed File
+
+Create `src/main/resources/db/testdata/V9999__test_seed_data.sql`:
+
+```sql
+-- Test data for integration tests (high version to run last)
+-- This file should be idempotent (use INSERT IGNORE or MERGE)
+
+MERGE INTO apps (id, external_id, name, type, status, created_at, updated_at) KEY(id)
+VALUES 
+    (1, 'app-001', 'Test Platform App', 'PLATFORM', 'ACTIVE', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    (2, 'app-002', 'Test Custom App', 'CUSTOM', 'ACTIVE', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    (3, 'app-003', 'Test Native App', 'NATIVE', 'ACTIVE', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
+
+MERGE INTO app_versions (id, app_id, version_number, status, created_at, updated_at) KEY(id)
+VALUES
+    (1, 1, '1.0.0', 'PUBLISHED', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    (2, 2, '1.0.0', 'DRAFT', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
+```
+
+## WireMock Setup for External Services
+
+### WireMock Directory Structure
+
+```
+postman/scripts/wiremock/
+├── mappings/                    # Stub definitions
+│   ├── freshid-api.json         # FreshID API mocks
+│   ├── marketplace-api.json     # Other service mocks
+│   └── ...
+└── __files/                     # Response body files (optional)
+    └── user-response.json
+```
+
+### WireMock Stub Example
+
+Create `postman/scripts/wiremock/mappings/freshid-api.json`:
+
+```json
+{
+  "mappings": [
+    {
+      "name": "FreshID - Get User Success",
+      "request": {
+        "method": "GET",
+        "urlPathPattern": "/freshid/api/v2/users/.*"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "Content-Type": "application/json"
+        },
+        "jsonBody": {
+          "id": "user-123",
+          "email": "test@example.com",
+          "name": "Test User",
+          "role": "admin"
+        }
+      }
+    },
+    {
+      "name": "FreshID - User Not Found",
+      "request": {
+        "method": "GET",
+        "urlPath": "/freshid/api/v2/users/nonexistent"
+      },
+      "response": {
+        "status": 404,
+        "headers": {
+          "Content-Type": "application/json"
+        },
+        "jsonBody": {
+          "error": "User not found"
+        }
+      }
+    },
+    {
+      "name": "FreshID - Create User",
+      "request": {
+        "method": "POST",
+        "urlPath": "/freshid/api/v2/users",
+        "bodyPatterns": [
+          {
+            "matchesJsonPath": "$.email"
+          }
+        ]
+      },
+      "response": {
+        "status": 201,
+        "headers": {
+          "Content-Type": "application/json"
+        },
+        "jsonBody": {
+          "id": "new-user-456",
+          "email": "{{jsonPath request.body '$.email'}}",
+          "created": true
+        },
+        "transformers": ["response-template"]
+      }
+    }
+  ]
+}
+```
+
+### Start/Stop WireMock Scripts
+
+The `start-mocks.sh` script starts WireMock on a configured port:
+
+```bash
+# In run-tests-local.sh, WireMock is started before tests:
+./start-mocks.sh
+
+# After tests complete:
+./stop-mocks.sh
+```
+
+### Configure Application to Use WireMock
+
+In `application-integration.properties`:
+
+```properties
+# Point Feign clients to WireMock
+freshid.api.base-url=http://localhost:8089
+marketplace.api.base-url=http://localhost:8089
+external-service.base-url=http://localhost:8089
+```
+
+## Mocking Feign Clients
+
+### Option 1: WireMock (Recommended for Postman Tests)
+
+WireMock intercepts HTTP calls - no code changes needed. Just configure the base URL.
+
+### Option 2: @MockBean for Java Integration Tests
+
+For Java integration tests using MockMvc:
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("integration")
+class AppControllerIntegrationTest {
+
+    @MockBean
+    private FreshIDApiClient freshIDApiClient;  // Mock the Feign client
+    
+    @MockBean
+    private MarketplaceApiClient marketplaceApiClient;
+    
+    @BeforeEach
+    void setUp() {
+        // Configure mock responses
+        when(freshIDApiClient.getUser(anyString()))
+            .thenReturn(new UserResponse("user-123", "test@example.com"));
+        
+        when(freshIDApiClient.getUser("nonexistent"))
+            .thenThrow(new FeignException.NotFound("User not found", mock(Request.class), null, null));
+    }
+    
+    @Test
+    void createApp_shouldCallFreshID() {
+        // Test that uses the mocked FreshID client
+    }
+}
+```
+
+## Mocking Redis Cache
+
+### Disable Redis for Local Tests
+
+In `application-integration.properties`:
+
+```properties
+# Disable Redis - use simple cache or no cache
+spring.cache.type=simple
+spring.data.redis.enabled=false
+
+# Or disable caching entirely
+spring.cache.type=none
+```
+
+### Mock Redis Template (if needed)
+
+```java
+@TestConfiguration
+public class TestCacheConfig {
+    
+    @Bean
+    @Primary
+    public RedisTemplate<String, Object> redisTemplate() {
+        // Return a mock or in-memory implementation
+        return mock(RedisTemplate.class);
+    }
+}
+```
+
+## Mocking AWS S3
+
+### Use LocalStack or Mock
+
+**Option 1: Disable S3 for Tests**
+
+```properties
+# application-integration.properties
+aws.s3.enabled=false
+```
+
+**Option 2: Mock S3Client**
+
+```java
+@MockBean
+private S3Client s3Client;
+
+@BeforeEach
+void setUp() {
+    when(s3Client.putObject(any(PutObjectRequest.class), any(RequestBody.class)))
+        .thenReturn(PutObjectResponse.builder().eTag("test-etag").build());
+}
+```
+
+**Option 3: Use LocalStack (Docker)**
+
+```yaml
+# docker-compose.test.yml
+services:
+  localstack:
+    image: localstack/localstack
+    ports:
+      - "4566:4566"
+    environment:
+      - SERVICES=s3
+```
+
+```properties
+# application-integration.properties
+aws.s3.endpoint=http://localhost:4566
+aws.s3.region=us-east-1
+```
+
+## Application Startup for Local Tests
+
+### run-tests-local.sh Flow
+
+1. Start WireMock (`./start-mocks.sh`)
+2. Start application with integration profile
+3. Wait for health check
+4. Run Newman tests
+5. Stop application
+6. Stop WireMock (`./stop-mocks.sh`)
+
+### Application Start Command
+
+```bash
+# Start with integration profile
+java -jar target/your-app.jar \
+    --spring.profiles.active=integration \
+    --server.port=9090 &
+
+# Wait for startup
+until curl -s http://localhost:9090/actuator/health | grep -q "UP"; do
+    sleep 2
+done
+```
+
+## Checklist for Local Test Setup
+
+Before running `./runners/run-tests-local.sh`, ensure:
+
+- [ ] `application-integration.properties` exists with H2 config
+- [ ] H2 dependency in `pom.xml` (test scope)
+- [ ] Flyway migrations are H2-compatible
+- [ ] Test seed data in `db/testdata/`
+- [ ] WireMock mappings for all external services in `postman/scripts/wiremock/mappings/`
+- [ ] Feign client base URLs point to WireMock port
+- [ ] Redis/cache disabled or mocked
+- [ ] S3/AWS disabled or mocked
+- [ ] `start-mocks.sh` and `stop-mocks.sh` configured
+
+## Common Issues
+
+| Issue | Cause | Fix |
+|-------|-------|-----|
+| "Table not found" | Flyway migration failed | Check H2 compatibility of SQL |
+| Connection refused | WireMock not started | Run `./start-mocks.sh` first |
+| 404 from external service | Missing WireMock mapping | Add stub to `wiremock/mappings/` |
+| "Unknown column type: JSON" | MySQL-specific type | Use `CLOB` or `VARCHAR` instead |
+| Test data not found | Seed file version too low | Use high version like `V9999__` |

package/templates/rules/testing-node.mdc

@@ -0,0 +1,66 @@
+---
+description: Test writing rules for Node.js — MANDATORY when editing test files
+globs:
+  - "**/*.test.js"
+  - "**/test/**/*.js"
+  - "**/test/unit/**/*.js"
+---
+
+# Node.js Test Writing Rules
+
+All unit tests MUST survive Stryker mutation testing. Weak assertions allow mutants to survive.
+
+## Test stack
+
+- **Runner**: Mocha
+- **Assertions**: Chai `expect`
+- **Mocks**: Sinon + proxyquire
+- **Coverage**: nyc (Istanbul)
+- **Mutation**: Stryker — target 80%+
+
+Run mutation tests: `yarn mutation-tests` (fast) or `yarn mutation-tests:full` (CI)
+
+## Assertion strength — CRITICAL
+
+### WRONG
+
+```javascript
+expect(result).to.exist;
+expect(list.length).to.be.above(0);
+expect(response.status).to.equal(200); // without body checks
+```
+
+### CORRECT
+
+```javascript
+expect(result.id).to.equal(42);
+expect(result.name).to.equal('expected-name');
+expect(list).to.deep.equal([{ id: 1, name: 'a' }]);
+```
+
+If a function returns N fields, assert on all N.
+
+## Stryker scope — keep it small
+
+Stryker is slow. **Never** use `src/**` in `mutate`. Target **under 80 files**:
+
+- **Include:** `src/actions/`, `src/services/`, `src/serializers/`, `src/middlewares/` (only files with branching logic)
+- **Exclude:** `src/controllers/`, `src/routes/`, `src/models/`, `src/config/`, migrations, seeders
+- **Helpers:** audit file-by-file — exclude SDK wrappers (aws, freshid, chargebee, etc.)
+- **Local:** `yarn mutation-tests` (since mode — changed files only)
+- **CI:** `yarn mutation-tests:full` (full narrow scope only)
+
+## Postman / Newman rules
+
+See `postman-standards` skill shared doc:
+- One HTTP status assertion per request
+- Cover all query params with dedicated tests
+- Document environment skips with `[SKIP] Reason: ... | Env: ...`
+
+## API coverage
+
+```bash
+./postman/scripts/report-generators/node-api-coverage-matrix.sh ./src/controllers ./postman
+```
+
+Target: 100% 2xx coverage before merge.