refactor(striped backups): Using new comparator and moving the class to the same file

Author: AdityaNPL

src/BackupChain.cs

@@ -92,9 +92,9 @@ private static IEnumerable<BackupMetadata> NextLogBackup(IEnumerable<BackupMetad
     {
       // also gets all the stripes of the next backup
       return backups.Where(b => b.BackupType == BackupFileTools.BackupType.Log &&
-                                prevBackup.LastLsn >= b.FirstLsn && 
+                                prevBackup.LastLsn >= b.FirstLsn &&
                                 prevBackup.LastLsn <= b.LastLsn &&
-                                !new BackupMetadataEqualityComparer().EqualsExceptForPhysicalDeviceName(prevBackup, b));
+                                !new StripedBackupEqualityComparer().Equals(prevBackup, b));
     }
 
     private static bool IsValidFilePath(BackupMetadata meta)

src/BackupMetadata.cs

@@ -2,15 +2,12 @@ namespace AgDatabaseMove
 {
   using System;
   using System.Collections.Generic;
+  using System.Linq;
   using SmoFacade;
 
-  public class BackupMetadataEqualityComparer : IEqualityComparer<BackupMetadata>
+  public class StripedBackupEqualityComparer : IEqualityComparer<BackupMetadata>
   {
-    /// <summary>
-    /// This is used for checking similar backups (like striped backups)
-    /// </summary>
-    /// <returns>bool</returns>
-    public bool EqualsExceptForPhysicalDeviceName(BackupMetadata x, BackupMetadata y)
+    public bool Equals(BackupMetadata x, BackupMetadata y)
     {
       return x.LastLsn == y.LastLsn &&
              x.FirstLsn == y.FirstLsn &&
@@ -20,21 +17,10 @@ public bool EqualsExceptForPhysicalDeviceName(BackupMetadata x, BackupMetadata y
              x.DatabaseBackupLsn == x.DatabaseBackupLsn;
     }
 
-    /// <summary>
-    /// This is used for checking exactly the same backup (like finding duplicates)
-    /// </summary>
-    /// <returns>bool</returns>
-    public bool Equals(BackupMetadata x, BackupMetadata y)
-    {
-      return EqualsExceptForPhysicalDeviceName(x, y)
-        && x.PhysicalDeviceName == y.PhysicalDeviceName;
-    }
-
     public int GetHashCode(BackupMetadata obj)
     {
       var hashCode = -1277603921;
       hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(obj.DatabaseName);
-      hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(obj.PhysicalDeviceName);
       hashCode = hashCode * -1521134295 +
                  EqualityComparer<BackupFileTools.BackupType>.Default.GetHashCode(obj.BackupType);
       hashCode = hashCode * -1521134295 + obj.FirstLsn.GetHashCode();
@@ -43,6 +29,28 @@ public int GetHashCode(BackupMetadata obj)
       hashCode = hashCode * -1521134295 + obj.DatabaseBackupLsn.GetHashCode();
       return hashCode;
     }
+
+  }
+
+  /// <summary>
+  /// Two BackupMetadatas are the same, if they are like striped backups but also have the same `PhysicalDeviceName`
+  /// </summary>
+  public class BackupMetadataEqualityComparer : IEqualityComparer<BackupMetadata>
+  {
+    private readonly StripedBackupEqualityComparer _stripedBackupEqualityComparer = new StripedBackupEqualityComparer();
+    
+    public bool Equals(BackupMetadata x, BackupMetadata y)
+    {
+      return _stripedBackupEqualityComparer.Equals(x, y)
+        && x.PhysicalDeviceName == y.PhysicalDeviceName;
+    }
+
+    public int GetHashCode(BackupMetadata obj)
+    {
+      var hashCode = _stripedBackupEqualityComparer.GetHashCode(obj);
+      hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(obj.PhysicalDeviceName);
+      return hashCode;
+    }
   }
 
   /// <summary>
@@ -72,4 +80,22 @@ public object Clone()
       return MemberwiseClone();
     }
   }
+
+  public class StripedBackupSet
+  {
+    public IEnumerable<BackupMetadata> StripedBackups { get; private set; }
+
+    private StripedBackupSet(IEnumerable<BackupMetadata> stripedBackups)
+    {
+      StripedBackups = stripedBackups;
+    }
+
+    public static IEnumerable<StripedBackupSet> GetStripedBackupSetChain(IEnumerable<BackupMetadata> backups)
+    {
+      var chain = backups
+        .GroupBy(b => b, new StripedBackupEqualityComparer())
+        .Select(group => new StripedBackupSet(group));
+      return chain;
+    }
+  }
 }

src/StripedBackupSet.cs

@@ -9,6 +9,7 @@ namespace AgDatabaseMove.Unit
   public class StripedBackupSetTests
   {
 
+    private static readonly StripedBackupEqualityComparer stripedBackupComparer = new StripedBackupEqualityComparer();
     private static readonly BackupMetadataEqualityComparer backupComparer = new BackupMetadataEqualityComparer();
 
     [Fact]
@@ -43,7 +44,7 @@ public void StripedBackupsAreEqualExceptForPhysicalDeviceName()
         {
           var otherBackup = stripes[i];
 
-          Assert.True(backupComparer.EqualsExceptForPhysicalDeviceName(backup, otherBackup));
+          Assert.Equal(backup, otherBackup, stripedBackupComparer);
           Assert.NotEqual(backup, otherBackup, backupComparer);
         }
       }