github.com/Venafi/vcert/v5@v5.10.2/pkg/venafi/tpp/tpp_test.go

/*
 * Copyright 2018 Venafi, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package tpp

import (
	"crypto/x509"
	"net/http"
	"strings"
	"testing"

	"github.com/Venafi/vcert/v5/pkg/certificate"
	"github.com/Venafi/vcert/v5/pkg/endpoint"
)

const (
	expectedURL = "https://localhost/"
)

func TestParseConfigFindPolicyData(t *testing.T) {
	data := []byte("{\"Locked\":false,\"PolicyDN\":\"\\\\VED\\\\Policy\\\\Web SDK Testing\",\"Result\":1,\"Values\":[\"Engineering\",\"Quality Assurance\"]}")
	tppData, err := parseConfigResult(http.StatusOK, "", data)
	if err != nil {
		t.Fatalf("err is not nil, err: %s", err)
	}
	if len(tppData.Values) != 2 {
		t.Fatalf("Values count was not expected count of 2 actual count is %d", len(tppData.Values))
	}

	tppData, err = parseConfigResult(http.StatusBadRequest, "Bad Request", data)
	if err == nil {
		t.Fatalf("err is nil when expected to not be")
	}

	if !strings.Contains(err.Error(), "Bad Request") {
		t.Fatalf("Parse Certificate error response did not include expected string: Bad Request -- Actual: %s", err)
	}

	data = []byte("bad data")
	tppData, err = parseConfigData(data)
	if err == nil {
		t.Fatalf("ParseConfigData with bad data did not return an error")
	}
}

func TestParseCertificateRequestData(t *testing.T) {
	data := []byte("{\"CertificateDN\":\"\\\\VED\\\\Policy\\\\Web SDK Testing\\\\bonjoTest 33\"}")

	requestDN, err := parseRequestResult(http.StatusOK, "", data)
	if err != nil {
		t.Fatalf("err is not nil, err: %s", err)
	}

	if !strings.EqualFold(requestDN, "\\VED\\Policy\\Web SDK Testing\\bonjoTest 33") {
		t.Fatalf("Parse Certificate retrieve response did not include expected CertificateDN: \\VED\\Policy\\Web SDK Testing\\bonjoTest 33 -- Actual: %s", requestDN)
	}

	requestDN, err = parseRequestResult(http.StatusBadRequest, "Bad Request", data)
	if err == nil {
		t.Fatalf("err is nil when expected to not be")
	}

	if !strings.Contains(err.Error(), "Bad Request") {
		t.Fatalf("Parse Certificate error response did not include expected string: Bad Request -- Actual: %s", err)
	}

	data = []byte("bad data")
	_, err = parseRequestData(data)
	if err == nil {
		t.Fatalf("ParseRequestData with bad data did not return an error")
	}
}

func TestParseCertificateRetrieveData(t *testing.T) {
	data := []byte("{\"CertificateData\":\"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\",\"Filename\":\"test.bonjo.com.cer\",\"Format\":\"base64\"}")

	resp, err := parseRetrieveResult(http.StatusOK, "", data)
	if err != nil {
		t.Fatalf("err is not nil, err: %s", err)
	}

	if !strings.EqualFold(resp.Filename, "test.bonjo.com.cer") {
		t.Fatalf("Parse Certificate retrieve response did not include expected filename: test.bonjo.com.cer -- Actual: %s", resp.Filename)
	}

	resp, err = parseRetrieveResult(http.StatusBadRequest, "Bad Request", data)
	if err == nil {
		t.Fatalf("err is nil when expected to not be")
	}

	if !strings.Contains(err.Error(), "Bad Request") {
		t.Fatalf("Parse Certificate error response did not include expected string: Bad Request -- Actual: %s", err)
	}

	data = []byte("bad data")
	_, err = parseRetrieveData(data)
	if err == nil {
		t.Fatalf("ParseRetrieveData with bad data did not return an error")
	}
}

func getBaseZoneConfiguration() *endpoint.ZoneConfiguration {
	z := endpoint.NewZoneConfiguration()
	z.Organization = "Venafi"
	z.OrganizationalUnit = []string{"Engineering", "Automated Tests"}
	z.Country = "US"
	z.Province = "Utah"
	z.Locality = "SLC"
	z.AllowedKeyConfigurations = []endpoint.AllowedKeyConfiguration{endpoint.AllowedKeyConfiguration{KeyType: certificate.KeyTypeRSA, KeySizes: []int{4096}}}
	z.HashAlgorithm = x509.SHA512WithRSA
	return z
}

func TestGetPolicyDN(t *testing.T) {
	const expectedPolicy = "\\VED\\Policy\\One\\Level 2\\This is level Three"

	actualPolicy := getPolicyDN("One\\Level 2\\This is level Three")
	if len(expectedPolicy) != len(actualPolicy) {
		t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
	}
	for i := 0; i < len(expectedPolicy); i++ {
		if expectedPolicy[i] != actualPolicy[i] {
			t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
		}
	}

	actualPolicy = getPolicyDN("\\One\\Level 2\\This is level Three")
	if len(expectedPolicy) != len(actualPolicy) {
		t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
	}
	for i := 0; i < len(expectedPolicy); i++ {
		if expectedPolicy[i] != actualPolicy[i] {
			t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
		}
	}

	actualPolicy = getPolicyDN(expectedPolicy)
	if len(expectedPolicy) != len(actualPolicy) {
		t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
	}
	for i := 0; i < len(expectedPolicy); i++ {
		if expectedPolicy[i] != actualPolicy[i] {
			t.Fatalf("getPolicyDN did not return the expected value of %s -- Actual value %s", expectedPolicy, actualPolicy)
		}
	}
}

func TestRetrieveChainOptionFromString(t *testing.T) {
	co := retrieveChainOptionFromString("RoOt-fIrSt")
	if co != retrieveChainOptionRootFirst {
		t.Fatalf("retrieveChainOptionFromString did not return the expected value of %v -- Actual value %v", retrieveChainOptionRootFirst, co)
	}
	co = retrieveChainOptionFromString("IGNORE")
	if co != retrieveChainOptionIgnore {
		t.Fatalf("retrieveChainOptionFromString did not return the expected value of %v -- Actual value %v", retrieveChainOptionIgnore, co)
	}
	co = retrieveChainOptionFromString("RoOt-LaSt")
	if co != retrieveChainOptionRootLast {
		t.Fatalf("retrieveChainOptionFromString did not return the expected value of %v -- Actual value %v", retrieveChainOptionRootLast, co)
	}
	co = retrieveChainOptionFromString("some value")
	if co != retrieveChainOptionRootLast {
		t.Fatalf("retrieveChainOptionFromString did not return the expected value of %v -- Actual value %v", retrieveChainOptionRootLast, co)
	}
}

func TestNewPEMCertificateCollectionFromResponse(t *testing.T) {
	var (
		tppResponse = "subject=CN=certafi-bonjo.venafi.com, OU=Quality Assurance, OU=Engineering, O="Venafi, Inc.", L=SLC, S=Utah, C=US
issuer=CN=VenQA Class G CA, DC=venqa, DC=venafi, DC=com
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----

subject=CN=VenQA Class G CA, DC=venqa, DC=venafi, DC=com
issuer=CN=VenQA CA, DC=venqa, DC=venafi, DC=com
-----BEGIN CERTIFICATE-----
MIIGGzCCBQOgAwIBAgIKK0kjHQAAACaHWjANBgkqhkiG9w0BAQUFADBXMRMwEQYK
CZImiZPyLGQBGRYDY29tMRYwFAYKCZImiZPyLGQBGRYGdmVuYWZpMRUwEwYKCZIm
iZPyLGQBGRYFdmVucWExETAPBgNVBAMTCFZlblFBIENBMB4XDTE0MDMwOTA3MzIw
N1oXDTE2MDMwOTA3NDIwN1owXzETMBEGCgmSJomT8ixkARkWA2NvbTEWMBQGCgmS
JomT8ixkARkWBnZlbmFmaTEVMBMGCgmSJomT8ixkARkWBXZlbnFhMRkwFwYDVQQD
ExBWZW5RQSBDbGFzcyBHIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEArRMPTrwXRaD71Szy070JQC1lw+k9LfhD7tLqn7lr8Og242+lxFERFolQdYW6
v0uvcnZrJxGj+c3BJv7JLSdLumN4+N9z+COlHj2hIEmZuH//a3iKA5+Y+46wsWqM
MNFxonMUYDRtH/cocx/Ym7yE+8DyuTXc4zZ38hgFiusDrCH9d4zKEdQrPiLc5EgI
oewa0JFiudm7Kph2th75o+KwyUXEmfAUjIoGlCC7F/0GREPij7tOfgXKodNVXz3K
zfucg0p8vf3wd5K6xnzG1Fo/0o3GlHZmM5TfLDurx/mgmde8LftC6BHtdBC+pwp0
pvyMUJab0Br6AlZeZG04IrVPBwIDAQABo4IC3zCCAtswEgYJKwYBBAGCNxUBBAUC
AwEAATAjBgkrBgEEAYI3FQIEFgQUjR/UGsyByiYbUReb1Jzr9Tk5DmcwHQYDVR0O
BBYEFPN+IlbEeT7kUjtFyH6ilVyiWFp4MBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIA
QwBBMAsGA1UdDwQEAwIBhjASBgNVHRMBAf8ECDAGAQH/AgEAMB8GA1UdIwQYMBaA
FEZWjbfYskbT3yHoRBI8UBNBLDsBMIIBWwYDVR0fBIIBUjCCAU4wggFKoIIBRqCC
AUKGP2h0dHA6Ly8yazgtdmVucWEtcGRjLnZlbnFhLnZlbmFmaS5jb20vQ2VydEVu
cm9sbC9WZW5RQSUyMENBLmNybIaBv2xkYXA6Ly8vQ049VmVuUUElMjBDQSxDTj0y
azgtdmVucWEtcGRjLENOPUNEUCxDTj1QdWJsaWMlMjBLZXklMjBTZXJ2aWNlcyxD
Tj1TZXJ2aWNlcyxDTj1Db25maWd1cmF0aW9uLERDPXZlbnFhLERDPXZlbmFmaSxE
Qz1jb20/Y2VydGlmaWNhdGVSZXZvY2F0aW9uTGlzdD9iYXNlP29iamVjdENsYXNz
PWNSTERpc3RyaWJ1dGlvblBvaW50hj1maWxlOi8vMms4LXZlbnFhLXBkYy52ZW5x
YS52ZW5hZmkuY29tL0NlcnRFbnJvbGwvVmVuUUEgQ0EuY3JsMIHEBggrBgEFBQcB
AQSBtzCBtDCBsQYIKwYBBQUHMAKGgaRsZGFwOi8vL0NOPVZlblFBJTIwQ0EsQ049
QUlBLENOPVB1YmxpYyUyMEtleSUyMFNlcnZpY2VzLENOPVNlcnZpY2VzLENOPUNv
bmZpZ3VyYXRpb24sREM9dmVucWEsREM9dmVuYWZpLERDPWNvbT9jQUNlcnRpZmlj
YXRlP2Jhc2U/b2JqZWN0Q2xhc3M9Y2VydGlmaWNhdGlvbkF1dGhvcml0eTANBgkq
hkiG9w0BAQUFAAOCAQEATNA8Cwul1UBQJHd+50b9g4jnXX7Kf+bUUmE9iJGOr2aB
E7/MAHGdjftvdJY0X+l1h8XS3Oaquo8trdGlxh9dBrQEYP2YlXnHgmY2xrI92bzd
ii3B9ZzLNKbMMPjowujZeB3GmytdNZvK+ghWZRZ9A2wNgYK4OTVJjlMDd9L8558T
yDnExeinI24X+z8CF1bYR5dX1NJThcwLwRPQd7EOQqYrfJV/7hsklbAypLAqePXt
P9B+DQ5bwFajgeL5en9UOfkJv34Y6xiZw5uZFuJD3QFqwpc5U6StaFfktYsKdYnK
2yktNHCiuRjFjzY27T2Ss2knEIbLjOJRZ+GRVxPm0Q==
-----END CERTIFICATE-----

subject=CN=VenQA CA, DC=venqa, DC=venafi, DC=com
issuer=CN=VenQA CA, DC=venqa, DC=venafi, DC=com
-----BEGIN CERTIFICATE-----
MIIDnjCCAoagAwIBAgIQSTHIy/5JtJ5D2IopGzYu2zANBgkqhkiG9w0BAQUFADBX
MRMwEQYKCZImiZPyLGQBGRYDY29tMRYwFAYKCZImiZPyLGQBGRYGdmVuYWZpMRUw
EwYKCZImiZPyLGQBGRYFdmVucWExETAPBgNVBAMTCFZlblFBIENBMB4XDTEyMTEw
OTIyNDkwM1oXDTE3MTEwOTIyNTgzMlowVzETMBEGCgmSJomT8ixkARkWA2NvbTEW
MBQGCgmSJomT8ixkARkWBnZlbmFmaTEVMBMGCgmSJomT8ixkARkWBXZlbnFhMREw
DwYDVQQDEwhWZW5RQSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
AJbrRU0aJwpditlw4c8PlLEc4vhtMuTIVCE2eGmQ3ozSByo/rgfbnyXjTIXR9Oyf
fbL/1wMQ3wieZ6+oPmrd+65rD+yKZc+jZPSzuZCklLgTmn5PhKq3qG6A/g9Ak6v8
Ubhhf5ohcdv8gzWo22h0KX+PL0RBZS+Zo+HfC8dVuB3ulTBAcxoOJcVW2BM0A5B6
VfAz+Haf2W3iq3qOq68XaRJh1/ul7eceufH/WHITNWXOLneudrWElm4iU82DbKVR
xVCkckTOtP3MY6F7iG1NxYaDCmv412arZTwqaGOaVt6a0fvF9S/fs4U+S5A8qRkN
8AF8vKF3tWArFnOfiZ+rHhsCAwEAAaNmMGQwEwYJKwYBBAGCNxQCBAYeBABDAEEw
CwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEZWjbfYskbT
3yHoRBI8UBNBLDsBMBAGCSsGAQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IB
AQAVuy2zduBG6XXUTx5gnZQlAa+fuPv/7G332XOUqct6D5RdUN9Ud9Q3c1GcUrdx
t71om/qWw1JhgnvHY2Ilopq1EtwYcrpf+Vq8FGK0eZKkT70AKEgSM6+86as7sqQs
3nIoJFBYOBLm1Dz4zms51Vgi75qCl4sW0TksIPqF6ZFRsHTyfaNp+6tDncivhfJ0
/72oturg7T2X2Voj2F74mO3+ulzdXH06xbd1NFRozaYgEB21U5S0shSrdOGHB1R8
tgKbuMWPjeVvjGy45NK5XTIDQLzr9fbLM3+7ODfbj0qtvvvpqrUwlhKn3052RgNL
2pDjcSrk0YMU5/VX4IWr7vrZ
-----END CERTIFICATE-----

"
	)

	col, err := newPEMCollectionFromResponse(tppResponse, certificate.ChainOptionRootLast)
	if err != nil {
		t.Fatalf("Error: %s", err)
	}
	if len(col.Chain) != 2 {
		t.Fatalf("PEM Chain did not contain the expected number of elements 2, actual count %d", len(col.Chain))
	}
}

func TestGenerateRequest(t *testing.T) {
	tpp := Connector{}
	zoneConfig := getBaseZoneConfiguration()
	req := certificate.Request{}
	req.Subject.CommonName = "vcert.test.vfidev.com"
	req.Subject.Organization = []string{"Venafi, Inc."}
	req.Subject.OrganizationalUnit = []string{"Automated Tests"}
	req.Subject.Locality = []string{"Las Vegas"}
	req.Subject.Province = []string{"Nevada"}
	req.Subject.Country = []string{"US"}
	zoneConfig.UpdateCertificateRequest(&req)
	err := tpp.GenerateRequest(zoneConfig, &req)
	if err != nil {
		t.Fatalf("Error: %s", err)
	}
}

func TestGenerateRequestWithLockedMgmtType(t *testing.T) {
	tpp := Connector{}
	zoneConfig := getBaseZoneConfiguration()
	zoneConfig.CustomAttributeValues[tppAttributeManagementType] = "Monitoring"
	req := certificate.Request{}
	req.Subject.CommonName = "vcert.test.vfidev.com"
	req.Subject.Organization = []string{"Venafi, Inc."}
	req.Subject.OrganizationalUnit = []string{"Automated Tests"}
	req.Subject.Locality = []string{"Las Vegas"}
	req.Subject.Province = []string{"Nevada"}
	req.Subject.Country = []string{"US"}
	zoneConfig.UpdateCertificateRequest(&req)
	err := tpp.GenerateRequest(zoneConfig, &req)
	if err == nil {
		t.Fatalf("Error expected, request should not be generated with mgmt type set to Monitoring")
	}
}

func TestGenerateRequestWithNoUserProvidedCSRAllowed(t *testing.T) {
	tpp := Connector{}
	zoneConfig := getBaseZoneConfiguration()
	zoneConfig.CustomAttributeValues[tppAttributeManualCSR] = "0"
	req := certificate.Request{}
	req.Subject.CommonName = "vcert.test.vfidev.com"
	req.Subject.Organization = []string{"Venafi, Inc."}
	req.Subject.OrganizationalUnit = []string{"Automated Tests"}
	req.Subject.Locality = []string{"Las Vegas"}
	req.Subject.Province = []string{"Nevada"}
	req.Subject.Country = []string{"US"}
	zoneConfig.UpdateCertificateRequest(&req)
	err := tpp.GenerateRequest(zoneConfig, &req)
	if err == nil {
		t.Fatalf("Error expected, request should not be generated with Manual CSR set to 0")
	}
}

func TestGenerateRequestWithLockedKeyConfiguration(t *testing.T) {
	tpp := Connector{}
	zoneConfig := getBaseZoneConfiguration()
	zoneConfig.AllowedKeyConfigurations = []endpoint.AllowedKeyConfiguration{{KeyType: certificate.KeyTypeECDSA, KeyCurves: []certificate.EllipticCurve{certificate.EllipticCurveP384}}}
	req := certificate.Request{}
	req.Subject.CommonName = "vcert.test.vfidev.com"
	req.Subject.Organization = []string{"Venafi, Inc."}
	req.Subject.OrganizationalUnit = []string{"Automated Tests"}
	req.Subject.Locality = []string{"Las Vegas"}
	req.Subject.Province = []string{"Nevada"}
	req.Subject.Country = []string{"US"}
	req.KeyType = certificate.KeyTypeRSA
	zoneConfig.UpdateCertificateRequest(&req)
	err := tpp.GenerateRequest(zoneConfig, &req)
	if err != nil {
		t.Fatalf("Error expected, request should be update with key type goten from zone")
	}
}

func TestGetHttpClient(t *testing.T) {
	tpp := Connector{}
	if tpp.getHTTPClient() == nil {
		t.Fatalf("Failed to get http client")
	}
}

func TestConvertServerPolicyToInternalPolicy(t *testing.T) {
	sp := serverPolicy{
		KeyPair: struct {
			KeyAlgorithm _strValue
			KeySize      struct {
				Locked bool
				Value  int
			}
			EllipticCurve struct {
				Locked bool
				Value  string
			}
		}{
			KeyAlgorithm: _strValue{
				Locked: true,
				Value:  "rsa",
			},
			KeySize: struct {
				Locked bool
				Value  int
			}{
				Locked: true,
				Value:  2048,
			},
			EllipticCurve: struct {
				Locked bool
				Value  string
			}{
				Locked: false,
				Value:  "",
			},
		},
	}
	p := sp.toPolicy()
	if len(p.AllowedKeyConfigurations) != 1 {
		t.Fatal("invalid configurations values")
	}
	k := p.AllowedKeyConfigurations[0]
	if k.KeyType != certificate.KeyTypeRSA {
		t.Fatal("invalid key type")
	}
	if len(k.KeySizes) != 4 || k.KeySizes[0] != 2048 || k.KeySizes[1] != 3072 || k.KeySizes[2] != 4096 || k.KeySizes[3] != 8192 {
		t.Fatal("bad key lengths")
	}

	sp = serverPolicy{
		KeyPair: struct {
			KeyAlgorithm _strValue
			KeySize      struct {
				Locked bool
				Value  int
			}
			EllipticCurve struct {
				Locked bool
				Value  string
			}
		}{
			KeyAlgorithm: _strValue{
				Locked: true,
				Value:  "ec",
			},
			KeySize: struct {
				Locked bool
				Value  int
			}{
				Locked: true,
				Value:  2048,
			},
			EllipticCurve: struct {
				Locked bool
				Value  string
			}{
				Locked: true,
				Value:  "p521",
			},
		},
	}
	p = sp.toPolicy()
	if len(p.AllowedKeyConfigurations) != 1 {
		t.Fatal("invalid configurations values")
	}
	k = p.AllowedKeyConfigurations[0]
	if k.KeyType != certificate.KeyTypeECDSA {
		t.Fatal("invalid key type")
	}
	if len(k.KeyCurves) != 1 || k.KeyCurves[0] != certificate.EllipticCurveP521 {
		t.Fatal("bad key curve")
	}

	sp = serverPolicy{
		KeyPair: struct {
			KeyAlgorithm _strValue
			KeySize      struct {
				Locked bool
				Value  int
			}
			EllipticCurve struct {
				Locked bool
				Value  string
			}
		}{
			KeyAlgorithm: _strValue{
				Locked: false,
				Value:  "ec",
			},
			KeySize: struct {
				Locked bool
				Value  int
			}{
				Locked: true,
				Value:  2048,
			},
			EllipticCurve: struct {
				Locked bool
				Value  string
			}{
				Locked: true,
				Value:  "p384",
			},
		},
	}
	p = sp.toPolicy()
	if len(p.AllowedKeyConfigurations) != 2 {
		t.Fatal("invalid configurations values")
	}
	k = p.AllowedKeyConfigurations[0]
	if k.KeyType != certificate.KeyTypeRSA {
		t.Fatal("invalid key type")
	}
	if len(k.KeySizes) != 4 || k.KeySizes[0] != 2048 || k.KeySizes[1] != 3072 || k.KeySizes[2] != 4096 || k.KeySizes[3] != 8192 {
		t.Fatal("bad key lengths")
	}
	k = p.AllowedKeyConfigurations[1]
	if k.KeyType != certificate.KeyTypeECDSA {
		t.Fatal("invalid key type")
	}
	if len(k.KeyCurves) != 1 || k.KeyCurves[0] != certificate.EllipticCurveP384 {
		t.Fatal("bad key curve")
	}

	sp = serverPolicy{
		WhitelistedDomains: []string{
			"test1.com",
			"test2.com",
			".test3.com",
		},
	}
	p = sp.toPolicy()
	if len(p.SubjectCNRegexes) != 3 {
		t.Fatalf("invalid SubjectCNRegexes length, expected 3, got %d", len(p.SubjectCNRegexes))
	}
	if p.SubjectCNRegexes[0] != "^([\\p{L}\\p{N}-]+\\.)*test1\\.com$" {
		t.Fatalf("invalid SubjectCNRegexes[0], expected ^([\\p{L}\\p{N}-*]+\\.)*test1\\.com$, got %s", p.SubjectCNRegexes[0])
	}
	if p.SubjectCNRegexes[1] != "^([\\p{L}\\p{N}-]+\\.)*test2\\.com$" {
		t.Fatalf("invalid SubjectCNRegexes[1], expected ^([\\p{L}\\p{N}-*]+\\.)*test2\\.com$, got %s", p.SubjectCNRegexes[1])
	}
	if p.SubjectCNRegexes[2] != "^([\\p{L}\\p{N}-]+\\.)+test3\\.com$" {
		t.Fatalf("invalid SubjectCNRegexes[2], expected ^([\\p{L}\\p{N}-*]+\\.)+test3\\.com$, got %s", p.SubjectCNRegexes[2])
	}
}