#66 : Additional unit tests

Author: badgeratu

src/Man.Dapr.Sidekick/Process/PortAssignmentBuilder.cs

@@ -70,15 +70,8 @@ public void Build(TOptions proposedOptions, TOptions lastSuccessfulOptions, IDap
                     continue;
                 }
 
-                // If port is already defined, then use it
-                if (proposedValue.HasValue)
-                {
-                    logger.LogDebug("Assigning preferred port {DaprPortNumber} for option {DaprPortName}", proposedValue, propertyName);
-                    reservedPorts.Add(proposedValue.Value);
-                    continue;
-                }
-
-                // If we have an environment variable defined attempt to get the port from it
+                // If we have an environment variable defined attempt to get the port from it.
+                // This overrides default/proposed configuration values.
                 if (!string.IsNullOrEmpty(port.EnvironmentVariable) &&
                     int.TryParse(Environment.GetEnvironmentVariable(port.EnvironmentVariable), out var environmentPort) &&
                     environmentPort > 0)
@@ -93,6 +86,14 @@ public void Build(TOptions proposedOptions, TOptions lastSuccessfulOptions, IDap
                     continue;
                 }
 
+                // If port is already defined, then use it
+                if (proposedValue.HasValue)
+                {
+                    logger.LogDebug("Assigning preferred port {DaprPortNumber} for option {DaprPortName}", proposedValue, propertyName);
+                    reservedPorts.Add(proposedValue.Value);
+                    continue;
+                }
+
                 if (AlwaysUseStartingPort || PortAvailabilityChecker == null)
                 {
                     logger.LogDebug("Assigning default port {DaprPortNumber} for option {DaprPortName}", port.StartingPort, propertyName);

tests/Man.Dapr.Sidekick.Tests/Process/DaprSidecarProcessTests.cs

@@ -129,6 +129,64 @@ public void Should_assign_expected_values()
                 Assert.That(options.MetricsPort, Is.EqualTo(9090));
                 Assert.That(options.ProfilePort, Is.EqualTo(7777));
             }
+
+            [TestCase(false)]
+            [TestCase(true)]
+            public void Should_assign_environment_variable_overrides(bool useEnvironmentVariables)
+            {
+                var p = new MockDaprSidecarProcess();
+                var builder = new PortAssignmentBuilder<DaprSidecarOptions>(new MockPortAvailabilityChecker());
+                var options = new DaprSidecarOptions
+                {
+                    AppPort = 2000,
+                    DaprGrpcPort = 3000,
+                    DaprHttpPort = 4000
+                };
+
+                var logger = Substitute.For<IDaprLogger>();
+
+                var existingAppPort = Environment.GetEnvironmentVariable(DaprConstants.DaprAppPortEnvironmentVariable);
+                var existingGrpcPort = Environment.GetEnvironmentVariable(DaprConstants.DaprGrpcPortEnvironmentVariable);
+                var existingHttpPort = Environment.GetEnvironmentVariable(DaprConstants.DaprHttpPortEnvironmentVariable);
+
+                try
+                {
+                    if (useEnvironmentVariables)
+                    {
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprAppPortEnvironmentVariable, "1234");
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprGrpcPortEnvironmentVariable, "98765");
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprHttpPortEnvironmentVariable, "7345");
+                    }
+
+                    p.AssignPorts(builder);
+                    builder.Build(options, new DaprSidecarOptions(), logger);
+
+                    // Should respect environment variables
+                    if (useEnvironmentVariables)
+                    {
+                        // Should use environment variable values
+                        Assert.That(options.AppPort, Is.EqualTo(1234));
+                        Assert.That(options.DaprGrpcPort, Is.EqualTo(98765));
+                        Assert.That(options.DaprHttpPort, Is.EqualTo(7345));
+                    }
+                    else
+                    {
+                        // Should use options values
+                        Assert.That(options.AppPort, Is.EqualTo(2000));
+                        Assert.That(options.DaprGrpcPort, Is.EqualTo(3000));
+                        Assert.That(options.DaprHttpPort, Is.EqualTo(4000));
+                    }
+                }
+                finally
+                {
+                    if (useEnvironmentVariables)
+                    {
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprAppPortEnvironmentVariable, existingAppPort);
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprGrpcPortEnvironmentVariable, existingGrpcPort);
+                        Environment.SetEnvironmentVariable(DaprConstants.DaprHttpPortEnvironmentVariable, existingHttpPort);
+                    }
+                }
+            }
         }
 
         public class AssignLocations

tests/Man.Dapr.Sidekick.Tests/Process/PortAssignmentBuilderTests.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Man.Dapr.Sidekick.Logging;
 using NSubstitute;
 using NUnit.Framework;
@@ -135,6 +136,32 @@ public void Should_use_starting_ports()
                 Assert.That(proposedOptions.DaprHttpPort, Is.EqualTo(200));
                 Assert.That(proposedOptions.MetricsPort, Is.EqualTo(4000));
             }
+
+            [Test]
+            public void Should_use_environment_variable_ports()
+            {
+                var logger = Substitute.For<IDaprLogger>();
+                var checker = Substitute.For<IPortAvailabilityChecker>();
+                var builder = new PortAssignmentBuilder<DaprSidecarOptions>(checker);
+
+                Environment.SetEnvironmentVariable("DAPRSIDEKICK_TESTS_VALID_PORT", "1234");
+                Environment.SetEnvironmentVariable("DAPRSIDEKICK_TESTS_INVALID_PORT", "Not_A_Number");
+
+                builder
+                    .Add(x => x.DaprGrpcPort, 2000, "DAPRSIDEKICK_TESTS_VALID_PORT")
+                    .Add(x => x.DaprHttpPort, 3000, "DAPRSIDEKICK_TESTS_INVALID_PORT")
+                    .Add(x => x.MetricsPort, 4000, "DAPRSIDEKICK_TESTS_MISSING_PORT");
+
+                checker.GetAvailablePort(3000, Arg.Any<IEnumerable<int>>()).Returns(3000);
+                checker.GetAvailablePort(4000, Arg.Any<IEnumerable<int>>()).Returns(4000);
+
+                var proposedOptions = new DaprSidecarOptions();
+
+                builder.Build(proposedOptions, null, logger);
+                Assert.That(proposedOptions.DaprGrpcPort, Is.EqualTo(1234));
+                Assert.That(proposedOptions.DaprHttpPort, Is.EqualTo(3000));
+                Assert.That(proposedOptions.MetricsPort, Is.EqualTo(4000));
+            }
         }
     }
 }