Merge pull request #595 from StanleyGoldman/fixes/tracking-collection-newer-comparer

Fixes/tracking collection newer comparer

Author: shana

src/GitHub.Exports.Reactive/Collections/TrackingCollection.cs

@@ -539,8 +539,8 @@ ActionData ProcessItem(ActionData data, List<T> list)
                 var old = list[idx];
                 if (newer != null)
                 {
-                    // the object is "older" than the one we have, ignore it
-                    if (newer(item, old) > 0)
+                    // the object is not "newer" than the one we have, ignore it
+                    if (newer(item, old) >= 0)
                         return new ActionData(TheAction.Ignore, list, item, null, idx, idx);
                 }
 

src/TrackingCollectionTests/TrackingCollectionTests.cs

@@ -333,7 +333,7 @@ public void FilterTitleRun2()
         var total = 1000;
 
         var list1 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, i, "Run 1")).ToList());
-        var list2 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, i, "Run 2")).ToList());
+        var list2 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, i + 1, "Run 2")).ToList());
 
         ITrackingCollection<Thing> col = new TrackingCollection<Thing>(
             list1.ToObservable(),
@@ -429,8 +429,8 @@ public void OrderByMatchesOriginalOrder()
         var count = 0;
         var total = 1000;
 
-        var list1 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, total - i, "Run 1")).ToList());
-        var list2 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, total - i, "Run 2")).ToList());
+        var list1 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, i, "Run 1")).Reverse().ToList());
+        var list2 = new List<Thing>(Enumerable.Range(1, total).Select(i => GetThing(i, i, i + 1, "Run 2")).Reverse().ToList());
 
         ITrackingCollection<Thing> col = new TrackingCollection<Thing>(
             list1.ToObservable(),
@@ -2014,4 +2014,126 @@ public async void AddingBeforeSubscribingWorks()
         await Observable.Timeout(done, TimeSpan.FromMilliseconds(500));
         Assert.AreEqual(2, col.Count);
     }
+
+    [Test]
+    public void DoesNotUpdateThingIfTimeIsOlder()
+    {
+        ITrackingCollection<Thing> col = new TrackingCollection<Thing>(
+            Observable.Never<Thing>(),
+            OrderedComparer<Thing>.OrderBy(x => x.UpdatedAt).Compare);
+        col.NewerComparer = OrderedComparer<Thing>.OrderByDescending(x => x.UpdatedAt).Compare;
+        col.ProcessingDelay = TimeSpan.Zero;
+
+        var evt = new ManualResetEvent(false);
+        col.Subscribe(t =>
+        {
+            evt.Set();
+        }, () => { });
+
+        var createdAndUpdatedTime = DateTimeOffset.Now;
+        var olderUpdateTime = createdAndUpdatedTime.Subtract(TimeSpan.FromMinutes(1));
+
+        const string originalTitle = "Original Thing";
+
+        var originalThing = new Thing(1, originalTitle, createdAndUpdatedTime, createdAndUpdatedTime);
+        col.AddItem(originalThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(originalTitle, col[0].Title);
+
+        const string updatedTitle = "Updated Thing";
+
+        var updatedThing = new Thing(1, updatedTitle, createdAndUpdatedTime, olderUpdateTime);
+        col.AddItem(updatedThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(originalTitle, col[0].Title);
+
+        col.Dispose();
+    }
+
+    [Test]
+    public void DoesNotUpdateThingIfTimeIsEqual()
+    {
+        ITrackingCollection<Thing> col = new TrackingCollection<Thing>(
+            Observable.Never<Thing>(),
+            OrderedComparer<Thing>.OrderBy(x => x.UpdatedAt).Compare);
+        col.NewerComparer = OrderedComparer<Thing>.OrderByDescending(x => x.UpdatedAt).Compare;
+        col.ProcessingDelay = TimeSpan.Zero;
+
+        var evt = new ManualResetEvent(false);
+        col.Subscribe(t =>
+        {
+            evt.Set();
+        }, () => { });
+
+        var createdAndUpdatedTime = DateTimeOffset.Now;
+
+        const string originalTitle = "Original Thing";
+
+        var originalThing = new Thing(1, originalTitle, createdAndUpdatedTime, createdAndUpdatedTime);
+        col.AddItem(originalThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(originalTitle, col[0].Title);
+
+        const string updatedTitle = "Updated Thing";
+
+        var updatedThing = new Thing(1, updatedTitle, createdAndUpdatedTime, createdAndUpdatedTime);
+        col.AddItem(updatedThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(originalTitle, col[0].Title);
+
+        col.Dispose();
+    }
+
+    [Test]
+    public void DoesUpdateThingIfTimeIsNewer()
+    {
+        ITrackingCollection<Thing> col = new TrackingCollection<Thing>(
+            Observable.Never<Thing>(),
+            OrderedComparer<Thing>.OrderBy(x => x.UpdatedAt).Compare);
+        col.NewerComparer = OrderedComparer<Thing>.OrderByDescending(x => x.UpdatedAt).Compare;
+        col.ProcessingDelay = TimeSpan.Zero;
+
+        var evt = new ManualResetEvent(false);
+        col.Subscribe(t =>
+        {
+            evt.Set();
+        }, () => { });
+
+        var createdAndUpdatedTime = DateTimeOffset.Now;
+        var newerUpdateTime = createdAndUpdatedTime.Add(TimeSpan.FromMinutes(1));
+
+        const string originalTitle = "Original Thing";
+
+        var originalThing = new Thing(1, originalTitle, createdAndUpdatedTime, createdAndUpdatedTime);
+        col.AddItem(originalThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(originalTitle, col[0].Title);
+
+        const string updatedTitle = "Updated Thing";
+
+        var updatedThing = new Thing(1, updatedTitle, createdAndUpdatedTime, newerUpdateTime);
+        col.AddItem(updatedThing);
+
+        evt.WaitOne();
+        evt.Reset();
+
+        Assert.AreEqual(updatedTitle, col[0].Title);
+
+        col.Dispose();
+    }
 }