@apidiff/core 1.0.0

package/tests/output.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { formatHtml } from '../src/output/html.js';
+import { formatMarkdown } from '../src/output/markdown.js';
+import { formatTerminal } from '../src/output/terminal.js';
+import { formatJson } from '../src/output/json.js';
+import type { SemanticChange } from '../src/types/index.js';
+
+describe('Output Formatters', () => {
+  const dummyChanges: SemanticChange[] = [
+    {
+      severity: 'breaking',
+      category: 'endpoint',
+      ruleId: 'ENDPOINT_REMOVED',
+      message: 'Endpoint removed',
+      location: { method: 'GET', path: '/test', paramName: 'id', field: 'data' },
+      consequence: 'Breaks things',
+      migration: 'Update URL'
+    },
+    {
+      severity: 'info',
+      category: 'meta',
+      ruleId: 'SERVER_ADDED',
+      message: 'Server added',
+      location: { method: 'ALL', path: 'GLOBAL' }
+    }
+  ];
+
+  it('formats HTML', () => {
+    const output = formatHtml(dummyChanges);
+    expect(output).toContain('Endpoint removed');
+    expect(output).toContain('Server added');
+    expect(output).toContain('Breaks things');
+    expect(output).toContain('Update URL');
+    expect(output).toContain('API Diff Report');
+  });
+
+  it('formats Markdown', () => {
+    const output = formatMarkdown(dummyChanges);
+    expect(output).toContain('Endpoint removed');
+    expect(output).toContain('Server added');
+    expect(output).toContain('Breaks things');
+    expect(output).toContain('Update URL');
+    expect(output).toContain('## API Changes');
+  });
+
+  it('formats Terminal', () => {
+    const output = formatTerminal(dummyChanges);
+    expect(output).toContain('Endpoint removed');
+    expect(output).toContain('Server added');
+  });
+
+  it('formats JSON', () => {
+    const output = formatJson(dummyChanges);
+    const parsed = JSON.parse(output);
+    expect(parsed.changes).toHaveLength(2);
+    expect(parsed.changes[0].ruleId).toBe('ENDPOINT_REMOVED');
+  });
+});

package/tests/parsers/openapi3-coverage.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi } from 'vitest';
+import { OpenApi3Parser } from '../../src/parsers/openapi3/index.js';
+import { normalizeSchema } from '../../src/parsers/openapi3/schema-normalizer.js';
+import { resolveRefs } from '../../src/parsers/openapi3/ref-resolver.js';
+import * as fs from 'node:fs';
+
+vi.mock('node:fs');
+
+describe('OpenAPI 3 Coverage', () => {
+  it('covers missing index.ts branches', async () => {
+    const parser = new OpenApi3Parser();
+    const ast = await parser.parse({
+      content: JSON.stringify({
+        openapi: '3.0.0',
+        info: { version: '1' }, // Missing title
+        paths: {
+          '/test': {
+            get: {
+              'x-custom': 'ext',
+              responses: {
+                '200': {
+                  description: 'ok',
+                  content: { 'app/json': {} } // No schema, no headers
+                }
+              }
+            }
+          }
+        }
+      }),
+      format: 'openapi3'
+    });
+    
+    expect(ast.meta.title).toBe('Unknown API');
+    expect(ast.endpoints[0].extensions['x-custom']).toBe('ext');
+    expect(ast.endpoints[0].responses[0].headers).toEqual({});
+  });
+
+  it('covers ref-resolver external refs', () => {
+    // mock readFileSync
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ type: 'string' }));
+    
+    const root = {
+      prop: { $ref: './external.json' }
+    };
+    
+    expect(() => resolveRefs({ ...root }, root)).toThrow('Cannot resolve relative ref without sourcePath');
+    
+    const resolved = resolveRefs(root, root, '/app/spec.json');
+    expect(resolved.prop.type).toBe('string');
+    
+    expect(() => resolveRefs({ $ref: 'http://example.com' }, {}, '/app/spec.json')).toThrow('URL refs not implemented synchronously');
+    expect(() => resolveRefs({ $ref: 'invalid-format' }, {}, '/app/spec.json')).toThrow('Unsupported ref format');
+  });
+
+  it('covers schema-normalizer missing branches', () => {
+    // nullable string
+    const s1 = normalizeSchema({ type: 'string', nullable: true });
+    expect(s1.type).toEqual(['string', 'null']);
+
+    // nullable array type
+    const s2 = normalizeSchema({ type: ['string'], nullable: true });
+    expect(s2.type).toEqual(['string', 'null']);
+
+    // items
+    const s3 = normalizeSchema({ type: 'array', items: { type: 'string' } });
+    expect(s3.items.type).toBe('string');
+
+    // additionalProperties
+    const s4 = normalizeSchema({ type: 'object', additionalProperties: { type: 'number' } });
+    expect((s4.additionalProperties as any).type).toBe('number');
+
+    // oneOf / anyOf
+    const s5 = normalizeSchema({ oneOf: [{ type: 'string' }], anyOf: [{ type: 'number' }] });
+    expect(s5.oneOf[0].type).toBe('string');
+    expect(s5.anyOf[0].type).toBe('number');
+  });
+});

package/tests/parsers/openapi3.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { OpenApi3Parser } from '../../src/parsers/openapi3/index.js';
+
+describe('OpenAPI 3 Parser', () => {
+  it('parses valid OpenAPI 3 document', async () => {
+    const doc = {
+      openapi: '3.0.0',
+      info: { title: 'Test API', version: '1.0' },
+      servers: [{ url: 'http://test.com' }],
+      paths: {
+        '/test': {
+          get: {
+            operationId: 'getTest',
+            summary: 'Test',
+            parameters: [{ name: 'q', in: 'query', required: true, schema: { type: 'string' } }],
+            responses: {
+              '200': {
+                description: 'OK',
+                content: { 'application/json': { schema: { type: 'string' } } }
+              }
+            }
+          }
+        }
+      }
+    };
+
+    const parser = new OpenApi3Parser();
+    const ast = await parser.parse({ content: JSON.stringify(doc), format: 'openapi3' });
+    expect(ast.meta.title).toBe('Test API');
+    expect(ast.endpoints).toHaveLength(1);
+    expect(ast.endpoints[0].method).toBe('GET');
+    expect(ast.endpoints[0].parameters).toHaveLength(1);
+    expect(ast.endpoints[0].responses).toHaveLength(1);
+    expect(ast.endpoints[0].responses[0].statusCode).toBe('200');
+  });
+
+  it('throws on unsupported version', async () => {
+    const parser = new OpenApi3Parser();
+    await expect(parser.parse({ content: JSON.stringify({ swagger: '2.0' }), format: 'openapi3' })).rejects.toThrow();
+  });
+});

package/tests/parsers/parsers-other.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { GraphqlParser } from '../../src/parsers/graphql/index.js';
+import { OpenApi2Parser } from '../../src/parsers/openapi2/index.js';
+import { ProtobufParser } from '../../src/parsers/protobuf/index.js';
+
+describe('Other Parsers', () => {
+  describe('GraphqlParser', () => {
+    it('can parse graphql', () => {
+      const parser = new GraphqlParser();
+      expect(parser.canParse({ content: 'type Query { hello: String! }', format: 'graphql' })).toBe(true);
+    });
+
+    it('parses simple schema', async () => {
+      const parser = new GraphqlParser();
+      const ast = await parser.parse({
+        content: `
+          type Query { hello(name: String!): String! }
+          type Mutation { create(id: ID!, tags: [String]): Boolean }
+          input Config { key: String! }
+          interface Node { id: ID! }
+          enum Status { ACTIVE INACTIVE }
+        `,
+        format: 'graphql'
+      });
+      expect(ast.endpoints).toHaveLength(2);
+      expect(ast.endpoints[0].id).toBe('POST:query.hello');
+      expect(ast.components.schemas['Status'].type).toBe('string');
+      expect(ast.components.schemas['Config'].type).toBe('object');
+      expect(ast.components.schemas['Node'].type).toBe('object');
+    });
+
+    it('throws on invalid', async () => {
+      const parser = new GraphqlParser();
+      await expect(parser.parse({ content: 'invalid' })).rejects.toThrow('Failed to parse GraphQL');
+    });
+  });
+
+  describe('OpenApi2Parser', () => {
+    it('can parse openapi2', () => {
+      const parser = new OpenApi2Parser();
+      expect(parser.canParse({ content: '', format: 'openapi2' })).toBe(true);
+    });
+
+    it('parses swagger 2.0', async () => {
+      const parser = new OpenApi2Parser();
+      const ast = await parser.parse({
+        content: JSON.stringify({
+          swagger: '2.0',
+          info: { title: 'Test', version: '1' },
+          host: 'api.example.com',
+          schemes: ['http', 'https'],
+          basePath: '/v1',
+          securityDefinitions: { basic: { type: 'basic' } },
+          security: [{ basic: [] }],
+          paths: {
+            '/test/{id}': {
+              parameters: [{ name: 'id', in: 'path', required: true, type: 'string' }],
+              get: {
+                operationId: 'getTest',
+                tags: ['test'],
+                parameters: [
+                  { name: 'q', in: 'query', type: 'string' },
+                  { name: 'body', in: 'body', schema: { type: 'object' } }
+                ],
+                responses: { '200': { description: 'ok', headers: { 'X-Test': { type: 'string' } }, schema: { type: 'string' } } },
+                'x-test': true
+              },
+              post: {
+                consumes: ['multipart/form-data'],
+                parameters: [
+                  { name: 'file', in: 'formData', type: 'file', required: true }
+                ],
+                responses: { '204': { description: 'ok' } }
+              }
+            }
+          },
+          definitions: { User: { type: 'object' } }
+        }),
+        format: 'openapi2'
+      });
+      expect(ast.endpoints).toHaveLength(2);
+      expect(ast.servers).toHaveLength(2);
+      expect(ast.components.schemas['User']).toBeDefined();
+    });
+
+    it('throws on invalid format', async () => {
+      const parser = new OpenApi2Parser();
+      await expect(parser.parse({ content: '{}' })).rejects.toThrow('Not a valid OpenAPI 2.x spec');
+      await expect(parser.parse({ content: 'invalid: { yaml' })).rejects.toThrow();
+    });
+  });
+
+  describe('ProtobufParser', () => {
+    it('can parse proto', () => {
+      const parser = new ProtobufParser();
+      expect(parser.canParse({ content: 'syntax = "proto3";', format: 'protobuf' })).toBe(true);
+    });
+
+    it('parses simple proto', async () => {
+      const parser = new ProtobufParser();
+      const ast = await parser.parse({
+        content: `
+          syntax = "proto3";
+          package test.pkg;
+          service TestService {
+            // A method
+            rpc Get(Request) returns (Response);
+          }
+          message Request { 
+            string id = 1; 
+            repeated string tags = 2;
+            Nested msg = 3;
+            double d = 4;
+            int32 i = 5;
+            int64 l = 6;
+            bool b = 7;
+            bytes by = 8;
+          }
+          message Response { bool ok = 1; }
+          enum Status { OK = 0; ERR = 1; }
+          message Nested { string n = 1; }
+        `,
+        format: 'protobuf'
+      });
+      expect(ast.endpoints).toHaveLength(1);
+      expect(ast.endpoints[0].id).toBe('RPC:test.pkg.TestService/Get');
+      expect(ast.components.schemas['test.pkg.Request']).toBeDefined();
+    });
+
+    it('throws on invalid', async () => {
+      const parser = new ProtobufParser();
+      await expect(parser.parse({ content: 'invalid' })).rejects.toThrow('Failed to parse Protobuf');
+    });
+  });
+});

package/tests/parsers/ref-resolver.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { resolveRefs } from '../../src/parsers/openapi3/ref-resolver.js';
+
+describe('Ref Resolver', () => {
+  it('resolves simple local refs', () => {
+    const doc = {
+      components: {
+        schemas: {
+          A: { type: 'string' }
+        }
+      },
+      paths: {
+        '/test': {
+          get: {
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: { $ref: '#/components/schemas/A' }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    
+    const resolved = resolveRefs(doc, doc) as any;
+    expect(resolved.paths['/test'].get.responses['200'].content['application/json'].schema.type).toBe('string');
+  });
+
+  it('handles circular references safely', () => {
+    const doc = {
+      components: {
+        schemas: {
+          Node: {
+            type: 'object',
+            properties: {
+              child: { $ref: '#/components/schemas/Node' }
+            }
+          }
+        }
+      }
+    };
+    const resolved = resolveRefs(doc, doc) as any;
+    // Circular reference should point to an empty object or just stop without throwing a stack overflow
+    expect(resolved.components.schemas.Node.properties.child).toBeDefined();
+  });
+
+  it('throws on unresolvable local ref', () => {
+    const doc = {
+      test: { $ref: '#/components/schemas/NotFound' }
+    };
+    expect(() => resolveRefs(doc, doc)).toThrow('Local ref not found');
+  });
+
+  it('throws on missing sourcePath for relative ref', () => {
+    const doc = {
+      test: { $ref: './external.yaml' }
+    };
+    expect(() => resolveRefs(doc, doc)).toThrow('Cannot resolve relative ref without sourcePath');
+  });
+
+  it('throws on unsupported ref format', () => {
+    const doc = {
+      test: { $ref: 'invalid-ref' }
+    };
+    expect(() => resolveRefs(doc, doc, '/base/path.yaml')).toThrow('Unsupported ref format');
+  });
+
+  it('throws on url ref', () => {
+    const doc = {
+      test: { $ref: 'https://example.com/schema.json' }
+    };
+    expect(() => resolveRefs(doc, doc)).toThrow('URL refs not implemented synchronously');
+  });
+});

package/tests/parsers/schema-normalizer.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeSchema } from '../../src/parsers/openapi3/schema-normalizer.js';
+
+describe('Schema Normalizer', () => {
+  it('merges allOf arrays', () => {
+    const schema = {
+      allOf: [
+        { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] },
+        { type: 'object', properties: { b: { type: 'number' } }, required: ['b'] }
+      ]
+    };
+    
+    const normalized = normalizeSchema(schema);
+    expect(normalized.type).toBe('object');
+    expect(normalized.properties).toBeDefined();
+    expect(normalized.properties?.a.type).toBe('string');
+    expect(normalized.properties?.b.type).toBe('number');
+    expect(normalized.required).toContain('a');
+    expect(normalized.required).toContain('b');
+  });
+
+  it('normalizes oneOf/anyOf to empty object (fallback)', () => {
+    const schema = {
+      anyOf: [{ type: 'string' }, { type: 'number' }]
+    };
+    const normalized = normalizeSchema(schema);
+    expect(normalized.type).toBeUndefined(); // currently normalizer drops it or picks first?
+    // Looking at schema-normalizer, it says: "In a robust implementation, we'd handle anyOf/oneOf properly."
+  });
+});

package/tests/rules/auth-meta.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { SecurityRemovedRule } from '../../src/rules/auth/security-removed.js';
+import { SecuritySchemeTypeChangedRule } from '../../src/rules/auth/security-scheme-type-changed.js';
+import { OauthScopeRemovedRule } from '../../src/rules/auth/oauth-scope-removed.js';
+import { ServerRemovedRule } from '../../src/rules/meta/server-removed.js';
+import type { DiffSet, RuleContext } from '../../src/types/index.js';
+
+describe('Auth & Meta Rules', () => {
+  const context: RuleContext = {
+    config: { failOn: 'breaking', disabledRules: [], ignorePaths: [], output: { format: 'terminal' } },
+    oldSpec: { meta: { title: 'v1', version: '1.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+    newSpec: { meta: { title: 'v2', version: '2.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+  };
+
+  const dummyEndpoint = { id: 'GET:/test', path: '/test', method: 'GET' as const, summary: '', description: '', tags: [], deprecated: false, security: [], parameters: [], responses: [] };
+
+  it('SECURITY_REMOVED triggers when a global security scheme is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [], componentDiffs: [], serverDiffs: [],
+      securityDiffs: [
+        { schemeId: 'ApiKeyAuth', changeType: 'removed', fieldChanges: [] }
+      ]
+    };
+    const rule = new SecurityRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('SECURITY_REMOVED');
+  });
+
+  it('SECURITY_REMOVED triggers when an endpoint security requirement is removed', () => {
+    const diff: DiffSet = {
+      securityDiffs: [], componentDiffs: [], serverDiffs: [],
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['security', 'ApiKeyAuth'], changeType: 'removed', oldValue: 'ApiKeyAuth' }
+        ]}
+      ]
+    };
+    const rule = new SecurityRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('SECURITY_REMOVED');
+  });
+
+  it('SECURITY_SCHEME_TYPE_CHANGED triggers when scheme type changes', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [], componentDiffs: [], serverDiffs: [],
+      securityDiffs: [
+        { schemeId: 'MyAuth', changeType: 'changed', fieldChanges: [
+          { fieldPath: ['type'], changeType: 'changed', oldValue: 'http', newValue: 'oauth2' }
+        ] }
+      ]
+    };
+    const rule = new SecuritySchemeTypeChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('SECURITY_SCHEME_TYPE_CHANGED');
+  });
+
+  it('OAUTH_SCOPE_REMOVED triggers when a scope is removed', () => {
+    const diff: DiffSet = {
+      securityDiffs: [], componentDiffs: [], serverDiffs: [],
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['security', 'OAuth2', 'scopes', 'read:users'], changeType: 'removed', oldValue: 'read:users' }
+        ]}
+      ]
+    };
+    const rule = new OauthScopeRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('OAUTH_SCOPE_REMOVED');
+  });
+
+  it('SERVER_REMOVED triggers when a server is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [], componentDiffs: [], securityDiffs: [],
+      serverDiffs: [
+        { changeType: 'removed', oldServer: { url: 'https://api.example.com/v1', description: '' } }
+      ]
+    };
+    const rule = new ServerRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('SERVER_REMOVED');
+  });
+});

package/tests/rules/base.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { BaseRule } from '../../src/rules/base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../src/types/index.js';
+
+class MockRule extends BaseRule {
+  id = 'MOCK_RULE';
+  description = 'Mock';
+  severity = 'info' as const;
+  
+  apply(diff: DiffSet, ctx: RuleContext): SemanticChange[] {
+    return [];
+  }
+
+  testIsIgnored(path: string, ctx: RuleContext) {
+    return this.isIgnored(path, ctx);
+  }
+
+  testMakeChange(ctx: RuleContext) {
+    return this.makeChange({
+      severity: 'warning',
+      category: 'endpoint',
+      message: 'test',
+      consequence: 'test',
+      migration: 'test',
+      location: { type: 'endpoint', method: 'GET', path: '/' }
+    }, ctx);
+  }
+}
+
+describe('BaseRule', () => {
+  it('makes changes', () => {
+    const rule = new MockRule();
+    const ctx: RuleContext = { changes: [], config: { failOn: 'breaking', ignorePaths: [], ruleSeverityOverrides: {}, disabledRules: [], customRules: [], output: { format: 'terminal', color: true, summary: false, quiet: false } }, source: { old: null as any, new: null as any } };
+    const change = rule.testMakeChange(ctx);
+    expect(change.ruleId).toBe('MOCK_RULE');
+  });
+
+  it('checks ignored paths', () => {
+    const rule = new MockRule();
+    const ctx: RuleContext = { changes: [], config: { failOn: 'breaking', ignorePaths: ['/test/*'], ruleSeverityOverrides: {}, disabledRules: [], customRules: [], output: { format: 'terminal', color: true, summary: false, quiet: false } }, source: { old: null as any, new: null as any } };
+    expect(rule.testIsIgnored('/test/foo', ctx)).toBe(true);
+    expect(rule.testIsIgnored('/foo', ctx)).toBe(false);
+  });
+});

package/tests/rules/endpoint.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import { EndpointAddedRule } from '../../src/rules/endpoint/endpoint-added.js';
+import { EndpointRemovedRule } from '../../src/rules/endpoint/endpoint-removed.js';
+import { EndpointDeprecatedRule } from '../../src/rules/endpoint/endpoint-deprecated.js';
+import { HttpMethodChangedRule } from '../../src/rules/endpoint/http-method-changed.js';
+import { PathChangedRule } from '../../src/rules/endpoint/path-changed.js';
+import type { DiffSet, EndpointDiff, RuleContext } from '../../src/types/index.js';
+
+describe('Endpoint Rules', () => {
+  const context: RuleContext = {
+    config: { failOn: 'breaking', disabledRules: [], ignorePaths: [], output: { format: 'terminal' } },
+    oldSpec: { meta: { title: 'v1', version: '1.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+    newSpec: { meta: { title: 'v2', version: '2.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+  };
+
+  const dummyEndpoint = { id: 'GET:/test', path: '/test', method: 'GET' as const, summary: '', description: '', tags: [], deprecated: false, security: [], parameters: [], responses: [] };
+
+  it('ENDPOINT_ADDED triggers on added endpoint', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'added', endpointId: 'GET:/test', path: '/test', method: 'GET', newEndpoint: dummyEndpoint, fieldChanges: [] }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new EndpointAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('ENDPOINT_ADDED');
+    expect(changes[0].severity).toBe('info');
+  });
+
+  it('ENDPOINT_REMOVED triggers on removed endpoint', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'removed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, fieldChanges: [] }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new EndpointRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('ENDPOINT_REMOVED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('ENDPOINT_DEPRECATED triggers on deprecated change', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', 
+          endpointId: 'GET:/test', 
+          path: '/test', 
+          method: 'GET', 
+          oldEndpoint: dummyEndpoint, 
+          newEndpoint: { ...dummyEndpoint, deprecated: true }, 
+          fieldChanges: [
+            { fieldPath: ['deprecated'], changeType: 'changed', oldValue: false, newValue: true }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new EndpointDeprecatedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('ENDPOINT_DEPRECATED');
+    expect(changes[0].severity).toBe('warning');
+  });
+
+  it('HTTP_METHOD_CHANGED triggers on method change', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', 
+          endpointId: 'GET:/test', 
+          path: '/test', 
+          method: 'POST', 
+          oldEndpoint: dummyEndpoint, 
+          newEndpoint: { ...dummyEndpoint, method: 'POST' }, 
+          fieldChanges: [
+            { fieldPath: ['method'], changeType: 'changed', oldValue: 'GET', newValue: 'POST' }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new HttpMethodChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('HTTP_METHOD_CHANGED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PATH_CHANGED triggers on path string change', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', 
+          endpointId: 'GET:/test', 
+          path: '/test-renamed', 
+          method: 'GET', 
+          oldEndpoint: dummyEndpoint, 
+          newEndpoint: { ...dummyEndpoint, path: '/test-renamed' }, 
+          fieldChanges: [
+            { fieldPath: ['path'], changeType: 'changed', oldValue: '/test', newValue: '/test-renamed' }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new PathChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PATH_CHANGED');
+    expect(changes[0].severity).toBe('info');
+  });
+});