https://github.com/nasa/openmct/issues/4369

#4460

src/api/objects/ObjectAPISpec.js

@@ -39,6 +39,7 @@ describe("The Object API", () => {
             type: "test-type"
         };
     });
+
     describe("The save function", () => {
         it("Rejects if no provider available", () => {
             let rejected = false;
@@ -332,6 +333,48 @@ describe("The Object API", () => {
             });
         });
     });
+
+    describe("transactions", () => {
+        beforeEach(() => {
+            spyOn(openmct.editor, 'isEditing').and.returnValue(true);
+        });
+
+        it('there is no active transaction', () => {
+            expect(objectAPI.isTransactionActive()).toBe(false);
+        });
+
+        it('start a transaction', () => {
+            objectAPI.startTransaction();
+            expect(objectAPI.isTransactionActive()).toBe(true);
+        });
+
+        it('has active transaction', () => {
+            objectAPI.startTransaction();
+            const activeTransaction = objectAPI.getActiveTransaction();
+            expect(activeTransaction).not.toBe(null);
+        });
+
+        it('end a transaction', () => {
+            objectAPI.endTransaction();
+            expect(objectAPI.isTransactionActive()).toBe(false);
+        });
+
+        it('returns dirty object on get', (done) => {
+            spyOn(objectAPI, 'supportsMutation').and.returnValue(true);
+
+            objectAPI.startTransaction();
+            objectAPI.mutate(mockDomainObject, 'name', 'dirty object');
+
+            const dirtyObject = objectAPI.transaction.getDirtyObject(mockDomainObject.identifier);
+
+            objectAPI.get(mockDomainObject.identifier)
+                .then(object => {
+                    const areEqual = JSON.stringify(object) === JSON.stringify(dirtyObject);
+                    expect(areEqual).toBe(true);
+                })
+                .finally(done);
+        });
+    });
 });
 
 function hasOwnProperty(object, property) {

src/api/objects/TransactionSpec.js

@@ -0,0 +1,102 @@
+import Transaction from "./Transaction";
+import utils from 'objectUtils';
+
+let openmct = {};
+let objectAPI;
+let transaction;
+
+describe("Transaction Class", () => {
+    beforeEach(() => {
+        objectAPI = {
+            makeKeyString: (identifier) => utils.makeKeyString(identifier),
+            save: (object) => object,
+            mutate: (object, prop, value) => {
+                object[prop] = value;
+
+                return object;
+            },
+            refresh: (object) => Promise.resolve(object)
+        };
+
+        transaction = new Transaction(objectAPI);
+
+        openmct.editor = {
+            isEditing: () => true
+        };
+    });
+
+    it('has no dirty objects', () => {
+        expect(transaction.dirtyObjects.size).toEqual(0);
+    });
+
+    it('add(), adds object to dirtyObjects', () => {
+        const mockDomainObjects = createMockDomainObjects();
+        transaction.add(mockDomainObjects[0]);
+        expect(transaction.dirtyObjects.size).toEqual(1);
+    });
+
+    it('cancel(), clears all dirtyObjects', (done) => {
+        const mockDomainObjects = createMockDomainObjects(3);
+        mockDomainObjects.forEach(transaction.add.bind(transaction));
+
+        expect(transaction.dirtyObjects.size).toEqual(3);
+
+        transaction.cancel()
+            .then(success => {
+                expect(transaction.dirtyObjects.size).toEqual(0);
+            }).finally(done);
+    });
+
+    it('commit(), saves all dirtyObjects', (done) => {
+        const mockDomainObjects = createMockDomainObjects(3);
+        mockDomainObjects.forEach(transaction.add.bind(transaction));
+
+        expect(transaction.dirtyObjects.size).toEqual(3);
+        spyOn(objectAPI, 'save');
+        transaction.commit()
+            .then(success => {
+                expect(transaction.dirtyObjects.size).toEqual(0);
+                expect(objectAPI.save.calls.count()).toEqual(3);
+            }).finally(done);
+    });
+
+    it('getDirtyObject(), returns correct dirtyObject', () => {
+        const mockDomainObjects = createMockDomainObjects();
+        transaction.add(mockDomainObjects[0]);
+
+        expect(transaction.dirtyObjects.size).toEqual(1);
+        const dirtyObject = transaction.getDirtyObject(mockDomainObjects[0].identifier);
+
+        expect(dirtyObject).toEqual(mockDomainObjects[0]);
+    });
+
+    it('getDirtyObject(), returns empty dirtyObject for no active transaction', () => {
+        const mockDomainObjects = createMockDomainObjects();
+
+        expect(transaction.dirtyObjects.size).toEqual(0);
+        const dirtyObject = transaction.getDirtyObject(mockDomainObjects[0].identifier);
+
+        expect(dirtyObject).toEqual(undefined);
+    });
+});
+
+function createMockDomainObjects(size = 1) {
+    const objects = [];
+
+    while (size > 0) {
+        const mockDomainObject = {
+            identifier: {
+                namespace: 'test-namespace',
+                key: `test-key-${size}`
+            },
+            name: `test object ${size}`,
+            type: 'test-type'
+        };
+
+        objects.push(mockDomainObject);
+
+        size--;
+    }
+
+    return objects;
+}