@tellescope/sdk 2.0.0-beta.2 → 2.0.0-beta.3

package/lib/esm/tests/api_tests/message_assignment_trigger.test.js

@@ -35,321 +35,272 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { log_header, wait, } from "@tellescope/testing";
-import { setup_tests } from "../setup";
+import { poll_for_results, wait, } from "@tellescope/testing";
+import { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
+var host = process.env.API_URL || 'http://localhost:8080';
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
 /**
- * Tests for the "Assign to Incoming Message" trigger action
- * Verifies assignment works for all incoming message types: Email, SMS, and ChatRoom
+ * Tests for the "Assign to Incoming Message" trigger action.
+ * Verifies assignment works for all incoming message types: Email, SMS, and ChatRoom.
+ *
+ * Runs on its own provisioned tenant, which is not optional here: the three triggers this installs
+ * are filtered by channel and nothing else, so on the shared organization every inbound email, SMS
+ * and chat created by any concurrently running suite was auto-assigned to this suite's user for as
+ * long as this suite ran. It never calls `sdk.reset_db()`, which clears throttle namespaces shared
+ * with other suites.
+ *
+ * Each case uses its own patient — triggers are throttled to one fire per trigger per enduser per
+ * minute — and the `wait` after each write is the trigger-processing barrier. The three positive
+ * cases then poll, which returns immediately once the assignment is visible, so a slow API reports
+ * a real failure rather than a timing one. The outbound-exclusion case is read once: polling a
+ * "must not happen" check only delays it.
+ *
+ * No records are deleted individually; the tenant teardown in the `finally` removes every record it
+ * owns, and nothing outside the tenant can see them in the meantime.
  */
-export var message_assignment_trigger_tests = function (_a) {
-    var sdk = _a.sdk;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var _b, emailPatient, smsPatient, chatPatient, emailTrigger, smsTrigger, chatTrigger, emailMessage, smsMessage, chatRoom, chatMessage, updatedEmail, emailAssigned, updatedSMS, smsAssigned, updatedChatRoom, chatAssigned, outboundSMS, unchangedOutboundSMS, outboundNotAssigned, allTestsPassed, cleanupPromises, error_1;
-        var _c, _d, _e, _f, _g, _h;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
-                case 0:
-                    log_header("Message Assignment Trigger Tests");
-                    return [4 /*yield*/, sdk.api.endusers.createSome([
-                            { fname: 'Email', lname: 'Patient', assignedTo: [sdk.userInfo.id] },
-                            { fname: 'SMS', lname: 'Patient', assignedTo: [sdk.userInfo.id] },
-                            { fname: 'Chat', lname: 'Patient', assignedTo: [sdk.userInfo.id] }, // Assign to care team
-                        ])];
-                case 1:
-                    _b = (_j.sent()).created, emailPatient = _b[0], smsPatient = _b[1], chatPatient = _b[2];
-                    console.log("Created test patients:");
-                    console.log("  Email: ".concat(emailPatient.id));
-                    console.log("  SMS: ".concat(smsPatient.id));
-                    console.log("  Chat: ".concat(chatPatient.id));
-                    _j.label = 2;
-                case 2:
-                    _j.trys.push([2, , 21, 25]);
-                    return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                            title: "Email Message Assignment Test ".concat(Date.now()),
-                            status: 'Active',
-                            event: {
-                                type: 'Incoming Message',
-                                info: {
-                                    channels: ['Email'], // Only trigger for email messages
-                                }
-                            },
-                            action: {
-                                type: 'Assign to Incoming Message',
-                                info: {
-                                    careTeamOnly: true,
-                                    maxUsers: 3
-                                }
+export var message_assignment_trigger_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, tenant, sdk_1, _a, emailPatient, smsPatient, chatPatient, outboundPatient, emailTrigger, smsTrigger, chatTrigger, emailMessage_1, updatedEmail, smsMessage_1, updatedSMS, chatRoom_1, chatMessage, updatedChatRoom, outboundSMS, unchangedOutboundSMS, e_1;
+    var _b, _c, _d, _e, _f, _g;
+    return __generator(this, function (_h) {
+        switch (_h.label) {
+            case 0:
+                checks = [];
+                record = function (label, pass, detail) { return checks.push({ label: label, pass: pass, detail: detail }); };
+                _h.label = 1;
+            case 1:
+                _h.trys.push([1, , 22, 27]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Message assignment trigger ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _h.sent();
+                sdk_1 = tenant.sdk;
+                // emails.createOne is registered `requiresInboxConfiguration`, which reads username/orgEmail off
+                // the JWT, and a provisioned user has neither — the Email case would 400 before any trigger ran.
+                // (The shared fixture's user was hand-seeded with them, so this step is new to the isolated run.)
+                // configure_inbox is a plain POST: it mints a token but does not install it, hence the refresh.
+                // username is unique per organization; a fresh random one keeps back-to-back runs independent.
+                return [4 /*yield*/, sdk_1.api.users.configure_inbox({ username: "inbox".concat(RAND()), fname: 'Assignment', lname: 'Staff' })];
+            case 3:
+                // emails.createOne is registered `requiresInboxConfiguration`, which reads username/orgEmail off
+                // the JWT, and a provisioned user has neither — the Email case would 400 before any trigger ran.
+                // (The shared fixture's user was hand-seeded with them, so this step is new to the isolated run.)
+                // configure_inbox is a plain POST: it mints a token but does not install it, hence the refresh.
+                // username is unique per organization; a fresh random one keeps back-to-back runs independent.
+                _h.sent();
+                return [4 /*yield*/, sdk_1.refresh_session()
+                    // Create different patients for each test to avoid rate limiting
+                ];
+            case 4:
+                _h.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createSome([
+                        { fname: 'Email', lname: 'Patient', assignedTo: [sdk_1.userInfo.id] },
+                        { fname: 'SMS', lname: 'Patient', assignedTo: [sdk_1.userInfo.id] },
+                        { fname: 'Chat', lname: 'Patient', assignedTo: [sdk_1.userInfo.id] },
+                        { fname: 'Outbound', lname: 'Patient', assignedTo: [sdk_1.userInfo.id] }, // Assign to care team
+                    ])];
+            case 5:
+                _a = (_h.sent()).created, emailPatient = _a[0], smsPatient = _a[1], chatPatient = _a[2], outboundPatient = _a[3];
+                console.log("Created test patients:");
+                console.log("  Email: ".concat(emailPatient.id));
+                console.log("  SMS: ".concat(smsPatient.id));
+                console.log("  Chat: ".concat(chatPatient.id));
+                console.log("  Outbound: ".concat(outboundPatient.id));
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "Email Message Assignment Test ".concat(Date.now()),
+                        status: 'Active',
+                        event: {
+                            type: 'Incoming Message',
+                            info: {
+                                channels: ['Email'], // Only trigger for email messages
                             }
-                        })];
-                case 3:
-                    // Create triggers using the "Incoming Message" event type
-                    emailTrigger = _j.sent();
-                    return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                            title: "SMS Message Assignment Test ".concat(Date.now()),
-                            status: 'Active',
-                            event: {
-                                type: 'Incoming Message',
-                                info: {
-                                    channels: ['SMS'], // Only trigger for SMS messages
-                                }
-                            },
-                            action: {
-                                type: 'Assign to Incoming Message',
-                                info: {
-                                    careTeamOnly: true,
-                                    maxUsers: 3
-                                }
+                        },
+                        action: {
+                            type: 'Assign to Incoming Message',
+                            info: {
+                                careTeamOnly: true,
+                                maxUsers: 3
                             }
-                        })];
-                case 4:
-                    smsTrigger = _j.sent();
-                    return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                            title: "Chat Message Assignment Test ".concat(Date.now()),
-                            status: 'Active',
-                            event: {
-                                type: 'Incoming Message',
-                                info: {
-                                    channels: ['Chat'], // Only trigger for chat messages
-                                }
-                            },
-                            action: {
-                                type: 'Assign to Incoming Message',
-                                info: {
-                                    careTeamOnly: true,
-                                    maxUsers: 3
-                                }
+                        }
+                    })];
+            case 6:
+                emailTrigger = _h.sent();
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "SMS Message Assignment Test ".concat(Date.now()),
+                        status: 'Active',
+                        event: {
+                            type: 'Incoming Message',
+                            info: {
+                                channels: ['SMS'], // Only trigger for SMS messages
                             }
-                        })];
-                case 5:
-                    chatTrigger = _j.sent();
-                    console.log("Created triggers:");
-                    console.log("  Email Trigger: ".concat(emailTrigger.id));
-                    console.log("  SMS Trigger: ".concat(smsTrigger.id));
-                    console.log("  Chat Trigger: ".concat(chatTrigger.id));
-                    // Test 1: Email Message Assignment
-                    console.log("\n=== Testing Email Message Assignment ===");
-                    return [4 /*yield*/, sdk.api.emails.createOne({
-                            logOnly: true,
-                            enduserId: emailPatient.id,
-                            subject: 'Test Incoming Email __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
-                            textContent: 'This is a test incoming email for assignment __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
-                        })];
-                case 6:
-                    // Create email with logOnly: true to prevent actual sending
-                    // Note: In real scenarios, emails have source fields added by the system
-                    // For testing purposes, we'll create the email and test the assignment logic
-                    emailMessage = _j.sent();
-                    console.log("Created email message: ".concat(emailMessage.id));
-                    console.log("Note: In production, creating an inbound email would automatically trigger the Incoming Message event");
-                    console.log("For testing, we rely on the trigger system to process the created email");
-                    // Wait for trigger processing
-                    return [4 /*yield*/, wait(undefined, 1000)
-                        // Check if email was assigned
-                    ];
-                case 7:
-                    // Wait for trigger processing
-                    _j.sent();
-                    return [4 /*yield*/, sdk.api.emails.getOne(emailMessage.id)];
-                case 8:
-                    updatedEmail = _j.sent();
-                    console.log("Email assignment result:");
-                    console.log("  assignedTo: ".concat(JSON.stringify(updatedEmail.assignedTo)));
-                    console.log("  Expected user: ".concat(sdk.userInfo.id));
-                    emailAssigned = (_d = (_c = updatedEmail.assignedTo) === null || _c === void 0 ? void 0 : _c.includes(sdk.userInfo.id)) !== null && _d !== void 0 ? _d : false;
-                    if (emailAssigned) {
-                        console.log("\u2705 Email message successfully assigned to user");
-                    }
-                    else {
-                        console.log("\u274C Email message assignment failed");
-                    }
-                    // Test 2: SMS Message Assignment  
-                    console.log("\n=== Testing SMS Message Assignment ===");
-                    return [4 /*yield*/, sdk.api.sms_messages.createOne({
-                            logOnly: true,
-                            inbound: true,
-                            enduserId: smsPatient.id,
-                            message: 'This is a test incoming SMS for assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
-                        })];
-                case 9:
-                    // Create inbound SMS with logOnly: true and inbound: true
-                    smsMessage = _j.sent();
-                    console.log("Created SMS message: ".concat(smsMessage.id));
-                    console.log("Note: In production, creating an inbound SMS would automatically trigger the Incoming Message event");
-                    console.log("For testing, we rely on the trigger system to process the created SMS");
-                    // Wait for trigger processing
-                    return [4 /*yield*/, wait(undefined, 1000)
-                        // Check if SMS was assigned
-                    ];
-                case 10:
-                    // Wait for trigger processing
-                    _j.sent();
-                    return [4 /*yield*/, sdk.api.sms_messages.getOne(smsMessage.id)];
-                case 11:
-                    updatedSMS = _j.sent();
-                    console.log("SMS assignment result:");
-                    console.log("  assignedTo: ".concat(JSON.stringify(updatedSMS.assignedTo)));
-                    console.log("  Expected user: ".concat(sdk.userInfo.id));
-                    smsAssigned = (_f = (_e = updatedSMS.assignedTo) === null || _e === void 0 ? void 0 : _e.includes(sdk.userInfo.id)) !== null && _f !== void 0 ? _f : false;
-                    if (smsAssigned) {
-                        console.log("\u2705 SMS message successfully assigned to user");
-                    }
-                    else {
-                        console.log("\u274C SMS message assignment failed");
-                    }
-                    // Test 3: Chat Room Assignment
-                    console.log("\n=== Testing Chat Room Assignment ===");
-                    return [4 /*yield*/, sdk.api.chat_rooms.createOne({
-                            aboutEnduserId: chatPatient.id,
-                            userIds: [sdk.userInfo.id],
-                            enduserIds: [chatPatient.id],
-                        })];
-                case 12:
-                    // Create a chat room for the patient
-                    chatRoom = _j.sent();
-                    console.log("Created chat room: ".concat(chatRoom.id));
-                    return [4 /*yield*/, sdk.api.chats.createOne({
-                            roomId: chatRoom.id,
-                            message: 'This is a test incoming chat message for assignment',
-                            senderId: chatPatient.id, // Message from patient (incoming)
-                        })];
-                case 13:
-                    // Create a chat message in the room (this represents an incoming message)
-                    chatMessage = _j.sent();
-                    console.log("Created chat message: ".concat(chatMessage.id));
-                    console.log("Note: In production, creating an inbound chat would automatically trigger the Incoming Message event");
-                    console.log("For testing, we rely on the trigger system to process the created chat message");
-                    // Wait for trigger processing
-                    return [4 /*yield*/, wait(undefined, 1000)
-                        // Check if chat room was assigned
-                    ];
-                case 14:
-                    // Wait for trigger processing
-                    _j.sent();
-                    return [4 /*yield*/, sdk.api.chat_rooms.getOne(chatRoom.id)];
-                case 15:
-                    updatedChatRoom = _j.sent();
-                    console.log("Chat room assignment result:");
-                    console.log("  assignedTo: ".concat(JSON.stringify(updatedChatRoom.assignedTo)));
-                    console.log("  Expected user: ".concat(sdk.userInfo.id));
-                    chatAssigned = (_h = (_g = updatedChatRoom.assignedTo) === null || _g === void 0 ? void 0 : _g.includes(sdk.userInfo.id)) !== null && _h !== void 0 ? _h : false;
-                    if (chatAssigned) {
-                        console.log("\u2705 Chat room successfully assigned to user");
-                    }
-                    else {
-                        console.log("\u274C Chat room assignment failed");
-                    }
-                    // Test 4: Verify outbound messages don't trigger assignment
-                    console.log("\n=== Testing Outbound Message Exclusion ===");
-                    return [4 /*yield*/, sdk.api.sms_messages.createOne({
-                            logOnly: true,
-                            inbound: false,
-                            enduserId: smsPatient.id,
-                            message: 'This is an outbound SMS that should not trigger assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
-                        })];
-                case 16:
-                    outboundSMS = _j.sent();
-                    console.log("Created outbound SMS: ".concat(outboundSMS.id));
-                    console.log("Outbound SMS created for verification that it should NOT be assigned");
-                    console.log("The Incoming Message trigger should only activate for inbound: true messages");
-                    // Wait for potential trigger processing
-                    return [4 /*yield*/, wait(undefined, 1000)
-                        // Verify outbound SMS was NOT assigned (should still be null/undefined)
-                    ];
-                case 17:
-                    // Wait for potential trigger processing
-                    _j.sent();
-                    return [4 /*yield*/, sdk.api.sms_messages.getOne(outboundSMS.id)];
-                case 18:
-                    unchangedOutboundSMS = _j.sent();
-                    outboundNotAssigned = !unchangedOutboundSMS.assignedTo || unchangedOutboundSMS.assignedTo.length === 0;
-                    if (outboundNotAssigned) {
-                        console.log("\u2705 Outbound SMS correctly NOT assigned (as expected)");
-                    }
-                    else {
-                        console.log("\u274C Outbound SMS was incorrectly assigned: ".concat(JSON.stringify(unchangedOutboundSMS.assignedTo)));
-                    }
-                    // Summary
-                    console.log("\n=== Test Results Summary ===");
-                    console.log("Email Assignment: ".concat(emailAssigned ? '✅ PASSED' : '❌ FAILED'));
-                    console.log("SMS Assignment: ".concat(smsAssigned ? '✅ PASSED' : '❌ FAILED'));
-                    console.log("Chat Assignment: ".concat(chatAssigned ? '✅ PASSED' : '❌ FAILED'));
-                    console.log("Outbound Exclusion: ".concat(outboundNotAssigned ? '✅ PASSED' : '❌ FAILED'));
-                    allTestsPassed = emailAssigned && smsAssigned && chatAssigned && outboundNotAssigned;
-                    console.log("\nOverall Result: ".concat(allTestsPassed ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'));
-                    if (!allTestsPassed) {
-                        throw new Error('Message assignment trigger tests failed');
-                    }
-                    // Cleanup test triggers
-                    return [4 /*yield*/, Promise.all([
-                            sdk.api.automation_triggers.deleteOne(emailTrigger.id),
-                            sdk.api.automation_triggers.deleteOne(smsTrigger.id),
-                            sdk.api.automation_triggers.deleteOne(chatTrigger.id),
-                        ])];
-                case 19:
-                    // Cleanup test triggers
-                    _j.sent();
-                    console.log("Cleaned up test triggers");
-                    // Cleanup test patients  
-                    return [4 /*yield*/, Promise.all([
-                            sdk.api.endusers.deleteOne(emailPatient.id),
-                            sdk.api.endusers.deleteOne(smsPatient.id),
-                            sdk.api.endusers.deleteOne(chatPatient.id),
-                        ])];
-                case 20:
-                    // Cleanup test patients  
-                    _j.sent();
-                    console.log("Cleaned up test patients");
-                    return [2 /*return*/, { success: true, results: { emailAssigned: emailAssigned, smsAssigned: smsAssigned, chatAssigned: chatAssigned, outboundNotAssigned: outboundNotAssigned } }];
-                case 21:
-                    _j.trys.push([21, 23, , 24]);
-                    cleanupPromises = [];
-                    if (emailTrigger === null || emailTrigger === void 0 ? void 0 : emailTrigger.id)
-                        cleanupPromises.push(sdk.api.automation_triggers.deleteOne(emailTrigger.id).catch(function () { }));
-                    if (smsTrigger === null || smsTrigger === void 0 ? void 0 : smsTrigger.id)
-                        cleanupPromises.push(sdk.api.automation_triggers.deleteOne(smsTrigger.id).catch(function () { }));
-                    if (chatTrigger === null || chatTrigger === void 0 ? void 0 : chatTrigger.id)
-                        cleanupPromises.push(sdk.api.automation_triggers.deleteOne(chatTrigger.id).catch(function () { }));
-                    if (emailPatient === null || emailPatient === void 0 ? void 0 : emailPatient.id)
-                        cleanupPromises.push(sdk.api.endusers.deleteOne(emailPatient.id).catch(function () { }));
-                    if (smsPatient === null || smsPatient === void 0 ? void 0 : smsPatient.id)
-                        cleanupPromises.push(sdk.api.endusers.deleteOne(smsPatient.id).catch(function () { }));
-                    if (chatPatient === null || chatPatient === void 0 ? void 0 : chatPatient.id)
-                        cleanupPromises.push(sdk.api.endusers.deleteOne(chatPatient.id).catch(function () { }));
-                    return [4 /*yield*/, Promise.all(cleanupPromises)];
-                case 22:
-                    _j.sent();
-                    console.log("Final cleanup completed");
-                    return [3 /*break*/, 24];
-                case 23:
-                    error_1 = _j.sent();
-                    console.error("Cleanup error: ".concat(error_1));
-                    return [3 /*break*/, 24];
-                case 24: return [7 /*endfinally*/];
-                case 25: return [2 /*return*/];
-            }
-        });
+                        },
+                        action: {
+                            type: 'Assign to Incoming Message',
+                            info: {
+                                careTeamOnly: true,
+                                maxUsers: 3
+                            }
+                        }
+                    })];
+            case 7:
+                smsTrigger = _h.sent();
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "Chat Message Assignment Test ".concat(Date.now()),
+                        status: 'Active',
+                        event: {
+                            type: 'Incoming Message',
+                            info: {
+                                channels: ['Chat'], // Only trigger for chat messages
+                            }
+                        },
+                        action: {
+                            type: 'Assign to Incoming Message',
+                            info: {
+                                careTeamOnly: true,
+                                maxUsers: 3
+                            }
+                        }
+                    })];
+            case 8:
+                chatTrigger = _h.sent();
+                console.log("Created triggers:");
+                console.log("  Email Trigger: ".concat(emailTrigger.id));
+                console.log("  SMS Trigger: ".concat(smsTrigger.id));
+                console.log("  Chat Trigger: ".concat(chatTrigger.id));
+                // Test 1: Email Message Assignment
+                console.log("\n=== Testing Email Message Assignment ===");
+                return [4 /*yield*/, sdk_1.api.emails.createOne({
+                        logOnly: true,
+                        enduserId: emailPatient.id,
+                        subject: 'Test Incoming Email __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
+                        textContent: 'This is a test incoming email for assignment __TELLESCOPE_TEST_INCOMING_EMAIL_AUTOMATION__',
+                    })];
+            case 9:
+                emailMessage_1 = _h.sent();
+                console.log("Created email message: ".concat(emailMessage_1.id));
+                // Wait for trigger processing
+                return [4 /*yield*/, wait(undefined, 1000)];
+            case 10:
+                // Wait for trigger processing
+                _h.sent();
+                return [4 /*yield*/, poll_for_results(function () { return sdk_1.api.emails.getOne(emailMessage_1.id); }, function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(sdk_1.userInfo.id)); })];
+            case 11:
+                updatedEmail = _h.sent();
+                record('Email message successfully assigned to user', (_c = (_b = updatedEmail.assignedTo) === null || _b === void 0 ? void 0 : _b.includes(sdk_1.userInfo.id)) !== null && _c !== void 0 ? _c : false, "assignedTo=".concat(JSON.stringify(updatedEmail.assignedTo), " expected to include ").concat(sdk_1.userInfo.id));
+                // Test 2: SMS Message Assignment
+                console.log("\n=== Testing SMS Message Assignment ===");
+                return [4 /*yield*/, sdk_1.api.sms_messages.createOne({
+                        logOnly: true,
+                        inbound: true,
+                        enduserId: smsPatient.id,
+                        message: 'This is a test incoming SMS for assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
+                    })];
+            case 12:
+                smsMessage_1 = _h.sent();
+                console.log("Created SMS message: ".concat(smsMessage_1.id));
+                // Wait for trigger processing
+                return [4 /*yield*/, wait(undefined, 1000)];
+            case 13:
+                // Wait for trigger processing
+                _h.sent();
+                return [4 /*yield*/, poll_for_results(function () { return sdk_1.api.sms_messages.getOne(smsMessage_1.id); }, function (s) { var _a; return !!((_a = s.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(sdk_1.userInfo.id)); })];
+            case 14:
+                updatedSMS = _h.sent();
+                record('SMS message successfully assigned to user', (_e = (_d = updatedSMS.assignedTo) === null || _d === void 0 ? void 0 : _d.includes(sdk_1.userInfo.id)) !== null && _e !== void 0 ? _e : false, "assignedTo=".concat(JSON.stringify(updatedSMS.assignedTo), " expected to include ").concat(sdk_1.userInfo.id));
+                // Test 3: Chat Room Assignment
+                console.log("\n=== Testing Chat Room Assignment ===");
+                return [4 /*yield*/, sdk_1.api.chat_rooms.createOne({
+                        aboutEnduserId: chatPatient.id,
+                        userIds: [sdk_1.userInfo.id],
+                        enduserIds: [chatPatient.id],
+                    })];
+            case 15:
+                chatRoom_1 = _h.sent();
+                console.log("Created chat room: ".concat(chatRoom_1.id));
+                return [4 /*yield*/, sdk_1.api.chats.createOne({
+                        roomId: chatRoom_1.id,
+                        message: 'This is a test incoming chat message for assignment',
+                        senderId: chatPatient.id, // Message from patient (incoming)
+                    })];
+            case 16:
+                chatMessage = _h.sent();
+                console.log("Created chat message: ".concat(chatMessage.id));
+                // Wait for trigger processing
+                return [4 /*yield*/, wait(undefined, 1000)];
+            case 17:
+                // Wait for trigger processing
+                _h.sent();
+                return [4 /*yield*/, poll_for_results(function () { return sdk_1.api.chat_rooms.getOne(chatRoom_1.id); }, function (r) { var _a; return !!((_a = r.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(sdk_1.userInfo.id)); })];
+            case 18:
+                updatedChatRoom = _h.sent();
+                record('Chat room successfully assigned to user', (_g = (_f = updatedChatRoom.assignedTo) === null || _f === void 0 ? void 0 : _f.includes(sdk_1.userInfo.id)) !== null && _g !== void 0 ? _g : false, "assignedTo=".concat(JSON.stringify(updatedChatRoom.assignedTo), " expected to include ").concat(sdk_1.userInfo.id));
+                // Test 4: Verify outbound messages don't trigger assignment
+                console.log("\n=== Testing Outbound Message Exclusion ===");
+                return [4 /*yield*/, sdk_1.api.sms_messages.createOne({
+                        logOnly: true,
+                        inbound: false,
+                        enduserId: outboundPatient.id,
+                        message: 'This is an outbound SMS that should not trigger assignment __TELLESCOPE_TEST_INCOMING_SMS_AUTOMATION__',
+                    })];
+            case 19:
+                outboundSMS = _h.sent();
+                console.log("Created outbound SMS: ".concat(outboundSMS.id));
+                // Wait for potential trigger processing
+                return [4 /*yield*/, wait(undefined, 1000)
+                    // Verify outbound SMS was NOT assigned (should still be null/undefined)
+                ];
+            case 20:
+                // Wait for potential trigger processing
+                _h.sent();
+                return [4 /*yield*/, sdk_1.api.sms_messages.getOne(outboundSMS.id)];
+            case 21:
+                unchangedOutboundSMS = _h.sent();
+                record('Outbound SMS correctly NOT assigned (as expected)', !unchangedOutboundSMS.assignedTo || unchangedOutboundSMS.assignedTo.length === 0, "assignedTo=".concat(JSON.stringify(unchangedOutboundSMS.assignedTo), " expected empty"));
+                return [3 /*break*/, 27];
+            case 22:
+                if (!tenant) return [3 /*break*/, 26];
+                _h.label = 23;
+            case 23:
+                _h.trys.push([23, 25, , 26]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 24:
+                _h.sent();
+                return [3 /*break*/, 26];
+            case 25:
+                e_1 = _h.sent();
+                console.error('teardown failed', e_1);
+                return [3 /*break*/, 26];
+            case 26: return [7 /*endfinally*/];
+            case 27: return [2 /*return*/, checks];
+        }
+    });
+}); };
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export var message_assignment_trigger_tests = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = assert_checks;
+                _b = ['Message assignment trigger'];
+                return [4 /*yield*/, message_assignment_trigger_checks()];
+            case 1:
+                _a.apply(void 0, _b.concat([_c.sent()]));
+                return [2 /*return*/];
+        }
     });
+}); };
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export var ISOLATED_SUITE = {
+    name: 'Message assignment trigger',
+    run: message_assignment_trigger_checks,
 };
 // Allow running this test file independently
 if (require.main === module) {
-    var host = process.env.API_URL || 'http://localhost:8080';
     console.log("\uD83C\uDF10 Using API URL: ".concat(host));
-    var sdk_1 = new Session({ host: host });
-    var runTests = function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, setup_tests(sdk_1, sdk_1)]; // Use same SDK for both admin and non-admin (simplified for this test)
-                case 1:
-                    _a.sent(); // Use same SDK for both admin and non-admin (simplified for this test)
-                    return [4 /*yield*/, message_assignment_trigger_tests({ sdk: sdk_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    message_assignment_trigger_tests()
         .then(function () {
         console.log("✅ Message assignment trigger tests completed successfully");
         process.exit(0);