@forge/teamwork-graph 2.2.0-next.1 → 2.2.0-next.3

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

@@ -43,7 +43,7 @@ describe('TeamWorkGraphClient - setObjects', () => {
             ],
             'atlassian:document': {
                 type: {
-                    category: 'document',
+                    category: 'DOCUMENT',
                     iconUrl: 'http://icon.com'
                 },
                 content: {
@@ -81,7 +81,7 @@ describe('TeamWorkGraphClient - setObjects', () => {
             ],
             'atlassian:document': {
                 type: {
-                    category: 'document',
+                    category: 'DOCUMENT',
                     iconUrl: 'http://icon.com'
                 },
                 content: {
@@ -91,13 +91,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             }
         };
         const req = { objects: [documentObject] };
-        const expected = { success: true, results: [{ objectId: 'my-document', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:document',
+                    entityId: { id: 'my-document' },
+                    thirdPartyAri: 'ari:third-party:test::document/my-document'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts message entities to /api/v1/entities/bulk and returns response', async () => {
@@ -142,13 +154,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             }
         };
         const req = { objects: [messageObject] };
-        const expected = { success: true, results: [{ objectId: 'message-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:message',
+                    entityId: { id: 'message-1' },
+                    thirdPartyAri: 'ari:third-party:test::message/message-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts organisation entities to /api/v1/entities/bulk and returns response', async () => {
@@ -182,13 +206,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             'atlassian:organisation': {}
         };
         const req = { objects: [organisationObject] };
-        const expected = { success: false, results: [{ objectId: 'org-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:organisation',
+                    entityId: { id: 'org-1' },
+                    thirdPartyAri: 'ari:third-party:test::organisation/org-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('throws if objects is not an array', async () => {
@@ -224,13 +260,13 @@ describe('TeamWorkGraphClient - getObjectByExternalId', () => {
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expectedObject)
+            json: () => Promise.resolve({ entities: [expectedObject] })
         });
         const result = await graphClient.getObjectByExternalId({
             objectType: 'atlassian:document',
             externalId: 'pipelines/123/builds/456'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.GET_BY_EXTERNAL_ID), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.GET_BY_EXTERNAL_ID), {
             method: 'POST',
             redirect: 'follow',
             headers: { 'Content-Type': 'application/json' },
@@ -291,22 +327,25 @@ describe('TeamWorkGraphClient - deleteObjectsByExternalId', () => {
         jest.clearAllMocks();
     });
     it('should successfully delete objects in bulk', async () => {
+        const backendResponse = {
+            deleted: [
+                { entityType: 'atlassian:document', entityId: { entityId: 'pipelines/123/builds/456' } },
+                { entityType: 'atlassian:document', entityId: { entityId: 'pipelines/123/builds/789' } }
+            ]
+        };
         const expectedResponse = {
             success: true,
-            results: [
-                { externalId: 'pipelines/123/builds/456', success: true },
-                { externalId: 'pipelines/123/builds/789', success: true }
-            ]
+            results: backendResponse.deleted
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expectedResponse)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.deleteObjectsByExternalId({
             objectType: 'atlassian:document',
             externalIds: ['pipelines/123/builds/456', 'pipelines/123/builds/789']
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK_DELETE), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK_DELETE), {
             method: 'DELETE',
             body: JSON.stringify({
                 entityType: 'atlassian:document',
@@ -368,7 +407,7 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             environment: 'staging',
             status: 'failed'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.DELETE_BY_PROPERTIES), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.DELETE_BY_PROPERTIES), {
             method: 'DELETE',
             body: JSON.stringify({
                 environment: 'staging',
@@ -395,7 +434,7 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             team: 'backend',
             region: 'us-east-1'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.DELETE_BY_PROPERTIES), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.DELETE_BY_PROPERTIES), {
             method: 'DELETE',
             body: JSON.stringify({
                 environment: 'production',
@@ -418,6 +457,16 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
     it('should throw error when properties object is empty', async () => {
         await expect(graphClient.deleteObjectsByProperties({})).rejects.toThrow('properties object cannot be empty');
     });
+});
+describe('TeamWorkGraphClient - bulk entities', () => {
+    let graphClient;
+    let mockFetch;
+    beforeEach(() => {
+        graphClient = new graph_1.TeamWorkGraphClient();
+        mockFetch = jest.fn();
+        api_1.__fetchProduct.mockReturnValue(mockFetch);
+        jest.clearAllMocks();
+    });
     it('posts branch entities to /api/v1/entities/bulk and returns response', async () => {
         const branchObject = {
             schemaVersion: '2.0',
@@ -443,13 +492,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             'atlassian:branch': {}
         };
         const req = { objects: [branchObject] };
-        const expected = { success: true, results: [{ objectId: 'branch-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:branch',
+                    entityId: { id: 'branch-1' },
+                    thirdPartyAri: 'ari:third-party:test::branch/branch-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts commit entities to /api/v1/entities/bulk and returns response', async () => {
@@ -489,13 +550,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [commitObject] };
-        const expected = { success: true, results: [{ objectId: 'commit-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:commit',
+                    entityId: { id: 'commit-1' },
+                    thirdPartyAri: 'ari:third-party:test::commit/commit-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts build entities to /api/v1/entities/bulk and returns response', async () => {
@@ -547,13 +620,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [buildObject] };
-        const expected = { success: true, results: [{ objectId: 'build-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:build',
+                    entityId: { id: 'build-1' },
+                    thirdPartyAri: 'ari:third-party:test::build/build-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts calendar event entities to /api/v1/entities/bulk and returns response', async () => {
@@ -620,13 +705,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [calendarEventObject] };
-        const expected = { success: true, results: [{ objectId: 'calendar-event-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:calendar-event',
+                    entityId: { id: 'calendar-event-1' },
+                    thirdPartyAri: 'ari:third-party:test::calendar-event/calendar-event-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts comment entities to /api/v1/entities/bulk and returns response', async () => {
@@ -667,13 +764,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [commentObject] };
-        const expected = { success: true, results: [{ objectId: 'comment-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:comment',
+                    entityId: { id: 'comment-1' },
+                    thirdPartyAri: 'ari:third-party:test::comment/comment-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts conversation entities to /api/v1/entities/bulk and returns response', async () => {
@@ -733,13 +842,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [conversationObject] };
-        const expected = { success: true, results: [{ objectId: 'conversation-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:conversation',
+                    entityId: { id: 'conversation-1' },
+                    thirdPartyAri: 'ari:third-party:test::conversation/conversation-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts customer org entities to /api/v1/entities/bulk and returns response', async () => {
@@ -808,13 +929,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [customerOrgObject] };
-        const expected = { success: true, results: [{ objectId: 'customer-org-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:customer-org',
+                    entityId: { id: 'customer-org-1' },
+                    thirdPartyAri: 'ari:third-party:test::customer-org/customer-org-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deal entities to /api/v1/entities/bulk and returns response', async () => {
@@ -883,13 +1016,21 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [dealObject] };
-        const expected = { success: true, results: [{ objectId: 'deal-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                { entityType: 'atlassian:deal', entityId: { id: 'deal-1' }, thirdPartyAri: 'ari:third-party:test::deal/deal-1' }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deployment entities to /api/v1/entities/bulk and returns response', async () => {
@@ -954,13 +1095,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [deploymentObject] };
-        const expected = { success: true, results: [{ objectId: 'deployment-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:deployment',
+                    entityId: { id: 'deployment-1' },
+                    thirdPartyAri: 'ari:third-party:test::deployment/deployment-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts design entities to /api/v1/entities/bulk and returns response', async () => {
@@ -995,13 +1148,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [designObject] };
-        const expected = { success: true, results: [{ objectId: 'design-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:design',
+                    entityId: { id: 'design-1' },
+                    thirdPartyAri: 'ari:third-party:test::design/design-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts position entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1047,13 +1212,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [positionObject] };
-        const expected = { success: true, results: [{ objectId: 'position-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:position',
+                    entityId: { id: 'position-1' },
+                    thirdPartyAri: 'ari:third-party:test::position/position-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts project entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1128,13 +1305,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [projectObject] };
-        const expected = { success: true, results: [{ objectId: 'project-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:project',
+                    entityId: { id: 'project-1' },
+                    thirdPartyAri: 'ari:third-party:test::project/project-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts pull request entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1210,13 +1399,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [pullRequestObject] };
-        const expected = { success: true, results: [{ objectId: 'pr-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:pull-request',
+                    entityId: { id: 'pr-1' },
+                    thirdPartyAri: 'ari:third-party:test::pull-request/pr-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts remote link entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1276,13 +1477,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [remoteLinkObject] };
-        const expected = { success: true, results: [{ objectId: 'remote-link-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:remote-link',
+                    entityId: { id: 'remote-link-1' },
+                    thirdPartyAri: 'ari:third-party:test::remote-link/remote-link-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts repository entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1315,13 +1528,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [repositoryObject] };
-        const expected = { success: true, results: [{ objectId: 'repository-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:repository',
+                    entityId: { id: 'repository-1' },
+                    thirdPartyAri: 'ari:third-party:test::repository/repository-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts software service entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1363,13 +1588,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [softwareServiceObject] };
-        const expected = { success: true, results: [{ objectId: 'software-service-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:software-service',
+                    entityId: { id: 'software-service-1' },
+                    thirdPartyAri: 'ari:third-party:test::software-service/software-service-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts space entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1408,13 +1645,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [spaceObject] };
-        const expected = { success: true, results: [{ objectId: 'space-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:space',
+                    entityId: { id: 'space-1' },
+                    thirdPartyAri: 'ari:third-party:test::space/space-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts video entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1525,13 +1774,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [videoObject] };
-        const expected = { success: true, results: [{ objectId: 'video-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:video',
+                    entityId: { id: 'video-1' },
+                    thirdPartyAri: 'ari:third-party:test::video/video-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts work item entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1621,13 +1882,25 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [workItemObject] };
-        const expected = { success: true, results: [{ objectId: 'work-item-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:work-item',
+                    entityId: { id: 'work-item-1' },
+                    thirdPartyAri: 'ari:third-party:test::work-item/work-item-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts worker entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1668,13 +1941,315 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             }
         };
         const req = { objects: [workerObject] };
-        const expected = { success: true, results: [{ objectId: 'worker-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:worker',
+                    entityId: { id: 'worker-1' },
+                    thirdPartyAri: 'ari:third-party:test::worker/worker-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(backendResponse)
+        });
+        const result = await graphClient.setObjects(req);
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts dashboard entities to /api/v1/entities/bulk and returns response', async () => {
+        const dashboardObject = {
+            schemaVersion: '2.0',
+            id: 'dashboard-1',
+            updateSequenceNumber: 1,
+            displayName: 'Analytics Dashboard',
+            description: 'Main analytics dashboard for sales data',
+            url: 'https://analytics.example.com/dashboard/sales',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            'atlassian:dashboard': {
+                description: 'Real-time sales analytics and performance metrics',
+                workspaceName: 'Sales Analytics Workspace',
+                pages: [{ name: 'Overview' }, { name: 'Sales Metrics' }],
+                elements: [
+                    {
+                        name: 'Revenue Chart',
+                        innerComponents: ['chart-widget', 'filter-panel']
+                    }
+                ]
+            }
+        };
+        const req = { objects: [dashboardObject] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:dashboard',
+                    entityId: { id: 'dashboard-1' },
+                    thirdPartyAri: 'ari:third-party:test::dashboard/dashboard-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(backendResponse)
+        });
+        const result = await graphClient.setObjects(req);
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts test entities to /api/v1/entities/bulk and returns response', async () => {
+        const testObject = {
+            schemaVersion: '2.0',
+            id: 'test-1',
+            updateSequenceNumber: 1,
+            displayName: 'Login API Test',
+            description: 'Test case for user login API endpoint',
+            url: 'https://testmanagement.example.com/tests/login-api',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            'atlassian:test': {
+                status: 'active',
+                testType: 'integration',
+                statusPrecedence: 'high',
+                version: '1.2.0',
+                environment: 'staging'
+            }
+        };
+        const req = { objects: [testObject] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test',
+                    entityId: { id: 'test-1' },
+                    thirdPartyAri: 'ari:third-party:test::test/test-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(backendResponse)
+        });
+        const result = await graphClient.setObjects(req);
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts test execution entities to /api/v1/entities/bulk and returns response', async () => {
+        const testExecutionObject = {
+            schemaVersion: '2.0',
+            id: 'test-execution-1',
+            updateSequenceNumber: 1,
+            displayName: 'Login API Test Execution - Run #42',
+            description: 'Execution of login API test in staging environment',
+            url: 'https://testmanagement.example.com/executions/login-api-42',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            'atlassian:test-execution': {
+                status: 'passed',
+                version: '1.2.0',
+                environment: 'staging'
+            }
+        };
+        const req = { objects: [testExecutionObject] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-execution',
+                    entityId: { id: 'test-execution-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-execution/test-execution-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(backendResponse)
+        });
+        const result = await graphClient.setObjects(req);
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts test plan entities to /api/v1/entities/bulk and returns response', async () => {
+        const testPlanObject = {
+            schemaVersion: '2.0',
+            id: 'test-plan-1',
+            updateSequenceNumber: 1,
+            displayName: 'Q4 Release Test Plan',
+            description: 'Comprehensive test plan for Q4 release cycle',
+            url: 'https://testmanagement.example.com/plans/q4-release',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            'atlassian:test-plan': {}
+        };
+        const req = { objects: [testPlanObject] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-plan',
+                    entityId: { id: 'test-plan-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-plan/test-plan-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(backendResponse)
+        });
+        const result = await graphClient.setObjects(req);
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts test run entities to /api/v1/entities/bulk and returns response', async () => {
+        const testRunObject = {
+            schemaVersion: '2.0',
+            id: 'test-run-1',
+            updateSequenceNumber: 1,
+            displayName: 'Sprint 23 Regression Test Run',
+            description: 'Regression test run for sprint 23 release candidate',
+            url: 'https://testmanagement.example.com/runs/sprint-23-regression',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            'atlassian:test-run': {
+                status: 'in-progress',
+                assignee: {
+                    accountId: 'tester-alice-123',
+                    externalId: 'alice-tester-456',
+                    name: 'Alice Tester',
+                    userName: 'atester',
+                    email: 'alice.tester@example.com',
+                    avatar: 'https://avatar.example.com/alice.jpg',
+                    url: 'https://company.com/people/alice.tester',
+                    ari: 'ari:cloud:identity::user/tester-alice-123'
+                },
+                startedAt: '2024-07-09T09:00:00.000Z',
+                version: '1.2.0',
+                environment: 'staging'
+            }
+        };
+        const req = { objects: [testRunObject] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-run',
+                    entityId: { id: 'test-run-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-run/test-run-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
 });