added command line argument to configure registration contact

added command line argument to configure agreement uri
removed hard coded contact email
improved unit tests

src/Oocx.ACME.Console/AcmeProcess.cs

@@ -164,7 +164,7 @@ private async Task<bool> AuthorizeForDomain(string domain)
 
  private async Task RegisterWithServer()
  {
- var registration = await client.RegisterAsync(options.AcceptTermsOfService);
+ var registration = await client.RegisterAsync(options.AcceptTermsOfService ? options.TermsOfServiceUri : null, options.Contact);
  Info($"Terms of service: {registration.Agreement}");
  Verbose($"Created at: {registration.CreatedAt}");
  Verbose($"Id: {registration.Id}");
@@ -174,7 +174,12 @@ private async Task RegisterWithServer()
  if (!string.IsNullOrWhiteSpace(registration.Location) && options.AcceptTermsOfService)
  {
  Info("accepting terms of service");
- await client.UpdateRegistrationAsync(registration.Location, registration.Agreement); 
+ if (!string.Equals(registration.Agreement, options.TermsOfServiceUri))
+ {
+ Error($"Cannot accept terms of service. The terms of service uri is '{registration.Agreement}', expected it to be '{options.TermsOfServiceUri}'.");
+ return;
+ }
+ await client.UpdateRegistrationAsync(registration.Location, registration.Agreement, options.Contact); 
  }
  }
 

src/Oocx.ACME.Console/Options.cs

@@ -14,9 +14,12 @@ public class Options
  [Value(0, HelpText = "The names of the domains for which you want to request a certificate.", Required = true, MetaName = "domains")]
  public IEnumerable<string> Domains { get; set; }
 
- [Option('a', "acceptTOS", HelpText = "Accept the terms of service of the ACME server")]
+ [Option('a', "acceptTermsOfService", HelpText = "Accept the terms of service of the ACME server")]
  public bool AcceptTermsOfService { get; set; }
 
+ [Option('t', "termsOfServiceUri", HelpText = "The uri of the terms of service that you accept.", Default = "https://letsencrypt.org/documents/LE-SA-v1.0.1-July-27-2015.pdf")]
+ public string TermsOfServiceUri { get; set; }
+
  [Option('i', "ignoreSSLErrors", HelpText = "Ignore SSL certificate errors for the HTTPS connection to the ACME server (useful for debugging messages with fiddler)")]
  public bool IgnoreSSLCertificateErrors { get; set; }
 
@@ -43,5 +46,8 @@ public class Options
 
  [Option('b', "iisBinding", HelpText = "The IIS binding that should be configured to use the new certificate. Syntax: ip:port:hostname, for example '*:443:www.example.com' (used with --serverConfigurationProvider iis). If you do not specifiy a binding, the provider will try to find a matching binding. It will create a binding if no matching binding exists.")]
  public string IISBinidng { get; set; }
+
+ [Option('m', "contact", HelpText = "The contact information for the registration request. Example: mailto:[email protected]")]
+ public string[] Contact { get; set; }
  } 
 }

src/Oocx.ACME.Tests/ClientTests.cs

@@ -1,29 +1,32 @@
 using System;
-using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
-using System.Net.Http.Formatting;
 using System.Security.Cryptography;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Oocx.ACME.Client;
 using Oocx.ACME.Protocol;
-using WorldDomination.Net.Http;
+using Oocx.ACME.Tests.FakeHttp;
 using Xunit;
 
 namespace Oocx.ACME.Tests
 {
  public class ClientTests
  {
+
+
  [Fact]
  public async Task Should_get_a_Directory_object_from_the_default_endpoint()
  {
  // Arrange
+ var http = new FakeHttpMessageHandler("http://baseaddress/");
  var directory = new Directory();
- var response = new HttpResponseMessage(HttpStatusCode.OK) {Content = new ObjectContent<Directory>(directory, new JsonMediaTypeFormatter()) };
- response.Headers.Add("Replay-Nonce", "nonce");
- var handler = new FakeHttpMessageHandler("http://baseaddress/directory", response); 
- var client = new HttpClient(handler) { BaseAddress = new Uri("http://baseAddress")};
+
+ var client = 
+ http.RequestTo("directory").Returns(directory).WithNonce("nonce")
+ .GetHttpClient();
+
  var sut = new AcmeClient(client, new RSACryptoServiceProvider());
 
  // Act
@@ -37,28 +40,62 @@ public async Task Should_get_a_Directory_object_from_the_default_endpoint()
  public async Task Should_post_a_valid_Registration_message()
  {
  // Arrange
+ var http = new FakeHttpMessageHandler("http://baseaddress/");
  var directory = new Directory() { NewRegistration = new Uri("http://baseaddress/registration")};
- var response1 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ObjectContent<Directory>(directory, new JsonMediaTypeFormatter()) };
- response1.Headers.Add("Replay-Nonce", "nonce");
-
  var registration = new RegistrationResponse();
- var response2 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ObjectContent<RegistrationResponse>(registration, new JsonMediaTypeFormatter()) };
- response2.Headers.Add("Replay-Nonce", "nonce");
 
- var handler = new FakeHttpMessageHandler(new Dictionary<string, HttpResponseMessage>()
+ var client = 
+ http.RequestTo("directory").Returns(directory).WithNonce("nonce").
+ RequestTo("registration").Returns(registration).WithNonce("nonce").
+ GetHttpClient();
+
+ var sut = new AcmeClient(client, new RSACryptoServiceProvider());
+
+ // Act
+ var registrationResponse = await sut.RegisterAsync("agreementUri", new []{ "mailto:[email protected]"});
+
+ // Assert
+ registrationResponse.Should().NotBeNull();
+ http.ReceivedRequestsTo("directory").Single().HasMethod(HttpMethod.Get);
+ http.ReceivedRequestsTo("registration").Single().HasMethod(HttpMethod.Post).HasJwsPayload<NewRegistrationRequest>(r =>
  {
- {"http://baseaddress/directory", response1 },
- {"http://baseaddress/registration", response2 }
+ r.Agreement.Should().Be("agreementUri"); 
+ r.Contact.Should().Contain("mailto:[email protected]");
  });
+ }
+
+ [Fact]
+ public async Task Should_POST_to_get_registration_details_if_the_registration_already_exists()
+ {
+ // Arrange
+ var http = new FakeHttpMessageHandler("http://baseaddress/");
+ var directory = new Directory() { NewRegistration = new Uri("http://baseaddress/registration") };
+ var registration = new RegistrationResponse();
+
+ var client =
+ http.RequestTo("directory").Returns(directory).WithNonce("nonce").
+ RequestTo("registration").Returns(new Problem(), "application/problem+json").HasStatusCode(HttpStatusCode.Conflict).WithHeader("Location", "http://baseaddress/existingreguri").WithNonce("nonce").
+ RequestTo("existingreguri").Returns(registration).WithNonce("nonce").
+ GetHttpClient();
 
- var client = new HttpClient(handler) { BaseAddress = new Uri("http://baseAddress") };
  var sut = new AcmeClient(client, new RSACryptoServiceProvider());
 
  // Act
- var registrationResponse =  await sut.RegisterAsync(false);
+ var registrationResponse = await sut.RegisterAsync("agreementUri", new[] { "mailto:[email protected]" });
 
  // Assert
  registrationResponse.Should().NotBeNull();
+ http.ReceivedRequestsTo("directory").Single().HasMethod(HttpMethod.Get);
+ http.ReceivedRequestsTo("registration").Single().HasMethod(HttpMethod.Post).HasJwsPayload<NewRegistrationRequest>(r =>
+ {
+ r.Agreement.Should().Be("agreementUri");
+ r.Contact.Should().Contain("mailto:[email protected]");
+ });
+ http.ReceivedRequestsTo("existingreguri").Single().HasMethod(HttpMethod.Post).HasJwsPayload<UpdateRegistrationRequest>(r =>
+ {
+ r.Agreement.Should().BeNull();
+ r.Contact.Should().BeNull();
+ });
  }
  }
 }

src/Oocx.ACME.Tests/FakeHttp/FakeHttpMessageHandler.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions.Execution;
+
+namespace Oocx.ACME.Tests.FakeHttp
+{
+ public class FakeHttpMessageHandler : HttpMessageHandler
+ { 
+ private readonly Queue<FakeRequestConfiguration> requestConfigurations = new Queue<FakeRequestConfiguration>();
+
+ private readonly List<HttpRequestMessage> actualRequests = new List<HttpRequestMessage>(); 
+
+ public string BaseAddress { get; }
+
+ public FakeHttpMessageHandler(string baseAddress)
+ {
+ this.BaseAddress = baseAddress;
+ }
+
+ public FakeRequestConfiguration RequestTo(string uri)
+ {
+ return new FakeRequestConfiguration(this) { Uri = BaseAddress + uri };
+ }
+
+ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ request.Content = await PreventDisposeContentWrapper.CreateWrapperAsync(request.Content);
+
+ actualRequests.Add(request);
+
+ var expected = requestConfigurations.Dequeue();
+ if (!request.RequestUri.Equals(new Uri(expected.Uri, UriKind.RelativeOrAbsolute)))
+ {
+ throw new AssertionFailedException($"expected request to '{expected.Uri}', but got request to '{request.RequestUri}'");
+ }
+
+ return expected.GetResponseMessage();
+ }
+
+ public HttpRequestMessage[] ReceivedRequestsTo(string uri)
+ {
+ var requests = actualRequests.Where(r => r.RequestUri.Equals(new Uri(BaseAddress + uri))).ToArray();
+ if (!requests.Any())
+ { 
+ throw new AssertionFailedException($"expected a request to {uri}, but only got the following requests: {string.Join(", ", actualRequests.Select(r => r.RequestUri.ToString()))}");
+ }
+ return requests;
+ }
+
+ public void Enqueue(FakeRequestConfiguration fakeRequestConfiguration)
+ {
+ requestConfigurations.Enqueue(fakeRequestConfiguration);
+ }
+ }
+}

src/Oocx.ACME.Tests/FakeHttp/FakeRequestConfiguration.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+
+namespace Oocx.ACME.Tests.FakeHttp
+{
+ public class FakeRequestConfiguration
+ {
+ private readonly FakeHttpMessageHandler fakeHttpMessageHandler;
+ private static readonly JsonMediaTypeFormatter Formatter = new JsonMediaTypeFormatter();
+
+ public FakeRequestConfiguration(FakeHttpMessageHandler fakeHttpMessageHandler)
+ {
+ this.fakeHttpMessageHandler = fakeHttpMessageHandler;
+ fakeHttpMessageHandler.Enqueue(this);
+ }
+
+ public string Uri { get; set; }
+
+ public ObjectContent Content { get; set; }
+
+ public Dictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(); 
+
+ public HttpStatusCode StatusCode { get; set; } = HttpStatusCode.OK;
+
+ public FakeRequestConfiguration Returns<T>(T content, string contentType = "application/json")
+ {
+ Content = new ObjectContent<T>(content, Formatter);
+ Content.Headers.ContentType.MediaType = contentType;
+ return this;
+ }
+
+ public FakeRequestConfiguration HasStatusCode(HttpStatusCode statusCode)
+ {
+ StatusCode = statusCode;
+ return this;
+ }
+
+ public FakeRequestConfiguration WithHeader(string key, string value)
+ {
+ Headers[key] = value;
+ return this;
+ }
+
+ public FakeRequestConfiguration WithNonce(string value)
+ {
+ Headers["Replay-Nonce"] = value;
+ return this;
+ }
+
+ public FakeRequestConfiguration RequestTo(string uri)
+ {
+ return fakeHttpMessageHandler.RequestTo(uri);
+ }
+
+ public HttpResponseMessage GetResponseMessage()
+ {
+ var response = new HttpResponseMessage(StatusCode) { Content = Content};
+ foreach (var header in Headers)
+ {
+ response.Headers.Add(header.Key, header.Value);
+ }
+ return response;
+ }
+
+ public HttpClient GetHttpClient()
+ { 
+ var client = new HttpClient(fakeHttpMessageHandler) { BaseAddress = new Uri(fakeHttpMessageHandler.BaseAddress, UriKind.Absolute) };
+ return client;
+ }
+ }
+}

src/Oocx.ACME.Tests/FakeHttp/HttpRequestMessageAssertions.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Net.Http;
+using System.Text;
+using FluentAssertions;
+using Newtonsoft.Json;
+using Oocx.ACME.Jose;
+using Oocx.Asn1PKCS.Asn1BaseTypes;
+
+namespace Oocx.ACME.Tests.FakeHttp
+{
+ public static class HttpRequestMessageAssertions
+ {
+ public static HttpRequestMessage HasContent(this HttpRequestMessage request, Action<HttpContent> contentAssertion)
+ {
+ contentAssertion(request.Content);
+ return request;
+ }
+
+ public static HttpRequestMessage HasContent<T>(this HttpRequestMessage request, Action<T> contentAssertion)
+ {
+ contentAssertion(request.Content.ReadAsAsync<T>().Result);
+ return request;
+ }
+
+ public static HttpRequestMessage HasJwsPayload<T>(this HttpRequestMessage request, Action<T> contentAssertion)
+ {
+ var message = request.Content.ReadAsAsync<JWSMessage>().Result;
+ var contentJson = Encoding.UTF8.GetString(message.Payload.Base64UrlDecode());
+ var content = JsonConvert.DeserializeObject<T>(contentJson);
+
+ contentAssertion(content);
+ return request;
+ }
+
+ public static HttpRequestMessage HasHeader(this HttpRequestMessage request, string headerName, string headerValue)
+ {
+ request.Headers.Should().Contain(headerName);
+ request.Headers.GetValues(headerName).Should().Contain(headerValue);
+ return request;
+ }
+
+ public static HttpRequestMessage HasMethod(this HttpRequestMessage request, HttpMethod method)
+ {
+ request.Method.Should().Be(method);
+ return request;
+ }
+ }
+}