1
0
mirror of https://github.com/go-acme/lego.git synced 2024-12-23 09:15:11 +02:00
lego/providers/dns/transip/transip_test.go

338 lines
7.7 KiB
Go
Raw Normal View History

package transip // import "github.com/xenolf/lego/providers/dns/transip"
2018-11-06 12:56:28 +02:00
import (
"encoding/xml"
"fmt"
"reflect"
"strings"
"sync"
2018-11-06 12:56:28 +02:00
"testing"
"time"
"github.com/stretchr/testify/assert"
2018-11-06 12:56:28 +02:00
"github.com/stretchr/testify/require"
"github.com/transip/gotransip"
"github.com/transip/gotransip/domain"
"github.com/xenolf/lego/log"
2018-11-06 12:56:28 +02:00
"github.com/xenolf/lego/platform/tester"
)
type argDNSEntries struct {
Items domain.DNSEntries `xml:"item"`
}
type argDomainName struct {
DomainName string `xml:",chardata"`
}
type fakeClient struct {
dnsEntries []domain.DNSEntry
setDNSEntriesLatency time.Duration
getInfoLatency time.Duration
}
func (f *fakeClient) Call(r gotransip.SoapRequest, b interface{}) error {
switch r.Method {
case "getInfo":
d := b.(*domain.Domain)
cp := f.dnsEntries
if f.getInfoLatency != 0 {
time.Sleep(f.getInfoLatency)
}
d.DNSEntries = cp
log.Printf("getInfo: %+v\n", d.DNSEntries)
return nil
case "setDnsEntries":
var domainName argDomainName
var dnsEntries argDNSEntries
args := readArgs(r)
for _, arg := range args {
if strings.HasPrefix(arg, "<domainName") {
err := xml.Unmarshal([]byte(arg), &domainName)
if err != nil {
panic(err)
}
} else if strings.HasPrefix(arg, "<dnsEntries") {
err := xml.Unmarshal([]byte(arg), &dnsEntries)
if err != nil {
panic(err)
}
}
}
log.Printf("setDnsEntries domainName: %+v\n", domainName)
log.Printf("setDnsEntries dnsEntries: %+v\n", dnsEntries)
if f.setDNSEntriesLatency != 0 {
time.Sleep(f.setDNSEntriesLatency)
}
f.dnsEntries = dnsEntries.Items
return nil
default:
return nil
}
}
2018-11-06 12:56:28 +02:00
var envTest = tester.NewEnvTest(
"TRANSIP_ACCOUNT_NAME",
"TRANSIP_PRIVATE_KEY_PATH").
WithDomain("TRANSIP_DOMAIN")
func TestNewDNSProvider(t *testing.T) {
testCases := []struct {
desc string
envVars map[string]string
expected string
}{
{
desc: "success",
envVars: map[string]string{
"TRANSIP_ACCOUNT_NAME": "johndoe",
"TRANSIP_PRIVATE_KEY_PATH": "./fixtures/private.key",
},
},
{
desc: "missing all credentials",
envVars: map[string]string{
"TRANSIP_ACCOUNT_NAME": "",
"TRANSIP_PRIVATE_KEY_PATH": "",
},
expected: "transip: some credentials information are missing: TRANSIP_ACCOUNT_NAME,TRANSIP_PRIVATE_KEY_PATH",
},
{
desc: "missing account name",
envVars: map[string]string{
"TRANSIP_ACCOUNT_NAME": "",
"TRANSIP_PRIVATE_KEY_PATH": "./fixtures/private.key",
},
expected: "transip: some credentials information are missing: TRANSIP_ACCOUNT_NAME",
},
{
desc: "missing private key path",
envVars: map[string]string{
"TRANSIP_ACCOUNT_NAME": "johndoe",
"TRANSIP_PRIVATE_KEY_PATH": "",
},
expected: "transip: some credentials information are missing: TRANSIP_PRIVATE_KEY_PATH",
},
{
desc: "could not open private key path",
envVars: map[string]string{
"TRANSIP_ACCOUNT_NAME": "johndoe",
"TRANSIP_PRIVATE_KEY_PATH": "./fixtures/non/existent/private.key",
},
expected: "transip: could not open private key: stat ./fixtures/non/existent/private.key: no such file or directory",
},
}
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
defer envTest.RestoreEnv()
envTest.ClearEnv()
envTest.Apply(test.envVars)
p, err := NewDNSProvider()
if len(test.expected) == 0 {
require.NoError(t, err)
require.NotNil(t, p)
require.NotNil(t, p.config)
require.NotNil(t, p.client)
} else {
require.EqualError(t, err, test.expected)
}
})
}
}
func TestNewDNSProviderConfig(t *testing.T) {
testCases := []struct {
desc string
accountName string
privateKeyPath string
expected string
}{
{
desc: "success",
accountName: "johndoe",
privateKeyPath: "./fixtures/private.key",
},
{
desc: "missing all credentials",
expected: "transip: AccountName is required",
},
{
desc: "missing account name",
privateKeyPath: "./fixtures/private.key",
expected: "transip: AccountName is required",
},
{
desc: "missing private key path",
accountName: "johndoe",
expected: "transip: PrivateKeyPath or PrivateKeyBody is required",
},
{
desc: "could not open private key path",
accountName: "johndoe",
privateKeyPath: "./fixtures/non/existent/private.key",
expected: "transip: could not open private key: stat ./fixtures/non/existent/private.key: no such file or directory",
},
}
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
config := NewDefaultConfig()
config.AccountName = test.accountName
config.PrivateKeyPath = test.privateKeyPath
p, err := NewDNSProviderConfig(config)
if len(test.expected) == 0 {
require.NoError(t, err)
require.NotNil(t, p)
require.NotNil(t, p.config)
require.NotNil(t, p.client)
} else {
require.EqualError(t, err, test.expected)
}
})
}
}
func TestDNSProvider_concurrentGetInfo(t *testing.T) {
client := &fakeClient{
getInfoLatency: 50 * time.Millisecond,
setDNSEntriesLatency: 500 * time.Millisecond,
}
p := &DNSProvider{
config: NewDefaultConfig(),
client: client,
}
var wg sync.WaitGroup
wg.Add(2)
solve := func(domain1 string, suffix string, timeoutPresent time.Duration, timeoutSolve time.Duration, timeoutCleanup time.Duration) error {
time.Sleep(timeoutPresent)
err := p.Present(domain1, "", "")
if err != nil {
return err
}
time.Sleep(timeoutSolve)
var found bool
for _, entry := range client.dnsEntries {
if strings.HasSuffix(entry.Name, suffix) {
found = true
}
}
if !found {
return fmt.Errorf("record %s not found: %v", suffix, client.dnsEntries)
}
time.Sleep(timeoutCleanup)
return p.CleanUp(domain1, "", "")
}
go func() {
defer wg.Done()
err := solve("bar.lego.wtf", ".bar", 500*time.Millisecond, 100*time.Millisecond, 100*time.Millisecond)
require.NoError(t, err)
}()
go func() {
defer wg.Done()
err := solve("foo.lego.wtf", ".foo", 500*time.Millisecond, 200*time.Millisecond, 100*time.Millisecond)
require.NoError(t, err)
}()
wg.Wait()
assert.Empty(t, client.dnsEntries)
}
func TestDNSProvider_concurrentSetDNSEntries(t *testing.T) {
client := &fakeClient{}
p := &DNSProvider{
config: NewDefaultConfig(),
client: client,
}
var wg sync.WaitGroup
wg.Add(2)
solve := func(domain1 string, timeoutPresent time.Duration, timeoutCleanup time.Duration) error {
time.Sleep(timeoutPresent)
err := p.Present(domain1, "", "")
if err != nil {
return err
}
time.Sleep(timeoutCleanup)
return p.CleanUp(domain1, "", "")
}
go func() {
defer wg.Done()
err := solve("bar.lego.wtf", 550*time.Millisecond, 500*time.Millisecond)
require.NoError(t, err)
}()
go func() {
defer wg.Done()
err := solve("foo.lego.wtf", 500*time.Millisecond, 100*time.Millisecond)
require.NoError(t, err)
}()
wg.Wait()
assert.Empty(t, client.dnsEntries)
}
func readArgs(req gotransip.SoapRequest) []string {
v := reflect.ValueOf(req)
f := v.FieldByName("args")
var args []string
for i := 0; i < f.Len(); i++ {
args = append(args, f.Slice(0, f.Len()).Index(i).String())
}
return args
}
2018-11-06 12:56:28 +02:00
func TestLivePresent(t *testing.T) {
if !envTest.IsLiveTest() {
t.Skip("skipping live test")
}
envTest.RestoreEnv()
provider, err := NewDNSProvider()
require.NoError(t, err)
err = provider.Present(envTest.GetDomain(), "", "123d==")
require.NoError(t, err)
}
func TestLiveCleanUp(t *testing.T) {
if !envTest.IsLiveTest() {
t.Skip("skipping live test")
}
envTest.RestoreEnv()
provider, err := NewDNSProvider()
require.NoError(t, err)
time.Sleep(1 * time.Second)
err = provider.CleanUp(envTest.GetDomain(), "", "123d==")
require.NoError(t, err)
}