From 7b2c4952ebc469bcab6550a0a206417d3a339fac Mon Sep 17 00:00:00 2001
From: ktmitton <kdrive113@gmail.com>
Date: Sun, 17 Apr 2022 13:05:57 -0400
Subject: [PATCH 1/3] Moved the Option extension into the option class, no
 reason to have an extension when we control the class

---
 .../Extensions/OptionExtensionsTests.cs       | 85 ++-----------------
 .../Models/OptionTests.cs                     | 76 +++++++++++++++++
 .../Extensions/IEnumerableExtensions.cs       | 22 +++++
 .../Extensions/OptionExtensions.cs            | 53 ------------
 Mittons.Fixtures/Models/Option.cs             | 22 ++++-
 5 files changed, 123 insertions(+), 135 deletions(-)
 create mode 100644 Mittons.Fixtures.Tests.Unit/Models/OptionTests.cs
 create mode 100644 Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
 delete mode 100644 Mittons.Fixtures/Extensions/OptionExtensions.cs

diff --git a/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs b/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs
index 28ce38c..906d758 100644
--- a/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs
+++ b/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using Mittons.Fixtures.Extensions;
 using Mittons.Fixtures.Models;
@@ -10,87 +9,13 @@ namespace Mittons.Fixtures.Tests.Unit.Extensions;
 public class OptionExtensionsTests
 {
     [Fact]
-    public void ToExecutionParameterFormattedString_WhenOptionIsNull_ExpectArgumentNullException()
-    {
-        Option? stubOption = null;
-
-        Assert.Throws<ArgumentNullException>(() => stubOption.ToExecutionParameterFormattedString());
-    }
-
-    [Fact]
-    public void ToExecutionParameterFormattedString_WhenNameIsNull_ExpectArgumentNullException()
-    {
-        var stubOption = new Option
-        {
-            Name = null,
-            Value = "value"
-        };
-
-        Assert.Throws<ArgumentNullException>(() => stubOption.ToExecutionParameterFormattedString());
-    }
-
-    [Fact]
-    public void ToExecutionParameterFormattedString_WhenValueIsNull_ExpectExecutionParameterFormattedStringWithOnlyName()
-    {
-        var stubOption = new Option
-        {
-            Name = "--option",
-            Value = null
-        };
-
-        var commandFormattedString = stubOption.ToExecutionParameterFormattedString();
-
-        Assert.Equal("--option", commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParameterFormattedString_WhenValueIsEmptyString_ExpectExecutionParameterFormattedStringWithOnlyName()
-    {
-        var stubOption = new Option
-        {
-            Name = "--option",
-            Value = string.Empty
-        };
-
-        var commandFormattedString = stubOption.ToExecutionParameterFormattedString();
-
-        Assert.Equal("--option", commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParameterFormattedString_WhenValueIsWhiteSpace_ExpectExecutionParameterFormattedStringWithOnlyName()
-    {
-        var stubOption = new Option
-        {
-            Name = "--option",
-            Value = " "
-        };
-
-        var commandFormattedString = stubOption.ToExecutionParameterFormattedString();
-
-        Assert.Equal("--option", commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParameterFormattedString_WhenNameAndValueAreNotNull_ExpectExecutionParameterFormattedString()
-    {
-        var stubOption = new Option
-        {
-            Name = "--option",
-            Value = "value"
-        };
-
-        var commandFormattedString = stubOption.ToExecutionParameterFormattedString();
-
-        Assert.Equal("--option \"value\"", commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParametersFormattedString_WhenOptionsIsNull_ExpectArgumentNullException()
+    public void ToExecutionParametersFormattedString_WhenOptionsIsNull_ExpectEmptyString()
     {
         IEnumerable<Option>? stubOptions = null;
 
-        Assert.Throws<ArgumentNullException>(() => stubOptions.ToExecutionParametersFormattedString());
+        var commandFormattedString = stubOptions.ToExecutionParametersFormattedString();
+
+        Assert.Equal(string.Empty, commandFormattedString);
     }
 
     [Fact]
diff --git a/Mittons.Fixtures.Tests.Unit/Models/OptionTests.cs b/Mittons.Fixtures.Tests.Unit/Models/OptionTests.cs
new file mode 100644
index 0000000..dad92c3
--- /dev/null
+++ b/Mittons.Fixtures.Tests.Unit/Models/OptionTests.cs
@@ -0,0 +1,76 @@
+using System;
+using Mittons.Fixtures.Models;
+using Xunit;
+
+namespace Mittons.Fixtures.Tests.Unit.Models;
+
+public class OptionTests
+{
+    [Fact]
+    public void ExecutionParameter_WhenNameIsNull_ExpectArgumentNullException()
+    {
+        var stubOption = new Option
+        {
+            Name = null,
+            Value = "value"
+        };
+
+        Assert.Throws<ArgumentNullException>(() => stubOption.ExecutionParameter);
+    }
+
+    [Fact]
+    public void ExecutionParameter_WhenValueIsNull_ExpectExecutionParameterFormattedStringWithOnlyName()
+    {
+        var stubOption = new Option
+        {
+            Name = "--option",
+            Value = null
+        };
+
+        var commandFormattedString = stubOption.ExecutionParameter;
+
+        Assert.Equal("--option", commandFormattedString);
+    }
+
+    [Fact]
+    public void ExecutionParameter_WhenValueIsEmptyString_ExpectExecutionParameterFormattedStringWithOnlyName()
+    {
+        var stubOption = new Option
+        {
+            Name = "--option",
+            Value = string.Empty
+        };
+
+        var commandFormattedString = stubOption.ExecutionParameter;
+
+        Assert.Equal("--option", commandFormattedString);
+    }
+
+    [Fact]
+    public void ExecutionParameter_WhenValueIsWhiteSpace_ExpectExecutionParameterFormattedStringWithOnlyName()
+    {
+        var stubOption = new Option
+        {
+            Name = "--option",
+            Value = " "
+        };
+
+        var commandFormattedString = stubOption.ExecutionParameter;
+
+        Assert.Equal("--option", commandFormattedString);
+    }
+
+    [Fact]
+    public void ExecutionParameter_WhenNameAndValueAreNotNull_ExpectExecutionParameterFormattedString()
+    {
+        var stubOption = new Option
+        {
+            Name = "--option",
+            Value = "value"
+        };
+
+        var commandFormattedString = stubOption.ExecutionParameter;
+
+        Assert.Equal("--option \"value\"", commandFormattedString);
+    }
+}
diff --git a/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs b/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
new file mode 100644
index 0000000..9673522
--- /dev/null
+++ b/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Mittons.Fixtures.Models;
+
+namespace Mittons.Fixtures.Extensions
+{
+    /// <summary>
+    /// Extensions methods for <see cref="IEnumerable"/>.
+    /// </summary>
+    public static class IEnumerableExtensions
+    {
+        /// <summary>
+        /// Gets the collection of options as a string formatted for use as execution parameters in a <c>docker</c> command.
+        /// </summary>
+        /// <param name="options"></param>
+        /// <returns>The options as a string formatted for use in a <c>docker</c> command.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when the options, any option, or their properties, are <c>null</c>.</exception>
+        public static string ToExecutionParametersFormattedString(this IEnumerable<Option> options)
+            => string.Join(" ", (options ?? Enumerable.Empty<Option>()).Select(option => option.ExecutionParameter).ToList());
+    }
+}
diff --git a/Mittons.Fixtures/Extensions/OptionExtensions.cs b/Mittons.Fixtures/Extensions/OptionExtensions.cs
deleted file mode 100644
index 1ec7601..0000000
--- a/Mittons.Fixtures/Extensions/OptionExtensions.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Mittons.Fixtures.Models;
-
-namespace Mittons.Fixtures.Extensions
-{
-    /// <summary>
-    /// Extensions methods for <see cref="Option"/>.
-    /// </summary>
-    public static class OptionExtensions
-    {
-        /// <summary>
-        /// Gets the option as a string formatted for use as an execution parameter in a <c>docker</c> command.
-        /// </summary>
-        /// <param name="option"></param>
-        /// <returns>The option as a string formatted for use in a <c>docker</c> command.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when the option, or its name property is <c>null</c>.</exception>
-        public static string ToExecutionParameterFormattedString(this Option option)
-        {
-            if(option is null)
-            {
-                throw new ArgumentNullException(nameof(option));
-            }
-
-            if(option.Name is null)
-            {
-                throw new ArgumentNullException(nameof(option.Name));
-            }
-
-            return string.IsNullOrWhiteSpace(option.Value) ? option.Name : $"{option.Name} \"{option.Value}\"";
-        }
-
-        /// <summary>
-        /// Gets the collection of options as a string formatted for use as execution parameters in a <c>docker</c> command.
-        /// </summary>
-        /// <param name="options"></param>
-        /// <returns>The options as a string formatted for use in a <c>docker</c> command.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when the options, any option, or their properties, are <c>null</c>.</exception>
-        public static string ToExecutionParametersFormattedString(this IEnumerable<Option> options)
-        {
-            if(options is null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
-            var formattedOptions = options.Select(option => option.ToExecutionParameterFormattedString())
-                .ToList();
-
-            return formattedOptions.Any() ? string.Join(" ", formattedOptions) : string.Empty;
-        }
-    }
-}
diff --git a/Mittons.Fixtures/Models/Option.cs b/Mittons.Fixtures/Models/Option.cs
index d11cbcb..776a702 100644
--- a/Mittons.Fixtures/Models/Option.cs
+++ b/Mittons.Fixtures/Models/Option.cs
@@ -1,4 +1,6 @@
-namespace Mittons.Fixtures.Models
+using System;
+
+namespace Mittons.Fixtures.Models
 {
     /// <summary>
     /// A docker option used to further configure a command.
@@ -14,9 +16,25 @@ public class Option
         /// The value for the option.
         /// </summary>
         /// <remarks>
-        /// Set as a direct value with no quotations.  
+        /// Set as a direct value with no quotations.
         /// Set to <c>null</c>, <c>empty string</c>, or <c>white-space</c> if there is no value to accompany the option name.
         /// </remarks>
         public string Value { get; set; }
+
+        /// <summary>
+        /// The parameter string that can be inserted in the execution string.
+        /// </summary>
+        public string ExecutionParameter
+        {
+            get
+            {
+                if (Name is null)
+                {
+                    throw new ArgumentNullException();
+                }
+
+                return string.IsNullOrWhiteSpace(Value) ? Name : $"{Name} \"{Value}\"";
+            }
+        }
     }
 }

From 1defbf162c09122f37f8e6f212d3a0013e3bfa9f Mon Sep 17 00:00:00 2001
From: ktmitton <kdrive113@gmail.com>
Date: Sun, 17 Apr 2022 13:35:59 -0400
Subject: [PATCH 2/3] Made remaining extension internal

---
 .../Docker/Gateways/ContainerGatewayTests.cs  | 74 ++++++++++++++++---
 .../Docker/Gateways/NetworkGatewayTests.cs    | 58 +++++++++++++++
 .../Extensions/OptionExtensionsTests.cs       | 69 -----------------
 .../Extensions/IEnumerableExtensions.cs       |  2 +-
 4 files changed, 121 insertions(+), 82 deletions(-)
 delete mode 100644 Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs

diff --git a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/ContainerGatewayTests.cs b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/ContainerGatewayTests.cs
index 4d6f6d7..17f98b6 100644
--- a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/ContainerGatewayTests.cs
+++ b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/ContainerGatewayTests.cs
@@ -47,7 +47,7 @@ public void Dispose()
         }
 
         [Fact]
-        public async Task Run_WhenCalledWithLabels_ExpectContainerToHaveTheLabelsApplied()
+        public async Task RunAsync_WhenCalledWithLabels_ExpectContainerToHaveTheLabelsApplied()
         {
             // Arrange
             var imageName = "alpine:3.15";
@@ -94,7 +94,7 @@ public async Task Run_WhenCalledWithLabels_ExpectContainerToHaveTheLabelsApplied
         }
 
         [Fact]
-        public async Task Run_WhenCalledWithAnImage_ExpectContainerToBeForTheRequestedImage()
+        public async Task RunAsync_WhenCalledWithAnImage_ExpectContainerToBeForTheRequestedImage()
         {
             // Arrange
             var images = new[] { "alpine:3.15", "alpine:3.14" };
@@ -102,7 +102,7 @@ public async Task Run_WhenCalledWithAnImage_ExpectContainerToBeForTheRequestedIm
             var containerGateway = new ContainerGateway();
 
             // Act
-            var containers = images.Select(x => (Image: x, Task: containerGateway.RunAsync(x, string.Empty, Enumerable.Empty<Option>(), _cancellationToken)));
+            var containers = images.Select(x => (Image: x, Task: containerGateway.RunAsync(x, string.Empty, Enumerable.Empty<Option>(), _cancellationToken))).ToArray();
             await Task.WhenAll(containers.Select(x => x.Task));
 
             _containerIds.AddRange(containers.Select(x => x.Task.Result));
@@ -128,7 +128,7 @@ public async Task Run_WhenCalledWithAnImage_ExpectContainerToBeForTheRequestedIm
         }
 
         [Fact]
-        public async Task Run_WhenCalledForAlpineWithNoCommand_ExpectContainerToHaveStartedWithTheDefaultCommand()
+        public async Task RunAsync_WhenCalledForAlpineWithNoCommand_ExpectContainerToHaveStartedWithTheDefaultCommand()
         {
             // Arrange
             var containerGateway = new ContainerGateway();
@@ -160,7 +160,7 @@ public async Task Run_WhenCalledForAlpineWithNoCommand_ExpectContainerToHaveStar
         }
 
         [Fact]
-        public async Task Run_WhenCalledForAlpineWithACommand_ExpectContainerToHaveStartedWithTheCommand()
+        public async Task RunAsync_WhenCalledForAlpineWithACommand_ExpectContainerToHaveStartedWithTheCommand()
         {
             // Arrange
             var containerGateway = new ContainerGateway();
@@ -190,6 +190,56 @@ public async Task Run_WhenCalledForAlpineWithACommand_ExpectContainerToHaveStart
 
             Assert.Equal("'[/bin/bash]'", output);
         }
+
+        [Fact]
+        public async Task RunAsync_WhenOptionsIsNull_ExpectContainerToStillRun()
+        {
+            // Arrange
+            var containerGateway = new ContainerGateway();
+
+            // Act
+            var containerId = await containerGateway.RunAsync("alpine:3.15", "/bin/sh", default(IEnumerable<Option>), _cancellationToken);
+            _containerIds.Add(containerId);
+
+            // Assert
+            using var proc = new Process();
+            proc.StartInfo.FileName = "docker";
+            proc.StartInfo.Arguments = $"ps -aqf Id={containerId}";
+            proc.StartInfo.UseShellExecute = false;
+            proc.StartInfo.RedirectStandardOutput = true;
+
+            proc.Start();
+            proc.WaitForExit();
+
+            var shortContainerId = proc.StandardOutput.ReadLine();
+
+            Assert.StartsWith(shortContainerId, containerId);
+        }
+
+        [Fact]
+        public async Task RunAsync_WhenOptionsIsEmpty_ExpectContainerToStillRun()
+        {
+            // Arrange
+            var containerGateway = new ContainerGateway();
+
+            // Act
+            var containerId = await containerGateway.RunAsync("alpine:3.15", "/bin/sh", Enumerable.Empty<Option>(), _cancellationToken);
+            _containerIds.Add(containerId);
+
+            // Assert
+            using var proc = new Process();
+            proc.StartInfo.FileName = "docker";
+            proc.StartInfo.Arguments = $"ps -aqf Id={containerId}";
+            proc.StartInfo.UseShellExecute = false;
+            proc.StartInfo.RedirectStandardOutput = true;
+
+            proc.Start();
+            proc.WaitForExit();
+
+            var shortContainerId = proc.StandardOutput.ReadLine();
+
+            Assert.StartsWith(shortContainerId, containerId);
+        }
     }
 
     public class RemoveTests : IDisposable
@@ -378,7 +428,7 @@ public async Task AddFile_WhenCalledForMissingDirectory_ExpectDirectoryToBeCreat
             _containerIds.Add(containerId);
 
             // Act
-            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken));
+            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken)).ToList();
             await Task.WhenAll(tasks);
 
             // Assert
@@ -425,7 +475,7 @@ public async Task AddFile_WhenCalled_ExpectFileToBeCopiedToTheContainer()
             _containerIds.Add(containerId);
 
             // Act
-            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken));
+            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken)).ToList();
             await Task.WhenAll(tasks);
 
             // Assert
@@ -472,7 +522,7 @@ public async Task AddFile_WhenCalledWithPermissions_ExpectThePermissionsToBeSet(
             _containerIds.Add(containerId);
 
             // Act
-            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), x.Permissions, _cancellationToken));
+            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), x.Permissions, _cancellationToken)).ToList();
             await Task.WhenAll(tasks);
 
             // Assert
@@ -519,7 +569,7 @@ public async Task AddFile_WhenCalledWithAnOwner_ExpectThePermissionsToBeSet()
             _containerIds.Add(containerId);
 
             // Act
-            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, x.Owner, default(string), _cancellationToken));
+            var tasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, x.Owner, default(string), _cancellationToken)).ToList();
             await Task.WhenAll(tasks);
 
             // Assert
@@ -604,11 +654,11 @@ public async Task RemoveFile_WhenCalled_ExpectFileToBeRemoved()
             var containerId = await containerGateway.RunAsync("atmoz/sftp:alpine", "guest:guest tester:tester", Enumerable.Empty<Option>(), _cancellationToken);
             _containerIds.Add(containerId);
 
-            var addTasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken));
+            var addTasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken)).ToList();
             await Task.WhenAll(addTasks);
 
             // Act
-            var removeTasks = files.Select(x => containerGateway.RemoveFileAsync(containerId, x.ContainerFilename, _cancellationToken));
+            var removeTasks = files.Select(x => containerGateway.RemoveFileAsync(containerId, x.ContainerFilename, _cancellationToken)).ToList();
             await Task.WhenAll(removeTasks);
 
             // Assert
@@ -692,7 +742,7 @@ public async Task EmptyDirectory_WhenCalled_ExpectDirectoryToBeEmptied()
             var containerId = await containerGateway.RunAsync("atmoz/sftp:alpine", "guest:guest tester:tester", Enumerable.Empty<Option>(), _cancellationToken);
             _containerIds.Add(containerId);
 
-            var addTasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken));
+            var addTasks = files.Select(x => containerGateway.AddFileAsync(containerId, x.TemporaryFilename, x.ContainerFilename, default(string), default(string), _cancellationToken)).ToList();
             await Task.WhenAll(addTasks);
 
             // Act
diff --git a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
index 61a2c30..bdc3ef3 100644
--- a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
+++ b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
@@ -205,4 +205,62 @@ public async Task ConnectAsync_WhenCalled_ExpectContainerToBeConnectedToNetwork(
 
         Assert.Contains(uniqueName, connectedNetworks);
     }
+
+    [Fact]
+    public async Task CreateAsync_WhenOptionsIsNull_ExpectNetworkToBeCreated()
+    {
+        // Arrange
+        var networkName = "test";
+        var uniqueName = $"{networkName}-{Guid.NewGuid()}";
+
+        var networkGateway = new NetworkGateway();
+
+        _networkNames.Add(uniqueName);
+
+        // Act
+        await networkGateway.CreateAsync(uniqueName, default(IEnumerable<Option>), _cancellationToken.CreateLinkedTimeoutToken(TimeSpan.FromSeconds(5)));
+
+        // Assert
+        using var proc = new Process();
+        proc.StartInfo.FileName = "docker";
+        proc.StartInfo.Arguments = $"network ls -qf Name={uniqueName}";
+        proc.StartInfo.UseShellExecute = false;
+        proc.StartInfo.RedirectStandardOutput = true;
+
+        proc.Start();
+        proc.WaitForExit();
+
+        var shortNetworkId = proc.StandardOutput.ReadLine();
+
+        Assert.NotEmpty(shortNetworkId);
+    }
+
+    [Fact]
+    public async Task CreateAsync_WhenOptionsIsEmpty_ExpectNetworkToBeCreated()
+    {
+        // Arrange
+        var networkName = "test";
+        var uniqueName = $"{networkName}-{Guid.NewGuid()}";
+
+        var networkGateway = new NetworkGateway();
+
+        _networkNames.Add(uniqueName);
+
+        // Act
+        await networkGateway.CreateAsync(uniqueName, Enumerable.Empty<Option>(), _cancellationToken.CreateLinkedTimeoutToken(TimeSpan.FromSeconds(5)));
+
+        // Assert
+        using var proc = new Process();
+        proc.StartInfo.FileName = "docker";
+        proc.StartInfo.Arguments = $"network ls -qf Name={uniqueName}";
+        proc.StartInfo.UseShellExecute = false;
+        proc.StartInfo.RedirectStandardOutput = true;
+
+        proc.Start();
+        proc.WaitForExit();
+
+        var shortNetworkId = proc.StandardOutput.ReadLine();
+
+        Assert.NotEmpty(shortNetworkId);
+    }
 }
diff --git a/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs b/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs
deleted file mode 100644
index 906d758..0000000
--- a/Mittons.Fixtures.Tests.Unit/Extensions/OptionExtensionsTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Mittons.Fixtures.Extensions;
-using Mittons.Fixtures.Models;
-using Xunit;
-
-namespace Mittons.Fixtures.Tests.Unit.Extensions;
-
-public class OptionExtensionsTests
-{
-    [Fact]
-    public void ToExecutionParametersFormattedString_WhenOptionsIsNull_ExpectEmptyString()
-    {
-        IEnumerable<Option>? stubOptions = null;
-
-        var commandFormattedString = stubOptions.ToExecutionParametersFormattedString();
-
-        Assert.Equal(string.Empty, commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParametersFormattedString_WhenOptionsIsEmpty_ExpectEmptyString()
-    {
-        var stubOptions = Enumerable.Empty<Option>();
-
-        var commandFormattedString = stubOptions.ToExecutionParametersFormattedString();
-
-        Assert.Equal(string.Empty, commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParametersFormattedString_WhenOptionsHasElement_ExpectExecutionParameterFormattedString()
-    {
-        var stubOptions = new Option[]
-        {
-            new Option
-            {
-                Name = "--option",
-                Value = "value"
-            }
-        };
-
-        var commandFormattedString = stubOptions.ToExecutionParametersFormattedString();
-
-        Assert.Equal("--option \"value\"", commandFormattedString);
-    }
-
-    [Fact]
-    public void ToExecutionParametersFormattedString_WhenOptionsHasElements_ExpectExecutionParameterFormattedString()
-    {
-        var stubOptions = new Option[]
-        {
-            new Option
-            {
-                Name = "--option",
-                Value = "value"
-            },
-            new Option
-            {
-                Name = "--option",
-                Value = "value"
-            }
-        };
-
-        var commandFormattedString = stubOptions.ToExecutionParametersFormattedString();
-
-        Assert.Equal("--option \"value\" --option \"value\"", commandFormattedString);
-    }
-}
diff --git a/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs b/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
index 9673522..361c9a2 100644
--- a/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
+++ b/Mittons.Fixtures/Extensions/IEnumerableExtensions.cs
@@ -16,7 +16,7 @@ public static class IEnumerableExtensions
         /// <param name="options"></param>
         /// <returns>The options as a string formatted for use in a <c>docker</c> command.</returns>
         /// <exception cref="ArgumentNullException">Thrown when the options, any option, or their properties, are <c>null</c>.</exception>
-        public static string ToExecutionParametersFormattedString(this IEnumerable<Option> options)
+        internal static string ToExecutionParametersFormattedString(this IEnumerable<Option> options)
             => string.Join(" ", (options ?? Enumerable.Empty<Option>()).Select(option => option.ExecutionParameter).ToList());
     }
 }

From b39c6fe9166ad6473864d739e00ae554711706b6 Mon Sep 17 00:00:00 2001
From: ktmitton <kdrive113@gmail.com>
Date: Sun, 17 Apr 2022 13:50:33 -0400
Subject: [PATCH 3/3] Removed missing timeout token

---
 .../Docker/Gateways/NetworkGatewayTests.cs                    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
index bdc3ef3..f68e299 100644
--- a/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
+++ b/Mittons.Fixtures.Tests.Integration/Docker/Gateways/NetworkGatewayTests.cs
@@ -218,7 +218,7 @@ public async Task CreateAsync_WhenOptionsIsNull_ExpectNetworkToBeCreated()
         _networkNames.Add(uniqueName);
 
         // Act
-        await networkGateway.CreateAsync(uniqueName, default(IEnumerable<Option>), _cancellationToken.CreateLinkedTimeoutToken(TimeSpan.FromSeconds(5)));
+        await networkGateway.CreateAsync(uniqueName, default(IEnumerable<Option>), _cancellationToken);
 
         // Assert
         using var proc = new Process();
@@ -247,7 +247,7 @@ public async Task CreateAsync_WhenOptionsIsEmpty_ExpectNetworkToBeCreated()
         _networkNames.Add(uniqueName);
 
         // Act
-        await networkGateway.CreateAsync(uniqueName, Enumerable.Empty<Option>(), _cancellationToken.CreateLinkedTimeoutToken(TimeSpan.FromSeconds(5)));
+        await networkGateway.CreateAsync(uniqueName, Enumerable.Empty<Option>(), _cancellationToken);
 
         // Assert
         using var proc = new Process();