Make HandleCurrentMessageLater obsolete (#138)

* Removing the NSB.Testing.Fakes as a source packages and copying the code base into the project

* Adding obsoletes to HandleCurrentMessageLater

* Change to the approved API to include the obsoletes

* Moving obsoletes into obsolete.cs

Author: Michał Wójcik

src/NServiceBus.Testing.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt

@@ -233,6 +233,8 @@ namespace NServiceBus.Testing
     {
         public TestableInvokeHandlerContext(NServiceBus.IMessageCreator messageCreator = null) { }
         public bool DoNotContinueDispatchingCurrentMessageToHandlersWasCalled { get; set; }
+        [System.ObsoleteAttribute("HandleCurrentMessageLater has been deprecated. The member currently throws a NotI" +
+            "mplementedException. Will be removed in version 8.0.0.", true)]
         public bool HandleCurrentMessageLaterWasCalled { get; }
         public bool HandlerInvocationAborted { get; }
         public System.Collections.Generic.Dictionary<string, string> Headers { get; set; }
@@ -241,6 +243,8 @@ namespace NServiceBus.Testing
         public NServiceBus.Unicast.Messages.MessageMetadata MessageMetadata { get; set; }
         public NServiceBus.Persistence.SynchronizedStorageSession SynchronizedStorageSession { get; set; }
         public void DoNotContinueDispatchingCurrentMessageToHandlers() { }
+        [System.ObsoleteAttribute("HandleCurrentMessageLater has been deprecated. The member currently throws a NotI" +
+            "mplementedException. Will be removed in version 8.0.0.", true)]
         public System.Threading.Tasks.Task HandleCurrentMessageLater() { }
     }
     public class TestableMessageHandlerContext : NServiceBus.Testing.TestableInvokeHandlerContext

src/NServiceBus.Testing/NSB.Testing.Fakes/DefaultTestingLoggerFactory.cs

@@ -0,0 +1,62 @@
+namespace NServiceBus.Testing
+{
+    using System;
+    using System.IO;
+    using Logging;
+
+    class DefaultTestingLoggerFactory : ILoggerFactory
+    {
+        public DefaultTestingLoggerFactory(LogLevel filterLevel, TextWriter textWriter)
+        {
+            this.filterLevel = filterLevel;
+            textWriterLogger = new TextWriterLogger(textWriter);
+            isDebugEnabled = LogLevel.Debug >= filterLevel;
+            isInfoEnabled = LogLevel.Info >= filterLevel;
+            isWarnEnabled = LogLevel.Warn >= filterLevel;
+            isErrorEnabled = LogLevel.Error >= filterLevel;
+            isFatalEnabled = LogLevel.Fatal >= filterLevel;
+        }
+
+        public ILog GetLogger(Type type)
+        {
+            return GetLogger(type.FullName);
+        }
+
+        public ILog GetLogger(string name)
+        {
+            return new NamedLogger(name, this)
+            {
+                IsDebugEnabled = isDebugEnabled,
+                IsInfoEnabled = isInfoEnabled,
+                IsWarnEnabled = isWarnEnabled,
+                IsErrorEnabled = isErrorEnabled,
+                IsFatalEnabled = isFatalEnabled
+            };
+        }
+
+        public void Write(string name, LogLevel messageLevel, string message)
+        {
+            if (messageLevel < filterLevel)
+            {
+                return;
+            }
+            var datePart = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
+            var paddedLevel = messageLevel.ToString().ToUpper().PadRight(5);
+            var fullMessage = $"{datePart} {paddedLevel} {name} {message}";
+            lock (locker)
+            {
+                textWriterLogger.Write(fullMessage);
+            }
+        }
+
+        LogLevel filterLevel;
+        bool isDebugEnabled;
+        bool isErrorEnabled;
+        bool isFatalEnabled;
+        bool isInfoEnabled;
+        bool isWarnEnabled;
+
+        object locker = new object();
+        TextWriterLogger textWriterLogger;
+    }
+}

src/NServiceBus.Testing/NSB.Testing.Fakes/FakeBuilder.cs

@@ -0,0 +1,155 @@
+// ReSharper disable PartialTypeWithSinglePart
+namespace NServiceBus.Testing
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using ObjectBuilder;
+
+    /// <summary>
+    /// A fake implementation of <see cref="IBuilder" /> for testing purposes.
+    /// </summary>
+    public partial class FakeBuilder : IBuilder
+    {
+        /// <summary>
+        /// Returns an instantiation of the given type.
+        /// </summary>
+        /// <param name="typeToBuild">The <see cref="T:System.Type" /> to build.</param>
+        /// <returns>
+        /// The component instance.
+        /// </returns>
+        public virtual object Build(Type typeToBuild)
+        {
+            return BuildAll(typeToBuild).First();
+        }
+
+        /// <summary>
+        /// Creates an instance of the given type, injecting it with all defined dependencies.
+        /// </summary>
+        /// <typeparam name="T">Type to be resolved.</typeparam>
+        /// <returns>
+        /// Instance of <typeparamref name="T" />.
+        /// </returns>
+        public virtual T Build<T>()
+        {
+            return BuildAll<T>().First();
+        }
+
+        /// <summary>
+        /// For each type that is compatible with the given type, an instance is created with all dependencies injected.
+        /// </summary>
+        /// <param name="typeToBuild">The <see cref="T:System.Type" /> to build.</param>
+        /// <returns>
+        /// The component instances.
+        /// </returns>
+        public virtual IEnumerable<object> BuildAll(Type typeToBuild)
+        {
+            if (instances.ContainsKey(typeToBuild))
+            {
+                return instances[typeToBuild];
+            }
+
+            if (factories.ContainsKey(typeToBuild))
+            {
+                return factories[typeToBuild]();
+            }
+
+            throw new Exception($"Cannot build instance of type {typeToBuild} because there was no instance of factory registered for it.");
+        }
+
+        /// <summary>
+        /// For each type that is compatible with T, an instance is created with all dependencies injected, and yielded to the
+        /// caller.
+        /// </summary>
+        /// <typeparam name="T">Type to be resolved.</typeparam>
+        /// <returns>
+        /// Instances of <typeparamref name="T" />.
+        /// </returns>
+        public virtual IEnumerable<T> BuildAll<T>()
+        {
+            var type = typeof(T);
+
+            if (instances.ContainsKey(type))
+            {
+                return instances[type].Cast<T>();
+            }
+
+            if (factories.ContainsKey(type))
+            {
+                return factories[type]().Cast<T>();
+            }
+
+            return Enumerable.Empty<T>();
+        }
+
+        /// <summary>
+        /// Builds an instance of the defined type injecting it with all defined dependencies
+        /// and invokes the given action on the instance.
+        /// </summary>
+        /// <param name="typeToBuild">The <see cref="T:System.Type" /> to build.</param>
+        /// <param name="action">The callback to call.</param>
+        public virtual void BuildAndDispatch(Type typeToBuild, Action<object> action)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Returns a child instance of the container to facilitate deterministic disposal
+        /// of all resources built by the child container.
+        /// </summary>
+        /// <returns>
+        /// Returns a new child container.
+        /// </returns>
+        public virtual IBuilder CreateChildBuilder()
+        {
+            return this;
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        /// <filterpriority>2</filterpriority>
+        public virtual void Dispose()
+        {
+        }
+
+        /// <summary>
+        /// Releases a component instance.
+        /// </summary>
+        /// <param name="instance">The component instance to release.</param>
+        public virtual void Release(object instance)
+        {
+        }
+
+        /// <summary>
+        /// Registers an instance which will be returned every time an instance of <typeparamref name="T" /> is resolved.
+        /// </summary>
+        public void Register<T>(params T[] instance) where T : class
+        {
+            instances.Add(typeof(T), instance);
+        }
+
+        /// <summary>
+        /// Registers a factory method which will be invoked every time an instance of <typeparamref name="T" /> is resolved.
+        /// </summary>
+        public void Register<T>(Func<T> factory)
+        {
+            factories.Add(typeof(T), () => new object[]
+            {
+                factory()
+            });
+        }
+
+        /// <summary>
+        /// Registers a factory method which will be invoked every time an instance of <typeparamref name="T" /> is resolved.
+        /// </summary>
+        public void Register<T>(Func<T[]> factory) where T : class
+        {
+            factories.Add(typeof(T), factory);
+        }
+
+        Dictionary<Type, Func<object[]>> factories = new Dictionary<Type, Func<object[]>>();
+
+        Dictionary<Type, object[]> instances = new Dictionary<Type, object[]>();
+    }
+}

src/NServiceBus.Testing/NSB.Testing.Fakes/NamedLogger.cs

@@ -0,0 +1,98 @@
+namespace NServiceBus.Testing
+{
+    using System;
+    using Logging;
+
+    class NamedLogger : ILog
+    {
+        public NamedLogger(string name, DefaultTestingLoggerFactory defaultLoggerFactory)
+        {
+            this.name = name;
+            this.defaultLoggerFactory = defaultLoggerFactory;
+        }
+
+        public bool IsDebugEnabled { get; internal set; }
+        public bool IsInfoEnabled { get; internal set; }
+        public bool IsWarnEnabled { get; internal set; }
+        public bool IsErrorEnabled { get; internal set; }
+        public bool IsFatalEnabled { get; internal set; }
+
+        public void Debug(string message)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Debug, message);
+        }
+
+        public void Debug(string message, Exception exception)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Debug, message + Environment.NewLine + exception);
+        }
+
+        public void DebugFormat(string format, params object[] args)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Debug, string.Format(format, args));
+        }
+
+        public void Info(string message)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Info, message);
+        }
+
+        public void Info(string message, Exception exception)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Info, message + Environment.NewLine + exception);
+        }
+
+        public void InfoFormat(string format, params object[] args)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Info, string.Format(format, args));
+        }
+
+        public void Warn(string message)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Warn, message);
+        }
+
+        public void Warn(string message, Exception exception)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Warn, message + Environment.NewLine + exception);
+        }
+
+        public void WarnFormat(string format, params object[] args)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Warn, string.Format(format, args));
+        }
+
+        public void Error(string message)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Error, message);
+        }
+
+        public void Error(string message, Exception exception)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Error, message + Environment.NewLine + exception);
+        }
+
+        public void ErrorFormat(string format, params object[] args)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Error, string.Format(format, args));
+        }
+
+        public void Fatal(string message)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Fatal, message);
+        }
+
+        public void Fatal(string message, Exception exception)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Error, message + Environment.NewLine + exception);
+        }
+
+        public void FatalFormat(string format, params object[] args)
+        {
+            defaultLoggerFactory.Write(name, LogLevel.Fatal, string.Format(format, args));
+        }
+
+        DefaultTestingLoggerFactory defaultLoggerFactory;
+        string name;
+    }
+}

src/NServiceBus.Testing/NSB.Testing.Fakes/OutgoingMessage.cs

@@ -0,0 +1,31 @@
+namespace NServiceBus.Testing
+{
+    using Extensibility;
+
+    /// <summary>
+    /// Represents an outgoing message. Contains the message itself and its associated options.
+    /// </summary>
+    /// <typeparam name="TMessage">The message type.</typeparam>
+    /// <typeparam name="TOptions">The options type of the message.</typeparam>
+    public class OutgoingMessage<TMessage, TOptions> where TOptions : ExtendableOptions
+    {
+        /// <summary>
+        /// Creates a new instance for the given message and options.
+        /// </summary>
+        protected OutgoingMessage(TMessage message, TOptions options)
+        {
+            Message = message;
+            Options = options;
+        }
+
+        /// <summary>
+        /// The outgoing message.
+        /// </summary>
+        public TMessage Message { get; }
+
+        /// <summary>
+        /// The options of the outgoing message.
+        /// </summary>
+        public TOptions Options { get; }
+    }
+}