@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/test/channel-agent-multi-dialogue.js

@@ -0,0 +1,205 @@
+/**
+ * Channel Agent Multi-Turn Dialogue Test
+ *
+ * 测试场景：
+ * 1. 两个 Channel Agent (Alice/Bob) 之间的多轮对话
+ * 2. 基于判断力的 Harness 调用 (Gate 1-8)
+ * 3. 上下文感知的 Gate 选择
+ * 4. Persona 设计能力
+ *
+ * 运行: npx tsx src/test/channel-agent-multi-dialogue.ts
+ */
+import { config } from 'dotenv';
+import { createChannelAgent, ChannelAgentRegistry } from '../social/channels/channel-agent-session.js';
+config();
+const PORT_ALICE = 8001;
+const PORT_BOB = 8002;
+async function testMultiTurnDialogue() {
+    console.log('\n========================================');
+    console.log('  Channel Agent 多轮对话测试');
+    console.log('  场景: 完成一个用户认证系统的需求讨论');
+    console.log('========================================\n');
+    // 创建 Agent 注册表
+    const registry = new ChannelAgentRegistry();
+    // 创建 Alice
+    const alice = createChannelAgent({
+        name: 'Alice',
+        port: PORT_ALICE,
+        domain: '架构',
+        capabilities: ['架构设计', '代码审查', '任务分解']
+    });
+    // 创建 Bob
+    const bob = createChannelAgent({
+        name: 'Bob',
+        port: PORT_BOB,
+        domain: '开发',
+        capabilities: ['代码编写', '调试', '测试']
+    });
+    // 注册
+    registry.register(alice);
+    registry.register(bob);
+    // 设计 persona
+    alice.designPersona({
+        name: 'Alice',
+        type: 'developer',
+        domain: '架构',
+        tone: 'professional'
+    });
+    bob.designPersona({
+        name: 'Bob',
+        type: 'developer',
+        domain: '开发',
+        tone: 'technical'
+    });
+    // 启动
+    await alice.start();
+    await bob.start();
+    // 对话脚本
+    const script = [
+        // 第1轮 - 架构讨论
+        { from: 'Alice', to: 'Bob', content: 'Bob，我们需要设计一个新的用户认证系统。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，具体需要哪些功能？', expectHarness: false },
+        // 第2轮 - 需求讨论
+        { from: 'Alice', to: 'Bob', content: '需要登录、注册、找回密码，还要支持社交登录。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '明白了。这个系统需要什么级别的安全性？', expectHarness: false },
+        // 第3轮 - 安全讨论 → Gate 4
+        { from: 'Alice', to: 'Bob', content: '需要处理金融数据，所以安全性很重要。请检查一下架构设计。', expectHarness: true, expectGate: 4 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来分析一下架构设计，看看有没有安全风险。', expectHarness: true, expectGate: 1 },
+        // 第4轮 - 代码审查 → Gate 2
+        { from: 'Alice', to: 'Bob', content: '架构看起来不错。帮我 review 一下登录模块的实现。', expectHarness: true, expectGate: 2 },
+        { from: 'Bob', to: 'Alice', content: '好的，让我检查登录模块的代码实现。', expectHarness: true, expectGate: 2 },
+        // 第5轮 - 优化讨论
+        { from: 'Alice', to: 'Bob', content: '代码审查发现了一些问题，需要优化错误处理。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '同意，错误处理需要改进。', expectHarness: false },
+        // 第6轮 - 任务分解 → Gate 5
+        { from: 'Alice', to: 'Bob', content: '好的，现在我们来分解任务，制定开发计划。', expectHarness: true, expectGate: 5 },
+        { from: 'Bob', to: 'Alice', content: '我来帮你把任务分解成可执行的小块。', expectHarness: true, expectGate: 5 },
+        // 第7轮 - 开始实现
+        { from: 'Alice', to: 'Bob', content: '任务分解得很好。我们开始实现第一个任务吧。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，开始实现登录模块。', expectHarness: false },
+        // 第8轮 - 代码实现 → Gate 7
+        { from: 'Alice', to: 'Bob', content: '实现完成，帮我优化一下代码质量。', expectHarness: true, expectGate: 7 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来进行代码优化。', expectHarness: true, expectGate: 7 },
+        // 第9轮 - 测试验证 → Gate 8
+        { from: 'Alice', to: 'Bob', content: '代码优化完成，帮我验证一下质量。', expectHarness: true, expectGate: 8 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来运行测试验证。', expectHarness: true, expectGate: 8 },
+        // 第10轮 - 完成
+        { from: 'Alice', to: 'Bob', content: '测试通过了！继续下一个任务。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '太好了！继续加油。', expectHarness: false },
+    ];
+    console.log('━━━ 开始多轮对话 ━━━\n');
+    let harnessCallCount = 0;
+    const gateStats = new Map();
+    for (let i = 0; i < script.length; i++) {
+        const { from, to, content, expectHarness, expectGate } = script[i];
+        const targetPort = from === 'Alice' ? PORT_BOB : PORT_ALICE;
+        console.log(`━━━ 第 ${Math.floor(i / 2) + 1} 轮 ━━━`);
+        console.log(`[${from}] >>> ${content}`);
+        try {
+            const resp = await fetch(`http://localhost:${targetPort}/receive`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fromName: from, content })
+            });
+            const result = await resp.json();
+            console.log(`\n[${to}] 处理结果:`);
+            if (result.harnessCalled) {
+                console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+                console.log(`   📋 Skills: ${result.skills?.join(', ') || '无'}`);
+                harnessCallCount++;
+                gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+                if (expectHarness && result.gate !== expectGate) {
+                    console.log(`   ⚠️ 期望 Gate ${expectGate}，实际 ${result.gate}`);
+                }
+            }
+            else {
+                console.log(`   🧠 普通对话 (无需 Harness)`);
+            }
+            console.log(`   📤 回复: ${result.response?.substring(0, 80)}...`);
+            // 等待一下再继续
+            await new Promise(r => setTimeout(r, 300));
+        }
+        catch (err) {
+            console.log(`   ❌ 发送失败:`, err);
+        }
+        console.log('');
+    }
+    // 结果汇总
+    console.log('━━━ 结果汇总 ━━━\n');
+    console.log(`[Alice] 对话数: ${alice.getDialogHistory().length}`);
+    console.log(`[Bob] 对话数: ${bob.getDialogHistory().length}`);
+    console.log(`\nHarness 调用次数: ${harnessCallCount}`);
+    console.log('\nGate 统计:');
+    for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+        const gateNames = {
+            1: '架构设计',
+            2: '代码审查',
+            4: '安全检查',
+            5: '任务分解',
+            7: '代码实现',
+            8: '测试验证'
+        };
+        console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+    }
+    // 健康检查
+    console.log('\n━━━ 最终状态 ━━━\n');
+    const aliceHealth = await fetch(`http://localhost:${PORT_ALICE}/health`).then(r => r.json());
+    const bobHealth = await fetch(`http://localhost:${PORT_BOB}/health`).then(r => r.json());
+    console.log(`[Alice] DID: ${aliceHealth.id.substring(0, 16)}...`);
+    console.log(`[Bob]   DID: ${bobHealth.id.substring(0, 16)}...`);
+    console.log(`\n对话总数: ${aliceHealth.dialogCount + bobHealth.dialogCount}`);
+    console.log(`Harness 调用: ${harnessCallCount} 次`);
+    const success = harnessCallCount >= 6;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+    // 清理
+    registry.clear();
+    console.log('\n========================================\n');
+    return success;
+}
+async function testPersonaDesign() {
+    console.log('\n========================================');
+    console.log('  Persona 设计测试');
+    console.log('========================================\n');
+    const agent = createChannelAgent({
+        name: 'TestAgent',
+        port: 8010,
+        domain: '通用'
+    });
+    await agent.start();
+    // 设计不同类型的 persona
+    const personaTypes = [
+        { name: 'ArchMaster', type: 'developer', domain: '架构', tone: 'professional' },
+        { name: 'CodeReviewer', type: 'reviewer', domain: '安全', tone: 'formal' },
+        { name: 'TaskManager', type: 'manager', domain: '项目管理', tone: 'professional' },
+        { name: 'CreativeDesigner', type: 'designer', domain: '设计', tone: 'casual' }
+    ];
+    console.log('━━━ 设计 Persona ━━━\n');
+    for (const request of personaTypes) {
+        const persona = agent.designPersona(request);
+        console.log(`设计 ${request.type} persona:`);
+        console.log(`  名称: ${persona.name}`);
+        console.log(`  描述: ${persona.description}`);
+        console.log(`  性格: ${persona.personality}`);
+        console.log(`  能力: ${persona.capabilities.join(', ')}`);
+        console.log(`  兴趣: ${persona.interests.join(', ')}`);
+        console.log('');
+    }
+    // 获取当前 persona
+    const currentPersona = agent.getPersona();
+    console.log('当前 Persona:');
+    console.log(JSON.stringify(currentPersona, null, 2));
+    agent.shutdown();
+    console.log('\n========================================\n');
+}
+async function main() {
+    try {
+        await testMultiTurnDialogue();
+        await testPersonaDesign();
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/channel-heartbeat-agent-test.js

@@ -0,0 +1,201 @@
+/**
+ * Channel Heartbeat Agent Test
+ *
+ * 测试场景：
+ * 1. Heartbeat Agent 自动发现和解析 DiapDoc
+ * 2. 自动心跳发布 persona 到 IPFS
+ * 3. 基于判断力的 Harness 调用
+ * 4. 多智能体自动对话
+ *
+ * 运行: npx tsx src/test/channel-heartbeat-agent-test.ts
+ */
+import { config } from 'dotenv';
+import { createHeartbeatAgent, HeartbeatAgentRegistry } from '../social/channels/channel-heartbeat-agent.js';
+import { createDiapDocParser } from '../social/channels/diap-doc-parser.js';
+config();
+const PORT_ALICE = 9001;
+const PORT_BOB = 9002;
+async function testDiapDocParser() {
+    console.log('\n========================================');
+    console.log('  DiapDoc Parser 测试');
+    console.log('========================================\n');
+    const parser = createDiapDocParser();
+    // 测试标准 DiapDoc
+    const standardDoc = {
+        id: 'did:key:z6MkhaXqE2qVYVJ5V5Z7Z8Z9Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9Z0Z',
+        name: 'TestAgent',
+        version: '1.0',
+        capabilities: ['对话', '分析', '协作'],
+        interests: ['AI', '编程'],
+        peerId: 'QmTestPeer123',
+        channels: [
+            { id: 'ch_001', name: 'AI Discussion', topic: 'AI技术讨论' },
+            { id: 'ch_002', name: 'Coding Help', topic: '编程帮助' }
+        ]
+    };
+    const result = parser.parse(JSON.stringify(standardDoc));
+    if (result.success && result.doc) {
+        console.log('✅ 解析成功');
+        console.log(`  ID: ${result.doc.id}`);
+        console.log(`  Name: ${result.doc.name}`);
+        console.log(`  Capabilities: ${result.doc.capabilities.join(', ')}`);
+        console.log(`  Channels: ${result.doc.channels?.map(c => c.name).join(', ')}`);
+    }
+    else {
+        console.log('❌ 解析失败:', result.error);
+    }
+    // 测试兼容性格式
+    const compatDoc = {
+        did: 'did:key:zCompatibleDoc',
+        name: 'CompatibleAgent',
+        capability: ['代码审查', '架构设计'],
+        interest: ['软件开发'],
+        peer_id: 'QmCompatPeer',
+        channel: [
+            { channelId: 'ch_comp_001', channelName: 'Dev Chat' }
+        ]
+    };
+    const compatResult = parser.parse(JSON.stringify(compatDoc));
+    if (compatResult.success && compatResult.doc) {
+        console.log('\n✅ 兼容性格式解析成功');
+        console.log(`  ID: ${compatResult.doc.id}`);
+        console.log(`  Capabilities: ${compatResult.doc.capabilities.join(', ')}`);
+    }
+    else {
+        console.log('\n❌ 兼容性解析失败:', compatResult.error);
+    }
+    console.log('\n========================================\n');
+}
+async function testHeartbeatAgent() {
+    console.log('\n========================================');
+    console.log('  Heartbeat Agent 测试');
+    console.log('========================================\n');
+    const registry = new HeartbeatAgentRegistry();
+    // 创建 Alice
+    const alice = createHeartbeatAgent({
+        name: 'Alice',
+        port: PORT_ALICE,
+        autoDiscovery: true,
+        autoDialogue: false,
+        capabilities: ['架构设计', '代码审查']
+    });
+    // 创建 Bob
+    const bob = createHeartbeatAgent({
+        name: 'Bob',
+        port: PORT_BOB,
+        autoDiscovery: true,
+        autoDialogue: false,
+        capabilities: ['代码编写', '调试']
+    });
+    // 注册
+    registry.register(alice);
+    registry.register(bob);
+    // 启动
+    await alice.start();
+    await bob.start();
+    console.log('━━━ 模拟发现流程 ━━━\n');
+    // 模拟 Alice 发现 Bob
+    const announcement = {
+        leaderDid: bob.getDid(),
+        channelName: 'Bob 的频道',
+        channelId: 'ch_bob_001',
+        topic: '开发协作',
+        capabilities: ['代码编写', '调试'],
+        interests: ['编程', '架构']
+    };
+    alice.handleChannelAnnouncement(announcement);
+    console.log(`[Alice] 发现 Bob，存储到已发现列表`);
+    // 获取 Bob 的信息
+    const alicePeers = alice.getDiscoveredPeers();
+    console.log(`\n[Alice] 已发现 ${alicePeers.length} 个对等节点:`);
+    for (const peer of alicePeers) {
+        console.log(`  - ${peer.name} (${peer.did.substring(0, 20)}...)`);
+        console.log(`    Capabilities: ${peer.capabilities.join(', ')}`);
+    }
+    // 测试对话
+    console.log('\n━━━ 对话测试 ━━━\n');
+    const dialogueScript = [
+        { from: 'Alice', to: 'Bob', content: 'Bob，我们设计一个新的用户认证系统。' },
+        { from: 'Bob', to: 'Alice', content: '好的，需要哪些功能？' },
+        { from: 'Alice', to: 'Bob', content: '登录、注册、找回密码，还要支持社交登录。' },
+        { from: 'Bob', to: 'Alice', content: '明白了。安全性要求高吗？' },
+        { from: 'Alice', to: 'Bob', content: '需要处理金融数据，安全很重要。帮我分析一下架构设计。' },
+        { from: 'Bob', to: 'Alice', content: '好的，我来检查架构设计。' },
+        { from: 'Alice', to: 'Bob', content: '架构不错。帮我 review 代码。' },
+        { from: 'Bob', to: 'Alice', content: '代码审查完成，需要优化错误处理。' },
+        { from: 'Alice', to: 'Bob', content: '好的，现在分解任务。' },
+        { from: 'Bob', to: 'Alice', content: '任务已分解为 4 个子任务。' }
+    ];
+    let harnessCallCount = 0;
+    const gateStats = new Map();
+    for (let i = 0; i < dialogueScript.length; i++) {
+        const { from, to, content } = dialogueScript[i];
+        const targetAgent = from === 'Alice' ? bob : alice;
+        console.log(`[${from}] >>> ${content}`);
+        const result = await targetAgent.handleMessage(from === 'Alice' ? alice.getDid() : bob.getDid(), from, content);
+        console.log(`[${to}] 处理结果:`);
+        if (result.harnessCalled) {
+            console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+            harnessCallCount++;
+            gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+        }
+        else {
+            console.log(`   🧠 普通回复`);
+        }
+        console.log(`   📤 ${result.response.substring(0, 60)}...`);
+        console.log('');
+        await new Promise(r => setTimeout(r, 200));
+    }
+    // 结果汇总
+    console.log('━━━ 结果汇总 ━━━\n');
+    console.log(`Harness 调用次数: ${harnessCallCount}`);
+    console.log('\nGate 统计:');
+    for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+        const gateNames = {
+            1: '架构设计', 2: '代码审查', 4: '安全检查',
+            5: '任务分解', 7: '代码实现', 8: '测试验证'
+        };
+        console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+    }
+    const success = harnessCallCount >= 3;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+    // 清理
+    registry.clear();
+    console.log('\n========================================\n');
+    return success;
+}
+async function testAutoHeartbeat() {
+    console.log('\n========================================');
+    console.log('  自动心跳测试');
+    console.log('========================================\n');
+    const agent = createHeartbeatAgent({
+        name: 'AutoHeartbeatTest',
+        port: 9010,
+        autoDiscovery: true,
+        autoDialogue: false
+    });
+    await agent.start();
+    console.log(`[${agent.getName()}] 已启动`);
+    console.log(`  DID: ${agent.getDid()}`);
+    console.log(`  CID: ${agent.getOwnCID() || 'N/A'}`);
+    // 等待几个心跳周期
+    console.log('\n等待自动心跳...');
+    await new Promise(r => setTimeout(r, 5000));
+    const peers = agent.getDiscoveredPeers();
+    console.log(`\n发现的对等节点: ${peers.length}`);
+    agent.stop();
+    console.log('\n========================================\n');
+}
+async function main() {
+    try {
+        await testDiapDocParser();
+        await testHeartbeatAgent();
+        await testAutoHeartbeat();
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/constraint-layer.test.js

@@ -0,0 +1,164 @@
+/**
+ * ConstraintLayer Tests
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ConstraintLayer, AUTONOMOUS_ACTIONS, CONFIRM_REQUIRED_ACTIONS } from '../agents/constraint-layer.js';
+describe('ConstraintLayer', () => {
+    let layer;
+    beforeEach(() => {
+        layer = new ConstraintLayer();
+    });
+    describe('checkGuardrails', () => {
+        it('should pass when no guardrails fail', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(true);
+            expect(result.blocked).toBeUndefined();
+        });
+        it('should block send to unknown peer', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const step = {
+                id: 'send',
+                type: 'send',
+                config: { peerId: 'unknown-peer' },
+                retry: { max: 0, current: 0, backoffMs: 0 },
+                onFail: 'block'
+            };
+            const result = await layer.checkGuardrails(context, step);
+            expect(result.passed).toBe(false);
+            expect(result.blocked?.name).toBe('validateSendTarget');
+        });
+        it('should allow send to known peer', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const step = {
+                id: 'send',
+                type: 'send',
+                config: { peerId: 'peer1' },
+                retry: { max: 0, current: 0, backoffMs: 0 },
+                onFail: 'block'
+            };
+            const result = await layer.checkGuardrails(context, step);
+            expect(result.passed).toBe(true);
+        });
+        it('should warn for low quality summary', async () => {
+            const context = {
+                peers: [],
+                logs: [],
+                qualityScore: 0.3
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(false);
+            expect(result.blocked?.name).toBe('validateSummaryQuality');
+        });
+        it('should pass for acceptable quality summary', async () => {
+            const context = {
+                peers: [],
+                logs: [],
+                qualityScore: 0.7
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(true);
+        });
+    });
+    describe('isAutonomousAction', () => {
+        it('should identify autonomous actions', () => {
+            expect(layer.isAutonomousAction('summarize')).toBe(true);
+            expect(layer.isAutonomousAction('chunk')).toBe(true);
+            expect(layer.isAutonomousAction('improve')).toBe(true);
+        });
+        it('should return false for non-autonomous actions', () => {
+            expect(layer.isAutonomousAction('send')).toBe(false);
+            expect(layer.isAutonomousAction('delete')).toBe(false);
+        });
+    });
+    describe('requiresConfirmation', () => {
+        it('should identify confirmation-required actions', () => {
+            expect(layer.requiresConfirmation('send')).toBe(true);
+            expect(layer.requiresConfirmation('delete')).toBe(true);
+        });
+        it('should return false for non-confirmation-required actions', () => {
+            expect(layer.requiresConfirmation('summarize')).toBe(false);
+            expect(layer.requiresConfirmation('chunk')).toBe(false);
+        });
+    });
+    describe('logging', () => {
+        it('should record operations', () => {
+            layer.log('test action', { key: 'value' }, 'success');
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(1);
+            expect(logs[0].action).toBe('test action');
+            expect(logs[0].status).toBe('success');
+            expect(logs[0].details).toEqual({ key: 'value' });
+        });
+        it('should record multiple operations', () => {
+            layer.log('action1', {}, 'success');
+            layer.log('action2', { data: 123 }, 'warn');
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(2);
+        });
+        it('should clear logs', () => {
+            layer.log('action1', {}, 'success');
+            layer.log('action2', {}, 'failed');
+            layer.clearLogs();
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(0);
+        });
+        it('should track timestamp for logs', () => {
+            const before = Date.now();
+            layer.log('test', {}, 'success');
+            const after = Date.now();
+            const logs = layer.getLogs();
+            expect(logs[0].timestamp).toBeGreaterThanOrEqual(before);
+            expect(logs[0].timestamp).toBeLessThanOrEqual(after);
+        });
+    });
+    describe('registerRule', () => {
+        it('should register new rules', () => {
+            const rule = {
+                id: 'custom-rule',
+                description: 'Custom rule',
+                guardrails: [{
+                        name: 'customGuard',
+                        check: async () => true
+                    }]
+            };
+            layer.registerRule(rule);
+            expect(layer.getRuleIds()).toContain('custom-rule');
+        });
+        it('should unregister rules', () => {
+            const rule = {
+                id: 'temp-rule',
+                description: 'Temporary rule',
+                guardrails: [{
+                        name: 'tempGuard',
+                        check: async () => true
+                    }]
+            };
+            layer.registerRule(rule);
+            expect(layer.unregisterRule('temp-rule')).toBe(true);
+            expect(layer.getRuleIds()).not.toContain('temp-rule');
+        });
+    });
+    describe('AUTONOMOUS_ACTIONS constant', () => {
+        it('should contain expected actions', () => {
+            expect(AUTONOMOUS_ACTIONS).toContain('summarize');
+            expect(AUTONOMOUS_ACTIONS).toContain('chunk');
+            expect(AUTONOMOUS_ACTIONS).toContain('improve');
+        });
+    });
+    describe('CONFIRM_REQUIRED_ACTIONS constant', () => {
+        it('should contain expected actions', () => {
+            expect(CONFIRM_REQUIRED_ACTIONS).toContain('send');
+            expect(CONFIRM_REQUIRED_ACTIONS).toContain('delete');
+        });
+    });
+});