Convert test mock to Moq

Azure · Oct 27, 2022 · c6897f3 · c6897f3
1 parent 660609e
commit c6897f3
Show file tree

Hide file tree

Showing 11 changed files with 49 additions and 41 deletions.
diff --git a/iothub/device/src/IotHubBaseClient.cs b/iothub/device/src/IotHubBaseClient.cs
@@ -183,7 +183,7 @@ public async Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages
                 }
             }
 
-            await InnerHandler.SendTelemetryAsync(messages, cancellationToken).ConfigureAwait(false);
+            await InnerHandler.SendTelemetryBatchAsync(messages, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>

diff --git a/iothub/device/src/IotHubModuleClient.cs b/iothub/device/src/IotHubModuleClient.cs
@@ -175,7 +175,7 @@ public async Task SendTelemetryBatchAsync(string outputName, IEnumerable<Telemet
             {
                 messagesList.ForEach(m => m.SystemProperties.Add(MessageSystemPropertyNames.OutputName, outputName));
 
-                await InnerHandler.SendTelemetryAsync(messagesList, cancellationToken).ConfigureAwait(false);
+                await InnerHandler.SendTelemetryBatchAsync(messagesList, cancellationToken).ConfigureAwait(false);
             }
             finally
             {

diff --git a/iothub/device/src/Pipeline/DefaultDelegatingHandler.cs b/iothub/device/src/Pipeline/DefaultDelegatingHandler.cs
@@ -90,10 +90,10 @@ public virtual Task SendTelemetryAsync(TelemetryMessage message, CancellationTok
             return NextHandler?.SendTelemetryAsync(message, cancellationToken) ?? Task.CompletedTask;
         }
 
-        public virtual Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
+        public virtual Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
         {
             ThrowIfDisposed();
-            return NextHandler?.SendTelemetryAsync(messages, cancellationToken) ?? Task.CompletedTask;
+            return NextHandler?.SendTelemetryBatchAsync(messages, cancellationToken) ?? Task.CompletedTask;
         }
 
         public virtual Task EnableMethodsAsync(CancellationToken cancellationToken)

diff --git a/iothub/device/src/Pipeline/ErrorDelegatingHandler.cs b/iothub/device/src/Pipeline/ErrorDelegatingHandler.cs
@@ -78,9 +78,9 @@ public override Task<long> UpdateReportedPropertiesAsync(ReportedProperties repo
             return ExecuteWithErrorHandlingAsync(() => base.UpdateReportedPropertiesAsync(reportedProperties, cancellationToken));
         }
 
-        public override Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
+        public override Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
         {
-            return ExecuteWithErrorHandlingAsync(() => base.SendTelemetryAsync(messages, cancellationToken));
+            return ExecuteWithErrorHandlingAsync(() => base.SendTelemetryBatchAsync(messages, cancellationToken));
         }
 
         public override Task SendTelemetryAsync(TelemetryMessage message, CancellationToken cancellationToken)

diff --git a/iothub/device/src/Pipeline/IDelegatingHandler.cs b/iothub/device/src/Pipeline/IDelegatingHandler.cs
@@ -22,7 +22,7 @@ internal interface IDelegatingHandler : IContinuationProvider<IDelegatingHandler
         // Telemetry uplink.
         Task SendTelemetryAsync(TelemetryMessage message, CancellationToken cancellationToken);
 
-        Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken);
+        Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken);
 
         Task EnableReceiveMessageAsync(CancellationToken cancellationToken);
 

diff --git a/iothub/device/src/Pipeline/RetryDelegatingHandler.cs b/iothub/device/src/Pipeline/RetryDelegatingHandler.cs
@@ -75,7 +75,7 @@ await _internalRetryHandler
             }
         }
 
-        public override async Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
+        public override async Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
         {
             if (Logging.IsEnabled)
                 Logging.Enter(this, messages, cancellationToken, nameof(SendTelemetryAsync));
@@ -87,7 +87,7 @@ await _internalRetryHandler
                         async () =>
                         {
                             await VerifyIsOpenAsync(cancellationToken).ConfigureAwait(false);
-                            await base.SendTelemetryAsync(messages, cancellationToken).ConfigureAwait(false);
+                            await base.SendTelemetryBatchAsync(messages, cancellationToken).ConfigureAwait(false);
                         },
                         cancellationToken)
                     .ConfigureAwait(false);

diff --git a/iothub/device/src/Transport/Amqp/AmqpTransportHandler.cs b/iothub/device/src/Transport/Amqp/AmqpTransportHandler.cs
@@ -173,7 +173,7 @@ public override async Task SendTelemetryAsync(TelemetryMessage message, Cancella
             }
         }
 
-        public override async Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
+        public override async Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
         {
             if (Logging.IsEnabled)
                 Logging.Enter(this, messages, cancellationToken, nameof(SendTelemetryAsync));

diff --git a/iothub/device/src/Transport/Mqtt/MqttTransportHandler.cs b/iothub/device/src/Transport/Mqtt/MqttTransportHandler.cs
@@ -393,7 +393,7 @@ public override async Task SendTelemetryAsync(TelemetryMessage message, Cancella
             }
         }
 
-        public override async Task SendTelemetryAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
+        public override async Task SendTelemetryBatchAsync(IEnumerable<TelemetryMessage> messages, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 

diff --git a/iothub/device/tests/Pipeline/RetryDelegatingHandlerImplicitOpenTests.cs b/iothub/device/tests/Pipeline/RetryDelegatingHandlerImplicitOpenTests.cs
@@ -39,13 +39,13 @@ public async Task ImplicitOpenSubjWasNotOpenSubjIsOpen()
             var nextHandlerMock = Substitute.For<IDelegatingHandler>();
             nextHandlerMock.OpenAsync(Arg.Any<CancellationToken>()).Returns(t => Task.CompletedTask);
             nextHandlerMock.SendTelemetryAsync(Arg.Any<TelemetryMessage>(), Arg.Any<CancellationToken>()).Returns(t => Task.CompletedTask);
-            nextHandlerMock.SendTelemetryAsync(Arg.Any<IEnumerable<TelemetryMessage>>(), Arg.Any<CancellationToken>()).Returns(t => Task.CompletedTask);
+            nextHandlerMock.SendTelemetryBatchAsync(Arg.Any<IEnumerable<TelemetryMessage>>(), Arg.Any<CancellationToken>()).Returns(t => Task.CompletedTask);
             nextHandlerMock.WaitForTransportClosedAsync().Returns(Task.Delay(TimeSpan.FromSeconds(10)));
             var cancellationToken = new CancellationToken();
             var actions = new Func<IDelegatingHandler, Task>[]
             {
                 sut => sut.SendTelemetryAsync(new TelemetryMessage(), cancellationToken),
-                sut => sut.SendTelemetryAsync(new[] { new TelemetryMessage() }, cancellationToken),
+                sut => sut.SendTelemetryBatchAsync(new[] { new TelemetryMessage() }, cancellationToken),
             };
 
             foreach (Func<IDelegatingHandler, Task> action in actions)

diff --git a/iothub/device/tests/Pipeline/RetryDelegatingHandlerTests.cs b/iothub/device/tests/Pipeline/RetryDelegatingHandlerTests.cs
@@ -10,8 +10,9 @@
 using System.Threading.Tasks;
 using Microsoft.Azure.Devices.Client.Transport;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using NSubstitute;
 using FluentAssertions;
+using NSubstitute;
+using Moq;
 
 namespace Microsoft.Azure.Devices.Client.Test
 {
@@ -128,7 +129,7 @@ public async Task RetryOneMessageHasBeenTouchedTransientExceptionOccuredSuccess(
             IEnumerable<TelemetryMessage> messages = new[] { message };
             nextHandlerMock.OpenAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
             nextHandlerMock
-                .SendTelemetryAsync(Arg.Is(messages), Arg.Any<CancellationToken>())
+                .SendTelemetryBatchAsync(Arg.Is(messages), Arg.Any<CancellationToken>())
                 .Returns(t =>
                     {
                         if (++callCounter == 1)
@@ -142,7 +143,7 @@ public async Task RetryOneMessageHasBeenTouchedTransientExceptionOccuredSuccess(
 
             // act
             await sut.OpenAsync(CancellationToken.None).ConfigureAwait(false);
-            await sut.SendTelemetryAsync(messages, CancellationToken.None).ConfigureAwait(false);
+            await sut.SendTelemetryBatchAsync(messages, CancellationToken.None).ConfigureAwait(false);
 
             // assert
             callCounter.Should().Be(2);
@@ -304,53 +305,60 @@ public async Task RetryCancellationTokenCanceledSendEvent()
         public async Task RetryCancellationTokenCanceledSendEventWithIEnumMessage()
         {
             // arrange
-            var contextMock = Substitute.For<PipelineContext>();
-            contextMock.ConnectionStatusChangeHandler = (connectionInfo) => { };
-            var nextHandlerMock = Substitute.For<IDelegatingHandler>();
-            nextHandlerMock.OpenAsync(CancellationToken.None).Returns(Task.CompletedTask);
-            nextHandlerMock.SendTelemetryAsync((IEnumerable<TelemetryMessage>)null, CancellationToken.None).ReturnsForAnyArgs(Task.CompletedTask);
+            var contextMock = new PipelineContext();
+            contextMock.ConnectionStatusChangeHandler = (connectionInfo) => { }; // avoid NRE
 
-            var sut = new RetryDelegatingHandler(contextMock, nextHandlerMock);
+            var nextHandlerMock = new Mock<IDelegatingHandler>();
+            nextHandlerMock
+                .Setup(x => x.OpenAsync(CancellationToken.None))
+                .Returns(() => Task.CompletedTask);
+            nextHandlerMock
+                .Setup(x => x.SendTelemetryBatchAsync(null, CancellationToken.None))
+                .Returns(() => Task.CompletedTask);
+
+            var sut = new RetryDelegatingHandler(contextMock, nextHandlerMock.Object);
             await sut.OpenAsync(CancellationToken.None).ConfigureAwait(false);
-            using var cts = new CancellationTokenSource();
-            cts.Cancel();
+            var ct = new CancellationToken(true);
             var telemetry = new List<TelemetryMessage>(0);
 
-            // act
-            await sut.SendTelemetryAsync(telemetry, cts.Token).ExpectedAsync<OperationCanceledException>().ConfigureAwait(false);
-
-            // assert
-            await nextHandlerMock.Received(0).SendTelemetryAsync(telemetry, cts.Token).ConfigureAwait(false);
+            // act and assert
+            await sut.SendTelemetryBatchAsync(telemetry, ct).ExpectedAsync<OperationCanceledException>().ConfigureAwait(false);
+            nextHandlerMock.Verify(
+                x => x.SendTelemetryBatchAsync(It.IsAny<IEnumerable<TelemetryMessage>>(), It.IsAny<CancellationToken>()),
+                Times.Never());
         }
 
         [TestMethod]
         public async Task RetrySetRetryPolicyVerifyInternalsSuccess()
         {
             // arrange
-            var nextHandlerMock = Substitute.For<IDelegatingHandler>();
-            var contextMock = Substitute.For<PipelineContext>();
-            contextMock.ConnectionStatusChangeHandler = (connectionStatusInfo) => { };
-            var sut = new RetryDelegatingHandler(contextMock, nextHandlerMock);
+            var contextMock = new PipelineContext();
+            contextMock.ConnectionStatusChangeHandler = (connectionStatusInfo) => { }; // avoid NRE
+
+            var nextHandlerMock = new Mock<IDelegatingHandler>();
+
+            var sut = new RetryDelegatingHandler(contextMock, nextHandlerMock.Object);
 
             var retryPolicy = new TestRetryPolicy();
             sut.SetRetryPolicy(retryPolicy);
 
             int nextHandlerCallCounter = 0;
 
-            nextHandlerMock.OpenAsync(CancellationToken.None).Returns(t =>
-               {
-                   nextHandlerCallCounter++;
-                   throw new IotHubClientException(IotHubClientErrorCode.NetworkErrors);
-               });
+            nextHandlerMock
+                .Setup(x => x.OpenAsync(CancellationToken.None))
+                .Returns(() =>
+                   {
+                       nextHandlerCallCounter++;
+                       throw new IotHubClientException(IotHubClientErrorCode.NetworkErrors);
+                   });
 
             // act and assert
             var exception = await sut.OpenAsync(CancellationToken.None).ExpectedAsync<IotHubClientException>().ConfigureAwait(false);
             exception.ErrorCode.Should().Be(IotHubClientErrorCode.NetworkErrors);
             nextHandlerCallCounter.Should().Be(2);
             retryPolicy.Counter.Should().Be(2);
 
-            var noretry = new NoRetry();
-            sut.SetRetryPolicy(noretry);
+            sut.SetRetryPolicy(new NoRetry());
 
             exception = await sut.OpenAsync(CancellationToken.None).ExpectedAsync<IotHubClientException>().ConfigureAwait(false);
             exception.ErrorCode.Should().Be(IotHubClientErrorCode.NetworkErrors);

diff --git a/iothub/device/tests/Transport/Amqp/AmqpTransportHandlerTests.cs b/iothub/device/tests/Transport/Amqp/AmqpTransportHandlerTests.cs
@@ -37,7 +37,7 @@ public async Task AmqpTransportHandlerSendTelemetryAsyncTokenCancellationRequest
         [TestMethod]
         public async Task AmqpTransportHandlerSendTelemetryAsyncMultipleMessagesTokenCancellationRequested()
         {
-            await TestOperationCanceledByToken(token => CreateFromConnectionString().SendTelemetryAsync(new List<TelemetryMessage>(), token)).ConfigureAwait(false);
+            await TestOperationCanceledByToken(token => CreateFromConnectionString().SendTelemetryBatchAsync(new List<TelemetryMessage>(), token)).ConfigureAwait(false);
         }
 
         [TestMethod]