fix InvalidOperationException getting universal stats for BGG game wi…

…th no game definitions #772
NemeStats · Jan 16, 2023 · 25f4b72 · 25f4b72
1 parent 2a19b98
commit 25f4b72
Show file tree

Hide file tree

Showing 2 changed files with 46 additions and 13 deletions.
diff --git a/Source/BusinessLogic/Logic/BoardGameGeekGameDefinitions/UniversalStatsRetriever.cs b/Source/BusinessLogic/Logic/BoardGameGeekGameDefinitions/UniversalStatsRetriever.cs
@@ -1,13 +1,11 @@
-using System;
+using System.Data.Entity;
 using System.Linq;
 using BusinessLogic.Caching;
 using BusinessLogic.DataAccess;
 using BusinessLogic.Exceptions;
 using BusinessLogic.Logic.Utilities;
 using BusinessLogic.Models;
 using BusinessLogic.Models.Games;
-using System.Collections;
-using BusinessLogic.Facades;
 
 namespace BusinessLogic.Logic.BoardGameGeekGameDefinitions
 {
@@ -22,21 +20,31 @@ public UniversalStatsRetriever(IDateUtilities dateUtilities, ICacheService cache
 
         public override UniversalGameStats GetFromSource(int boardGameGeekGameDefinitionId)
         {
-            var result = _dataContext.GetQueryable<BoardGameGeekGameDefinition>()
+            var definition = _dataContext
+                .GetQueryable<BoardGameGeekGameDefinition>()
                 .Where(x => x.Id == boardGameGeekGameDefinitionId)
-                .Select(x => new UniversalGameStats
-                {
-                    AveragePlayersPerGame = x.GameDefinitions.Average(y => y.PlayedGames.Select(p => p.NumberOfPlayers).Average()),
-                    TotalNumberOfGamesPlayed = x.GameDefinitions.Sum(y => y.PlayedGames.Count),
-                    TotalGamingGroupsWithThisGame = x.GameDefinitions.Where(g=>g.Active && g.PlayedGames.Any()).GroupBy(y => y.GamingGroupId).Select(z => z.Key).Count()
-                }).SingleOrDefault();
+                .Include(x => x.GameDefinitions)
+                .Include(x => x.GameDefinitions.Select(y => y.PlayedGames))
+                .SingleOrDefault();
 
-            if (result == null)
+            if (definition == null)
             {
                 throw new EntityDoesNotExistException<BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
             }
 
-            return result;
+            if (definition.GameDefinitions.Any())
+            {
+                return new UniversalGameStats
+                {
+                    AveragePlayersPerGame = definition.GameDefinitions.Average(y => y.PlayedGames.Select(p => p.NumberOfPlayers).Average()),
+                    TotalNumberOfGamesPlayed = definition.GameDefinitions.Sum(y => y.PlayedGames.Count),
+                    TotalGamingGroupsWithThisGame = definition.GameDefinitions.Where(g => g.Active && g.PlayedGames.Any()).GroupBy(y => y.GamingGroupId).Select(z => z.Key).Count()
+                };
+            }
+            else
+            {
+                return new UniversalGameStats();
+            }
         }
     }
 }
diff --git a/...ests/BoardGameGeekGameDefinitionsTests/UniversalStatsRetrieverTests/GetFromSourceTests.cs b/...ests/BoardGameGeekGameDefinitionsTests/UniversalStatsRetrieverTests/GetFromSourceTests.cs
@@ -13,7 +13,7 @@ namespace BusinessLogic.Tests.UnitTests.LogicTests.BoardGameGeekGameDefinitionsT
 {
     public class GetFromSourceTests
     {
-        private int _boardGameGeekGameDefinitionId = 1;
+        private readonly int _boardGameGeekGameDefinitionId = 1;
         private RhinoAutoMocker<UniversalStatsRetriever> _autoMocker;
         private BoardGameGeekGameDefinition _expectedBoardGameGeekGameDefinition;
 
@@ -109,5 +109,30 @@ public void It_Returns_The_Total_Number_Of_Gaming_Groups_That_Have_Played_This_G
             //--assert
             result.TotalGamingGroupsWithThisGame.ShouldBe(2);
         }
+
+        [Test]
+        public void It_Returns_Defaults_If_There_Are_No_Game_Definitions()
+        {
+            //--arrange
+            var expectedBggDefinition = new BoardGameGeekGameDefinition
+            {
+                Id = _boardGameGeekGameDefinitionId,
+                GameDefinitions = new List<GameDefinition>(),
+            };
+            var queryable = new List<BoardGameGeekGameDefinition>
+            {
+                expectedBggDefinition,
+            }.AsQueryable();
+            var mockRetriever = new RhinoAutoMocker<UniversalStatsRetriever>();
+            mockRetriever.Get<IDataContext>().Expect(mock => mock.GetQueryable<BoardGameGeekGameDefinition>()).Return(queryable);
+
+            //--act
+            var result = mockRetriever.ClassUnderTest.GetFromSource(_boardGameGeekGameDefinitionId);
+
+            //--assert
+            result.AveragePlayersPerGame.ShouldBe(null);
+            result.TotalGamingGroupsWithThisGame.ShouldBe(0);
+            result.TotalNumberOfGamesPlayed.ShouldBe(0);
+        }
     }
 }