Merge pull request #562 from JongHyun070105/jonghyun/test

#553

Lib9c.Models/States/WorldInformationState.cs

@@ -25,6 +25,8 @@ public record WorldInformationState : IBencodable
             .Add(kv.Key.Serialize())
             .Add(kv.Value.Bencoded)));
 
+    public WorldInformationState(){}
+
     public WorldInformationState(IValue bencoded)
     {
         if (bencoded is not Dictionary d)

Mimir.MongoDB/Repositories/WorldInformationRepository.cs

@@ -3,10 +3,16 @@
 using Mimir.MongoDB.Exceptions;
 using Mimir.MongoDB.Services;
 using MongoDB.Driver;
+using Lib9c.Models.States;
 
 namespace Mimir.MongoDB.Repositories;
 
-public class WorldInformationRepository(IMongoDbService dbService)
+public interface IWorldInformationRepository
+{
+    Task<WorldInformationDocument> GetByAddressAsync(Address address);
+}
+
+public class WorldInformationRepository(IMongoDbService dbService) : IWorldInformationRepository
 {
     public async Task<WorldInformationDocument> GetByAddressAsync(Address address)
     {
@@ -27,4 +33,4 @@ public async Task<WorldInformationDocument> GetByAddressAsync(Address address)
 
         return document;
     }
-}
+}

Mimir.Tests/QueryTests/WorldInformationTest.GraphQL_Query_WorldInformation_Returns_CorrectValue.verified.txt

@@ -0,0 +1,22 @@
+{
+  "data": {
+    "worldInformation": {
+      "worldDictionary": [
+        {
+          "key": 1,
+          "value": {
+            "id": 1,
+            "isStageCleared": true,
+            "isUnlocked": true,
+            "name": "kim",
+            "stageBegin": 2,
+            "stageClearedBlockIndex": 1,
+            "stageClearedId": 2,
+            "stageEnd": 3,
+            "unlockedBlockIndex": 2
+          }
+        }
+      ]
+    }
+  }
+}

Mimir.Tests/QueryTests/WorldInformationTest.cs

@@ -0,0 +1,74 @@
+using Bencodex.Types;
+using Lib9c.Models.States;
+using Lib9c.Models.WorldInformation;
+using Libplanet.Crypto;
+using Mimir.MongoDB.Bson;
+using Mimir.MongoDB.Repositories;
+using Mimir.Tests;
+using Moq;
+using Nekoyume.Model.State;
+
+public class WorldInformationTest
+{
+    [Fact]
+    public async Task GraphQL_Query_WorldInformation_Returns_CorrectValue()
+    {
+        var address = new Address("0x0000000000000000000000000000000000000000");
+
+        var mockRepo = new Mock<IWorldInformationRepository>();
+        mockRepo
+            .Setup(repo => repo.GetByAddressAsync(It.IsAny<Address>()))
+            .ReturnsAsync(new WorldInformationDocument(
+                0,
+                default,
+                new WorldInformationState()
+                {
+                    WorldDictionary = new Dictionary<int, World>()
+                    {
+                        { 
+                            1, 
+                            new World(new Dictionary(new Dictionary<IKey, IValue>
+                            {
+                                [(Text)"Id"] = 1.Serialize(), 
+                                [(Text)"Name"] = "kim".Serialize(), 
+                                [(Text)"StageBegin"] = 2.Serialize(),
+                                [(Text)"StageEnd"] = 3.Serialize(),
+                                [(Text)"UnlockedBlockIndex"] = 2.Serialize(),
+                                [(Text)"StageClearedBlockIndex"] = 1.Serialize(),
+                                [(Text)"StageClearedId"] = 2.Serialize(),
+                            }))
+                        }
+                    }
+                }
+            ));
+
+        var serviceProvider = TestServices.Builder
+            .With(mockRepo.Object)
+            .Build();
+
+        var query = $$"""
+            query {
+                worldInformation(address: "{{address}}") {
+                    worldDictionary {
+                        key
+                        value {
+                            id
+                            isStageCleared
+                            isUnlocked
+                            name
+                            stageBegin
+                            stageClearedBlockIndex
+                            stageClearedId
+                            stageEnd
+                            unlockedBlockIndex
+                        }
+                    }
+                }
+            }
+            """;
+
+        var result = await TestServices.ExecuteRequestAsync(serviceProvider, b => b.SetDocument(query));
+
+        await Verify(result);
+    }
+}

Mimir/GraphQL/Queries/Query.cs

@@ -12,6 +12,7 @@
 using Nekoyume;
 using Nekoyume.Action;
 using Nekoyume.Extensions;
+using Lib9c.Models.States;
 using Nekoyume.TableData;
 
 namespace Mimir.GraphQL.Queries;
@@ -253,6 +254,6 @@ public async Task<RaiderState> GetWorldBossRaiderAsync(
     /// <returns>The world information state.</returns>
     public async Task<WorldInformationState> GetWorldInformationAsync(
         Address address,
-        [Service] WorldInformationRepository repo) =>
+        [Service] IWorldInformationRepository repo) => 
         (await repo.GetByAddressAsync(address)).Object;
-}
+}

Mimir/Program.cs

@@ -58,7 +58,8 @@
 builder.Services.AddSingleton<WorldBossKillRewardRecordRepository>();
 builder.Services.AddSingleton<WorldBossRaiderRepository>();
 builder.Services.AddSingleton<WorldBossRepository>();
-builder.Services.AddSingleton<WorldInformationRepository>();
+builder.Services.AddSingleton<IWorldInformationRepository, WorldInformationRepository>();
+
 // ~MongoDB repositories.
 builder.Services.AddCors();
 builder.Services.AddHttpClient();