letsencrypt
/
boulder
mirror of https://github.com/letsencrypt/boulder.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor(va): rename testAccountURL to testAccountURI for naming consistency

This commit is contained in:
Shiloh Heurich 2025-04-28 21:21:56 +00:00
parent db7d2f110c
commit 605f8b5f1b
No known key found for this signature in database
2 changed files with 18 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
va/dns_account_test.go
View File

@ -16,67 +16,67 @@ import (
"github.com/letsencrypt/boulder/test"
)
// Use a consistent test account URL, matching the example in the draft
const testAccountURL = "https://example.com/acme/acct/ExampleAccount"
// Use a consistent test account URI, matching the example in the draft
const testAccountURI = "https://example.com/acme/acct/ExampleAccount"
// Expected label prefix derived from testAccountURL (as per draft example)
// Expected label prefix derived from testAccountURI (as per draft example)
const expectedLabelPrefix = "_ujmmovf2vn55tgye._acme-challenge"
func TestDNSAccount01ValidationWrong(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("wrong-dns01.com"), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("wrong-dns01.com"), expectedKeyAuthorization, testAccountURI)
if err == nil {
t.Fatalf("Successful DNS validation with wrong TXT record")
}
prob := detailedError(err)
expectedErr := "unauthorized :: Incorrect TXT record \"a\" found at " + expectedLabelPrefix + ".wrong-dns01.com" +
" (account: " + testAccountURL + ")"
" (account: " + testAccountURI + ")"
test.AssertEquals(t, prob.String(), expectedErr)
}
func TestDNSAccount01ValidationWrongMany(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("wrong-many-dns01.com"), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("wrong-many-dns01.com"), expectedKeyAuthorization, testAccountURI)
if err == nil {
t.Fatalf("Successful DNS validation with wrong TXT record")
}
prob := detailedError(err)
expectedErr := "unauthorized :: Incorrect TXT record \"a\" (and 4 more) found at " + expectedLabelPrefix + ".wrong-many-dns01.com" +
" (account: " + testAccountURL + ")"
" (account: " + testAccountURI + ")"
test.AssertEquals(t, prob.String(), expectedErr)
}
func TestDNSAccount01ValidationWrongLong(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("long-dns01.com"), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(context.Background(), identifier.NewDNS("long-dns01.com"), expectedKeyAuthorization, testAccountURI)
if err == nil {
t.Fatalf("Successful DNS validation with wrong TXT record")
}
prob := detailedError(err)
expectedErr := "unauthorized :: Incorrect TXT record \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...\" found at " + expectedLabelPrefix + ".long-dns01.com" +
" (account: " + testAccountURL + ")"
" (account: " + testAccountURI + ")"
test.AssertEquals(t, prob.String(), expectedErr)
}
func TestDNSAccount01ValidationFailure(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(ctx, identifier.NewDNS("localhost"), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(ctx, identifier.NewDNS("localhost"), expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.UnauthorizedProblem)
expectedErr := "unauthorized :: Incorrect TXT record \"hostname\" found at " + expectedLabelPrefix + ".localhost" +
" (account: " + testAccountURL + ")"
" (account: " + testAccountURI + ")"
test.AssertEquals(t, prob.String(), expectedErr)
}
func TestDNSAccount01ValidationIP(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(ctx, identifier.NewIP(netip.MustParseAddr("127.0.0.1")), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(ctx, identifier.NewIP(netip.MustParseAddr("127.0.0.1")), expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.MalformedProblem)
@ -90,7 +90,7 @@ func TestDNSAccount01ValidationInvalid(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(ctx, notDNS, expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(ctx, notDNS, expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.MalformedProblem)
@ -99,7 +99,7 @@ func TestDNSAccount01ValidationInvalid(t *testing.T) {
func TestDNSAccount01ValidationServFail(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateDNSAccount01(ctx, identifier.NewDNS("servfail.com"), expectedKeyAuthorization, testAccountURL)
_, err := va.validateDNSAccount01(ctx, identifier.NewDNS("servfail.com"), expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.DNSProblem)
@ -120,7 +120,7 @@ func TestDNSAccount01ValidationNoServer(t *testing.T) {
log,
nil)
_, err = va.validateDNSAccount01(ctx, identifier.NewDNS("localhost"), expectedKeyAuthorization, testAccountURL)
_, err = va.validateDNSAccount01(ctx, identifier.NewDNS("localhost"), expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.DNSProblem)
}
@ -128,7 +128,7 @@ func TestDNSAccount01ValidationNoServer(t *testing.T) {
func TestDNSAccount01ValidationOK(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, prob := va.validateDNSAccount01(ctx, identifier.NewDNS("good-dns01.com"), expectedKeyAuthorization, testAccountURL)
_, prob := va.validateDNSAccount01(ctx, identifier.NewDNS("good-dns01.com"), expectedKeyAuthorization, testAccountURI)
test.Assert(t, prob == nil, "Should be valid.")
}
@ -136,7 +136,7 @@ func TestDNSAccount01ValidationOK(t *testing.T) {
func TestDNSAccount01ValidationNoAuthorityOK(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, prob := va.validateDNSAccount01(ctx, identifier.NewDNS("no-authority-dns01.com"), expectedKeyAuthorization, testAccountURL)
_, prob := va.validateDNSAccount01(ctx, identifier.NewDNS("no-authority-dns01.com"), expectedKeyAuthorization, testAccountURI)
test.Assert(t, prob == nil, "Should be valid.")
}

2
va/va_test.go
View File

@ -377,7 +377,7 @@ func TestPerformValidationWithMismatchedRemoteVARIRs(t *testing.T) {
func TestValidateMalformedChallenge(t *testing.T) {
va, _ := setup(nil, "", nil, nil)
_, err := va.validateChallenge(ctx, identifier.NewDNS("example.com"), "fake-type-01", expectedToken, expectedKeyAuthorization, testAccountURL)
_, err := va.validateChallenge(ctx, identifier.NewDNS("example.com"), "fake-type-01", expectedToken, expectedKeyAuthorization, testAccountURI)
prob := detailedError(err)
test.AssertEquals(t, prob.Type, probs.MalformedProblem)