Merge to main

cscglobal-caplugin.Tests/CSCGlobalCAPluginTests.cs

@@ -420,7 +420,7 @@ public async Task Synchronize_ValidCertificateContent_AddsToBufferWithMappedProd
         {
             Results = new List<CertificateResponse>
             {
-                new CertificateResponse { Uuid = "u1", Status = "ACTIVE", Certificate = apiBase64, CertificateType = "4" }
+                new CertificateResponse { Uuid = "u1", Status = "ACTIVE", Certificate = apiBase64, CertificateType = "CSC TrustedSecure DV" }
             }
         });
 
@@ -432,7 +432,10 @@ public async Task Synchronize_ValidCertificateContent_AddsToBufferWithMappedProd
         var items = buffer.ToArray();
         Assert.Single(items);
         Assert.Equal("u1", items[0].CARequestID);
-        Assert.Equal("CSC TrustedSecure Domain Validated SSL", items[0].ProductID);
+        // CSC's list/sync API returns the certificate's current product name directly, so the
+        // synced ProductID must match it verbatim (and therefore match the canonical Certificate
+        // Profile name configured in Command) rather than going through a name-remapping table.
+        Assert.Equal("CSC TrustedSecure DV", items[0].ProductID);
     }
 
     [Fact]
@@ -834,6 +837,58 @@ public async Task Enroll_New_Success_ReturnsExternalValidation()
 
         Assert.Equal((int)EndEntityStatus.EXTERNALVALIDATION, result.Status);
         Assert.Equal("uuid-new", result.CARequestID);
+        // Command's enrollment UI doesn't surface StatusMessage on a successful/pending result -
+        // only EnrollmentContext is - so the flow summary must be attached there instead, one
+        // bullet per step so it renders readably rather than as a single run-on blob.
+        Assert.NotNull(result.EnrollmentContext);
+        Assert.True(result.EnrollmentContext.ContainsKey("Flow: Enroll-New"));
+        Assert.True(result.EnrollmentContext.Keys.Count(k => k.StartsWith("Flow Step ")) > 1);
+    }
+
+    [Fact]
+    public async Task Enroll_New_SuccessWithDcvDetails_KeepsDcvEntriesAlongsideFlowSummary()
+    {
+        var mockClient = new Mock<ICscGlobalClient>();
+        mockClient.Setup(c => c.SubmitGetCustomFields()).ReturnsAsync(new List<GetCustomField>());
+        mockClient.Setup(c => c.SubmitRegistrationAsync(It.IsAny<RegistrationRequest>())).ReturnsAsync(new RegistrationResponse
+        {
+            Result = new Result
+            {
+                CommonName = "dcv.example.com",
+                Status = new Status { Uuid = "uuid-dcv" },
+                DcvDetails = new List<DcvDetail>
+                {
+                    new DcvDetail { CName = new CName { Name = "_dnsauth.example.com", Value = "token" } }
+                }
+            }
+        });
+
+        var plugin = MakePlugin(mockClient);
+        var result = await plugin.Enroll("csr", "CN=test", new Dictionary<string, string[]>(), ProductInfo(),
+            RequestFormat.PKCS10, EnrollmentType.New);
+
+        Assert.Equal("token", result.EnrollmentContext["_dnsauth.example.com"]);
+        Assert.True(result.EnrollmentContext.ContainsKey("Flow: Enroll-New"));
+        Assert.True(result.EnrollmentContext.Keys.Count(k => k.StartsWith("Flow Step ")) > 1);
+    }
+
+    [Fact]
+    public async Task Enroll_New_RegistrationErrorFromCsc_PrependsFlowSummaryToStatusMessage()
+    {
+        var mockClient = new Mock<ICscGlobalClient>();
+        mockClient.Setup(c => c.SubmitGetCustomFields()).ReturnsAsync(new List<GetCustomField>());
+        mockClient.Setup(c => c.SubmitRegistrationAsync(It.IsAny<RegistrationRequest>())).ReturnsAsync(new RegistrationResponse
+        {
+            RegistrationError = new RegistrationError { Description = "Open order in progress" }
+        });
+
+        var plugin = MakePlugin(mockClient);
+        var result = await plugin.Enroll("csr", "CN=test", new Dictionary<string, string[]>(), ProductInfo(),
+            RequestFormat.PKCS10, EnrollmentType.New);
+
+        Assert.Equal((int)EndEntityStatus.FAILED, result.Status);
+        Assert.Contains("Enroll-New", result.StatusMessage);
+        Assert.Contains("Open order in progress", result.StatusMessage);
     }
 
     [Fact]
@@ -993,10 +1048,14 @@ public async Task Enroll_New_WithDnsValidatorFactoryButEmailMethod_DoesNotAttemp
             [EnrollmentConfigConstants.DomainControlValidationMethod] = "EMAIL"
         });
 
-        await plugin.Enroll("csr", "CN=test", new Dictionary<string, string[]>(), productInfo,
+        var result = await plugin.Enroll("csr", "CN=test", new Dictionary<string, string[]>(), productInfo,
             RequestFormat.PKCS10, EnrollmentType.New);
 
         mockFactory.Verify(f => f.ResolveDomainValidator(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+        // The DcvAutoPublish step must explain *why* it was a no-op for a non-CNAME method,
+        // rather than showing a bare [OK] under a CNAME-sounding step name.
+        var publishStep = result.EnrollmentContext.Single(e => e.Key.Contains("DcvAutoPublish"));
+        Assert.Contains("not CNAME", publishStep.Value);
     }
 
     [Fact]

cscglobal-caplugin.Tests/FlowLoggerTests.cs

@@ -117,6 +117,51 @@ public void EndBranch_WithoutBranch_DoesNotThrow()
         flow.EndBranch();
     }
 
+    [Fact]
+    public void GetSummaryEntries_OneEntryPerStepPlusHeader()
+    {
+        using var flow = new FlowLogger(NewLoggerMock().Object, "MyFlow");
+        flow.Step("StepOne");
+        flow.Fail("StepTwo", "boom");
+
+        var entries = flow.GetSummaryEntries();
+
+        Assert.True(entries.ContainsKey("Flow: MyFlow"));
+        Assert.Contains("FAILED", entries["Flow: MyFlow"]);
+        Assert.Equal(3, entries.Count); // header + 2 steps
+        Assert.Contains(entries, e => e.Key.Contains("StepOne") && e.Value.Contains("OK"));
+        Assert.Contains(entries, e => e.Key.Contains("StepTwo") && e.Value.Contains("boom"));
+    }
+
+    [Fact]
+    public void GetSummaryEntries_AllStepsSucceed_HeaderReportsOk()
+    {
+        using var flow = new FlowLogger(NewLoggerMock().Object, "MyFlow");
+        flow.Step("StepOne");
+        flow.Step("StepTwo");
+
+        var entries = flow.GetSummaryEntries();
+
+        Assert.Contains("[OK]", entries["Flow: MyFlow"]);
+    }
+
+    [Fact]
+    public void GetSummaryEntries_BranchChildren_IncludedAsSeparateEntries()
+    {
+        using var flow = new FlowLogger(NewLoggerMock().Object, "MyFlow");
+        flow.Branch("Inner");
+        flow.Step("NestedStep");
+        flow.Fail("NestedFail", "inner reason");
+        flow.EndBranch();
+        flow.Step("TopLevelStep");
+
+        var entries = flow.GetSummaryEntries();
+
+        Assert.Contains(entries, e => e.Key.Contains("NestedStep"));
+        Assert.Contains(entries, e => e.Key.Contains("NestedFail") && e.Value.Contains("inner reason"));
+        Assert.Contains(entries, e => e.Key.Contains("TopLevelStep"));
+    }
+
     [Fact]
     public void Dispose_NoSteps_DoesNotThrow()
     {

cscglobal-caplugin.Tests/RequestManagerTests.cs

@@ -402,7 +402,7 @@ public void GetRevokeResult_Success_ReturnsRevoked()
     }
 
     // ---------------------------------------------------------------------
-    // MapReturnStatus / MapCertificateTypeToProductId
+    // MapReturnStatus
     // ---------------------------------------------------------------------
 
     [Theory]
@@ -417,28 +417,6 @@ public void MapReturnStatus_MapsExpectedStatus(string? cscStatus, Keyfactor.PKI.
         Assert.Equal((int)expected, Manager.MapReturnStatus(cscStatus!));
     }
 
-    [Theory]
-    [InlineData("4", "CSC TrustedSecure Domain Validated SSL")]
-    [InlineData("CSC TrustedSecure Domain Validated SSL", "CSC TrustedSecure Domain Validated SSL")]
-    [InlineData("CSC Trusted Secure Domain Validated SSL", "CSC TrustedSecure Domain Validated SSL")]
-    [InlineData("9", "CSC TrustedSecure DV Wildcard, Multiple Names")]
-    public void MapCertificateTypeToProductId_KnownValue_MapsToProductId(string cscType, string expectedProductId)
-    {
-        Assert.Equal(expectedProductId, Manager.MapCertificateTypeToProductId(cscType));
-    }
-
-    [Fact]
-    public void MapCertificateTypeToProductId_UnknownValue_PassesThrough()
-    {
-        Assert.Equal("SomeUnknownType", Manager.MapCertificateTypeToProductId("SomeUnknownType"));
-    }
-
-    [Fact]
-    public void MapCertificateTypeToProductId_Null_ReturnsFallback()
-    {
-        Assert.Equal("CscGlobal", Manager.MapCertificateTypeToProductId(null!));
-    }
-
     // ---------------------------------------------------------------------
     // GetNotifications
     // ---------------------------------------------------------------------