Update finalise order logic, and tests

acme_test.go

@@ -102,7 +102,7 @@ func TestClient_Directory(t *testing.T) {
 }
 
 func TestClient_Fetch(t *testing.T) {
-	_, account1order, _ := makeOrderFinalised(t, []string{ChallengeTypeDNS01}, Identifier{"dns", "example.com"})
+	_, account1order, _ := makeOrderFinalised(t, []string{ChallengeTypeDNS01}, Identifier{"dns", randString() + ".com"})
 	account2 := makeAccount(t)
 	err := testClient.Fetch(account2, account1order.URL, &Account{})
 	if err == nil {

order.go

@@ -108,29 +108,56 @@ func (c Client) FinalizeOrder(account Account, order Order, csr *x509.Certificat
 	}
 
 	order.URL = resp.Header.Get("Location")
-	retryAfter, err := parseRetryAfter(resp.Header.Get("Retry-After"))
-	if err != nil {
-		return order, fmt.Errorf("acme: error parsing retry-after header: %v", err)
+
+	updateOrder := func(resp *http.Response) (bool, error) {
+		if finished, err := checkFinalizedOrderStatus(order); finished {
+			return true, err
+		}
+
+		retryAfter, err := parseRetryAfter(resp.Header.Get("Retry-After"))
+		if err != nil {
+			return false, fmt.Errorf("acme: error parsing retry-after header: %v", err)
+		}
+		order.RetryAfter = retryAfter
+
+		return false, nil
 	}
-	order.RetryAfter = retryAfter
 
-	if finished, err := checkFinalizedOrderStatus(order); finished {
+	if finished, err := updateOrder(resp); finished || err != nil {
 		return order, err
 	}
 
-	if !c.IgnoreRetryAfter {
-		if retryAfter.IsZero() || retryAfter.Before(time.Now()) {
-			_, err := c.post(order.URL, account.URL, account.PrivateKey, "", &order, http.StatusOK)
-			return order, err
+	fetchOrder := func() (bool, error) {
+		resp, err := c.post(order.URL, account.URL, account.PrivateKey, "", &order, http.StatusOK)
+		if err != nil {
+			return false, nil
 		}
-		diff := time.Until(retryAfter)
+
+		return updateOrder(resp)
+	}
+
+	if !c.IgnoreRetryAfter && !order.RetryAfter.IsZero() {
 		_, pollTimeout := c.getPollingDurations()
-		if diff > pollTimeout {
-			return order, fmt.Errorf("acme: Retry-After (%v) longer than poll timeout (%v)", diff, c.PollTimeout)
+		end := time.Now().Add(pollTimeout)
+
+		for {
+			if time.Now().After(end) {
+				return order, errors.New("acme: finalized order timeout")
+			}
+
+			diff := time.Until(order.RetryAfter)
+			_, pollTimeout := c.getPollingDurations()
+			if diff > pollTimeout {
+				return order, fmt.Errorf("acme: Retry-After (%v) longer than poll timeout (%v)", diff, c.PollTimeout)
+			}
+			if diff > 0 {
+				time.Sleep(diff)
+			}
+
+			if finished, err := fetchOrder(); finished || err != nil {
+				return order, err
+			}
 		}
-		time.Sleep(diff)
-		_, err := c.post(order.URL, account.URL, account.PrivateKey, "", &order, http.StatusOK)
-		return order, err
 	}
 
 	if !c.IgnoreRetryAfter {
@@ -142,15 +169,7 @@ func (c Client) FinalizeOrder(account Account, order Order, csr *x509.Certificat
 			}
 			time.Sleep(pollInterval)
 
-			if _, err := c.post(order.URL, account.URL, account.PrivateKey, "", &order, http.StatusOK); err != nil {
-				// i dont think it's worth exiting the loop on this error
-				// it could just be connectivity issue thats resolved before the timeout duration
-				continue
-			}
-
-			order.URL = resp.Header.Get("Location")
-
-			if finished, err := checkFinalizedOrderStatus(order); finished {
+			if finished, err := fetchOrder(); finished || err != nil {
 				return order, err
 			}
 		}

problem_test.go

@@ -57,7 +57,7 @@ func TestProblem_Error(t *testing.T) {
 			{
 				Type:       "type2",
 				Detail:     "detail",
-				Identifier: Identifier{"DNS", "example.com"},
+				Identifier: Identifier{"DNS", randString() + ".com"},
 			},
 		},
 	}