Merge pull request #51 from pkalinowski/fix_updating_tableview_cell

#41 fixed a bug with not updating cell content after moving it

Author: lightsprint09

Sourcing/FetchedResultsDataProvider.swift

@@ -103,6 +103,13 @@ open class FetchedResultsDataProvider<Object: NSFetchRequestResult>: NSObject, N
 
     public func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
         dataProviderDidChangeContets(with: updates)
+        let updatesByMoves = updates.map({ (operation: DataProviderUpdate<Object>) -> DataProviderUpdate<Object>? in
+            if case .move(_, let newIndexPath) = operation {
+                return .update(newIndexPath, object(at: newIndexPath))
+            }
+            return nil
+        }).flatMap { $0 }
+        dataProviderDidChangeContets(with: updatesByMoves)
     }
 
     func dataProviderDidChangeContets(with updates: [DataProviderUpdate<Object>]?, triggerdByTableView: Bool = false) {

SourcingTests/CDTrain+CoreDataProperties.swift

@@ -13,6 +13,11 @@ import Foundation
 import CoreData
 
 extension CDTrain {
+    
+    @nonobjc public class func fetchRequest() -> NSFetchRequest<CDTrain> {
+        return NSFetchRequest<CDTrain>(entityName: "CDTrain")
+    }
+
     @NSManaged var id: String
     @NSManaged var name: String
 }

SourcingTests/CDTrain.swift

@@ -10,4 +10,12 @@ import Foundation
 import CoreData
 
 class CDTrain: NSManagedObject {
+    
+    private static let entityName = String(describing: CDTrain.self)
+    
+    public class func newObject(in managedContext: NSManagedObjectContext) -> CDTrain {
+        // swiftlint:disable force_unwrapping
+        let entityDesc = NSEntityDescription.entity(forEntityName: entityName, in: managedContext)!
+        return CDTrain(entity: entityDesc, insertInto: managedContext)
+    }
 }

SourcingTests/CollectionViewDataSource_SingleCellTest.swift

@@ -30,7 +30,7 @@ import XCTest
 import UIKit
 @testable import Sourcing
 
-// swiftlint:disable force_cast force_unwrapping
+// swiftlint:disable force_cast force_unwrapping xctfail_message
 class CollectionViewDataSourceSingleCellTest: XCTestCase {
 
     let cellIdentifier = "cellIdentifier"

SourcingTests/FetchedResultsDataProviderTests.swift

@@ -29,7 +29,7 @@ import XCTest
 import CoreData
 @testable import Sourcing
 
-// swiftlint:disable force_cast force_try force_unwrapping
+// swiftlint:disable force_cast force_try force_unwrapping xctfail_message
 class FetchedResultsDataProviderTests: XCTestCase {
     func managedObjectContextForTesting() -> NSManagedObjectContext {
         let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
@@ -42,46 +42,61 @@ class FetchedResultsDataProviderTests: XCTestCase {
     }
 
     var managedObjectContext: NSManagedObjectContext!
-    var train: CDTrain!
+    var train1: CDTrain!
+    var train2: CDTrain!
     var fetchedResultsController: NSFetchedResultsController<CDTrain>!
     var dataProvider: FetchedResultsDataProvider<CDTrain>!
 
     override func setUp() {
         managedObjectContext = managedObjectContextForTesting()
 
-        train = NSEntityDescription.insertNewObject(forEntityName: "CDTrain", into: managedObjectContext) as! CDTrain
-        train.id = "1"
-        train.name = "ICE"
-        managedObjectContext.insert(train)
+        train1 = self.train(id: "1", name: "ICE")
+        managedObjectContext.insert(train1)
 
-        let fetchReuqest = NSFetchRequest<CDTrain>(entityName: "CDTrain")
-        let sortDescriptor = NSSortDescriptor(key: "name", ascending: true)
+        train2 = self.train(id: "2", name: "ICE")
+        managedObjectContext.insert(train2)
+        
+        let fetchReuqest: NSFetchRequest<CDTrain> = CDTrain.fetchRequest()
+        let sortDescriptor = NSSortDescriptor(key: #keyPath(CDTrain.id), ascending: true)
         fetchReuqest.sortDescriptors = [sortDescriptor]
         fetchedResultsController = NSFetchedResultsController(fetchRequest: fetchReuqest, managedObjectContext: managedObjectContext,
-                                                              sectionNameKeyPath: "name", cacheName: nil)
+                                                              sectionNameKeyPath: #keyPath(CDTrain.name), cacheName: nil)
         dataProvider = try! FetchedResultsDataProvider(fetchedResultsController: fetchedResultsController, dataProviderDidUpdate: { _ in })
     }
 
+    private func train(id: String, name: String) -> CDTrain {
+        let train = CDTrain.newObject(in: managedObjectContext)
+        train.id = id
+        train.name = name
+        return train
+    }
+    
     func testNumberOfSections() {
         //Then
         XCTAssertEqual(dataProvider.numberOfSections(), 1)
     }
 
     func testNumberOfItems() {
         //Then
-        XCTAssertEqual(dataProvider.numberOfItems(inSection: 0), 1)
+        XCTAssertEqual(dataProvider.numberOfItems(inSection: 0), 2)
     }
 
     func testObjectAtIndexPath() {
         //Then
-        let indexPath = IndexPath(item: 0, section: 0)
-        XCTAssertEqual(dataProvider.object(at: indexPath), train)
+        var indexPath = IndexPath(item: 0, section: 0)
+        XCTAssertEqual(dataProvider.object(at: indexPath), train1)
+        
+        indexPath = IndexPath(item: 1, section: 0)
+        XCTAssertEqual(dataProvider.object(at: indexPath), train2)
     }
 
     func testIndexPathForObject() {
         //Then
-        let indexPath = IndexPath(item: 0, section: 0)
-        XCTAssertEqual(dataProvider.indexPath(for: train), indexPath)
+        var indexPath = IndexPath(item: 0, section: 0)
+        XCTAssertEqual(dataProvider.indexPath(for: train1), indexPath)
+        
+        indexPath = IndexPath(item: 1, section: 0)
+        XCTAssertEqual(dataProvider.indexPath(for: train2), indexPath)
     }
 
     func testReconfigureFetchRequest() {
@@ -201,6 +216,106 @@ class FetchedResultsDataProviderTests: XCTestCase {
         XCTAssert(didUpdateDataSource)
     }
 
+    func testProcessUpdatesForMoveChange() {
+        //Given
+        var updateIndexPath = IndexPath()
+        var moveIndexPaths = [IndexPath]()
+        
+        dataProvider = try! FetchedResultsDataProvider(fetchedResultsController: fetchedResultsController, dataProviderDidUpdate: { _ in })
+        dataProvider.whenDataProviderChanged = { updates in
+            guard let updates = updates, !updates.isEmpty else {
+                return
+            }
+            
+            for update in updates {
+                switch update {
+                case .update(let indexPath, _):
+                    updateIndexPath = indexPath
+                case .move(let indexPath, let newIndexPath):
+                    moveIndexPaths = [indexPath, newIndexPath]
+                default: break
+                }
+            }
+        }
+        
+        let oldIndexPath = IndexPath(row: 0, section: 0)
+        let newIndexPath = IndexPath(row: 1, section: 0)
+        dataProvider.controller(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>,
+                                didChange: 1, at: oldIndexPath, for: .move, newIndexPath: newIndexPath)
+        
+        //When
+        dataProvider.controllerDidChangeContent(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>)
+        
+        //Then
+        XCTAssertEqual(updateIndexPath, newIndexPath)
+        XCTAssertEqual(moveIndexPaths, [oldIndexPath, newIndexPath])
+    }
+    
+    func testProcessUpdatesOrderForMoveChange() {
+        var updatesNumber = 0
+        var isFirstMoveCall = false
+        var isSecondUpdateCall = false
+        
+        dataProvider = try! FetchedResultsDataProvider(fetchedResultsController: fetchedResultsController, dataProviderDidUpdate: { _ in })
+        dataProvider.whenDataProviderChanged = { updates in
+            guard let updates = updates, !updates.isEmpty else {
+                return
+            }
+            
+            updatesNumber += 1
+            
+            if case .move(_, _) = updates.first! {
+                isFirstMoveCall = true
+            }
+            
+            if case .update(_, _) = updates.first! {
+                if isFirstMoveCall {
+                    isSecondUpdateCall = true
+                }
+            }
+            
+        }
+        
+        let oldIndexPath = IndexPath(row: 0, section: 0)
+        let newIndexPath = IndexPath(row: 1, section: 0)
+        dataProvider.controller(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>,
+                                didChange: 1, at: oldIndexPath, for: .move, newIndexPath: newIndexPath)
+        
+        //When
+        dataProvider.controllerDidChangeContent(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>)
+        
+        //Then
+        XCTAssertEqual(updatesNumber, 2)
+        XCTAssert(isFirstMoveCall)
+        XCTAssert(isSecondUpdateCall)
+    }
+    
+    func testProcessUpdatesForUpdateChange() {
+        //Given
+        var updateIndexPath = IndexPath()
+        
+        dataProvider = try! FetchedResultsDataProvider(fetchedResultsController: fetchedResultsController, dataProviderDidUpdate: { _ in })
+        dataProvider.whenDataProviderChanged = { updates in
+            guard let updates = updates, !updates.isEmpty else {
+                return
+            }
+            
+            if case .update(let indexPath, _) = updates.first! {
+                updateIndexPath = indexPath
+            }
+        }
+        
+        let indexPath = IndexPath(row: 1, section: 0)
+        dataProvider.controller(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>,
+                                didChange: 1, at: indexPath, for: .update, newIndexPath: indexPath)
+        
+        //When
+        dataProvider.controllerDidChangeContent(fetchedResultsController as! NSFetchedResultsController<NSFetchRequestResult>)
+        
+        //Then
+        XCTAssertEqual(updateIndexPath, indexPath)
+    }
+    
     func testWillChangeContent() {
         //Given
         let oldIndexPath = IndexPath(row: 0, section: 0)