739 lines
21 KiB
TypeScript
739 lines
21 KiB
TypeScript
/**
|
|
* Agentic-Jujutsu Validation Tests
|
|
*
|
|
* Comprehensive validation suite for data integrity, security, and correctness.
|
|
*
|
|
* Test Coverage:
|
|
* - Data integrity verification
|
|
* - Cryptographic signature validation
|
|
* - Version history accuracy
|
|
* - Rollback functionality
|
|
* - Input validation (v2.3.1+)
|
|
* - Quantum fingerprint integrity
|
|
* - Cross-agent data consistency
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach } from '@jest/globals';
|
|
import * as crypto from 'crypto';
|
|
|
|
interface ValidationResult {
|
|
isValid: boolean;
|
|
errors: string[];
|
|
warnings: string[];
|
|
}
|
|
|
|
interface IntegrityCheck {
|
|
dataHash: string;
|
|
timestamp: number;
|
|
verified: boolean;
|
|
}
|
|
|
|
interface RollbackState {
|
|
commitId: string;
|
|
timestamp: number;
|
|
data: any;
|
|
}
|
|
|
|
// Mock validation utilities
|
|
class ValidationJjWrapper {
|
|
private commits: Map<string, any> = new Map();
|
|
private branches: Map<string, string> = new Map();
|
|
private trajectories: any[] = [];
|
|
private fingerprints: Map<string, Buffer> = new Map();
|
|
|
|
async newCommit(message: string, data?: any): Promise<string> {
|
|
const commitId = this.generateCommitId();
|
|
const commitData = {
|
|
id: commitId,
|
|
message,
|
|
data: data || {},
|
|
timestamp: Date.now(),
|
|
hash: this.calculateHash({ message, data, timestamp: Date.now() })
|
|
};
|
|
|
|
this.commits.set(commitId, commitData);
|
|
return commitId;
|
|
}
|
|
|
|
async getCommit(commitId: string): Promise<any | null> {
|
|
return this.commits.get(commitId) || null;
|
|
}
|
|
|
|
async verifyCommitIntegrity(commitId: string): Promise<ValidationResult> {
|
|
const commit = this.commits.get(commitId);
|
|
if (!commit) {
|
|
return {
|
|
isValid: false,
|
|
errors: ['Commit not found'],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
const recalculatedHash = this.calculateHash({
|
|
message: commit.message,
|
|
data: commit.data,
|
|
timestamp: commit.timestamp
|
|
});
|
|
|
|
const isValid = recalculatedHash === commit.hash;
|
|
|
|
return {
|
|
isValid,
|
|
errors: isValid ? [] : ['Hash mismatch - data may be corrupted'],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
async branchCreate(name: string, fromCommit?: string): Promise<void> {
|
|
const commitId = fromCommit || Array.from(this.commits.keys()).pop() || 'genesis';
|
|
this.branches.set(name, commitId);
|
|
}
|
|
|
|
async getBranchHead(name: string): Promise<string | null> {
|
|
return this.branches.get(name) || null;
|
|
}
|
|
|
|
async verifyBranchIntegrity(name: string): Promise<ValidationResult> {
|
|
const commitId = this.branches.get(name);
|
|
if (!commitId) {
|
|
return {
|
|
isValid: false,
|
|
errors: ['Branch not found'],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
const commit = this.commits.get(commitId);
|
|
if (!commit) {
|
|
return {
|
|
isValid: false,
|
|
errors: ['Branch points to non-existent commit'],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
return {
|
|
isValid: true,
|
|
errors: [],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
startTrajectory(task: string): string {
|
|
// Validate task according to v2.3.1 rules
|
|
if (!task || task.trim().length === 0) {
|
|
throw new Error('Validation error: task cannot be empty');
|
|
}
|
|
|
|
const trimmed = task.trim();
|
|
if (Buffer.byteLength(trimmed, 'utf8') > 10000) {
|
|
throw new Error('Validation error: task exceeds maximum length of 10KB');
|
|
}
|
|
|
|
const id = `traj-${Date.now()}`;
|
|
this.trajectories.push({
|
|
id,
|
|
task: trimmed,
|
|
operations: [],
|
|
context: {},
|
|
finalized: false
|
|
});
|
|
|
|
return id;
|
|
}
|
|
|
|
addToTrajectory(): void {
|
|
const current = this.trajectories[this.trajectories.length - 1];
|
|
if (current) {
|
|
current.operations.push({
|
|
type: 'operation',
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
}
|
|
|
|
finalizeTrajectory(score: number, critique?: string): void {
|
|
const current = this.trajectories[this.trajectories.length - 1];
|
|
|
|
if (!current) {
|
|
throw new Error('No active trajectory');
|
|
}
|
|
|
|
// Validate score
|
|
if (!Number.isFinite(score)) {
|
|
throw new Error('Validation error: score must be finite');
|
|
}
|
|
|
|
if (score < 0 || score > 1) {
|
|
throw new Error('Validation error: score must be between 0.0 and 1.0');
|
|
}
|
|
|
|
// Validate operations
|
|
if (current.operations.length === 0) {
|
|
throw new Error('Validation error: must have at least one operation before finalizing');
|
|
}
|
|
|
|
current.score = score;
|
|
current.critique = critique || '';
|
|
current.finalized = true;
|
|
}
|
|
|
|
setTrajectoryContext(key: string, value: string): void {
|
|
const current = this.trajectories[this.trajectories.length - 1];
|
|
if (!current) {
|
|
throw new Error('No active trajectory');
|
|
}
|
|
|
|
// Validate context key
|
|
if (!key || key.trim().length === 0) {
|
|
throw new Error('Validation error: context key cannot be empty');
|
|
}
|
|
|
|
if (Buffer.byteLength(key, 'utf8') > 1000) {
|
|
throw new Error('Validation error: context key exceeds maximum length of 1KB');
|
|
}
|
|
|
|
// Validate context value
|
|
if (Buffer.byteLength(value, 'utf8') > 10000) {
|
|
throw new Error('Validation error: context value exceeds maximum length of 10KB');
|
|
}
|
|
|
|
current.context[key] = value;
|
|
}
|
|
|
|
verifyTrajectoryIntegrity(trajectoryId: string): ValidationResult {
|
|
const trajectory = this.trajectories.find(t => t.id === trajectoryId);
|
|
|
|
if (!trajectory) {
|
|
return {
|
|
isValid: false,
|
|
errors: ['Trajectory not found'],
|
|
warnings: []
|
|
};
|
|
}
|
|
|
|
const errors: string[] = [];
|
|
const warnings: string[] = [];
|
|
|
|
// Check if finalized
|
|
if (!trajectory.finalized) {
|
|
warnings.push('Trajectory not finalized');
|
|
}
|
|
|
|
// Check score validity
|
|
if (trajectory.finalized) {
|
|
if (trajectory.score < 0 || trajectory.score > 1) {
|
|
errors.push('Invalid score value');
|
|
}
|
|
}
|
|
|
|
// Check operations
|
|
if (trajectory.operations.length === 0) {
|
|
errors.push('No operations recorded');
|
|
}
|
|
|
|
return {
|
|
isValid: errors.length === 0,
|
|
errors,
|
|
warnings
|
|
};
|
|
}
|
|
|
|
generateQuantumFingerprint(data: Buffer): Buffer {
|
|
// Simulate SHA3-512 (64 bytes)
|
|
const hash = crypto.createHash('sha512');
|
|
hash.update(data);
|
|
const fingerprint = hash.digest();
|
|
|
|
// Store for verification
|
|
const key = data.toString('hex');
|
|
this.fingerprints.set(key, fingerprint);
|
|
|
|
return fingerprint;
|
|
}
|
|
|
|
verifyQuantumFingerprint(data: Buffer, fingerprint: Buffer): boolean {
|
|
const hash = crypto.createHash('sha512');
|
|
hash.update(data);
|
|
const calculated = hash.digest();
|
|
|
|
return calculated.equals(fingerprint);
|
|
}
|
|
|
|
async createRollbackPoint(label: string): Promise<string> {
|
|
const state = {
|
|
commits: Array.from(this.commits.entries()),
|
|
branches: Array.from(this.branches.entries()),
|
|
trajectories: JSON.parse(JSON.stringify(this.trajectories))
|
|
};
|
|
|
|
const rollbackId = `rollback-${Date.now()}`;
|
|
const stateJson = JSON.stringify(state);
|
|
|
|
// Create commit for rollback point
|
|
await this.newCommit(`Rollback point: ${label}`, { state: stateJson });
|
|
|
|
return rollbackId;
|
|
}
|
|
|
|
async rollback(rollbackId: string): Promise<ValidationResult> {
|
|
// Simulate rollback
|
|
return {
|
|
isValid: true,
|
|
errors: [],
|
|
warnings: ['Rollback would reset state']
|
|
};
|
|
}
|
|
|
|
private generateCommitId(): string {
|
|
return crypto.randomBytes(20).toString('hex');
|
|
}
|
|
|
|
private calculateHash(data: any): string {
|
|
const json = JSON.stringify(data);
|
|
return crypto.createHash('sha256').update(json).digest('hex');
|
|
}
|
|
}
|
|
|
|
describe('Agentic-Jujutsu Validation Tests', () => {
|
|
let jj: ValidationJjWrapper;
|
|
|
|
beforeEach(() => {
|
|
jj = new ValidationJjWrapper();
|
|
});
|
|
|
|
describe('Data Integrity Verification', () => {
|
|
it('should verify commit data integrity', async () => {
|
|
const commitId = await jj.newCommit('Test commit', { content: 'test data' });
|
|
|
|
const validation = await jj.verifyCommitIntegrity(commitId);
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
expect(validation.errors).toHaveLength(0);
|
|
});
|
|
|
|
it('should detect corrupted commit data', async () => {
|
|
const commitId = await jj.newCommit('Test commit');
|
|
const commit = await jj.getCommit(commitId);
|
|
|
|
// Manually corrupt the commit
|
|
commit.data = 'corrupted';
|
|
|
|
const validation = await jj.verifyCommitIntegrity(commitId);
|
|
|
|
expect(validation.isValid).toBe(false);
|
|
expect(validation.errors.length).toBeGreaterThan(0);
|
|
expect(validation.errors[0]).toContain('Hash mismatch');
|
|
});
|
|
|
|
it('should verify branch integrity', async () => {
|
|
const commitId = await jj.newCommit('Test commit');
|
|
await jj.branchCreate('test-branch', commitId);
|
|
|
|
const validation = await jj.verifyBranchIntegrity('test-branch');
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
expect(validation.errors).toHaveLength(0);
|
|
});
|
|
|
|
it('should detect invalid branch references', async () => {
|
|
await jj.branchCreate('test-branch', 'non-existent-commit');
|
|
|
|
const validation = await jj.verifyBranchIntegrity('test-branch');
|
|
|
|
expect(validation.isValid).toBe(false);
|
|
expect(validation.errors).toContain('Branch points to non-existent commit');
|
|
});
|
|
|
|
it('should verify trajectory data integrity', async () => {
|
|
const trajectoryId = jj.startTrajectory('Test task');
|
|
jj.addToTrajectory();
|
|
jj.finalizeTrajectory(0.8, 'Test successful');
|
|
|
|
const validation = jj.verifyTrajectoryIntegrity(trajectoryId);
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
expect(validation.errors).toHaveLength(0);
|
|
});
|
|
|
|
it('should detect incomplete trajectories', async () => {
|
|
const trajectoryId = jj.startTrajectory('Incomplete task');
|
|
|
|
const validation = jj.verifyTrajectoryIntegrity(trajectoryId);
|
|
|
|
expect(validation.isValid).toBe(false);
|
|
expect(validation.warnings).toContain('Trajectory not finalized');
|
|
expect(validation.errors).toContain('No operations recorded');
|
|
});
|
|
});
|
|
|
|
describe('Input Validation (v2.3.1 Compliance)', () => {
|
|
describe('Task Description Validation', () => {
|
|
it('should reject empty task descriptions', () => {
|
|
expect(() => {
|
|
jj.startTrajectory('');
|
|
}).toThrow(/task cannot be empty/);
|
|
});
|
|
|
|
it('should reject whitespace-only task descriptions', () => {
|
|
expect(() => {
|
|
jj.startTrajectory(' ');
|
|
}).toThrow(/task cannot be empty/);
|
|
});
|
|
|
|
it('should accept and trim valid task descriptions', () => {
|
|
const trajectoryId = jj.startTrajectory(' Valid task ');
|
|
expect(trajectoryId).toBeTruthy();
|
|
});
|
|
|
|
it('should reject task descriptions exceeding 10KB', () => {
|
|
const largeTask = 'a'.repeat(10001);
|
|
|
|
expect(() => {
|
|
jj.startTrajectory(largeTask);
|
|
}).toThrow(/exceeds maximum length/);
|
|
});
|
|
|
|
it('should accept task descriptions at 10KB limit', () => {
|
|
const maxTask = 'a'.repeat(10000);
|
|
|
|
const trajectoryId = jj.startTrajectory(maxTask);
|
|
expect(trajectoryId).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe('Success Score Validation', () => {
|
|
beforeEach(() => {
|
|
jj.startTrajectory('Test task');
|
|
jj.addToTrajectory();
|
|
});
|
|
|
|
it('should accept valid scores (0.0 to 1.0)', () => {
|
|
expect(() => jj.finalizeTrajectory(0.0)).not.toThrow();
|
|
|
|
jj.startTrajectory('Test 2');
|
|
jj.addToTrajectory();
|
|
expect(() => jj.finalizeTrajectory(0.5)).not.toThrow();
|
|
|
|
jj.startTrajectory('Test 3');
|
|
jj.addToTrajectory();
|
|
expect(() => jj.finalizeTrajectory(1.0)).not.toThrow();
|
|
});
|
|
|
|
it('should reject scores below 0.0', () => {
|
|
expect(() => {
|
|
jj.finalizeTrajectory(-0.1);
|
|
}).toThrow(/score must be between/);
|
|
});
|
|
|
|
it('should reject scores above 1.0', () => {
|
|
expect(() => {
|
|
jj.finalizeTrajectory(1.1);
|
|
}).toThrow(/score must be between/);
|
|
});
|
|
|
|
it('should reject NaN scores', () => {
|
|
expect(() => {
|
|
jj.finalizeTrajectory(NaN);
|
|
}).toThrow(/score must be finite/);
|
|
});
|
|
|
|
it('should reject Infinity scores', () => {
|
|
expect(() => {
|
|
jj.finalizeTrajectory(Infinity);
|
|
}).toThrow(/score must be finite/);
|
|
});
|
|
});
|
|
|
|
describe('Operations Validation', () => {
|
|
it('should require operations before finalizing', () => {
|
|
jj.startTrajectory('Task without operations');
|
|
|
|
expect(() => {
|
|
jj.finalizeTrajectory(0.8);
|
|
}).toThrow(/must have at least one operation/);
|
|
});
|
|
|
|
it('should allow finalizing with operations', () => {
|
|
jj.startTrajectory('Task with operations');
|
|
jj.addToTrajectory();
|
|
|
|
expect(() => {
|
|
jj.finalizeTrajectory(0.8);
|
|
}).not.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('Context Validation', () => {
|
|
beforeEach(() => {
|
|
jj.startTrajectory('Test task');
|
|
});
|
|
|
|
it('should reject empty context keys', () => {
|
|
expect(() => {
|
|
jj.setTrajectoryContext('', 'value');
|
|
}).toThrow(/context key cannot be empty/);
|
|
});
|
|
|
|
it('should reject whitespace-only context keys', () => {
|
|
expect(() => {
|
|
jj.setTrajectoryContext(' ', 'value');
|
|
}).toThrow(/context key cannot be empty/);
|
|
});
|
|
|
|
it('should reject context keys exceeding 1KB', () => {
|
|
const largeKey = 'k'.repeat(1001);
|
|
|
|
expect(() => {
|
|
jj.setTrajectoryContext(largeKey, 'value');
|
|
}).toThrow(/context key exceeds/);
|
|
});
|
|
|
|
it('should reject context values exceeding 10KB', () => {
|
|
const largeValue = 'v'.repeat(10001);
|
|
|
|
expect(() => {
|
|
jj.setTrajectoryContext('key', largeValue);
|
|
}).toThrow(/context value exceeds/);
|
|
});
|
|
|
|
it('should accept valid context entries', () => {
|
|
expect(() => {
|
|
jj.setTrajectoryContext('environment', 'production');
|
|
jj.setTrajectoryContext('version', '1.0.0');
|
|
}).not.toThrow();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Cryptographic Signature Validation', () => {
|
|
it('should generate quantum-resistant fingerprints', () => {
|
|
const data = Buffer.from('test data');
|
|
|
|
const fingerprint = jj.generateQuantumFingerprint(data);
|
|
|
|
expect(fingerprint).toBeInstanceOf(Buffer);
|
|
expect(fingerprint.length).toBe(64); // SHA3-512 = 64 bytes
|
|
});
|
|
|
|
it('should verify valid quantum fingerprints', () => {
|
|
const data = Buffer.from('test data');
|
|
const fingerprint = jj.generateQuantumFingerprint(data);
|
|
|
|
const isValid = jj.verifyQuantumFingerprint(data, fingerprint);
|
|
|
|
expect(isValid).toBe(true);
|
|
});
|
|
|
|
it('should reject invalid quantum fingerprints', () => {
|
|
const data = Buffer.from('test data');
|
|
const wrongData = Buffer.from('wrong data');
|
|
const fingerprint = jj.generateQuantumFingerprint(data);
|
|
|
|
const isValid = jj.verifyQuantumFingerprint(wrongData, fingerprint);
|
|
|
|
expect(isValid).toBe(false);
|
|
});
|
|
|
|
it('should detect tampered fingerprints', () => {
|
|
const data = Buffer.from('test data');
|
|
const fingerprint = jj.generateQuantumFingerprint(data);
|
|
|
|
// Tamper with fingerprint
|
|
fingerprint[0] ^= 0xFF;
|
|
|
|
const isValid = jj.verifyQuantumFingerprint(data, fingerprint);
|
|
|
|
expect(isValid).toBe(false);
|
|
});
|
|
|
|
it('should generate unique fingerprints for different data', () => {
|
|
const data1 = Buffer.from('data 1');
|
|
const data2 = Buffer.from('data 2');
|
|
|
|
const fp1 = jj.generateQuantumFingerprint(data1);
|
|
const fp2 = jj.generateQuantumFingerprint(data2);
|
|
|
|
expect(fp1.equals(fp2)).toBe(false);
|
|
});
|
|
|
|
it('should generate consistent fingerprints for same data', () => {
|
|
const data = Buffer.from('consistent data');
|
|
|
|
const fp1 = jj.generateQuantumFingerprint(data);
|
|
const fp2 = jj.generateQuantumFingerprint(data);
|
|
|
|
expect(fp1.equals(fp2)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Version History Accuracy', () => {
|
|
it('should maintain accurate commit history', async () => {
|
|
const commit1 = await jj.newCommit('First commit');
|
|
const commit2 = await jj.newCommit('Second commit');
|
|
const commit3 = await jj.newCommit('Third commit');
|
|
|
|
const c1 = await jj.getCommit(commit1);
|
|
const c2 = await jj.getCommit(commit2);
|
|
const c3 = await jj.getCommit(commit3);
|
|
|
|
expect(c1?.message).toBe('First commit');
|
|
expect(c2?.message).toBe('Second commit');
|
|
expect(c3?.message).toBe('Third commit');
|
|
|
|
expect(c1?.timestamp).toBeLessThan(c2?.timestamp);
|
|
expect(c2?.timestamp).toBeLessThan(c3?.timestamp);
|
|
});
|
|
|
|
it('should maintain branch references accurately', async () => {
|
|
const mainCommit = await jj.newCommit('Main commit');
|
|
await jj.branchCreate('main', mainCommit);
|
|
|
|
const featureCommit = await jj.newCommit('Feature commit');
|
|
await jj.branchCreate('feature', featureCommit);
|
|
|
|
const mainHead = await jj.getBranchHead('main');
|
|
const featureHead = await jj.getBranchHead('feature');
|
|
|
|
expect(mainHead).toBe(mainCommit);
|
|
expect(featureHead).toBe(featureCommit);
|
|
});
|
|
|
|
it('should maintain trajectory history accurately', () => {
|
|
const traj1 = jj.startTrajectory('Task 1');
|
|
jj.addToTrajectory();
|
|
jj.finalizeTrajectory(0.8);
|
|
|
|
const traj2 = jj.startTrajectory('Task 2');
|
|
jj.addToTrajectory();
|
|
jj.finalizeTrajectory(0.9);
|
|
|
|
const v1 = jj.verifyTrajectoryIntegrity(traj1);
|
|
const v2 = jj.verifyTrajectoryIntegrity(traj2);
|
|
|
|
expect(v1.isValid).toBe(true);
|
|
expect(v2.isValid).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Rollback Functionality', () => {
|
|
it('should create rollback points', async () => {
|
|
await jj.newCommit('Before rollback');
|
|
|
|
const rollbackId = await jj.createRollbackPoint('Safe state');
|
|
|
|
expect(rollbackId).toBeTruthy();
|
|
expect(typeof rollbackId).toBe('string');
|
|
});
|
|
|
|
it('should rollback to previous state', async () => {
|
|
await jj.newCommit('Commit 1');
|
|
const rollbackId = await jj.createRollbackPoint('Checkpoint');
|
|
await jj.newCommit('Commit 2');
|
|
|
|
const result = await jj.rollback(rollbackId);
|
|
|
|
expect(result.isValid).toBe(true);
|
|
expect(result.warnings).toContain('Rollback would reset state');
|
|
});
|
|
|
|
it('should maintain data integrity after rollback', async () => {
|
|
const commit1 = await jj.newCommit('Original commit');
|
|
const rollbackId = await jj.createRollbackPoint('Original state');
|
|
|
|
await jj.rollback(rollbackId);
|
|
|
|
// Verify original commit still valid
|
|
const validation = await jj.verifyCommitIntegrity(commit1);
|
|
expect(validation.isValid).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Cross-Agent Data Consistency', () => {
|
|
it('should maintain consistency across multiple agents', async () => {
|
|
const agents = [
|
|
new ValidationJjWrapper(),
|
|
new ValidationJjWrapper(),
|
|
new ValidationJjWrapper()
|
|
];
|
|
|
|
// Each agent creates commits
|
|
const commits = await Promise.all(
|
|
agents.map((agent, idx) =>
|
|
agent.newCommit(`Agent ${idx} commit`)
|
|
)
|
|
);
|
|
|
|
// Verify all commits are valid
|
|
const validations = await Promise.all(
|
|
agents.map((agent, idx) =>
|
|
agent.verifyCommitIntegrity(commits[idx])
|
|
)
|
|
);
|
|
|
|
expect(validations.every(v => v.isValid)).toBe(true);
|
|
});
|
|
|
|
it('should detect inconsistencies in shared state', async () => {
|
|
const agent1 = new ValidationJjWrapper();
|
|
const agent2 = new ValidationJjWrapper();
|
|
|
|
// Agent 1 creates branch
|
|
const commit1 = await agent1.newCommit('Shared commit');
|
|
await agent1.branchCreate('shared-branch', commit1);
|
|
|
|
// Agent 2 tries to reference same branch
|
|
const validation = await agent2.verifyBranchIntegrity('shared-branch');
|
|
|
|
// Should detect branch doesn't exist in agent2's context
|
|
expect(validation.isValid).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('Edge Cases and Boundary Conditions', () => {
|
|
it('should handle empty commits gracefully', async () => {
|
|
const commitId = await jj.newCommit('');
|
|
const validation = await jj.verifyCommitIntegrity(commitId);
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
});
|
|
|
|
it('should handle very long commit messages', async () => {
|
|
const longMessage = 'x'.repeat(10000);
|
|
const commitId = await jj.newCommit(longMessage);
|
|
const validation = await jj.verifyCommitIntegrity(commitId);
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
});
|
|
|
|
it('should handle special characters in data', async () => {
|
|
const specialData = {
|
|
unicode: '你好世界 🚀',
|
|
special: '<>&"\'',
|
|
escape: '\\n\\t\\r'
|
|
};
|
|
|
|
const commitId = await jj.newCommit('Special chars', specialData);
|
|
const validation = await jj.verifyCommitIntegrity(commitId);
|
|
|
|
expect(validation.isValid).toBe(true);
|
|
});
|
|
|
|
it('should handle concurrent validation requests', async () => {
|
|
const commit1 = await jj.newCommit('Commit 1');
|
|
const commit2 = await jj.newCommit('Commit 2');
|
|
const commit3 = await jj.newCommit('Commit 3');
|
|
|
|
const validations = await Promise.all([
|
|
jj.verifyCommitIntegrity(commit1),
|
|
jj.verifyCommitIntegrity(commit2),
|
|
jj.verifyCommitIntegrity(commit3)
|
|
]);
|
|
|
|
expect(validations.every(v => v.isValid)).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
export { ValidationJjWrapper, ValidationResult };
|