@forge/teamwork-graph 1.2.0-next.5 → 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 () => {
@@ -479,4 +481,1147 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
+    it('posts build entities to /api/v1/entities/bulk and returns response', async () => {
+        const buildEntity = {
+            schemaVersion: '2.0',
+            id: 'build-1',
+            updateSequenceNumber: 1,
+            displayName: 'Build #42',
+            url: 'https://ci.example.com/builds/42',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:build': {
+                pipelineId: 'pipeline-123',
+                buildNumber: 42,
+                label: 'Release Build',
+                state: 'SUCCESS',
+                duration: 300,
+                testInfo: {
+                    totalNumber: 150,
+                    numberPassed: 145,
+                    numberFailed: 3,
+                    numberSkipped: 2
+                },
+                references: [
+                    {
+                        commit: {
+                            id: 'abc123def456',
+                            repositoryUri: 'https://github.com/org/repo'
+                        },
+                        ref: {
+                            name: 'main',
+                            uri: 'https://github.com/org/repo/tree/main'
+                        }
+                    }
+                ]
+            }
+        };
+        const req = { entities: [buildEntity] };
+        const expected = { success: true, results: [{ entityId: 'build-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 calendar event entities to /api/v1/entities/bulk and returns response', async () => {
+        const calendarEventEntity = {
+            schemaVersion: '2.0',
+            id: 'calendar-event-1',
+            updateSequenceNumber: 1,
+            displayName: 'Sprint Planning Meeting',
+            description: 'Weekly sprint planning session for the development team',
+            url: 'https://calendar.google.com/event/abc123',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            createdBy: {},
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:calendar-event': {
+                eventStartTime: '2024-07-10T09:00:00.000Z',
+                eventEndTime: '2024-07-10T10:00:00.000Z',
+                eventType: 'meeting',
+                attendees: [
+                    {
+                        user: 'user-123',
+                        isOptional: false,
+                        rsvpStatus: 'accepted'
+                    },
+                    {
+                        user: 'user-456',
+                        isOptional: true,
+                        rsvpStatus: 'tentatively_accepted'
+                    }
+                ],
+                location: {
+                    name: 'Conference Room A',
+                    address: '123 Main St, Building 1, Floor 2',
+                    url: 'https://maps.google.com/conference-room-a',
+                    coordinates: '40.7128,-74.0060'
+                },
+                videoMeetingUrl: 'https://meet.google.com/abc-defg-hij',
+                videoMeetingProvider: 'Google Meet',
+                isAllDayEvent: false,
+                attendeeCount: 2,
+                exceedsMaxAttendees: false,
+                isRecurringEvent: true,
+                recurringEventId: 'recurring-123',
+                attachments: [
+                    {
+                        url: 'https://example.com/agenda.pdf',
+                        title: 'Meeting Agenda',
+                        mimeType: 'application/pdf',
+                        byteSize: 1024
+                    }
+                ]
+            }
+        };
+        const req = { entities: [calendarEventEntity] };
+        const expected = { success: true, results: [{ entityId: 'calendar-event-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 comment entities to /api/v1/entities/bulk and returns response', async () => {
+        const commentEntity = {
+            schemaVersion: '2.0',
+            id: 'comment-1',
+            updateSequenceNumber: 1,
+            displayName: 'Great work on this feature!',
+            url: 'https://example.com/comments/comment-1',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            createdBy: {
+                id: 'ari:cloud:identity::user/user-789',
+                externalId: 'user-789',
+                displayName: 'Jane Developer'
+            },
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:comment': {
+                text: 'This is a really well-implemented feature. The code is clean and the tests are comprehensive. Thanks for the hard work!',
+                reactionsV2: [
+                    {
+                        reactionType: 'like',
+                        total: 5
+                    }
+                ]
+            }
+        };
+        const req = { entities: [commentEntity] };
+        const expected = { success: true, results: [{ entityId: 'comment-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 conversation entities to /api/v1/entities/bulk and returns response', async () => {
+        const conversationEntity = {
+            schemaVersion: '2.0',
+            id: 'conversation-1',
+            updateSequenceNumber: 1,
+            displayName: 'Development Team Chat',
+            description: 'Main channel for the development team discussions',
+            url: 'https://slack.com/channels/dev-team',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:conversation': {
+                type: 'channel',
+                membershipType: 'public',
+                workspace: 'atlassian-workspace',
+                topic: 'Daily standup and development discussions',
+                isArchived: false,
+                members: [
+                    {
+                        accountId: 'user-123',
+                        ari: 'ari:cloud:identity::user/user-123',
+                        externalId: 'user-123',
+                        name: 'John Developer',
+                        email: 'john.developer@example.com'
+                    },
+                    {
+                        accountId: 'user-456',
+                        ari: 'ari:cloud:identity::user/user-456',
+                        externalId: 'user-456',
+                        name: 'Jane Developer',
+                        email: 'jane.developer@example.com'
+                    },
+                    {
+                        accountId: 'user-789',
+                        ari: 'ari:cloud:identity::user/user-789',
+                        externalId: 'user-789',
+                        name: 'Bob Manager',
+                        email: 'bob.manager@example.com'
+                    }
+                ],
+                lastActive: '2024-07-09T16:30:00.000Z',
+                memberCount: 3
+            }
+        };
+        const req = { entities: [conversationEntity] };
+        const expected = { success: true, results: [{ entityId: 'conversation-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 customer org entities to /api/v1/entities/bulk and returns response', async () => {
+        const customerOrgEntity = {
+            schemaVersion: '2.0',
+            id: 'customer-org-1',
+            updateSequenceNumber: 1,
+            displayName: 'Acme Corporation',
+            description: 'Leading technology company specializing in enterprise solutions',
+            url: 'https://crm.example.com/customers/acme-corp',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:customer-org': {
+                contacts: [
+                    {
+                        accountId: 'contact-123',
+                        ari: 'ari:cloud:identity::user/contact-123',
+                        externalId: 'contact-123',
+                        name: 'Alice Johnson',
+                        email: 'alice.johnson@acme.com',
+                        avatar: 'https://avatar.example.com/alice.jpg'
+                    },
+                    {
+                        accountId: 'contact-456',
+                        ari: 'ari:cloud:identity::user/contact-456',
+                        externalId: 'contact-456',
+                        name: 'Bob Smith',
+                        email: 'bob.smith@acme.com'
+                    }
+                ],
+                customerOrgLastActivity: {
+                    lastActivityAt: '2024-07-09T16:30:00.000Z',
+                    event: 'Support ticket created for enterprise integration'
+                },
+                customerOrgLifeTimeValue: {
+                    value: 250000.0,
+                    currencyCode: 'USD'
+                },
+                websiteUrl: 'https://www.acme.com',
+                industry: 'Technology',
+                contributors: [
+                    {
+                        accountId: 'contributor-789',
+                        ari: 'ari:cloud:identity::user/contributor-789',
+                        externalId: 'contributor-789',
+                        name: 'Charlie Brown',
+                        email: 'charlie.brown@ourcompany.com',
+                        userName: 'cbrown'
+                    }
+                ],
+                country: 'United States',
+                accountType: 'Enterprise'
+            }
+        };
+        const req = { entities: [customerOrgEntity] };
+        const expected = { success: true, results: [{ entityId: 'customer-org-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 deal entities to /api/v1/entities/bulk and returns response', async () => {
+        const dealEntity = {
+            schemaVersion: '2.0',
+            id: 'deal-1',
+            updateSequenceNumber: 1,
+            displayName: 'Enterprise Software License Deal',
+            description: 'Large enterprise deal for software licensing and support services',
+            url: 'https://crm.example.com/deals/enterprise-software-123',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:deal': {
+                contact: {
+                    accountId: 'contact-deal-123',
+                    ari: 'ari:cloud:identity::user/contact-deal-123',
+                    externalId: 'contact-deal-123',
+                    name: 'Sarah Wilson',
+                    email: 'sarah.wilson@techcorp.com',
+                    avatar: 'https://avatar.example.com/sarah.jpg'
+                },
+                stage: 'Proposal Sent',
+                status: 'Active',
+                accountName: 'TechCorp Enterprises',
+                contributors: [
+                    {
+                        accountId: 'contributor-789',
+                        ari: 'ari:cloud:identity::user/contributor-789',
+                        externalId: 'contributor-789',
+                        name: 'Alex Rodriguez',
+                        email: 'alex.rodriguez@ourcompany.com',
+                        userName: 'arodriguez'
+                    },
+                    {
+                        accountId: 'contributor-456',
+                        ari: 'ari:cloud:identity::user/contributor-456',
+                        externalId: 'contributor-456',
+                        name: 'Jessica Chen',
+                        email: 'jessica.chen@ourcompany.com',
+                        userName: 'jchen'
+                    }
+                ],
+                lastActivity: {
+                    lastActivityAt: '2024-07-09T16:30:00.000Z',
+                    event: 'Contract proposal sent to client for review'
+                },
+                dealClosedAt: '2024-08-15T10:00:00.000Z',
+                opportunityAmount: {
+                    value: 500000.0,
+                    currencyCode: 'USD'
+                },
+                isClosed: false
+            }
+        };
+        const req = { entities: [dealEntity] };
+        const expected = { success: true, results: [{ entityId: 'deal-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 deployment entities to /api/v1/entities/bulk and returns response', async () => {
+        const deploymentEntity = {
+            schemaVersion: '2.0',
+            id: 'deployment-1',
+            updateSequenceNumber: 1,
+            displayName: 'Production API Deployment v2.4.5',
+            description: 'Deployment of version 2.4.5 to production environment',
+            url: 'https://ci.example.com/deployments/prod-api-v2.4.5',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:deployment': {
+                deploymentSequenceNumber: 12345,
+                label: 'v2.4.5 - Bug fixes and performance improvements',
+                state: 'successful',
+                duration: 1200,
+                pipeline: {
+                    id: 'pipeline-prod-api',
+                    displayName: 'Production API Pipeline',
+                    url: 'https://ci.example.com/pipelines/prod-api'
+                },
+                environment: {
+                    id: 'env-production',
+                    displayName: 'Production Environment',
+                    type: 'production'
+                },
+                commands: [
+                    {
+                        command: 'npm install --production'
+                    },
+                    {
+                        command: 'npm run build'
+                    },
+                    {
+                        command: 'kubectl apply -f deployment.yaml'
+                    }
+                ],
+                triggeredBy: {
+                    accountId: 'devops-user-123',
+                    ari: 'ari:cloud:identity::user/devops-user-123',
+                    externalId: 'devops-user-123',
+                    name: 'DevOps Team',
+                    email: 'devops@example.com',
+                    userName: 'devops-team',
+                    avatar: 'https://avatar.example.com/devops.jpg'
+                },
+                region: 'us-east-1'
+            }
+        };
+        const req = { entities: [deploymentEntity] };
+        const expected = { success: true, results: [{ entityId: 'deployment-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 design entities to /api/v1/entities/bulk and returns response', async () => {
+        const designEntity = {
+            schemaVersion: '2.0',
+            id: 'design-1',
+            updateSequenceNumber: 1,
+            displayName: 'Mobile App Login Screen',
+            description: 'Updated login screen design for mobile app with improved UX',
+            url: 'https://figma.com/design/mobile-login-screen',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:design': {
+                liveEmbedUrl: 'https://figma.com/embed/mobile-login-screen',
+                inspectUrl: 'https://figma.com/inspect/mobile-login-screen',
+                status: 'Ready for Development',
+                type: 'UI Design',
+                iconUrl: 'https://figma.com/icons/mobile-login-screen.svg'
+            }
+        };
+        const req = { entities: [designEntity] };
+        const expected = { success: true, results: [{ entityId: 'design-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 position entities to /api/v1/entities/bulk and returns response', async () => {
+        const positionEntity = {
+            schemaVersion: '2.0',
+            id: 'position-1',
+            updateSequenceNumber: 1,
+            displayName: 'Senior Software Engineer - Backend',
+            url: 'https://hr.example.com/positions/senior-backend-engineer',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            parentKey: {
+                type: 'atlassian:organisation',
+                value: {
+                    entityId: 'org-tech-company-123'
+                }
+            },
+            associations: {
+                set: [
+                    {
+                        associationType: 'atlassian:worker',
+                        values: ['worker-alice-johnson-456']
+                    }
+                ]
+            },
+            'atlassian:position': {
+                customAndSensitiveData: 'Salary range: $120,000-$150,000. Remote work eligible.',
+                status: 'Open',
+                jobTitle: 'Senior Software Engineer - Backend'
+            }
+        };
+        const req = { entities: [positionEntity] };
+        const expected = { success: true, results: [{ entityId: 'position-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 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);
+    });
 });