From 846291d20387ecf0e23669edb100ec288a3675b7 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 26 Jul 2022 16:30:44 +0900
Subject: [PATCH] Refactor new tests to not suck as much as the old importer
 tests

---
 .../Database/BeatmapImporterUpdateTests.cs    | 107 +++++++++++-------
 1 file changed, 69 insertions(+), 38 deletions(-)

diff --git a/osu.Game.Tests/Database/BeatmapImporterUpdateTests.cs b/osu.Game.Tests/Database/BeatmapImporterUpdateTests.cs
index cf4245ae83..38c5172227 100644
--- a/osu.Game.Tests/Database/BeatmapImporterUpdateTests.cs
+++ b/osu.Game.Tests/Database/BeatmapImporterUpdateTests.cs
@@ -1,15 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Linq.Expressions;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets;
 using osu.Game.Tests.Resources;
+using Realms;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
@@ -24,58 +28,85 @@ namespace osu.Game.Tests.Database
     public class BeatmapImporterUpdateTests : RealmTest
     {
         [Test]
-        public void TestImportThenUpdateWithNewDifficulty()
+        public void TestNewDifficultyAdded()
         {
             RunTestWithRealmAsync(async (realm, storage) =>
             {
                 var importer = new BeatmapImporter(storage, realm);
-                using var store = new RealmRulesetStore(realm, storage);
+                using var rulesets = new RealmRulesetStore(realm, storage);
 
-                string? pathOriginal = TestResources.GetTestBeatmapForImport();
-
-                string pathMissingOneBeatmap = pathOriginal.Replace(".osz", "_missing_difficulty.osz");
-
-                string extractedFolder = $"{pathOriginal}_extracted";
-                Directory.CreateDirectory(extractedFolder);
-
-                try
+                using var __ = getBeatmapArchive(out string pathOriginal);
+                using var _ = getBeatmapArchiveWithModifications(out string pathMissingOneBeatmap, directory =>
                 {
-                    using (var zip = ZipArchive.Open(pathOriginal))
-                        zip.WriteToDirectory(extractedFolder);
-
                     // remove one difficulty before first import
-                    new FileInfo(Directory.GetFiles(extractedFolder, "*.osu").First()).Delete();
+                    directory.GetFiles("*.osu").First().Delete();
+                });
 
-                    using (var zip = ZipArchive.Create())
-                    {
-                        zip.AddAllFromDirectory(extractedFolder);
-                        zip.SaveTo(pathMissingOneBeatmap, new ZipWriterOptions(CompressionType.Deflate));
-                    }
+                var importBeforeUpdate = await importer.Import(new ImportTask(pathMissingOneBeatmap));
 
-                    var firstImport = await importer.Import(new ImportTask(pathMissingOneBeatmap));
-                    Assert.That(firstImport, Is.Not.Null);
-                    Debug.Assert(firstImport != null);
+                Assert.That(importBeforeUpdate, Is.Not.Null);
+                Debug.Assert(importBeforeUpdate != null);
 
-                    Assert.That(realm.Realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending), Has.Count.EqualTo(1));
-                    Assert.That(realm.Realm.All<BeatmapSetInfo>().First(s => !s.DeletePending).Beatmaps, Has.Count.EqualTo(11));
+                checkCount<BeatmapSetInfo>(realm, 1, s => !s.DeletePending);
+                Assert.That(importBeforeUpdate.Value.Beatmaps, Has.Count.EqualTo(11));
 
-                    // Second import matches first but contains one extra .osu file.
-                    var secondImport = await importer.ImportAsUpdate(new ProgressNotification(), new ImportTask(pathOriginal), firstImport.Value);
-                    Assert.That(secondImport, Is.Not.Null);
-                    Debug.Assert(secondImport != null);
+                // Second import matches first but contains one extra .osu file.
+                var importAfterUpdate = await importer.ImportAsUpdate(new ProgressNotification(), new ImportTask(pathOriginal), importBeforeUpdate.Value);
 
-                    Assert.That(realm.Realm.All<BeatmapInfo>(), Has.Count.EqualTo(12));
-                    Assert.That(realm.Realm.All<BeatmapMetadata>(), Has.Count.EqualTo(12));
-                    Assert.That(realm.Realm.All<BeatmapSetInfo>(), Has.Count.EqualTo(1));
+                Assert.That(importAfterUpdate, Is.Not.Null);
+                Debug.Assert(importAfterUpdate != null);
 
-                    // check the newly "imported" beatmap is not the original.
-                    Assert.That(firstImport.ID, Is.Not.EqualTo(secondImport.ID));
-                }
-                finally
-                {
-                    Directory.Delete(extractedFolder, true);
-                }
+                checkCount<BeatmapInfo>(realm, 12);
+                checkCount<BeatmapMetadata>(realm, 12);
+                checkCount<BeatmapSetInfo>(realm, 1);
+
+                // check the newly "imported" beatmap is not the original.
+                Assert.That(importBeforeUpdate.ID, Is.Not.EqualTo(importAfterUpdate.ID));
             });
         }
+
+        private static void checkCount<T>(RealmAccess realm, int expected, Expression<Func<T, bool>>? condition = null) where T : RealmObject
+        {
+            var query = realm.Realm.All<T>();
+
+            if (condition != null)
+                query = query.Where(condition);
+
+            Assert.That(query, Has.Count.EqualTo(expected));
+        }
+
+        private static IDisposable getBeatmapArchiveWithModifications(out string path, Action<DirectoryInfo> applyModifications)
+        {
+            var cleanup = getBeatmapArchive(out path);
+
+            string extractedFolder = $"{path}_extracted";
+            Directory.CreateDirectory(extractedFolder);
+
+            using (var zip = ZipArchive.Open(path))
+                zip.WriteToDirectory(extractedFolder);
+
+            applyModifications(new DirectoryInfo(extractedFolder));
+
+            File.Delete(path);
+
+            using (var zip = ZipArchive.Create())
+            {
+                zip.AddAllFromDirectory(extractedFolder);
+                zip.SaveTo(path, new ZipWriterOptions(CompressionType.Deflate));
+            }
+
+            Directory.Delete(extractedFolder, true);
+
+            return cleanup;
+        }
+
+        private static IDisposable getBeatmapArchive(out string path, bool quick = true)
+        {
+            string beatmapPath = TestResources.GetTestBeatmapForImport(quick);
+
+            path = beatmapPath;
+
+            return new InvokeOnDisposal(() => File.Delete(beatmapPath));
+        }
     }
 }