Rename Batch to MessageBatch

SeanFeldman · SeanFeldman · commit a7b425da1039 · 2019-03-20T18:31:36.000-06:00
diff --git a/src/Microsoft.Azure.ServiceBus/Core/ISenderClient.cs b/src/Microsoft.Azure.ServiceBus/Core/ISenderClient.cs
@@ -27,13 +27,13 @@ public interface ISenderClient : IClientEntity
 
         // TODO: extract methods into this interface for the next major version
         //        /// <summary>
-        //        /// Sends a <see cref="Batch"/> of messages to Service Bus.
+        //        /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.
         //        /// </summary>
-        //        Task SendAsync(Batch batch);
+        //        Task SendAsync(MessageBatch batch);
         //        /// <summary>
-        //        /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
+        //        /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
         //        /// </summary>
-        //        Task<Batch> CreateBatch();
+        //        Task<MessageBatch> CreateBatch();
 
         /// <summary>
         /// Schedules a message to appear on Service Bus.
diff --git a/src/Microsoft.Azure.ServiceBus/Core/MessageBatch.cs b/src/Microsoft.Azure.ServiceBus/Core/MessageBatch.cs
@@ -1,20 +1,19 @@
 ﻿// Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.Threading.Tasks;
-
 namespace Microsoft.Azure.ServiceBus.Core
 {
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
+    using System.Threading.Tasks;
     using Microsoft.Azure.Amqp;
     using Microsoft.Azure.Amqp.Framing;
     using Microsoft.Azure.ServiceBus.Amqp;
     using Microsoft.Azure.ServiceBus.Diagnostics;
 
     [DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
-    public class Batch : IDisposable
+    public class MessageBatch : IDisposable
     {
         internal readonly ulong maximumBatchSize;
         private readonly Func<Message, Task<Message>> pluginsCallback;
@@ -32,7 +31,7 @@ public class Batch : IDisposable
         /// </summary>
         /// <param name="maximumBatchSize">Maximum batch size allowed for batch.</param>
         /// <param name="pluginsCallback">Plugins callback to invoke on outgoing messages regisered with batch.</param>
-        public Batch(ulong maximumBatchSize, Func<Message, Task<Message>> pluginsCallback)
+        internal MessageBatch(ulong maximumBatchSize, Func<Message, Task<Message>> pluginsCallback)
         {
             this.maximumBatchSize = maximumBatchSize;
             this.pluginsCallback = pluginsCallback;
@@ -86,7 +85,7 @@ public async Task<bool> TryAdd(Message message)
         /// Convert batch to AMQP message.
         /// </summary>
         /// <returns></returns>
-        public AmqpMessage ToAmqpMessage()
+        internal AmqpMessage ToAmqpMessage()
         {
             ThrowIfDisposed();
 
@@ -135,10 +134,10 @@ private void ThrowIfDisposed()
         {
             if (result == null)
             {
-                throw new Exception("Batch is has been disposed and cannot be re-used.");
+                throw new Exception("MessageBatch is has been disposed and cannot be re-used.");
             }
         }
 
-        private string DebuggerDisplay => $"Batch: size={Size} message count={datas.Count} maximum size={maximumBatchSize}";
+        private string DebuggerDisplay => $"MessageBatch: size={Size}, message count={datas.Count}, maximum size={maximumBatchSize}.";
     }
 }
diff --git a/src/Microsoft.Azure.ServiceBus/Core/MessageSender.cs b/src/Microsoft.Azure.ServiceBus/Core/MessageSender.cs
@@ -272,13 +272,13 @@ public async Task SendAsync(IList<Message> messageList)
         }
 
         /// <summary>
-        /// Sends a <see cref="Batch"/> of messages to Service Bus.
+        /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.
         /// </summary>
-        public async Task SendAsync(Batch batch)
+        public async Task SendAsync(MessageBatch messageBatch)
         {
             this.ThrowIfClosed();
 
-            MessagingEventSource.Log.MessageSendStart(this.ClientId, batch.Length);
+            MessagingEventSource.Log.MessageSendStart(this.ClientId, messageBatch.Length);
 
             var isDiagnosticSourceEnabled = ServiceBusDiagnosticSource.IsEnabled();
             // TODO: diagnostics (Start/Stop) is currently not possible. Requires change in how Diagnostics works.
@@ -288,7 +288,7 @@ public async Task SendAsync(Batch batch)
 
             try
             {
-                sendTask = this.RetryPolicy.RunOperation(() => this.OnSendAsync(batch.ToAmqpMessage), this.OperationTimeout);
+                sendTask = this.RetryPolicy.RunOperation(() => this.OnSendAsync(messageBatch.ToAmqpMessage), this.OperationTimeout);
                 await sendTask.ConfigureAwait(false);
             }
             catch (Exception exception)
@@ -310,13 +310,13 @@ public async Task SendAsync(Batch batch)
         }
 
         /// <summary>
-        /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
+        /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
         /// </summary>
-        public async Task<Batch> CreateBatch()
+        public async Task<MessageBatch> CreateBatch()
         {
             if (maxMessageSize != 0)
             {
-                return new Batch(maxMessageSize, ProcessMessage);
+                return new MessageBatch(maxMessageSize, ProcessMessage);
             }
 
             var timeoutHelper = new TimeoutHelper(this.OperationTimeout, true);
@@ -330,12 +330,12 @@ public async Task<Batch> CreateBatch()
 
                 if (!amqpLink.Settings.MaxMessageSize.HasValue)
                 {
-                    throw new Exception("Broker didn't provide maximum message size. Batch requires maximum message size to operate.");
+                    throw new Exception("Broker didn't provide maximum message size. MessageBatch requires maximum message size to operate.");
                 }
 
                 maxMessageSize = amqpLink.Settings.MaxMessageSize.Value;
 
-                return new Batch(maxMessageSize, ProcessMessage);
+                return new MessageBatch(maxMessageSize, ProcessMessage);
             }
             catch (Exception exception)
             {
diff --git a/src/Microsoft.Azure.ServiceBus/QueueClient.cs b/src/Microsoft.Azure.ServiceBus/QueueClient.cs
@@ -350,19 +350,19 @@ public Task SendAsync(IList<Message> messageList)
         }
 
         /// <summary>
-        /// Sends a <see cref="Batch"/> of messages to Service Bus.
+        /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.
         /// </summary>
-        public Task SendAsync(Batch batch)
+        public Task SendAsync(MessageBatch messageBatch)
         {
             this.ThrowIfClosed();
 
-            return this.innerSender.SendAsync(batch);
+            return this.innerSender.SendAsync(messageBatch);
         }
 
         /// <summary>
-        /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
+        /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
         /// </summary>
-        public Task<Batch> CreateBatch()
+        public Task<MessageBatch> CreateBatch()
         {
             this.ThrowIfClosed();
 
diff --git a/src/Microsoft.Azure.ServiceBus/TopicClient.cs b/src/Microsoft.Azure.ServiceBus/TopicClient.cs
@@ -185,19 +185,19 @@ public Task SendAsync(IList<Message> messageList)
         }
 
         /// <summary>
-        /// Sends a <see cref="Batch"/> of messages to Service Bus.
+        /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.
         /// </summary>
-        public Task SendAsync(Batch batch)
+        public Task SendAsync(MessageBatch messageBatch)
         {
             this.ThrowIfClosed();
 
-            return this.innerSender.SendAsync(batch);
+            return this.innerSender.SendAsync(messageBatch);
         }
 
         /// <summary>
-        /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
+        /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.
         /// </summary>
-        public Task<Batch> CreateBatch()
+        public Task<MessageBatch> CreateBatch()
         {
             this.ThrowIfClosed();
 
diff --git a/test/Microsoft.Azure.ServiceBus.UnitTests/Primitives/BatchTests.cs b/test/Microsoft.Azure.ServiceBus.UnitTests/Primitives/BatchTests.cs
@@ -17,7 +17,7 @@ public class BatchTests
         [Fact]
         public async Task Should_return_false_when_is_about_to_exceed_max_batch_size()
         {
-            using (var batch = new Batch(1, fakePluginsCallback))
+            using (var batch = new MessageBatch(1, fakePluginsCallback))
             {
                 var wasAdded = await batch.TryAdd(new Message(Encoding.UTF8.GetBytes("hello")));
                 Assert.False(wasAdded, "Message should not have been added, but it was.");
@@ -27,7 +27,7 @@ public async Task Should_return_false_when_is_about_to_exceed_max_batch_size()
         [Fact]
         public void Should_throw_if_batch_disposed()
         {
-            using (var batch = new Batch(1, fakePluginsCallback))
+            using (var batch = new MessageBatch(1, fakePluginsCallback))
             {
                 batch.Dispose();
                 Assert.ThrowsAsync<Exception>(() => batch.TryAdd(new Message()));
@@ -37,7 +37,7 @@ public void Should_throw_if_batch_disposed()
         [Fact]
         public void Should_throw_when_trying_to_add_an_already_received_message_to_batch()
         {
-            using (var batch = new Batch(100, fakePluginsCallback))
+            using (var batch = new MessageBatch(100, fakePluginsCallback))
             {
                 var message = new Message("test".GetBytes());
                 message.SystemProperties.LockTokenGuid = Guid.NewGuid();
@@ -51,7 +51,7 @@ public void Should_throw_when_trying_to_add_an_already_received_message_to_batch
         [InlineData(3)]
         public async Task Should_report_how_many_messages_are_in_batch(int numberOfMessages)
         {
-            using (var batch = new Batch(100, fakePluginsCallback))
+            using (var batch = new MessageBatch(100, fakePluginsCallback))
             {
                 for (var i = 0; i < numberOfMessages; i++)
                 {
@@ -65,7 +65,7 @@ public async Task Should_report_how_many_messages_are_in_batch(int numberOfMessa
         [Fact]
         public async Task Should_reflect_property_in_batch_size()
         {
-            using (var batch = new Batch(100, fakePluginsCallback))
+            using (var batch = new MessageBatch(100, fakePluginsCallback))
             {
                 var message = new Message();
 
@@ -74,7 +74,7 @@ public async Task Should_reflect_property_in_batch_size()
                 Assert.Equal((ulong)24, batch.Size);
             }
 
-            using (var batch = new Batch(100, fakePluginsCallback))
+            using (var batch = new MessageBatch(100, fakePluginsCallback))
             {
                 var message = new Message();
                 message.UserProperties["custom"] = "value";
diff --git a/test/Microsoft.Azure.ServiceBus.UnitTests/SenderReceiverTests.cs b/test/Microsoft.Azure.ServiceBus.UnitTests/SenderReceiverTests.cs
@@ -474,7 +474,7 @@ public async Task ClientsUseGlobalConnectionCloseFirstClientSecoundClientShouldS
                 var message2 = new Message("from".GetBytes());
                 var message3 = new Message("Sean Feldman".GetBytes());
 
-                var batch = new Batch(100, Task.FromResult);
+                var batch = new MessageBatch(100, Task.FromResult);
                 Assert.True(await batch.TryAdd(message1), "Couldn't add first message");
                 Assert.True(await batch.TryAdd(message2), "Couldn't add second message");
                 Assert.False(await batch.TryAdd(message3), "Shouldn't be able to add third message");
@@ -508,7 +508,7 @@ public async Task Sending_batch_with_properties()
                 var message = new Message("Hello Neeraj".GetBytes());
                 message.UserProperties["custom"] = "value";
 
-                var batch = new Batch(100, Task.FromResult);
+                var batch = new MessageBatch(100, Task.FromResult);
                 Assert.True(await batch.TryAdd(message), "Couldn't add  message");
                 await sender.SendAsync(batch);
                 batch.Dispose();

Original file line number	Diff line number	Diff line change
`@@ -1,20 +1,19 @@`
`1`	`1`	`// Copyright (c) Microsoft. All rights reserved.`
`2`	`2`	`// Licensed under the MIT license. See LICENSE file in the project root for full license information.`
`3`	`3`
`4`		`-using System.Threading.Tasks;`
`5`		`-`
`6`	`4`	`namespace Microsoft.Azure.ServiceBus.Core`
`7`	`5`	`{`
`8`	`6`	`using System;`
`9`	`7`	`using System.Collections.Generic;`
`10`	`8`	`using System.Diagnostics;`
	`9`	`+ using System.Threading.Tasks;`
`11`	`10`	`using Microsoft.Azure.Amqp;`
`12`	`11`	`using Microsoft.Azure.Amqp.Framing;`
`13`	`12`	`using Microsoft.Azure.ServiceBus.Amqp;`
`14`	`13`	`using Microsoft.Azure.ServiceBus.Diagnostics;`
`15`	`14`
`16`	`15`	`[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]`
`17`		`- public class Batch : IDisposable`
	`16`	`+ public class MessageBatch : IDisposable`
`18`	`17`	`{`
`19`	`18`	`internal readonly ulong maximumBatchSize;`
`20`	`19`	`private readonly Func<Message, Task<Message>> pluginsCallback;`
`@@ -32,7 +31,7 @@ public class Batch : IDisposable`
`32`	`31`	`/// </summary>`
`33`	`32`	`/// <param name="maximumBatchSize">Maximum batch size allowed for batch.</param>`
`34`	`33`	`/// <param name="pluginsCallback">Plugins callback to invoke on outgoing messages regisered with batch.</param>`
`35`		`- public Batch(ulong maximumBatchSize, Func<Message, Task<Message>> pluginsCallback)`
	`34`	`+ internal MessageBatch(ulong maximumBatchSize, Func<Message, Task<Message>> pluginsCallback)`
`36`	`35`	`{`
`37`	`36`	`this.maximumBatchSize = maximumBatchSize;`
`38`	`37`	`this.pluginsCallback = pluginsCallback;`
`@@ -86,7 +85,7 @@ public async Task<bool> TryAdd(Message message)`
`86`	`85`	`/// Convert batch to AMQP message.`
`87`	`86`	`/// </summary>`
`88`	`87`	`/// <returns></returns>`
`89`		`- public AmqpMessage ToAmqpMessage()`
	`88`	`+ internal AmqpMessage ToAmqpMessage()`
`90`	`89`	`{`
`91`	`90`	`ThrowIfDisposed();`
`92`	`91`
`@@ -135,10 +134,10 @@ private void ThrowIfDisposed()`
`135`	`134`	`{`
`136`	`135`	`if (result == null)`
`137`	`136`	`{`
`138`		`- throw new Exception("Batch is has been disposed and cannot be re-used.");`
	`137`	`+ throw new Exception("MessageBatch is has been disposed and cannot be re-used.");`
`139`	`138`	`}`
`140`	`139`	`}`
`141`	`140`
`142`		`- private string DebuggerDisplay => $"Batch: size={Size} message count={datas.Count} maximum size={maximumBatchSize}";`
	`141`	`+ private string DebuggerDisplay => $"MessageBatch: size={Size}, message count={datas.Count}, maximum size={maximumBatchSize}.";`
`143`	`142`	`}`
`144`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -272,13 +272,13 @@ public async Task SendAsync(IList<Message> messageList)`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`/// <summary>`
`275`		`- /// Sends a <see cref="Batch"/> of messages to Service Bus.`
	`275`	`+ /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.`
`276`	`276`	`/// </summary>`
`277`		`- public async Task SendAsync(Batch batch)`
	`277`	`+ public async Task SendAsync(MessageBatch messageBatch)`
`278`	`278`	`{`
`279`	`279`	`this.ThrowIfClosed();`
`280`	`280`
`281`		`- MessagingEventSource.Log.MessageSendStart(this.ClientId, batch.Length);`
	`281`	`+ MessagingEventSource.Log.MessageSendStart(this.ClientId, messageBatch.Length);`
`282`	`282`
`283`	`283`	`var isDiagnosticSourceEnabled = ServiceBusDiagnosticSource.IsEnabled();`
`284`	`284`	`// TODO: diagnostics (Start/Stop) is currently not possible. Requires change in how Diagnostics works.`
`@@ -288,7 +288,7 @@ public async Task SendAsync(Batch batch)`
`288`	`288`
`289`	`289`	`try`
`290`	`290`	`{`
`291`		`- sendTask = this.RetryPolicy.RunOperation(() => this.OnSendAsync(batch.ToAmqpMessage), this.OperationTimeout);`
	`291`	`+ sendTask = this.RetryPolicy.RunOperation(() => this.OnSendAsync(messageBatch.ToAmqpMessage), this.OperationTimeout);`
`292`	`292`	`await sendTask.ConfigureAwait(false);`
`293`	`293`	`}`
`294`	`294`	`catch (Exception exception)`
`@@ -310,13 +310,13 @@ public async Task SendAsync(Batch batch)`
`310`	`310`	`}`
`311`	`311`
`312`	`312`	`/// <summary>`
`313`		`- /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
	`313`	`+ /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
`314`	`314`	`/// </summary>`
`315`		`- public async Task<Batch> CreateBatch()`
	`315`	`+ public async Task<MessageBatch> CreateBatch()`
`316`	`316`	`{`
`317`	`317`	`if (maxMessageSize != 0)`
`318`	`318`	`{`
`319`		`- return new Batch(maxMessageSize, ProcessMessage);`
	`319`	`+ return new MessageBatch(maxMessageSize, ProcessMessage);`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`var timeoutHelper = new TimeoutHelper(this.OperationTimeout, true);`
`@@ -330,12 +330,12 @@ public async Task<Batch> CreateBatch()`
`330`	`330`
`331`	`331`	`if (!amqpLink.Settings.MaxMessageSize.HasValue)`
`332`	`332`	`{`
`333`		`- throw new Exception("Broker didn't provide maximum message size. Batch requires maximum message size to operate.");`
	`333`	`+ throw new Exception("Broker didn't provide maximum message size. MessageBatch requires maximum message size to operate.");`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`maxMessageSize = amqpLink.Settings.MaxMessageSize.Value;`
`337`	`337`
`338`		`- return new Batch(maxMessageSize, ProcessMessage);`
	`338`	`+ return new MessageBatch(maxMessageSize, ProcessMessage);`
`339`	`339`	`}`
`340`	`340`	`catch (Exception exception)`
`341`	`341`	`{`
Original file line number	Diff line number	Diff line change
`@@ -350,19 +350,19 @@ public Task SendAsync(IList<Message> messageList)`
`350`	`350`	`}`
`351`	`351`
`352`	`352`	`/// <summary>`
`353`		`- /// Sends a <see cref="Batch"/> of messages to Service Bus.`
	`353`	`+ /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.`
`354`	`354`	`/// </summary>`
`355`		`- public Task SendAsync(Batch batch)`
	`355`	`+ public Task SendAsync(MessageBatch messageBatch)`
`356`	`356`	`{`
`357`	`357`	`this.ThrowIfClosed();`
`358`	`358`
`359`		`- return this.innerSender.SendAsync(batch);`
	`359`	`+ return this.innerSender.SendAsync(messageBatch);`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`/// <summary>`
`363`		`- /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
	`363`	`+ /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
`364`	`364`	`/// </summary>`
`365`		`- public Task<Batch> CreateBatch()`
	`365`	`+ public Task<MessageBatch> CreateBatch()`
`366`	`366`	`{`
`367`	`367`	`this.ThrowIfClosed();`
`368`	`368`
Original file line number	Diff line number	Diff line change
`@@ -185,19 +185,19 @@ public Task SendAsync(IList<Message> messageList)`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`/// <summary>`
`188`		`- /// Sends a <see cref="Batch"/> of messages to Service Bus.`
	`188`	`+ /// Sends a <see cref="MessageBatch"/> of messages to Service Bus.`
`189`	`189`	`/// </summary>`
`190`		`- public Task SendAsync(Batch batch)`
	`190`	`+ public Task SendAsync(MessageBatch messageBatch)`
`191`	`191`	`{`
`192`	`192`	`this.ThrowIfClosed();`
`193`	`193`
`194`		`- return this.innerSender.SendAsync(batch);`
	`194`	`+ return this.innerSender.SendAsync(messageBatch);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`/// <summary>`
`198`		`- /// Create a new <see cref="Batch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
	`198`	`+ /// Create a new <see cref="MessageBatch"/> setting maximum size to the maximum message size allowed by the underlying namespace.`
`199`	`199`	`/// </summary>`
`200`		`- public Task<Batch> CreateBatch()`
	`200`	`+ public Task<MessageBatch> CreateBatch()`
`201`	`201`	`{`
`202`	`202`	`this.ThrowIfClosed();`
`203`	`203`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public class BatchTests`
`17`	`17`	`[Fact]`
`18`	`18`	`public async Task Should_return_false_when_is_about_to_exceed_max_batch_size()`
`19`	`19`	`{`
`20`		`- using (var batch = new Batch(1, fakePluginsCallback))`
	`20`	`+ using (var batch = new MessageBatch(1, fakePluginsCallback))`
`21`	`21`	`{`
`22`	`22`	`var wasAdded = await batch.TryAdd(new Message(Encoding.UTF8.GetBytes("hello")));`
`23`	`23`	`Assert.False(wasAdded, "Message should not have been added, but it was.");`
`@@ -27,7 +27,7 @@ public async Task Should_return_false_when_is_about_to_exceed_max_batch_size()`
`27`	`27`	`[Fact]`
`28`	`28`	`public void Should_throw_if_batch_disposed()`
`29`	`29`	`{`
`30`		`- using (var batch = new Batch(1, fakePluginsCallback))`
	`30`	`+ using (var batch = new MessageBatch(1, fakePluginsCallback))`
`31`	`31`	`{`
`32`	`32`	`batch.Dispose();`
`33`	`33`	`Assert.ThrowsAsync<Exception>(() => batch.TryAdd(new Message()));`
`@@ -37,7 +37,7 @@ public void Should_throw_if_batch_disposed()`
`37`	`37`	`[Fact]`
`38`	`38`	`public void Should_throw_when_trying_to_add_an_already_received_message_to_batch()`
`39`	`39`	`{`
`40`		`- using (var batch = new Batch(100, fakePluginsCallback))`
	`40`	`+ using (var batch = new MessageBatch(100, fakePluginsCallback))`
`41`	`41`	`{`
`42`	`42`	`var message = new Message("test".GetBytes());`
`43`	`43`	`message.SystemProperties.LockTokenGuid = Guid.NewGuid();`
`@@ -51,7 +51,7 @@ public void Should_throw_when_trying_to_add_an_already_received_message_to_batch`
`51`	`51`	`[InlineData(3)]`
`52`	`52`	`public async Task Should_report_how_many_messages_are_in_batch(int numberOfMessages)`
`53`	`53`	`{`
`54`		`- using (var batch = new Batch(100, fakePluginsCallback))`
	`54`	`+ using (var batch = new MessageBatch(100, fakePluginsCallback))`
`55`	`55`	`{`
`56`	`56`	`for (var i = 0; i < numberOfMessages; i++)`
`57`	`57`	`{`
`@@ -65,7 +65,7 @@ public async Task Should_report_how_many_messages_are_in_batch(int numberOfMessa`
`65`	`65`	`[Fact]`
`66`	`66`	`public async Task Should_reflect_property_in_batch_size()`
`67`	`67`	`{`
`68`		`- using (var batch = new Batch(100, fakePluginsCallback))`
	`68`	`+ using (var batch = new MessageBatch(100, fakePluginsCallback))`
`69`	`69`	`{`
`70`	`70`	`var message = new Message();`
`71`	`71`
`@@ -74,7 +74,7 @@ public async Task Should_reflect_property_in_batch_size()`
`74`	`74`	`Assert.Equal((ulong)24, batch.Size);`
`75`	`75`	`}`
`76`	`76`
`77`		`- using (var batch = new Batch(100, fakePluginsCallback))`
	`77`	`+ using (var batch = new MessageBatch(100, fakePluginsCallback))`
`78`	`78`	`{`
`79`	`79`	`var message = new Message();`
`80`	`80`	`message.UserProperties["custom"] = "value";`