DEVX-6548 | [Video] Moderation (#317)

* Implement DisconnectConnection, more ErrorResponse to Common namespace

* Implement MuteStream

* Implement MuteStreamsRequest

* Implement MuteStreamsUseCase

* Adapt Xml Documentation

Vonage.Video.Beta.Test/Extensions/FsCheckExtensions.cs

@@ -1,6 +1,6 @@
 using System.Net;
 using FsCheck;
-using Vonage.Video.Beta.Video.Sessions;
+using Vonage.Video.Beta.Common;
 
 namespace Vonage.Video.Beta.Test.Extensions
 {

Vonage.Video.Beta.Test/Video/Moderation/DisconnectConnection/DisconnectConnectionRequestTest.cs

@@ -0,0 +1,69 @@
+using AutoFixture;
+using FluentAssertions;
+using Vonage.Video.Beta.Common.Failures;
+using Vonage.Video.Beta.Test.Extensions;
+using Vonage.Video.Beta.Video.Moderation.DisconnectConnection;
+using Xunit;
+
+namespace Vonage.Video.Beta.Test.Video.Moderation.DisconnectConnection
+{
+    public class DisconnectConnectionRequestTest
+    {
+        private readonly string applicationId;
+        private readonly string sessionId;
+        private readonly string connectionId;
+
+        public DisconnectConnectionRequestTest()
+        {
+            var fixture = new Fixture();
+            this.applicationId = fixture.Create<string>();
+            this.sessionId = fixture.Create<string>();
+            this.connectionId = fixture.Create<string>();
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenApplicationIdIsNullOrWhitespace(string value) =>
+            DisconnectConnectionRequest.Parse(value, this.sessionId, this.connectionId)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("ApplicationId cannot be null or whitespace."));
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenSessionIdIsNullOrWhitespace(string value) =>
+            DisconnectConnectionRequest.Parse(this.applicationId, value, this.connectionId)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("SessionId cannot be null or whitespace."));
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenConnectionIdIsNullOrWhitespace(string value) =>
+            DisconnectConnectionRequest.Parse(this.applicationId, this.sessionId, value)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("ConnectionId cannot be null or whitespace."));
+
+        [Fact]
+        public void Parse_ShouldReturnSuccess_GivenValuesAreProvided() =>
+            DisconnectConnectionRequest.Parse(this.applicationId, this.sessionId, this.connectionId)
+                .Should()
+                .BeSuccess(request =>
+                {
+                    request.ApplicationId.Should().Be(this.applicationId);
+                    request.SessionId.Should().Be(this.sessionId);
+                    request.ConnectionId.Should().Be(this.connectionId);
+                });
+
+        [Fact]
+        public void GetEndpointPath_ShouldReturnApiEndpoint() =>
+            DisconnectConnectionRequest.Parse(this.applicationId, this.sessionId, this.connectionId)
+                .Map(request => request.GetEndpointPath())
+                .Should()
+                .BeSuccess($"/project/{this.applicationId}/session/{this.sessionId}/connection/{this.connectionId}");
+    }
+}

Vonage.Video.Beta.Test/Video/Moderation/DisconnectConnection/DisconnectConnectionTest.cs

@@ -0,0 +1,90 @@
+using System.Net;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.Kernel;
+using FsCheck;
+using FsCheck.Xunit;
+using Vonage.Video.Beta.Common;
+using Vonage.Video.Beta.Common.Failures;
+using Vonage.Video.Beta.Common.Monads;
+using Vonage.Video.Beta.Test.Extensions;
+using Vonage.Video.Beta.Video.Moderation;
+using Vonage.Video.Beta.Video.Moderation.DisconnectConnection;
+using WireMock.RequestBuilders;
+using Xunit;
+
+namespace Vonage.Video.Beta.Test.Video.Moderation.DisconnectConnection
+{
+    public class DisconnectConnectionTest
+    {
+        private readonly ModerationClient client;
+        private readonly Result<DisconnectConnectionRequest> request;
+        private readonly UseCaseHelper helper;
+
+        public DisconnectConnectionTest()
+        {
+            this.helper = new UseCaseHelper();
+            this.client = new ModerationClient(this.helper.Server.CreateClient(), () => this.helper.Token);
+            this.request = BuildRequest(this.helper.Fixture);
+        }
+
+        [Property]
+        public Property ShouldReturnFailure_GivenApiResponseIsError() =>
+            Prop.ForAll(
+                FsCheckExtensions.GetErrorResponses(),
+                error => this.VerifyReturnsFailureGivenStatusCodeIsFailure(error).Wait());
+
+        [Property]
+        public Property ShouldReturnFailure_GivenApiErrorCannotBeParsed() =>
+            Prop.ForAll(
+                FsCheckExtensions.GetInvalidStatusCodes(),
+                FsCheckExtensions.GetNonEmptyStrings(),
+                (statusCode, jsonError) =>
+                    this.VerifyReturnsFailureGivenErrorCannotBeParsed(statusCode, jsonError).Wait());
+
+        [Fact]
+        public async Task ShouldReturnSuccess_GivenApiResponseIsSuccess()
+        {
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(HttpStatusCode.OK));
+            var result =
+                await this.request.BindAsync(requestValue => this.client.DisconnectConnectionAsync(requestValue));
+            result.Should().BeSuccess(Unit.Default);
+        }
+
+        private static Result<DisconnectConnectionRequest> BuildRequest(ISpecimenBuilder fixture) =>
+            DisconnectConnectionRequest.Parse(fixture.Create<string>(), fixture.Create<string>(),
+                fixture.Create<string>());
+
+        private async Task VerifyReturnsFailureGivenStatusCodeIsFailure(ErrorResponse error)
+        {
+            var expectedBody = error.Message is null
+                ? null
+                : this.helper.Serializer.SerializeObject(error);
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(error.Code, expectedBody));
+            var result =
+                await this.request.BindAsync(requestValue => this.client.DisconnectConnectionAsync(requestValue));
+            result.Should().BeFailure(error.ToHttpFailure());
+        }
+
+        private async Task VerifyReturnsFailureGivenErrorCannotBeParsed(HttpStatusCode code, string jsonError)
+        {
+            var expectedFailureMessage = $"Unable to deserialize '{jsonError}' into '{nameof(ErrorResponse)}'.";
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(code,
+                    jsonError));
+            var result =
+                await this.request.BindAsync(requestValue => this.client.DisconnectConnectionAsync(requestValue));
+            result.Should().BeFailure(ResultFailure.FromErrorMessage(expectedFailureMessage));
+        }
+
+        private IRequestBuilder CreateRequest() =>
+            WireMockExtensions
+                .CreateRequest(this.helper.Token, UseCaseHelper.GetPathFromRequest(this.request))
+                .UsingDelete();
+    }
+}

Vonage.Video.Beta.Test/Video/Moderation/MuteStream/MuteStreamRequestTest.cs

@@ -0,0 +1,69 @@
+using AutoFixture;
+using FluentAssertions;
+using Vonage.Video.Beta.Common.Failures;
+using Vonage.Video.Beta.Test.Extensions;
+using Vonage.Video.Beta.Video.Moderation.MuteStream;
+using Xunit;
+
+namespace Vonage.Video.Beta.Test.Video.Moderation.MuteStream
+{
+    public class MuteStreamRequestTest
+    {
+        private readonly string applicationId;
+        private readonly string sessionId;
+        private readonly string streamId;
+
+        public MuteStreamRequestTest()
+        {
+            var fixture = new Fixture();
+            this.applicationId = fixture.Create<string>();
+            this.sessionId = fixture.Create<string>();
+            this.streamId = fixture.Create<string>();
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenApplicationIdIsNullOrWhitespace(string value) =>
+            MuteStreamRequest.Parse(value, this.sessionId, this.streamId)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("ApplicationId cannot be null or whitespace."));
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenSessionIdIsNullOrWhitespace(string value) =>
+            MuteStreamRequest.Parse(this.applicationId, value, this.streamId)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("SessionId cannot be null or whitespace."));
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void Parse_ShouldReturnFailure_GivenStreamIdIsNullOrWhitespace(string value) =>
+            MuteStreamRequest.Parse(this.applicationId, this.sessionId, value)
+                .Should()
+                .BeFailure(ResultFailure.FromErrorMessage("StreamId cannot be null or whitespace."));
+
+        [Fact]
+        public void Parse_ShouldReturnSuccess_GivenValuesAreProvided() =>
+            MuteStreamRequest.Parse(this.applicationId, this.sessionId, this.streamId)
+                .Should()
+                .BeSuccess(request =>
+                {
+                    request.ApplicationId.Should().Be(this.applicationId);
+                    request.SessionId.Should().Be(this.sessionId);
+                    request.StreamId.Should().Be(this.streamId);
+                });
+
+        [Fact]
+        public void GetEndpointPath_ShouldReturnApiEndpoint() =>
+            MuteStreamRequest.Parse(this.applicationId, this.sessionId, this.streamId)
+                .Map(request => request.GetEndpointPath())
+                .Should()
+                .BeSuccess($"/project/{this.applicationId}/session/{this.sessionId}/stream/{this.streamId}/mute");
+    }
+}

Vonage.Video.Beta.Test/Video/Moderation/MuteStream/MuteStreamTest.cs

@@ -0,0 +1,100 @@
+using System.Net;
+using System.Threading.Tasks;
+using AutoFixture;
+using AutoFixture.Kernel;
+using FsCheck;
+using FsCheck.Xunit;
+using Vonage.Video.Beta.Common;
+using Vonage.Video.Beta.Common.Failures;
+using Vonage.Video.Beta.Common.Monads;
+using Vonage.Video.Beta.Test.Extensions;
+using Vonage.Video.Beta.Video.Moderation;
+using Vonage.Video.Beta.Video.Moderation.MuteStream;
+using WireMock.RequestBuilders;
+using Xunit;
+
+namespace Vonage.Video.Beta.Test.Video.Moderation.MuteStream
+{
+    public class MuteStreamTest
+    {
+        private readonly ModerationClient client;
+        private readonly Result<MuteStreamRequest> request;
+        private readonly UseCaseHelper helper;
+
+        public MuteStreamTest()
+        {
+            this.helper = new UseCaseHelper();
+            this.client = new ModerationClient(this.helper.Server.CreateClient(), () => this.helper.Token);
+            this.request = BuildRequest(this.helper.Fixture);
+        }
+
+        [Property]
+        public Property ShouldReturnFailure_GivenApiResponseIsError() =>
+            Prop.ForAll(
+                FsCheckExtensions.GetErrorResponses(),
+                error => this.VerifyReturnsFailureGivenStatusCodeIsFailure(error).Wait());
+
+        [Property]
+        public Property ShouldReturnFailure_GivenApiErrorCannotBeParsed() =>
+            Prop.ForAll(
+                FsCheckExtensions.GetInvalidStatusCodes(),
+                FsCheckExtensions.GetNonEmptyStrings(),
+                (statusCode, jsonError) =>
+                    this.VerifyReturnsFailureGivenErrorCannotBeParsed(statusCode, jsonError).Wait());
+
+        [Fact]
+        public async Task ShouldReturnSuccess_GivenApiResponseIsSuccess()
+        {
+            var expectedResponse = this.helper.Fixture.Create<MuteStreamResponse>();
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(HttpStatusCode.OK,
+                    this.helper.Serializer.SerializeObject(expectedResponse)));
+            var result = await this.request.BindAsync(requestValue => this.client.MuteStreamAsync(requestValue));
+            result.Should().BeSuccess(expectedResponse);
+        }
+
+        [Fact]
+        public async Task ShouldReturnFailure_GivenApiResponseCannotBeParsed()
+        {
+            var body = this.helper.Fixture.Create<string>();
+            var expectedFailureMessage = $"Unable to deserialize '{body}' into '{nameof(MuteStreamResponse)}'.";
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(HttpStatusCode.OK, body));
+            var result = await this.request.BindAsync(requestValue => this.client.MuteStreamAsync(requestValue));
+            result.Should().BeFailure(ResultFailure.FromErrorMessage(expectedFailureMessage));
+        }
+
+        private IRequestBuilder CreateRequest() =>
+            WireMockExtensions
+                .CreateRequest(this.helper.Token, UseCaseHelper.GetPathFromRequest(this.request)).UsingPost();
+
+        private static Result<MuteStreamRequest> BuildRequest(ISpecimenBuilder fixture) =>
+            MuteStreamRequest.Parse(fixture.Create<string>(),
+                fixture.Create<string>(),
+                fixture.Create<string>());
+
+        private async Task VerifyReturnsFailureGivenStatusCodeIsFailure(ErrorResponse error)
+        {
+            var expectedBody = error.Message is null
+                ? null
+                : this.helper.Serializer.SerializeObject(error);
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(error.Code, expectedBody));
+            var result = await this.request.BindAsync(requestValue => this.client.MuteStreamAsync(requestValue));
+            result.Should().BeFailure(error.ToHttpFailure());
+        }
+
+        private async Task VerifyReturnsFailureGivenErrorCannotBeParsed(HttpStatusCode code, string jsonError)
+        {
+            var expectedFailureMessage = $"Unable to deserialize '{jsonError}' into '{nameof(ErrorResponse)}'.";
+            this.helper.Server
+                .Given(this.CreateRequest())
+                .RespondWith(WireMockExtensions.CreateResponse(code, jsonError));
+            var result = await this.request.BindAsync(requestValue => this.client.MuteStreamAsync(requestValue));
+            result.Should().BeFailure(ResultFailure.FromErrorMessage(expectedFailureMessage));
+        }
+    }
+}