Merge pull request #184 from JonnyPower/feature/uow-register-dirty-fields

Feature/uow register dirty fields

Author: dfruddffdc

fflib/src/classes/fflib_ISObjectUnitOfWork.cls

@@ -59,6 +59,16 @@ public interface fflib_ISObjectUnitOfWork
      * @param record An existing record
      **/
     void registerDirty(SObject record);
+    /**
+     * Register specific fields on record to be updated when work is commited
+     *
+     * If the record has previously been registered as dirty, the dirty fields on the record in this call will overwrite
+     * the values of the previously registered dirty record
+     *
+     * @param record An existing record
+     * @param dirtyFields The fields to update if record is already registered
+     **/
+    void registerDirty(SObject record, List<SObjectField> dirtyFields);
     /**
      * Register an existing record to be updated when commitWork is called,
      *   you may also provide a reference to the parent record instance (should also be registered as new separatly)

fflib/src/classes/fflib_SObjectMocks.cls

@@ -81,6 +81,15 @@ public class fflib_SObjectMocks
 			mocks.mockVoidMethod(this, 'registerDirty', new List<Type> {SObject.class}, new List<Object> {record});
 		}
 
+		public void registerDirty(SObject record, List<SObjectField> dirtyFields)
+		{
+			mocks.mockVoidMethod(this, 'registerDirty', new List<Type> {
+					SObject.class, System.Type.forName('List<SObjectField>')
+			}, new List<Object> {
+					record, dirtyFields
+			});
+		}
+
         public void registerDirty(SObject record, Schema.sObjectField relatedToParentField, SObject relatedToParentRecord)
         {
             mocks.mockVoidMethod(this, 'registerDirty', new List<Type> {SObject.class}, new List<Object> {record});

fflib/src/classes/fflib_SObjectUnitOfWork.cls

@@ -247,13 +247,35 @@ public virtual class fflib_SObjectUnitOfWork
      * @param record An existing record
      **/
     public void registerDirty(SObject record)
+    {
+        registerDirty(record, new List<SObjectField>());
+    }
+
+    public void registerDirty(SObject record, List<SObjectField> dirtyFields)
     {
         if(record.Id == null)
             throw new UnitOfWorkException('New records cannot be registered as dirty');
         String sObjectType = record.getSObjectType().getDescribe().getName();
         if(!m_dirtyMapByType.containsKey(sObjectType))
             throw new UnitOfWorkException(String.format('SObject type {0} is not supported by this unit of work', new String[] { sObjectType }));
-        m_dirtyMapByType.get(sObjectType).put(record.Id, record);
+
+        // If record isn't registered as dirty, or no dirty fields to drive a merge
+        if (!m_dirtyMapByType.get(sObjectType).containsKey(record.Id) || dirtyFields.isEmpty())
+        {
+            // Register the record as dirty
+            m_dirtyMapByType.get(sObjectType).put(record.Id, record);
+        }
+        else
+        {
+            // Update the registered record's fields
+            SObject registeredRecord = m_dirtyMapByType.get(sObjectType).get(record.Id);
+
+            for (SObjectField dirtyField : dirtyFields) {
+                registeredRecord.put(dirtyField, record.get(dirtyField));
+            }
+
+            m_dirtyMapByType.get(sObjectType).put(record.Id, registeredRecord);
+        }
     }
 
     /**

fflib/src/classes/fflib_SObjectUnitOfWorkTest.cls

@@ -338,6 +338,54 @@ private with sharing class fflib_SObjectUnitOfWorkTest
             , uow.getCommitWorkEventsFired(), new Set<Schema.SObjectType>(MY_SOBJECTS), uow.getRegisteredTypes());
     }
 
+    /**
+     * Try registering two instances of the same record as dirty. Second register should overwrite first.
+     *
+     *  Testing:
+     *
+     *      - Exception is thrown stopping second registration
+     */
+    @isTest
+    private static void testRegisterDirty_ExpectReplacement() {
+        final Opportunity insertedOpp = new Opportunity(Name = 'Original', StageName = 'Open', CloseDate = System.today());
+        insert insertedOpp;
+
+        Opportunity opp = new Opportunity(Id = insertedOpp.Id, Name = 'Never');
+        Opportunity opp2 = new Opportunity(Id = insertedOpp.Id, Name = 'Expected');
+
+        fflib_SObjectUnitOfWork uow = new fflib_SObjectUnitOfWork(MY_SOBJECTS);
+        uow.registerDirty(opp);
+        uow.registerDirty(opp2);
+        uow.commitWork();
+
+        Opportunity updated = [select Id, Name from Opportunity where Id = :insertedOpp.Id];
+        System.assertEquals('Expected', updated.Name);
+    }
+
+    /**
+     * Try registering a single field as dirty.
+     *
+     *  Testing:
+     *
+     *      - field is updated
+     */
+    @isTest
+    private static void testRegisterDirty_field() {
+        Opportunity opp = new Opportunity(Name = 'test name', StageName = 'Open', CloseDate = System.today());
+        insert opp;
+
+        Opportunity nameUpdate = new Opportunity(Id = opp.Id, Name = 'UpdateName');
+        Opportunity amountUpdate = new Opportunity(Id = opp.Id, Amount = 250);
+        fflib_SObjectUnitOfWork uow = new fflib_SObjectUnitOfWork(MY_SOBJECTS);
+        uow.registerDirty(nameUpdate);
+        uow.registerDirty(amountUpdate, new List<SObjectField> { Opportunity.Amount } );
+        uow.commitWork();
+
+        opp = [select Name, Amount from Opportunity where Id = :opp.Id];
+        System.assertEquals(opp.Name, nameUpdate.Name);
+        System.assertEquals(opp.Amount, amountUpdate.Amount);
+    }
+
     /**
      * Assert that actual events exactly match expected events (size, order and name)
      * and types match expected types