Add Index Controller (#23)

alexandrebouthinon · Aschen · commit 9c1340af72a7 · 2019-07-15T18:37:14.000+02:00
Add Index controller to the SDK C#:
diff --git a/.travis.yml b/.travis.yml
@@ -1,7 +1,8 @@
-
 jobs:
   include:
-    - name: Unit Tests
+    - stage: "Tests"
+      name: "Unit Tests"
+      if: type = pull_request OR type = push AND branch =~ /^master|[0-9]+-dev$/ OR type = cron
       language: csharp
       solution: sdk-csharp.sln
       sudo: required
@@ -12,22 +13,38 @@ jobs:
         - dotnet restore
 
       script:
-        # incompatibilities with msbuild, so building with .net core instead
-        - dotnet build $TRAVIS_BUILD_DIR/Kuzzle/Kuzzle.csproj -c Release
-        - dotnet build $TRAVIS_BUILD_DIR/Kuzzle.Tests/Kuzzle.Tests.csproj
         - dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=lcov /p:CoverletOutput=$TRAVIS_BUILD_DIR/lcov.info
         - curl -s https://codecov.io/bash > codecov && bash codecov
 
-      deploy:
-        skip_cleanup: true
-        email: support@kuzzle.io
-        provider: script
-        script: bash deploy.sh
-
-    - name: Documentation tests
+    - stage: "Tests"
+      name: "Documentation"
+      if: type = pull_request OR type = push AND branch =~ /^master|[0-9]+-dev$/ OR type = cron
       stage: Tests
       language: node_js
       node_js: 8
 
       script:
         - docker-compose -f .ci/doc/docker-compose.yml run doc-tests node index
+
+    - stage: "Deployments"
+      name: "NuGet"
+      if: tag IS present AND branch = master
+      language: csharp
+      solution: sdk-csharp.sln
+      sudo: required
+      dist: xenial
+      dotnet: 2.2
+      mono: latest
+      install:
+        - dotnet restore
+
+      script:
+        # incompatibilities with msbuild, so building with .net core instead
+        - dotnet build $TRAVIS_BUILD_DIR/Kuzzle/Kuzzle.csproj -c Release
+        - dotnet build $TRAVIS_BUILD_DIR/Kuzzle.Tests/Kuzzle.Tests.csproj
+
+      deploy:
+        skip_cleanup: true
+        email: support@kuzzle.io
+        provider: script
+        script: bash deploy.sh
diff --git a/Kuzzle.Tests/API/Controllers/IndexControllerTest.cs b/Kuzzle.Tests/API/Controllers/IndexControllerTest.cs
@@ -0,0 +1,192 @@
+﻿using KuzzleSdk.API.Controllers;
+using Newtonsoft.Json.Linq;
+using Xunit;
+
+namespace Kuzzle.Tests.API.Controllers {
+  public class IndexControllerTest {
+    private readonly IndexController _indexController;
+    private readonly KuzzleApiMock _api;
+
+    public IndexControllerTest() {
+      _api = new KuzzleApiMock();
+      _indexController = new IndexController(_api.MockedObject);
+    }
+
+    [Fact]
+    public async void CreateAsyncTest() {
+      _api.SetResult(@"
+        { 
+          result: {
+            acknowledged: true, 
+            shards_acknowledged: true
+          }
+        }
+      ");
+
+      await _indexController.CreateAsync("foo");
+      
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "create" },
+        { "index", "foo" }
+      });
+    }
+
+    [Fact]
+    public async void DeleteAsyncTest() {
+      _api.SetResult(@"
+        {
+          result: {
+            acknowledged: true
+          } 
+        }
+      ");
+
+      await _indexController.DeleteAsync("foo");
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "delete" },
+        { "index", "foo" }
+      });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void ExistsAsyncTest(bool result) {
+      _api.SetResult(new JObject { { "result" , result } } );
+
+      Assert.Equal(
+        result, 
+        await _indexController.ExistsAsync("foo")
+      );
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "exists" },
+        { "index", "foo" }
+      });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void GetAutoRefreshAsyncTest(bool result) {
+      _api.SetResult(new JObject { { "result" , result } } );
+
+      Assert.Equal(
+        result, 
+        await _indexController.GetAutoRefreshAsync("foo")
+      );
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "getAutoRefresh" },
+        { "index", "foo" }
+      });
+    }
+
+    [Fact]
+    public async void ListAsyncTest() {
+      var indexes = new JArray { "foo", "bar", "zoo" };
+      _api.SetResult(new JObject { 
+        { "result" , new JObject { { "indexes", indexes } } } 
+      });
+
+      Assert.Equal(
+        indexes,
+        await _indexController.ListAsync(), 
+        new JTokenEqualityComparer()
+      );
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "list" },
+      });
+    }
+
+    [Fact]
+    public async void MDeleteAsyncTest() {
+      var indexes = new JArray { "foo", "bar", "zoo" };
+      _api.SetResult(new JObject { 
+        { "result" , new JObject { { "indexes", indexes } } } 
+      });
+
+      Assert.Equal(
+        indexes, 
+        await _indexController.MDeleteAsync(indexes), 
+        new JTokenEqualityComparer()
+      );
+
+      _api.Verify(new JObject {
+        { "controller", "index" }, 
+        { "action", "mDelete" },
+        { "body", new JObject { { "indexes", indexes } } }
+      });
+    }
+
+    [Fact]
+    public async void RefreshAsyncTest() {
+      _api.SetResult(@"
+        {
+          result: {
+            _shards: {
+              failed: 0,
+              successful: 5,
+              total: 10
+            }
+          }
+        }
+      ");
+
+      Assert.Equal(new JObject {
+        { "failed", 0 },
+        { "successful", 5 },
+        { "total", 10 }
+      }, await _indexController.RefreshAsync("foo"));
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "refresh" },
+        { "index", "foo" }
+      });
+    }
+
+    [Fact]
+    public async void RefreshInternalAsyncTest() {
+      _api.SetResult(@"
+        {
+          result: {
+            acknowledged: true 
+          }
+        }
+      ");
+
+      await _indexController.RefreshInternalAsync();
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "refreshInternal" },
+      });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async void SetAutoRefreshAsyncTest(bool autoRefresh) {
+      _api.SetResult(new JObject { 
+        { "result" , new JObject { { "response", autoRefresh } } } 
+      });
+
+      await _indexController.SetAutoRefreshAsync("foo", autoRefresh);
+
+      _api.Verify(new JObject {
+        { "controller", "index" },
+        { "action", "setAutoRefresh" }, 
+        { "index", "foo" },
+        { "body", new JObject { { "autoRefresh", autoRefresh } } }
+      });
+    }
+  }
+}
diff --git a/Kuzzle.Tests/KuzzleTest.cs b/Kuzzle.Tests/KuzzleTest.cs
@@ -40,6 +40,7 @@ public void KuzzleConstructorTest() {
       Assert.IsType<AuthController>(_kuzzle.Auth);
       Assert.IsType<CollectionController>(_kuzzle.Collection);
       Assert.IsType<DocumentController>(_kuzzle.Document);
+      Assert.IsType<IndexController>(_kuzzle.Index);
       Assert.IsType<RealtimeController>(_kuzzle.Realtime);
       Assert.IsType<ServerController>(_kuzzle.Server);
       Assert.NotEqual(_kuzzle.InstanceId, kuzzle2.InstanceId);
@@ -204,4 +205,4 @@ await Assert.ThrowsAsync<ConnectionLostException>(async () => {
       Assert.Empty(_kuzzle.requests.Keys);
     }
   }
-}
+}
diff --git a/Kuzzle/API/Controllers/IndexController.cs b/Kuzzle/API/Controllers/IndexController.cs
@@ -0,0 +1,121 @@
+﻿using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace KuzzleSdk.API.Controllers {
+  /// <summary>
+  /// Implements the "index" Kuzzle API controller
+  /// </summary>
+  public class IndexController: BaseController {
+    internal IndexController(IKuzzleApi api) : base(api) {}
+
+    /// <summary>
+    /// Creates a new index in Kuzzle via the persistence engine.
+    /// </summary>
+    public async Task CreateAsync(string index) {
+      await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "create" },
+        { "index", index },
+      });
+    }
+
+    /// <summary>
+    /// Deletes an index from the Kuzzle persistence engine.
+    /// </summary>
+    public async Task DeleteAsync(string index) {
+      await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "delete" },
+        { "index", index },
+      });
+    }
+
+    /// <summary>
+    /// Checks if an index exists in the Kuzzle persistence engine.
+    /// </summary>
+    public async Task<bool> ExistsAsync(string index) {
+      Response response = await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "exists" },
+        { "index", index },
+      });
+
+      return (bool)response.Result;
+    }
+
+    /// <summary>
+    /// Gets the autoRefresh flag value for the given index.
+    /// </summary>
+    public async Task<bool> GetAutoRefreshAsync(string index) {
+      Response response = await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "getAutoRefresh" },
+        { "index", index },
+      });
+
+      return (bool)response.Result;
+    }
+
+    /// <summary>
+    /// Lists indexes from the Kuzzle persistence engine.
+    /// </summary>
+    public async Task<JArray> ListAsync() {
+      Response response = await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "list" },
+      });
+
+      return (JArray)response.Result["indexes"];
+    }
+
+    /// <summary>
+    /// Deletes multiple indexes from the Kuzzle persistence engine.
+    /// </summary>
+    public async Task<JArray> MDeleteAsync(JArray indexes) {
+      var request = new JObject {
+        { "controller", "index" },
+        { "action", "mDelete" },
+        { "body", new JObject { { "indexes", indexes } } }
+      };
+
+      Response response = await api.QueryAsync(request);
+
+      return (JArray)response.Result["indexes"];
+    }
+
+    /// <summary>
+    /// Forces an immediate reindexation of the provided index.
+    /// </summary>
+    public async Task<JObject> RefreshAsync(string index) {
+      Response response = await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "refresh" },
+        { "index", index },
+      });
+
+      return (JObject)response.Result["_shards"];
+    }
+
+    /// <summary>
+    /// Forces an immediate reindexation of Kuzzle internal storage.
+    /// </summary>
+    public async Task RefreshInternalAsync() {
+      await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "refreshInternal" },
+      });
+    }
+
+    /// <summary>
+    /// Changes the autoRefresh configuration of the given index.
+    /// </summary>
+    public async Task SetAutoRefreshAsync(string index, bool autoRefresh) {
+      await api.QueryAsync(new JObject {
+        { "controller", "index" },
+        { "action", "setAutoRefresh" }, 
+        { "index", index },
+        { "body", new JObject { { "autoRefresh", autoRefresh } } }
+      });
+    }
+  }
+}
diff --git a/Kuzzle/Kuzzle.cs b/Kuzzle/Kuzzle.cs

Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ public void KuzzleConstructorTest() {`
`40`	`40`	`Assert.IsType<AuthController>(_kuzzle.Auth);`
`41`	`41`	`Assert.IsType<CollectionController>(_kuzzle.Collection);`
`42`	`42`	`Assert.IsType<DocumentController>(_kuzzle.Document);`
	`43`	`+ Assert.IsType<IndexController>(_kuzzle.Index);`
`43`	`44`	`Assert.IsType<RealtimeController>(_kuzzle.Realtime);`
`44`	`45`	`Assert.IsType<ServerController>(_kuzzle.Server);`
`45`	`46`	`Assert.NotEqual(_kuzzle.InstanceId, kuzzle2.InstanceId);`
`@@ -204,4 +205,4 @@ await Assert.ThrowsAsync<ConnectionLostException>(async () => {`
`204`	`205`	`Assert.Empty(_kuzzle.requests.Keys);`
`205`	`206`	`}`
`206`	`207`	`}`
`207`		`-}`
	`208`	`+}`