enable to pass environment variables from outside

DockerComposeFixture/Compose/DockerCompose.cs

@@ -12,10 +12,15 @@ namespace DockerComposeFixture.Compose
 {
     public class DockerCompose : IDockerCompose
     {
-        public DockerCompose(ILogger[] logger)
+        private readonly IEnumerable<KeyValuePair<string, object>> environmentVariables;
+
+        public DockerCompose(ILogger[] logger, IEnumerable<KeyValuePair<string, object>> environmentVariables)
         {
+            this.environmentVariables = environmentVariables;
             this.Logger = logger;
         }
+        public DockerCompose(ILogger[] logger) : this(logger, Enumerable.Empty<KeyValuePair<string, object>>()) {}
+
         private string dockerComposeArgs,dockerComposeUpArgs, dockerComposeDownArgs;
 
         public void Init(string dockerComposeArgs, string dockerComposeUpArgs, string dockerComposeDownArgs)
@@ -33,6 +38,11 @@ public Task Up()
 
         private void RunProcess(ProcessStartInfo processStartInfo)
         {
+            foreach (var e in environmentVariables)
+            {
+                processStartInfo.EnvironmentVariables[e.Key] = e.Value.ToString();
+            }
+
             var runner = new ProcessRunner(processStartInfo);
             foreach (var logger in this.Logger)
             {

DockerComposeFixture/DockerFixture.cs

@@ -32,9 +32,9 @@ public DockerFixture(IMessageSink output)
         /// If you call this multiple times on the same DockerFixture then it will be ignored.
         /// </summary>
         /// <param name="setupOptions">Options that control how docker-compose is executed.</param>
-        public void InitOnce(Func<IDockerFixtureOptions> setupOptions)
+        public async Task InitOnceAsync(Func<IDockerFixtureOptions> setupOptions)
         {
-            InitOnce(setupOptions, null);
+            await InitOnceAsync(setupOptions, null);
         }
 
         /// <summary>
@@ -43,11 +43,11 @@ public void InitOnce(Func<IDockerFixtureOptions> setupOptions)
         /// </summary>
         /// <param name="setupOptions">Options that control how docker-compose is executed.</param>
         /// <param name="dockerCompose"></param>
-        public void InitOnce(Func<IDockerFixtureOptions> setupOptions, IDockerCompose dockerCompose)
+        public async Task InitOnceAsync(Func<IDockerFixtureOptions> setupOptions, IDockerCompose dockerCompose)
         {
             if (!this.initialised)
             {
-                this.Init(setupOptions, dockerCompose);
+                await this.InitAsync(setupOptions, dockerCompose);
                 this.initialised = true;
             }
         }
@@ -57,26 +57,26 @@ public void InitOnce(Func<IDockerFixtureOptions> setupOptions, IDockerCompose do
         /// Initialize docker compose services from file(s).
         /// </summary>
         /// <param name="setupOptions">Options that control how docker-compose is executed</param>
-        public void Init(Func<IDockerFixtureOptions> setupOptions)
+        public async Task InitAsync(Func<IDockerFixtureOptions> setupOptions)
         {
-            Init(setupOptions, null);
+            await InitAsync(setupOptions, null);
         }
 
         /// <summary>
         /// Initialize docker compose services from file(s).
         /// </summary>
         /// <param name="setupOptions">Options that control how docker-compose is executed</param>
         /// <param name="compose"></param>
-        public void Init(Func<IDockerFixtureOptions> setupOptions, IDockerCompose compose)
+        public async Task InitAsync(Func<IDockerFixtureOptions> setupOptions, IDockerCompose compose)
         {
             var options = setupOptions();
             options.Validate();
             string logFile = options.DebugLog
                 ? Path.Combine(Path.GetTempPath(), $"docker-compose-{DateTime.Now.Ticks}.log")
                 : null;
 
-            this.Init(options.DockerComposeFiles, options.DockerComposeUpArgs, options.DockerComposeDownArgs,
-                options.StartupTimeoutSecs, options.CustomUpTest, compose, this.GetLoggers(logFile).ToArray());
+            await this.InitAsync(options.DockerComposeFiles, options.DockerComposeUpArgs, options.DockerComposeDownArgs,
+                options.StartupTimeoutSecs, options.CustomUpTest, compose, this.GetLoggers(logFile).ToArray(), options.EnvironmentVariables);
         }
 
         private IEnumerable<ILogger> GetLoggers(string file)
@@ -103,14 +103,15 @@ private IEnumerable<ILogger> GetLoggers(string file)
         /// <param name="customUpTest">Checks whether the docker-compose services have come up correctly based upon the output of docker-compose</param>
         /// <param name="dockerCompose"></param>
         /// <param name="logger"></param>
-        public void Init(string[] dockerComposeFiles, string dockerComposeUpArgs, string dockerComposeDownArgs,
+        /// <param name="environmentVariables"></param>
+        public async Task InitAsync(string[] dockerComposeFiles, string dockerComposeUpArgs, string dockerComposeDownArgs,
             int startupTimeoutSecs, Func<string[], bool> customUpTest = null,
-            IDockerCompose dockerCompose = null, ILogger[] logger = null)
+            IDockerCompose dockerCompose = null, ILogger[] logger = null, IEnumerable<KeyValuePair<string, object>> environmentVariables = null)
         {
             this.loggers = logger ?? GetLoggers(null).ToArray();
 
             var dockerComposeFilePaths = dockerComposeFiles.Select(this.GetComposeFilePath);
-            this.dockerCompose = dockerCompose ?? new DockerCompose(this.loggers);
+            this.dockerCompose = dockerCompose ?? new DockerCompose(this.loggers, environmentVariables);
             this.customUpTest = customUpTest;
             this.startupTimeoutSecs = startupTimeoutSecs;
 
@@ -119,7 +120,7 @@ public void Init(string[] dockerComposeFiles, string dockerComposeUpArgs, string
                         dockerComposeFilePaths
                             .Select(f => $"-f \"{f}\""))
                     .Trim(), dockerComposeUpArgs, dockerComposeDownArgs);
-            this.Start();
+            await this.StartAsync();
         }
 
         private string GetComposeFilePath(string file)
@@ -195,7 +196,7 @@ public virtual void Dispose()
             this.Stop();
         }
 
-        private void Start()
+        private async Task StartAsync()
         {
             if (this.CheckIfRunning().hasContainers)
             {
@@ -214,7 +215,7 @@ private void Start()
                     break;
                 }
                 this.loggers.Log($"---- checking docker services ({i + 1}/{this.startupTimeoutSecs}) ----");
-                Thread.Sleep(this.dockerCompose.PauseMs);
+                await Task.Delay(1000);
                 if (this.customUpTest != null)
                 {
                     if (this.customUpTest(this.loggers.GetLoggedLines()))
@@ -252,7 +253,5 @@ private void Stop()
         {
             this.dockerCompose.Down();
         }
-
-
     }
 }

DockerComposeFixture/DockerFixtureOptions.cs

@@ -34,6 +34,8 @@ public class DockerFixtureOptions : IDockerFixtureOptions
         /// Default is 'docker-compose -f file.yml down --remove-orphans' you can add '--rmi all' if you want to guarantee a fresh build on each test
         /// </summary>
         public string DockerComposeDownArgs { get; set; } = "--remove-orphans";
+
+        public IEnumerable<KeyValuePair<string, object>> EnvironmentVariables { get; set; }
 
         /// <summary>
         /// How many seconds to wait for the application to start before giving up. (Default is 120.)

DockerComposeFixture/IDockerFixtureOptions.cs

@@ -11,6 +11,8 @@ public interface IDockerFixtureOptions
         string DockerComposeUpArgs { get; set; }
         string DockerComposeDownArgs { get; set; }
         int StartupTimeoutSecs { get; set; }
+
+        IEnumerable<KeyValuePair<string, object>> EnvironmentVariables { get; set; }
 
         void Validate();