Apply @scottinet requested changes

Author: alexandrebouthinon

Kuzzle.Tests/API/Controllers/IndexControllerTest.cs

@@ -19,152 +19,184 @@ public IndexControllerTest() {
 
     [Fact]
     public async void CreateAsyncTest() {
-      var expected = JObject.Parse(@"
-      {
-				acknowledged: true, 
-				shards_acknowledged: true
-			} ");
+      _api.SetResult(@"
+        { 
+          result: {
+            acknowledged: true, 
+            shards_acknowledged: true
+          }
+        }
+      ");
 
-      _api.SetResult(new JObject { { "result", expected } });
-
-      JObject result = await _indexController.CreateAsync("foo");
+      Assert.Equal(
+          new JObject {
+            { "acknowledged", true },
+            { "shards_acknowledged", true }
+          }, await _indexController.CreateAsync("foo")
+      );
+      
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "create" },
         { "index", "foo" }
       });
-
-			Assert.Equal(expected, result);
-		}
+    }
 
     [Fact]
     public async void DeleteAsyncTest() {
-      _api.SetResult(@"{result: {acknowledged: true} }");
+      _api.SetResult(@"
+        {
+          result: {
+            acknowledged: true
+          } 
+        }
+      ");
+
       await _indexController.DeleteAsync("foo");
 
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "delete" },
         { "index", "foo" }
       });
-		}
+    }
 
-    [Fact]
-    public async void ExistsAsyncTest() {
-      _api.SetResult(@"{result: true}");
-      bool result = await _indexController.ExistsAsync("foo");
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void ExistsAsyncTest(bool result) {
+      _api.SetResult($"{{result:{result.ToString().ToLower()}}}");
+
+      Assert.Equal(
+        result, 
+        await _indexController.ExistsAsync("foo")
+      );
 
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "exists" },
         { "index", "foo" }
       });
-			Assert.True(result);
-		}
+    }
 
-    [Fact]
-    public async void GetAutoRefreshAsyncTest() {
-      _api.SetResult(@"{result: true}");
-      bool result = await _indexController.GetAutoRefreshAsync("foo");
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void GetAutoRefreshAsyncTest(bool result) {
+      _api.SetResult($"{{result:{result.ToString().ToLower()}}}");
+
+      Assert.Equal(
+        result, 
+        await _indexController.GetAutoRefreshAsync("foo")
+      );
 
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "getAutoRefresh" },
         { "index", "foo" }
       });
-			Assert.True(result);
-		}
+    }
 
     [Fact]
     public async void ListAsyncTest() {
-      _api.SetResult(@"{result: { indexes: ['foo', 'bar', 'zoo'] } }");
-      JArray result = await _indexController.ListAsync();
+      var indexes = new JArray { "foo", "bar", "zoo" };
+      _api.SetResult($"{{result:{{indexes:{indexes.ToString().ToLower()}}}}}");
+
+      Assert.Equal(
+        indexes,
+        await _indexController.ListAsync(), 
+        new JTokenEqualityComparer()
+      );
 
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "list" },
       });
-
-      Assert.Equal(
-        new JArray { "foo", "bar", "zoo" },
-        result,
-        new JTokenEqualityComparer());
-		}
+    }
 
     [Fact]
     public async void MDeleteAsyncTest() {
-			var indexes = new JArray { "foo", "bar", "zoo" };
-			_api.SetResult(@"{result: { indexes:  ['foo', 'bar', 'zoo'] } }");
+      var indexes = new JArray { "foo", "bar", "zoo" };
+      _api.SetResult(
+          $"{{result:{{indexes:{indexes.ToString().ToLower()}}}}}");
 
-      JArray result = await _indexController.MDeleteAsync(indexes);
+      Assert.Equal(
+        indexes, 
+        await _indexController.MDeleteAsync(indexes), 
+        new JTokenEqualityComparer()
+      );
 
-      var expected = new JObject {
-        { "controller", "index" },
+      _api.Verify(new JObject {
+        { "controller", "index" }, 
         { "action", "mDelete" },
-      };
-
-      expected.Add("body", new JObject());
-      ((JObject)expected["body"]).Add("indexes", indexes);
+        { "body", new JObject { { "indexes", indexes } } }
+      });
+    }
 
-      _api.Verify(expected);
+    [Fact]
+    public async void RefreshAsyncTest() {
+      _api.SetResult(@"
+        {
+          result: {
+            _shards: {
+              failed: 0,
+              successful: 5,
+              total: 10
+            }
+          }
+        }
+      ");
 
       Assert.Equal(
-        indexes,
-        result,
-        new JTokenEqualityComparer());
-		}
+          new JObject {
+            { "failed", 0 },
+            { "successful", 5 },
+            { "total", 10 }
+          }, await _indexController.RefreshAsync("foo")
+      );
 
-    [Fact]
-    public async void RefreshAsyncTest() {
-      var expected = JObject.Parse(@"
-      {
-				_shards: {
-					failed: 0,
-					succressful: 5,
-					total: 10
-				}
-			} ");
-
-      _api.SetResult(new JObject { { "result", expected } });
-
-      JObject result = await _indexController.RefreshAsync("foo");
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "refresh" },
         { "index", "foo" }
       });
-
-			Assert.Equal(expected, result);
-		}
+    }
 
     [Fact]
     public async void RefreshInternalAsyncTest() {
-      _api.SetResult(@"{result: { acknowledged: true }}");
-      bool result = await _indexController.RefreshInternalAsync();
+      _api.SetResult(@"
+        {
+          result: {
+            acknowledged: true 
+          }
+        }
+      ");
+
+      await _indexController.RefreshInternalAsync();
 
       _api.Verify(new JObject {
         { "controller", "index" },
         { "action", "refreshInternal" },
       });
-			Assert.True(result);
-		}
-
-    [Fact]
-    public async void SetAutoRefreshAsyncTest() {
-      _api.SetResult(@"{result: { response: true } }");
-      var expected = new JObject {
-        { "controller", "index" },
-        { "action", "setAutoRefresh" },
-        { "index", "foo" }
-      };
+    }
 
-      expected.Add("body", new JObject());
-      ((JObject)expected["body"]).Add("autoRefresh", true);
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void SetAutoRefreshAsyncTest(bool result) {
+      _api.SetResult($"{{result:{{response:{result.ToString().ToLower()}}}}}");
 
-      bool result = await _indexController.SetAutoRefreshAsync("foo", true);
+      Assert.Equal(
+        result, 
+        await _indexController.SetAutoRefreshAsync("foo", result)
+      );
 
-      _api.Verify(expected);
-			Assert.True(result);
-		}
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "setAutoRefresh" }, 
+        { "index", "foo" },
+        { "body", new JObject { { "autoRefresh", result } } }
+      });
+    }
   }
 }