@forge/teamwork-graph 2.0.0-next.6 → 2.0.0-next.7

package/out/__test__/entity-operations.test.js

@@ -14,10 +14,11 @@ describe('TeamWorkGraphClient - setEntities', () => {
         jest.clearAllMocks();
     });
     it('throws if entities array is empty', async () => {
-        const req = { entities: [] };
-        await expect(graphClient.setEntities(req)).rejects.toThrow('entities array cannot be empty');
+        await expect(graphClient.setEntities({
+            entities: []
+        })).rejects.toThrow('entities array cannot be empty');
     });
-    it(`throws if more than ${validators_1.MAX_BULK_ENTITIES} entities`, async () => {
+    it('throws if more than 100 entities', async () => {
         const documentEntity = {
             schemaVersion: '1.0',
             id: 'my-document',
@@ -48,10 +49,10 @@ describe('TeamWorkGraphClient - setEntities', () => {
                 }
             }
         };
-        const req = {
-            entities: Array(validators_1.MAX_BULK_ENTITIES + 1).fill(documentEntity)
-        };
-        await expect(graphClient.setEntities(req)).rejects.toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_ENTITIES} entities`);
+        const manyEntities = Array(validators_1.MAX_BULK_ENTITIES + 1).fill(documentEntity);
+        await expect(graphClient.setEntities({
+            entities: manyEntities
+        })).rejects.toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_ENTITIES} entities. Received ${validators_1.MAX_BULK_ENTITIES + 1}`);
     });
     it('posts to /api/v1/entities/bulk and returns response', async () => {
         const documentEntity = {
@@ -238,10 +239,10 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
             headers: {
                 get: () => null
             },
-            text: () => Promise.resolve(JSON.stringify({
+            json: () => Promise.resolve({
                 code: 'ENTITY_NOT_FOUND',
                 message: 'Entity not found'
-            }))
+            })
         };
         mockFetch.mockResolvedValueOnce(errorResponse);
         const result = await graphClient.getEntityByExternalId({
@@ -250,7 +251,8 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
         });
         expect(result).toEqual({
             success: false,
-            error: 'Entity not found'
+            error: 'Failed to get entity by external ID: Not Found - Entity not found',
+            originalError: expect.any(Error)
         });
     });
     it('should throw error when entityType is missing', async () => {
@@ -1019,4 +1021,607 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
+    it('posts project entities to /api/v1/entities/bulk and returns response', async () => {
+        const projectEntity = {
+            schemaVersion: '2.0',
+            id: 'project-1',
+            updateSequenceNumber: 1,
+            displayName: 'E-commerce Platform Redesign',
+            description: 'Complete redesign of the e-commerce platform with modern UI/UX and improved performance',
+            url: 'https://jira.example.com/projects/ECOM-123',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            createdBy: {
+                externalId: 'creator-user-123',
+                userName: 'jdoe',
+                displayName: 'John Doe',
+                emails: [
+                    {
+                        value: 'john.doe@example.com',
+                        primary: true
+                    }
+                ]
+            },
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:project': {
+                key: 'ECOM-123',
+                dueDate: '2024-12-31T23:59:59.000Z',
+                priority: 'High',
+                assignee: {
+                    accountId: 'project-manager-123',
+                    ari: 'ari:cloud:identity::user/project-manager-123',
+                    externalId: 'project-manager-123',
+                    name: 'Sarah Johnson',
+                    email: 'sarah.johnson@example.com',
+                    userName: 'sjohnson',
+                    avatar: 'https://avatar.example.com/sarah.jpg'
+                },
+                status: 'In Progress',
+                attachments: [
+                    {
+                        url: 'https://files.example.com/project-spec.pdf',
+                        thumbnailUrl: 'https://files.example.com/thumbnails/project-spec.jpg',
+                        title: 'Project Specification Document',
+                        mimeType: 'application/pdf',
+                        byteSize: 2048000
+                    },
+                    {
+                        url: 'https://files.example.com/wireframes.figma',
+                        thumbnailUrl: 'https://files.example.com/thumbnails/wireframes.jpg',
+                        title: 'UI Wireframes',
+                        mimeType: 'application/figma',
+                        byteSize: 1024000
+                    }
+                ],
+                labels: ['frontend', 'redesign', 'high-priority'],
+                environment: 'production',
+                resolution: 'In Progress',
+                votesCount: 12,
+                watchersCount: 8
+            }
+        };
+        const req = { entities: [projectEntity] };
+        const expected = { success: true, results: [{ entityId: 'project-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts pull request entities to /api/v1/entities/bulk and returns response', async () => {
+        const pullRequestEntity = {
+            schemaVersion: '2.0',
+            id: 'pr-1',
+            updateSequenceNumber: 1,
+            displayName: 'Add user authentication feature',
+            description: 'Implement OAuth2 authentication system with JWT tokens for enhanced security',
+            url: 'https://github.com/company/repo/pull/42',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            containerKey: {
+                type: 'atlassian:repository',
+                value: {
+                    entityId: 'repo-company-main-123'
+                }
+            },
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:pull-request': {
+                title: 'Add user authentication feature',
+                displayId: 'PR-42',
+                status: 'OPEN',
+                author: {
+                    accountId: 'author-dev-456',
+                    externalId: 'author-dev-456',
+                    name: 'John Smith',
+                    userName: 'jsmith',
+                    email: 'john.smith@example.com',
+                    avatar: 'https://avatar.example.com/john.jpg',
+                    url: 'https://github.com/jsmith'
+                },
+                commentCount: 8,
+                sourceBranch: 'feature/oauth2-auth',
+                sourceBranchUrl: 'https://github.com/company/repo/tree/feature/oauth2-auth',
+                destinationBranch: 'main',
+                destinationBranchUrl: 'https://github.com/company/repo/tree/main',
+                reviewers: [
+                    {
+                        accountId: 'reviewer-senior-789',
+                        id: 'reviewer-senior-789',
+                        email: 'alice.johnson@example.com',
+                        approvalStatus: 'approved',
+                        name: 'Alice Johnson',
+                        avatar: 'https://avatar.example.com/alice.jpg',
+                        url: 'https://github.com/alicejohnson',
+                        ari: 'ari:cloud:identity::user/reviewer-senior-789'
+                    },
+                    {
+                        accountId: 'reviewer-lead-321',
+                        id: 'reviewer-lead-321',
+                        email: 'bob.wilson@example.com',
+                        approvalStatus: 'unapproved',
+                        name: 'Bob Wilson',
+                        avatar: 'https://avatar.example.com/bob.jpg',
+                        url: 'https://github.com/bobwilson',
+                        ari: 'ari:cloud:identity::user/reviewer-lead-321'
+                    }
+                ],
+                taskCount: 3
+            }
+        };
+        const req = { entities: [pullRequestEntity] };
+        const expected = { success: true, results: [{ entityId: 'pr-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts remote link entities to /api/v1/entities/bulk and returns response', async () => {
+        const remoteLinkEntity = {
+            schemaVersion: '2.0',
+            id: 'remote-link-1',
+            updateSequenceNumber: 1,
+            displayName: 'JIRA Issue Link - Fix user authentication bug',
+            url: 'https://company.atlassian.net/browse/AUTH-123',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:remote-link': {
+                type: 'issue',
+                status: {
+                    appearance: 'in_progress',
+                    label: 'In Progress'
+                },
+                actionIds: ['view', 'edit', 'comment'],
+                attributeMap: {
+                    priority: 'high',
+                    storyPoints: 5,
+                    sprint: 'Sprint 23',
+                    component: 'Authentication Service'
+                },
+                author: {
+                    accountId: 'author-dev-789',
+                    externalId: 'author-dev-789',
+                    name: 'Sarah Johnson',
+                    userName: 'sjohnson',
+                    email: 'sarah.johnson@example.com',
+                    avatar: 'https://avatar.example.com/sarah.jpg',
+                    url: 'https://company.atlassian.net/people/sarah.johnson'
+                },
+                category: 'bug',
+                assignee: {
+                    accountId: 'assignee-dev-456',
+                    externalId: 'assignee-dev-456',
+                    name: 'Michael Chen',
+                    userName: 'mchen',
+                    email: 'michael.chen@example.com',
+                    avatar: 'https://avatar.example.com/michael.jpg',
+                    url: 'https://company.atlassian.net/people/michael.chen'
+                },
+                fullNounThirdPartyAri: 'ari:cloud:jira:company-site:issue/AUTH-123'
+            }
+        };
+        const req = { entities: [remoteLinkEntity] };
+        const expected = { success: true, results: [{ entityId: 'remote-link-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts repository entities to /api/v1/entities/bulk and returns response', async () => {
+        const repositoryEntity = {
+            schemaVersion: '2.0',
+            id: 'repository-1',
+            updateSequenceNumber: 1,
+            displayName: 'E-commerce Platform Backend',
+            url: 'https://github.com/company/ecommerce-backend',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:repository': {
+                name: 'ecommerce-backend',
+                forkOf: 'https://github.com/upstream/ecommerce-platform',
+                avatar: 'https://avatars.githubusercontent.com/u/company?v=4',
+                avatarDescription: 'Company logo representing the ecommerce backend repository'
+            }
+        };
+        const req = { entities: [repositoryEntity] };
+        const expected = { success: true, results: [{ entityId: 'repository-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts software service entities to /api/v1/entities/bulk and returns response', async () => {
+        const softwareServiceEntity = {
+            schemaVersion: '2.0',
+            id: 'software-service-1',
+            updateSequenceNumber: 1,
+            displayName: 'Payment Processing Service',
+            url: 'https://monitoring.example.com/services/payment-processor',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:software-service': {
+                description: 'Microservice responsible for processing all payment transactions with secure payment gateway integration',
+                associationsMetadata: {
+                    ownership: 'payments-team',
+                    alertingChannel: '#payments-alerts',
+                    documentationUrl: 'https://docs.example.com/payment-service',
+                    repository: 'https://github.com/company/payment-processor',
+                    dashboardUrl: 'https://grafana.example.com/payment-service'
+                },
+                namespace: 'payment-system',
+                environment: 'production',
+                tags: ['payment', 'critical', 'pci-compliant', 'microservice', 'high-availability'],
+                tier: 'tier-1',
+                serviceType: 'REST API'
+            }
+        };
+        const req = { entities: [softwareServiceEntity] };
+        const expected = { success: true, results: [{ entityId: 'software-service-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts space entities to /api/v1/entities/bulk and returns response', async () => {
+        const spaceEntity = {
+            schemaVersion: '2.0',
+            id: 'space-1',
+            updateSequenceNumber: 1,
+            displayName: 'Engineering Team Documentation',
+            url: 'https://company.atlassian.net/wiki/spaces/ENGDOC',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:space': {
+                key: 'ENGDOC',
+                spaceType: 'global',
+                subtype: 'documentation',
+                icon: {
+                    url: 'https://company.atlassian.net/wiki/aa-avatar/5f7e8c123456789',
+                    width: 64,
+                    height: 64,
+                    isDefault: false
+                },
+                labels: ['engineering', 'documentation', 'team-resources', 'best-practices', 'onboarding']
+            }
+        };
+        const req = { entities: [spaceEntity] };
+        const expected = { success: true, results: [{ entityId: 'space-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts video entities to /api/v1/entities/bulk and returns response', async () => {
+        const videoEntity = {
+            schemaVersion: '2.0',
+            id: 'video-1',
+            updateSequenceNumber: 1,
+            displayName: 'Introduction to React Hooks - Team Training',
+            url: 'https://company.video.com/watch/react-hooks-intro',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:video': {
+                thumbnailUrl: 'https://company.video.com/thumbnails/react-hooks-intro.jpg',
+                embedUrl: 'https://company.video.com/embed/react-hooks-intro',
+                durationInSeconds: 1800,
+                width: 1920,
+                height: 1080,
+                commentCount: 15,
+                textTracks: [
+                    {
+                        name: 'English Subtitles',
+                        locale: 'en-US',
+                        cues: [
+                            {
+                                id: 'cue-1',
+                                startTimeInSeconds: 0.0,
+                                endTimeInSeconds: 5.5,
+                                text: 'Welcome to our React Hooks training session.'
+                            },
+                            {
+                                id: 'cue-2',
+                                startTimeInSeconds: 5.5,
+                                endTimeInSeconds: 12.0,
+                                text: 'Today we will cover useState, useEffect, and custom hooks.'
+                            }
+                        ]
+                    },
+                    {
+                        name: 'Spanish Subtitles',
+                        locale: 'es-ES',
+                        cues: [
+                            {
+                                id: 'cue-es-1',
+                                startTimeInSeconds: 0.0,
+                                endTimeInSeconds: 5.5,
+                                text: 'Bienvenidos a nuestra sesión de entrenamiento de React Hooks.'
+                            }
+                        ]
+                    }
+                ],
+                chapters: [
+                    {
+                        startTimeInSeconds: 0,
+                        title: 'Introduction'
+                    },
+                    {
+                        startTimeInSeconds: 300,
+                        title: 'useState Hook'
+                    },
+                    {
+                        startTimeInSeconds: 900,
+                        title: 'useEffect Hook'
+                    },
+                    {
+                        startTimeInSeconds: 1500,
+                        title: 'Custom Hooks'
+                    }
+                ],
+                contributors: [
+                    {
+                        user: {
+                            accountId: 'instructor-123',
+                            externalId: 'instructor-123',
+                            name: 'Sarah Johnson',
+                            userName: 'sjohnson',
+                            email: 'sarah.johnson@example.com',
+                            avatar: 'https://avatar.example.com/sarah.jpg',
+                            url: 'https://company.com/people/sarah.johnson'
+                        },
+                        interactionCount: 25
+                    },
+                    {
+                        user: {
+                            accountId: 'participant-456',
+                            externalId: 'participant-456',
+                            name: 'Mike Chen',
+                            userName: 'mchen',
+                            email: 'mike.chen@example.com',
+                            avatar: 'https://avatar.example.com/mike.jpg',
+                            url: 'https://company.com/people/mike.chen'
+                        },
+                        interactionCount: 8
+                    }
+                ]
+            }
+        };
+        const req = { entities: [videoEntity] };
+        const expected = { success: true, results: [{ entityId: 'video-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts work item entities to /api/v1/entities/bulk and returns response', async () => {
+        const workItemEntity = {
+            schemaVersion: '2.0',
+            id: 'work-item-1',
+            updateSequenceNumber: 1,
+            displayName: 'Implement user authentication API endpoints',
+            description: 'Develop secure REST API endpoints for user authentication including login, logout, password reset, and token refresh functionality with JWT implementation',
+            url: 'https://company.jira.com/browse/AUTH-456',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            containerKey: {
+                type: 'atlassian:space',
+                value: {
+                    entityId: 'space-engineering-team-docs'
+                }
+            },
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:work-item': {
+                dueDate: '2024-08-15T17:00:00.000Z',
+                assignee: {
+                    accountId: 'dev-lead-789',
+                    externalId: 'dev-lead-789',
+                    name: 'Alex Rodriguez',
+                    userName: 'arodriguez',
+                    email: 'alex.rodriguez@example.com',
+                    avatar: 'https://avatar.example.com/alex.jpg',
+                    url: 'https://company.com/people/alex.rodriguez'
+                },
+                workItemProject: {
+                    id: 'auth-service-project',
+                    name: 'Authentication Service Upgrade'
+                },
+                collaborators: [
+                    {
+                        accountId: 'backend-dev-123',
+                        externalId: 'backend-dev-123',
+                        name: 'Sarah Chen',
+                        userName: 'schen',
+                        email: 'sarah.chen@example.com',
+                        avatar: 'https://avatar.example.com/sarah.jpg',
+                        url: 'https://company.com/people/sarah.chen'
+                    },
+                    {
+                        accountId: 'security-expert-456',
+                        externalId: 'security-expert-456',
+                        name: 'Michael Thompson',
+                        userName: 'mthompson',
+                        email: 'michael.thompson@example.com',
+                        avatar: 'https://avatar.example.com/michael.jpg',
+                        url: 'https://company.com/people/michael.thompson'
+                    }
+                ],
+                exceedsMaxCollaborators: false,
+                status: 'In Progress',
+                subtype: 'Development Task',
+                attachments: [
+                    {
+                        url: 'https://files.example.com/auth-api-spec.pdf',
+                        thumbnailUrl: 'https://files.example.com/thumbnails/auth-api-spec.jpg',
+                        title: 'Authentication API Specification',
+                        mimeType: 'application/pdf',
+                        byteSize: 1024000
+                    },
+                    {
+                        url: 'https://files.example.com/security-requirements.docx',
+                        thumbnailUrl: 'https://files.example.com/thumbnails/security-requirements.jpg',
+                        title: 'Security Requirements Document',
+                        mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                        byteSize: 512000
+                    }
+                ],
+                team: 'Backend Infrastructure Team'
+            }
+        };
+        const req = { entities: [workItemEntity] };
+        const expected = { success: true, results: [{ entityId: 'work-item-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts worker entities to /api/v1/entities/bulk and returns response', async () => {
+        const workerEntity = {
+            schemaVersion: '2.0',
+            id: 'worker-1',
+            updateSequenceNumber: 1,
+            displayName: 'Sarah Johnson - Senior Software Engineer',
+            url: 'https://hr.example.com/employees/sarah-johnson',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:worker': {
+                hiredAt: '2022-03-15T09:00:00.000Z',
+                workerUser: {
+                    accountId: 'worker-sarah-123',
+                    externalId: 'emp-sarah-456',
+                    name: 'Sarah Johnson',
+                    userName: 'sjohnson',
+                    email: 'sarah.johnson@example.com',
+                    avatar: 'https://avatar.example.com/sarah.jpg',
+                    url: 'https://company.com/people/sarah.johnson',
+                    ari: 'ari:cloud:identity::user/worker-sarah-123'
+                },
+                customAndSensitiveData: 'Employee ID: EMP001234, Department: Engineering, Salary Grade: L5, Manager: Alex Rodriguez, Office Location: San Francisco HQ'
+            }
+        };
+        const req = { entities: [workerEntity] };
+        const expected = { success: true, results: [{ entityId: 'worker-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
 });