Merge branch 'master' into always-unique-test-online-ids

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs

@@ -17,15 +17,12 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -33,8 +30,8 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Spectate;
 using osu.Game.Tests.Resources;
-using osu.Game.Tests.Visual.OnlinePlay;
 using osu.Game.Users;
 using osuTK.Input;
 
@@ -46,11 +43,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private RulesetStore rulesets;
         private BeatmapSetInfo importedSet;
 
-        private DependenciesScreen dependenciesScreen;
+        private TestMultiplayerScreenStack multiplayerScreenStack;
-        private TestMultiplayer multiplayerScreen;
-        private TestMultiplayerClient client;
 
-        private TestMultiplayerRoomManager roomManager => multiplayerScreen.RoomManager;
+        private TestMultiplayerClient client => multiplayerScreenStack.Client;
+        private TestMultiplayerRoomManager roomManager => multiplayerScreenStack.RoomManager;
 
         [Cached(typeof(UserLookupCache))]
         private UserLookupCache lookupCache = new TestUserLookupCache();
@@ -72,22 +68,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
             });
 
-            AddStep("create multiplayer screen", () => multiplayerScreen = new TestMultiplayer());
+            AddStep("load multiplayer", () => LoadScreen(multiplayerScreenStack = new TestMultiplayerScreenStack()));
-
+            AddUntilStep("wait for multiplayer to load", () => multiplayerScreenStack.IsLoaded);
-            AddStep("load dependencies", () =>
-            {
-                client = new TestMultiplayerClient(roomManager);
-
-                // The screen gets suspended so it stops receiving updates.
-                Child = client;
-
-                LoadScreen(dependenciesScreen = new DependenciesScreen(client));
-            });
-
-            AddUntilStep("wait for dependencies to load", () => dependenciesScreen.IsLoaded);
-
-            AddStep("load multiplayer", () => LoadScreen(multiplayerScreen));
-            AddUntilStep("wait for multiplayer to load", () => multiplayerScreen.IsLoaded);
             AddUntilStep("wait for lounge to load", () => this.ChildrenOfType<MultiplayerLoungeSubScreen>().FirstOrDefault()?.IsLoaded == true);
         }
 
@@ -443,7 +425,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("start match externally", () => client.StartMatch());
 
-            AddAssert("play not started", () => multiplayerScreen.IsCurrentScreen());
+            AddAssert("play not started", () => multiplayerScreenStack.IsCurrentScreen());
         }
 
         [Test]
@@ -487,7 +469,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
             });
 
-            AddUntilStep("play started", () => !multiplayerScreen.IsCurrentScreen());
+            AddUntilStep("play started", () => multiplayerScreenStack.CurrentScreen is SpectatorScreen);
         }
 
         [Test]
@@ -529,16 +511,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("open mod overlay", () => this.ChildrenOfType<RoomSubScreen.UserModSelectButton>().Single().TriggerClick());
 
-            AddStep("invoke on back button", () => multiplayerScreen.OnBackButton());
+            AddStep("invoke on back button", () => multiplayerScreenStack.OnBackButton());
 
             AddAssert("mod overlay is hidden", () => this.ChildrenOfType<UserModSelectOverlay>().Single().State.Value == Visibility.Hidden);
 
             AddAssert("dialog overlay is hidden", () => DialogOverlay.State.Value == Visibility.Hidden);
 
-            testLeave("back button", () => multiplayerScreen.OnBackButton());
+            testLeave("back button", () => multiplayerScreenStack.OnBackButton());
 
             // mimics home button and OS window close
-            testLeave("forced exit", () => multiplayerScreen.Exit());
+            testLeave("forced exit", () => multiplayerScreenStack.Exit());
 
             void testLeave(string actionName, Action action)
             {
@@ -579,7 +561,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("click start button", () => InputManager.Click(MouseButton.Left));
 
-            AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+            AddUntilStep("wait for player", () => multiplayerScreenStack.CurrentScreen is Player);
 
             // Gameplay runs in real-time, so we need to incrementally check if gameplay has finished in order to not time out.
             for (double i = 1000; i < TestResources.QUICK_BEATMAP_LENGTH; i += 1000)
@@ -588,15 +570,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 AddUntilStep($"wait for time > {i}", () => this.ChildrenOfType<GameplayClockContainer>().SingleOrDefault()?.GameplayClock.CurrentTime > time);
             }
 
-            AddUntilStep("wait for results", () => Stack.CurrentScreen is ResultsScreen);
+            AddUntilStep("wait for results", () => multiplayerScreenStack.CurrentScreen is ResultsScreen);
         }
 
         private MultiplayerReadyButton readyButton => this.ChildrenOfType<MultiplayerReadyButton>().Single();
 
         private void createRoom(Func<Room> room)
         {
-            AddUntilStep("wait for lounge", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
+            AddUntilStep("wait for lounge", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
-            AddStep("open room", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));
+            AddStep("open room", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));
 
             AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
             AddWaitStep("wait for transition", 2);
@@ -609,35 +591,5 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => client.Room != null);
         }
-
-        /// <summary>
-        /// Used for the sole purpose of adding <see cref="TestMultiplayerClient"/> as a resolvable dependency.
-        /// </summary>
-        private class DependenciesScreen : OsuScreen
-        {
-            [Cached(typeof(MultiplayerClient))]
-            public readonly TestMultiplayerClient Client;
-
-            [Cached]
-            public readonly TestRoomRequestsHandler RequestsHandler = new TestRoomRequestsHandler();
-
-            public DependenciesScreen(TestMultiplayerClient client)
-            {
-                Client = client;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(IAPIProvider api, OsuGameBase game)
-            {
-                ((DummyAPIAccess)api).HandleRequest = request => RequestsHandler.HandleRequest(request, api.LocalUser.Value, game);
-            }
-        }
-
-        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
-        {
-            public new TestMultiplayerRoomManager RoomManager { get; private set; }
-
-            protected override RoomManager CreateRoomManager() => RoomManager = new TestMultiplayerRoomManager();
-        }
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneTeamVersus.cs

@@ -6,25 +6,19 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Online.API;
-using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Screens;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Participants;
 using osu.Game.Tests.Resources;
-using osu.Game.Tests.Visual.OnlinePlay;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
@@ -35,9 +29,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private RulesetStore rulesets;
         private BeatmapSetInfo importedSet;
 
-        private DependenciesScreen dependenciesScreen;
+        private TestMultiplayerScreenStack multiplayerScreenStack;
-        private TestMultiplayer multiplayerScreen;
+
-        private TestMultiplayerClient client;
+        private TestMultiplayerClient client => multiplayerScreenStack.Client;
 
         [Cached(typeof(UserLookupCache))]
         private UserLookupCache lookupCache = new TestUserLookupCache();
@@ -59,24 +53,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
             });
 
-            AddStep("create multiplayer screen", () => multiplayerScreen = new TestMultiplayer());
+            AddStep("load multiplayer", () => LoadScreen(multiplayerScreenStack = new TestMultiplayerScreenStack()));
-
+            AddUntilStep("wait for multiplayer to load", () => multiplayerScreenStack.IsLoaded);
-            AddStep("load dependencies", () =>
-            {
-                client = new TestMultiplayerClient(multiplayerScreen.RoomManager);
-
-                // The screen gets suspended so it stops receiving updates.
-                Child = client;
-
-                LoadScreen(dependenciesScreen = new DependenciesScreen(client));
-            });
-
-            AddUntilStep("wait for dependencies screen", () => Stack.CurrentScreen is DependenciesScreen);
-            AddUntilStep("wait for dependencies to start load", () => dependenciesScreen.LoadState > LoadState.NotLoaded);
-            AddUntilStep("wait for dependencies to load", () => dependenciesScreen.IsLoaded);
-
-            AddStep("load multiplayer", () => LoadScreen(multiplayerScreen));
-            AddUntilStep("wait for multiplayer to load", () => multiplayerScreen.IsLoaded);
             AddUntilStep("wait for lounge to load", () => this.ChildrenOfType<MultiplayerLoungeSubScreen>().FirstOrDefault()?.IsLoaded == true);
         }
 
@@ -122,7 +100,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("press button", () =>
             {
-                InputManager.MoveMouseTo(multiplayerScreen.ChildrenOfType<TeamDisplay>().First());
+                InputManager.MoveMouseTo(multiplayerScreenStack.ChildrenOfType<TeamDisplay>().First());
                 InputManager.Click(MouseButton.Left);
             });
             AddAssert("user on team 1", () => (client.Room?.Users.FirstOrDefault()?.MatchState as TeamVersusUserState)?.TeamID == 1);
@@ -156,7 +134,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void createRoom(Func<Room> room)
         {
-            AddStep("open room", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));
+            AddStep("open room", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().Single().Open(room()));
 
             AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
             AddWaitStep("wait for transition", 2);
@@ -169,35 +147,5 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => client.Room != null);
         }
-
-        /// <summary>
-        /// Used for the sole purpose of adding <see cref="TestMultiplayerClient"/> as a resolvable dependency.
-        /// </summary>
-        private class DependenciesScreen : OsuScreen
-        {
-            [Cached(typeof(MultiplayerClient))]
-            public readonly TestMultiplayerClient Client;
-
-            [Cached]
-            public readonly TestRoomRequestsHandler RequestsHandler = new TestRoomRequestsHandler();
-
-            public DependenciesScreen(TestMultiplayerClient client)
-            {
-                Client = client;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(IAPIProvider api, OsuGameBase game)
-            {
-                ((DummyAPIAccess)api).HandleRequest = request => RequestsHandler.HandleRequest(request, api.LocalUser.Value, game);
-            }
-        }
-
-        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
-        {
-            public new TestMultiplayerRoomManager RoomManager { get; private set; }
-
-            protected override RoomManager CreateRoomManager() => RoomManager = new TestMultiplayerRoomManager();
-        }
     }
 }

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -9,23 +9,18 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API;
-using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Options;
 using osu.Game.Tests.Beatmaps.IO;
-using osu.Game.Tests.Visual.Multiplayer;
-using osu.Game.Tests.Visual.OnlinePlay;
 using osuTK;
 using osuTK.Input;
 
@@ -335,12 +330,12 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestPushMatchSubScreenAndPressBackButtonImmediately()
         {
-            TestMultiplayer multiplayer = null;
+            TestMultiplayerScreenStack multiplayerScreenStack = null;
 
-            PushAndConfirm(() => multiplayer = new TestMultiplayer());
+            PushAndConfirm(() => multiplayerScreenStack = new TestMultiplayerScreenStack());
 
-            AddUntilStep("wait for lounge", () => multiplayer.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
+            AddUntilStep("wait for lounge", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
-            AddStep("open room", () => multiplayer.ChildrenOfType<LoungeSubScreen>().Single().Open());
+            AddStep("open room", () => multiplayerScreenStack.ChildrenOfType<LoungeSubScreen>().Single().Open());
             AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action());
             AddWaitStep("wait two frames", 2);
         }
@@ -455,28 +450,5 @@ namespace osu.Game.Tests.Visual.Navigation
 
             protected override bool DisplayStableImportPrompt => false;
         }
-
-        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
-        {
-            [Cached(typeof(MultiplayerClient))]
-            public readonly TestMultiplayerClient Client;
-
-            [Cached]
-            public readonly TestRoomRequestsHandler RequestsHandler;
-
-            public TestMultiplayer()
-            {
-                Client = new TestMultiplayerClient((TestMultiplayerRoomManager)RoomManager);
-                RequestsHandler = new TestRoomRequestsHandler();
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(IAPIProvider api, OsuGameBase game)
-            {
-                ((DummyAPIAccess)api).HandleRequest = request => RequestsHandler.HandleRequest(request, api.LocalUser.Value, game);
-            }
-
-            protected override RoomManager CreateRoomManager() => new TestMultiplayerRoomManager();
-        }
     }
 }

osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Settings
@@ -58,6 +59,13 @@ namespace osu.Game.Tests.Visual.Settings
                 Default = string.Empty,
                 Value = "Sample text"
             };
+
+            [SettingSource("Sample number textbox", "Textbox number entry", SettingControlType = typeof(SettingsNumberBox))]
+            public Bindable<int?> IntTextboxBindable { get; } = new Bindable<int?>
+            {
+                Default = null,
+                Value = null
+            };
         }
 
         private enum TestEnum

osu.Game.Tests/Visual/TestMultiplayerScreenStack.cs

@@ -0,0 +1,83 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.API;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens;
+using osu.Game.Screens.OnlinePlay.Components;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Tests.Visual.OnlinePlay;
+
+namespace osu.Game.Tests.Visual
+{
+    /// <summary>
+    /// An <see cref="OsuScreen"/> loadable into <see cref="ScreenTestScene"/>s via <see cref="ScreenTestScene.LoadScreen"/>,
+    /// which provides dependencies for and loads an isolated <see cref="Screens.OnlinePlay.Multiplayer.Multiplayer"/> screen.
+    /// <p>
+    /// This screen:
+    /// <list type="bullet">
+    /// <item>Provides a <see cref="TestMultiplayerClient"/> to be resolved as a dependency in the <see cref="Screens.OnlinePlay.Multiplayer.Multiplayer"/> screen,
+    /// which is typically a part of <see cref="OsuGameBase"/>.</item>
+    /// <item>Rebinds the <see cref="DummyAPIAccess"/> to handle requests via a <see cref="TestRoomRequestsHandler"/>.</item>
+    /// <item>Provides a <see cref="TestMultiplayerRoomManager"/> for the <see cref="Screens.OnlinePlay.Multiplayer.Multiplayer"/> screen.</item>
+    /// </list>
+    /// </p>
+    /// </summary>
+    public class TestMultiplayerScreenStack : OsuScreen
+    {
+        public Screens.OnlinePlay.Multiplayer.Multiplayer MultiplayerScreen => multiplayerScreen;
+
+        public TestMultiplayerRoomManager RoomManager => multiplayerScreen.RoomManager;
+
+        public IScreen CurrentScreen => screenStack.CurrentScreen;
+
+        public new bool IsLoaded => base.IsLoaded && MultiplayerScreen.IsLoaded;
+
+        [Cached(typeof(MultiplayerClient))]
+        public readonly TestMultiplayerClient Client;
+
+        private readonly OsuScreenStack screenStack;
+        private readonly TestMultiplayer multiplayerScreen;
+
+        public TestMultiplayerScreenStack()
+        {
+            multiplayerScreen = new TestMultiplayer();
+
+            InternalChildren = new Drawable[]
+            {
+                Client = new TestMultiplayerClient(RoomManager),
+                screenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both }
+            };
+
+            screenStack.Push(multiplayerScreen);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IAPIProvider api, OsuGameBase game)
+        {
+            ((DummyAPIAccess)api).HandleRequest = request => multiplayerScreen.RequestsHandler.HandleRequest(request, api.LocalUser.Value, game);
+        }
+
+        public override bool OnBackButton() => multiplayerScreen.OnBackButton();
+
+        public override bool OnExiting(IScreen next)
+        {
+            if (screenStack.CurrentScreen == null)
+                return base.OnExiting(next);
+
+            screenStack.Exit();
+            return true;
+        }
+
+        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
+        {
+            public new TestMultiplayerRoomManager RoomManager { get; private set; }
+            public TestRoomRequestsHandler RequestsHandler { get; private set; }
+
+            protected override RoomManager CreateRoomManager() => RoomManager = new TestMultiplayerRoomManager(RequestsHandler = new TestRoomRequestsHandler());
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs

@@ -41,6 +41,44 @@ namespace osu.Game.Tests.Visual.UserInterface
             notificationOverlay.UnreadCount.ValueChanged += count => { displayedCount.Text = $"displayed count: {count.NewValue}"; };
         });
 
+        [Test]
+        public void TestCompleteProgress()
+        {
+            ProgressNotification notification = null;
+            AddStep("add progress notification", () =>
+            {
+                notification = new ProgressNotification
+                {
+                    Text = @"Uploading to BSS...",
+                    CompletionText = "Uploaded to BSS!",
+                };
+                notificationOverlay.Post(notification);
+                progressingNotifications.Add(notification);
+            });
+
+            AddUntilStep("wait completion", () => notification.State == ProgressNotificationState.Completed);
+        }
+
+        [Test]
+        public void TestCancelProgress()
+        {
+            ProgressNotification notification = null;
+            AddStep("add progress notification", () =>
+            {
+                notification = new ProgressNotification
+                {
+                    Text = @"Uploading to BSS...",
+                    CompletionText = "Uploaded to BSS!",
+                };
+                notificationOverlay.Post(notification);
+                progressingNotifications.Add(notification);
+            });
+
+            AddWaitStep("wait 3", 3);
+
+            AddStep("cancel notification", () => notification.State = ProgressNotificationState.Cancelled);
+        }
+
         [Test]
         public void TestBasicFlow()
         {
@@ -138,7 +176,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             foreach (var n in progressingNotifications.FindAll(n => n.State == ProgressNotificationState.Active))
             {
                 if (n.Progress < 1)
-                    n.Progress += (float)(Time.Elapsed / 400) * RNG.NextSingle();
+                    n.Progress += (float)(Time.Elapsed / 2000);
                 else
                     n.State = ProgressNotificationState.Completed;
             }

osu.Game.Tests/Visual/UserInterface/TestSceneUpdateableBeatmapSetCover.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             AddStep("setup cover", () => Child = new UpdateableOnlineBeatmapSetCover(coverType)
             {
-                BeatmapSet = CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet,
+                OnlineInfo = CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet.OnlineInfo,
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
             });
@@ -68,7 +68,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
                     var cover = new UpdateableOnlineBeatmapSetCover(coverType)
                     {
-                        BeatmapSet = setInfo,
+                        OnlineInfo = setInfo.OnlineInfo,
                         Height = 100,
                         Masking = true,
                     };
@@ -99,12 +99,12 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("setup cover", () => Child = updateableCover = new TestUpdateableOnlineBeatmapSetCover
             {
-                BeatmapSet = CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet,
+                OnlineInfo = CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet.OnlineInfo,
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
             });
 
-            AddStep("change model", () => updateableCover.BeatmapSet = null);
+            AddStep("change model", () => updateableCover.OnlineInfo = null);
             AddWaitStep("wait some", 5);
             AddAssert("no cover added", () => !updateableCover.ChildrenOfType<DelayedLoadUnloadWrapper>().Any());
         }
@@ -117,7 +117,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("setup cover", () => Child = updateableCover = new TestUpdateableOnlineBeatmapSetCover(0)
             {
-                BeatmapSet = createBeatmapWithCover("https://assets.ppy.sh/beatmaps/1189904/covers/cover.jpg"),
+                OnlineInfo = createBeatmapWithCover("https://assets.ppy.sh/beatmaps/1189904/covers/cover.jpg").OnlineInfo,
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
                 Alpha = 0.4f
@@ -128,7 +128,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddUntilStep("wait for fade complete", () => initialCover.Alpha == 1);
 
             AddStep("switch beatmap",
-                () => updateableCover.BeatmapSet = createBeatmapWithCover("https://assets.ppy.sh/beatmaps/1079428/covers/cover.jpg"));
+                () => updateableCover.OnlineInfo = createBeatmapWithCover("https://assets.ppy.sh/beatmaps/1079428/covers/cover.jpg").OnlineInfo);
             AddUntilStep("new cover loaded", () => updateableCover.ChildrenOfType<OnlineBeatmapSetCover>().Except(new[] { initialCover }).Any());
         }
 

osu.Game.Tournament/Components/TournamentBeatmapPanel.cs

@@ -63,7 +63,7 @@ namespace osu.Game.Tournament.Components
                 {
                     RelativeSizeAxes = Axes.Both,
                     Colour = OsuColour.Gray(0.5f),
-                    BeatmapSet = Beatmap.BeatmapSet,
+                    OnlineInfo = Beatmap.BeatmapSet,
                 },
                 new FillFlowContainer
                 {

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -14,7 +14,7 @@ using osu.Game.Online.API.Requests.Responses;
 namespace osu.Game.Beatmaps
 {
     [ExcludeFromDynamicCompile]
-    public class BeatmapSetInfo : IHasPrimaryKey, IHasFiles<BeatmapSetFileInfo>, ISoftDelete, IEquatable<BeatmapSetInfo>, IBeatmapSetInfo, IBeatmapSetOnlineInfo
+    public class BeatmapSetInfo : IHasPrimaryKey, IHasFiles<BeatmapSetFileInfo>, ISoftDelete, IEquatable<BeatmapSetInfo>, IBeatmapSetInfo
     {
         public int ID { get; set; }
 
@@ -35,6 +35,7 @@ namespace osu.Game.Beatmaps
         [NotNull]
         public List<BeatmapSetFileInfo> Files { get; set; } = new List<BeatmapSetFileInfo>();
 
+        // This field is temporary and only used by `APIBeatmapSet.ToBeatmapSet` (soon to be removed) and tests (to be updated to provide APIBeatmapSet instead).
         [NotMapped]
         public APIBeatmapSet OnlineInfo { get; set; }
 

osu.Game/Beatmaps/Drawables/UpdateableBeatmapBackgroundSprite.cs

@@ -12,9 +12,9 @@ namespace osu.Game.Beatmaps.Drawables
     /// <summary>
     /// Display a beatmap background from a local source, but fallback to online source if not available.
     /// </summary>
-    public class UpdateableBeatmapBackgroundSprite : ModelBackedDrawable<BeatmapInfo>
+    public class UpdateableBeatmapBackgroundSprite : ModelBackedDrawable<IBeatmapInfo>
     {
-        public readonly Bindable<BeatmapInfo> Beatmap = new Bindable<BeatmapInfo>();
+        public readonly Bindable<IBeatmapInfo> Beatmap = new Bindable<IBeatmapInfo>();
 
         protected override double LoadDelay => 500;
 
@@ -39,7 +39,7 @@ namespace osu.Game.Beatmaps.Drawables
 
         protected override double TransformDuration => 400;
 
-        protected override Drawable CreateDrawable(BeatmapInfo model)
+        protected override Drawable CreateDrawable(IBeatmapInfo model)
         {
             var drawable = getDrawableForModel(model);
             drawable.RelativeSizeAxes = Axes.Both;
@@ -50,15 +50,21 @@ namespace osu.Game.Beatmaps.Drawables
             return drawable;
         }
 
-        private Drawable getDrawableForModel(BeatmapInfo model)
+        private Drawable getDrawableForModel(IBeatmapInfo model)
         {
             // prefer online cover where available.
-            if (model?.BeatmapSet?.OnlineInfo != null)
+            if (model?.BeatmapSet is IBeatmapSetOnlineInfo online)
-                return new OnlineBeatmapSetCover(model.BeatmapSet, beatmapSetCoverType);
+                return new OnlineBeatmapSetCover(online, beatmapSetCoverType);
 
-            return model?.ID > 0
+            if (model is BeatmapInfo localModel)
-                ? new BeatmapBackgroundSprite(beatmaps.GetWorkingBeatmap(model))
+            {
-                : new BeatmapBackgroundSprite(beatmaps.DefaultBeatmap);
+                if (localModel.BeatmapSet?.OnlineInfo != null)
+                    return new OnlineBeatmapSetCover(localModel.BeatmapSet.OnlineInfo, beatmapSetCoverType);
+
+                return new BeatmapBackgroundSprite(beatmaps.GetWorkingBeatmap(localModel));
+            }
+
+            return new BeatmapBackgroundSprite(beatmaps.DefaultBeatmap);
         }
     }
 }

osu.Game/Beatmaps/Drawables/UpdateableOnlineBeatmapSetCover.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Beatmaps.Drawables
     {
         private readonly BeatmapSetCoverType coverType;
 
-        public IBeatmapSetOnlineInfo BeatmapSet
+        public IBeatmapSetOnlineInfo OnlineInfo
         {
             get => Model;
             set => Model = value;

osu.Game/Overlays/BeatmapListing/BeatmapListingSearchControl.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Overlays.BeatmapListing
                     return;
                 }
 
-                beatmapCover.BeatmapSet = value;
+                beatmapCover.OnlineInfo = value.OnlineInfo;
                 beatmapCover.FadeTo(0.1f, 200, Easing.OutQuint);
             }
         }

osu.Game/Overlays/BeatmapListing/Panels/BeatmapPanel.cs

@@ -163,7 +163,7 @@ namespace osu.Game.Overlays.BeatmapListing.Panels
         protected Drawable CreateBackground() => new UpdateableOnlineBeatmapSetCover
         {
             RelativeSizeAxes = Axes.Both,
-            BeatmapSet = SetInfo,
+            OnlineInfo = SetInfo.OnlineInfo,
         };
 
         public class Statistic : FillFlowContainer

osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs

@@ -227,7 +227,7 @@ namespace osu.Game.Overlays.BeatmapSet
             BeatmapSet.BindValueChanged(setInfo =>
             {
                 Picker.BeatmapSet = rulesetSelector.BeatmapSet = author.BeatmapSet = beatmapAvailability.BeatmapSet = Details.BeatmapSet = setInfo.NewValue;
-                cover.BeatmapSet = setInfo.NewValue;
+                cover.OnlineInfo = setInfo.NewValue?.OnlineInfo;
 
                 if (setInfo.NewValue == null)
                 {

osu.Game/Overlays/Dashboard/Home/DashboardBeatmapPanel.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Overlays.Dashboard.Home
                                         RelativeSizeAxes = Axes.Both,
                                         Anchor = Anchor.Centre,
                                         Origin = Anchor.Centre,
-                                        BeatmapSet = SetInfo
+                                        OnlineInfo = SetInfo.OnlineInfo
                                     }
                                 },
                                 new Container

osu.Game/Overlays/Notifications/ProgressNotification.cs

@@ -4,11 +4,15 @@
 using System;
 using System.Threading;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osuTK;
 using osuTK.Graphics;
 
@@ -16,6 +20,8 @@ namespace osu.Game.Overlays.Notifications
 {
     public class ProgressNotification : Notification, IHasCompletionTarget
     {
+        private const float loading_spinner_size = 22;
+
         public string Text
         {
             set => Schedule(() => textDrawable.Text = value);
@@ -65,29 +71,53 @@ namespace osu.Game.Overlays.Notifications
 
         private void updateState()
         {
+            const double colour_fade_duration = 200;
+
             switch (state)
             {
                 case ProgressNotificationState.Queued:
                     Light.Colour = colourQueued;
                     Light.Pulsate = false;
                     progressBar.Active = false;
+
+                    iconBackground.FadeColour(ColourInfo.GradientVertical(colourQueued, colourQueued.Lighten(0.5f)), colour_fade_duration);
+                    loadingSpinner.Show();
                     break;
 
                 case ProgressNotificationState.Active:
                     Light.Colour = colourActive;
                     Light.Pulsate = true;
                     progressBar.Active = true;
+
+                    iconBackground.FadeColour(ColourInfo.GradientVertical(colourActive, colourActive.Lighten(0.5f)), colour_fade_duration);
+                    loadingSpinner.Show();
                     break;
 
                 case ProgressNotificationState.Cancelled:
                     cancellationTokenSource.Cancel();
 
+                    iconBackground.FadeColour(ColourInfo.GradientVertical(Color4.Gray, Color4.Gray.Lighten(0.5f)), colour_fade_duration);
+                    loadingSpinner.Hide();
+
+                    var icon = new SpriteIcon
+                    {
+                        Icon = FontAwesome.Solid.Ban,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Size = new Vector2(loading_spinner_size),
+                    };
+
+                    IconContent.Add(icon);
+
+                    icon.FadeInFromZero(200, Easing.OutQuint);
+
                     Light.Colour = colourCancelled;
                     Light.Pulsate = false;
                     progressBar.Active = false;
                     break;
 
                 case ProgressNotificationState.Completed:
+                    loadingSpinner.Hide();
                     NotificationContent.MoveToY(-DrawSize.Y / 2, 200, Easing.OutQuint);
                     this.FadeOut(200).Finally(d => Completed());
                     break;
@@ -115,15 +145,13 @@ namespace osu.Game.Overlays.Notifications
         private Color4 colourActive;
         private Color4 colourCancelled;
 
+        private Box iconBackground;
+        private LoadingSpinner loadingSpinner;
+
         private readonly TextFlowContainer textDrawable;
 
         public ProgressNotification()
         {
-            IconContent.Add(new Box
-            {
-                RelativeSizeAxes = Axes.Both,
-            });
-
             Content.Add(textDrawable = new OsuTextFlowContainer
             {
                 Colour = OsuColour.Gray(128),
@@ -138,6 +166,9 @@ namespace osu.Game.Overlays.Notifications
                 RelativeSizeAxes = Axes.X,
             });
 
+            // make some extra space for the progress bar.
+            IconContent.Margin = new MarginPadding { Bottom = 5 };
+
             State = ProgressNotificationState.Queued;
 
             // don't close on click by default.
@@ -150,6 +181,19 @@ namespace osu.Game.Overlays.Notifications
             colourQueued = colours.YellowDark;
             colourActive = colours.Blue;
             colourCancelled = colours.Red;
+
+            IconContent.AddRange(new Drawable[]
+            {
+                iconBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.White,
+                },
+                loadingSpinner = new LoadingSpinner
+                {
+                    Size = new Vector2(loading_spinner_size),
+                }
+            });
         }
 
         public override void Close()

osu.Game/Overlays/Profile/Sections/Historical/DrawableMostPlayedBeatmap.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
                 {
                     RelativeSizeAxes = Axes.Y,
                     Width = cover_width,
-                    BeatmapSet = mostPlayed.BeatmapSet,
+                    OnlineInfo = mostPlayed.BeatmapSet,
                 },
                 new Container
                 {

osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs

@@ -333,13 +333,14 @@ namespace osu.Game.Screens.OnlinePlay
 
             public PanelBackground()
             {
+                UpdateableBeatmapBackgroundSprite backgroundSprite;
+
                 InternalChildren = new Drawable[]
                 {
-                    new UpdateableBeatmapBackgroundSprite
+                    backgroundSprite = new UpdateableBeatmapBackgroundSprite
                     {
                         RelativeSizeAxes = Axes.Both,
                         FillMode = FillMode.Fill,
-                        Beatmap = { BindTarget = Beatmap }
                     },
                     new FillFlowContainer
                     {
@@ -374,6 +375,10 @@ namespace osu.Game.Screens.OnlinePlay
                         }
                     }
                 };
+
+                // manual binding required as playlists don't expose IBeatmapInfo currently.
+                // may be removed in the future if this changes.
+                Beatmap.BindValueChanged(beatmap => backgroundSprite.Beatmap.Value = beatmap.NewValue);
             }
         }
     }

osu.Game/Tests/Visual/Multiplayer/MultiplayerTestSceneDependencies.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             CacheAs<SpectatorClient>(SpectatorClient);
         }
 
-        protected override IRoomManager CreateRoomManager() => new TestMultiplayerRoomManager();
+        protected override IRoomManager CreateRoomManager() => new TestMultiplayerRoomManager(RequestsHandler);
 
         protected virtual TestSpectatorClient CreateSpectatorClient() => new TestSpectatorClient();
     }

osu.Game/Tests/Visual/Multiplayer/TestMultiplayerRoomManager.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Allocation;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
@@ -16,8 +15,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
     /// </summary>
     public class TestMultiplayerRoomManager : MultiplayerRoomManager
     {
-        [Resolved]
+        private readonly TestRoomRequestsHandler requestsHandler;
-        private TestRoomRequestsHandler requestsHandler { get; set; }
+
+        public TestMultiplayerRoomManager(TestRoomRequestsHandler requestsHandler)
+        {
+            this.requestsHandler = requestsHandler;
+        }
 
         public IReadOnlyList<Room> ServerSideRooms => requestsHandler.ServerSideRooms;
 

osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs

@@ -64,7 +64,12 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         public override void SetUpSteps()
         {
             base.SetUpSteps();
-            AddStep("setup API", () => ((DummyAPIAccess)API).HandleRequest = request => OnlinePlayDependencies.RequestsHandler.HandleRequest(request, API.LocalUser.Value, game));
+
+            AddStep("setup API", () =>
+            {
+                var handler = OnlinePlayDependencies.RequestsHandler;
+                ((DummyAPIAccess)API).HandleRequest = request => handler.HandleRequest(request, API.LocalUser.Value, game);
+            });
         }
 
         /// <summary>

osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestSceneDependencies.cs

@@ -34,10 +34,10 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         public OnlinePlayTestSceneDependencies()
         {
             SelectedRoom = new Bindable<Room>();
-            RoomManager = CreateRoomManager();
+            RequestsHandler = new TestRoomRequestsHandler();
             OngoingOperationTracker = new OngoingOperationTracker();
             AvailabilityTracker = new OnlinePlayBeatmapAvailabilityTracker();
-            RequestsHandler = new TestRoomRequestsHandler();
+            RoomManager = CreateRoomManager();
 
             dependencies = new DependencyContainer(new CachedModelDependencyContainer<Room>(null) { Model = { BindTarget = SelectedRoom } });