package namecheap
import (
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"testing"
)
var (
fakeUser = "foo"
fakeKey = "bar"
fakeClientIP = "10.0.0.1"
tlds = map[string]string{
"com.au": "com.au",
"com": "com",
"co.uk": "co.uk",
"uk": "uk",
"edu": "edu",
"co.com": "co.com",
"za.com": "za.com",
}
)
func assertEq(t *testing.T, variable, got, want string) {
if got != want {
t.Errorf("Expected %s to be '%s' but got '%s'", variable, want, got)
}
}
func assertHdr(tc *testcase, t *testing.T, values *url.Values) {
ch, _ := newChallenge(tc.domain, "", tlds)
assertEq(t, "ApiUser", values.Get("ApiUser"), fakeUser)
assertEq(t, "ApiKey", values.Get("ApiKey"), fakeKey)
assertEq(t, "UserName", values.Get("UserName"), fakeUser)
assertEq(t, "ClientIp", values.Get("ClientIp"), fakeClientIP)
assertEq(t, "SLD", values.Get("SLD"), ch.sld)
assertEq(t, "TLD", values.Get("TLD"), ch.tld)
}
func mockServer(tc *testcase, t *testing.T, w http.ResponseWriter, r *http.Request) {
switch r.Method {
case "GET":
values := r.URL.Query()
cmd := values.Get("Command")
switch cmd {
case "namecheap.domains.dns.getHosts":
assertHdr(tc, t, &values)
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, tc.getHostsResponse)
case "namecheap.domains.getTldList":
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, responseGetTlds)
default:
t.Errorf("Unexpected GET command: %s", cmd)
}
case "POST":
r.ParseForm()
values := r.Form
cmd := values.Get("Command")
switch cmd {
case "namecheap.domains.dns.setHosts":
assertHdr(tc, t, &values)
w.WriteHeader(http.StatusOK)
fmt.Fprint(w, tc.setHostsResponse)
default:
t.Errorf("Unexpected POST command: %s", cmd)
}
default:
t.Errorf("Unexpected http method: %s", r.Method)
}
}
func testGetHosts(tc *testcase, t *testing.T) {
mock := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
mockServer(tc, t, w, r)
}))
defer mock.Close()
prov := &DNSProvider{
baseURL: mock.URL,
apiUser: fakeUser,
apiKey: fakeKey,
clientIP: fakeClientIP,
}
ch, _ := newChallenge(tc.domain, "", tlds)
hosts, err := prov.getHosts(ch)
if tc.errString != "" {
if err == nil || err.Error() != tc.errString {
t.Errorf("Namecheap getHosts case %s expected error", tc.name)
}
} else {
if err != nil {
t.Errorf("Namecheap getHosts case %s failed\n%v", tc.name, err)
}
}
next1:
for _, h := range hosts {
for _, th := range tc.hosts {
if h == th {
continue next1
}
}
t.Errorf("getHosts case %s unexpected record [%s:%s:%s]",
tc.name, h.Type, h.Name, h.Address)
}
next2:
for _, th := range tc.hosts {
for _, h := range hosts {
if h == th {
continue next2
}
}
t.Errorf("getHosts case %s missing record [%s:%s:%s]",
tc.name, th.Type, th.Name, th.Address)
}
}
func mockDNSProvider(url string) *DNSProvider {
return &DNSProvider{
baseURL: url,
apiUser: fakeUser,
apiKey: fakeKey,
clientIP: fakeClientIP,
}
}
func testSetHosts(tc *testcase, t *testing.T) {
mock := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
mockServer(tc, t, w, r)
}))
defer mock.Close()
prov := mockDNSProvider(mock.URL)
ch, _ := newChallenge(tc.domain, "", tlds)
hosts, err := prov.getHosts(ch)
if tc.errString != "" {
if err == nil || err.Error() != tc.errString {
t.Errorf("Namecheap getHosts case %s expected error", tc.name)
}
} else {
if err != nil {
t.Errorf("Namecheap getHosts case %s failed\n%v", tc.name, err)
}
}
if err != nil {
return
}
err = prov.setHosts(ch, hosts)
if err != nil {
t.Errorf("Namecheap setHosts case %s failed", tc.name)
}
}
func testPresent(tc *testcase, t *testing.T) {
mock := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
mockServer(tc, t, w, r)
}))
defer mock.Close()
prov := mockDNSProvider(mock.URL)
err := prov.Present(tc.domain, "", "dummyKey")
if tc.errString != "" {
if err == nil || err.Error() != tc.errString {
t.Errorf("Namecheap Present case %s expected error", tc.name)
}
} else {
if err != nil {
t.Errorf("Namecheap Present case %s failed\n%v", tc.name, err)
}
}
}
func testCleanUp(tc *testcase, t *testing.T) {
mock := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
mockServer(tc, t, w, r)
}))
defer mock.Close()
prov := mockDNSProvider(mock.URL)
err := prov.CleanUp(tc.domain, "", "dummyKey")
if tc.errString != "" {
if err == nil || err.Error() != tc.errString {
t.Errorf("Namecheap CleanUp case %s expected error", tc.name)
}
} else {
if err != nil {
t.Errorf("Namecheap CleanUp case %s failed\n%v", tc.name, err)
}
}
}
func TestNamecheap(t *testing.T) {
for _, tc := range testcases {
testGetHosts(&tc, t)
testSetHosts(&tc, t)
testPresent(&tc, t)
testCleanUp(&tc, t)
}
}
func TestNamecheapDomainSplit(t *testing.T) {
tests := []struct {
domain string
valid bool
tld string
sld string
host string
}{
{"a.b.c.test.co.uk", true, "co.uk", "test", "a.b.c"},
{"test.co.uk", true, "co.uk", "test", ""},
{"test.com", true, "com", "test", ""},
{"test.co.com", true, "co.com", "test", ""},
{"www.test.com.au", true, "com.au", "test", "www"},
{"www.za.com", true, "za.com", "www", ""},
{"", false, "", "", ""},
{"a", false, "", "", ""},
{"com", false, "", "", ""},
{"co.com", false, "", "", ""},
{"co.uk", false, "", "", ""},
{"test.au", false, "", "", ""},
{"za.com", false, "", "", ""},
{"www.za", false, "", "", ""},
{"www.test.au", false, "", "", ""},
{"www.test.unk", false, "", "", ""},
}
for _, test := range tests {
valid := true
ch, err := newChallenge(test.domain, "", tlds)
if err != nil {
valid = false
}
if test.valid && !valid {
t.Errorf("Expected '%s' to split", test.domain)
} else if !test.valid && valid {
t.Errorf("Expected '%s' to produce error", test.domain)
}
if test.valid && valid {
assertEq(t, "domain", ch.domain, test.domain)
assertEq(t, "tld", ch.tld, test.tld)
assertEq(t, "sld", ch.sld, test.sld)
assertEq(t, "host", ch.host, test.host)
}
}
}
type testcase struct {
name string
domain string
hosts []host
errString string
getHostsResponse string
setHostsResponse string
}
var testcases []testcase = []testcase{
{
"Test:Success:1",
"test.example.com",
[]host{
{"A", "home", "10.0.0.1", "10", "1799"},
{"A", "www", "10.0.0.2", "10", "1200"},
{"AAAA", "a", "::0", "10", "1799"},
{"CNAME", "*", "example.com.", "10", "1799"},
{"MXE", "example.com", "10.0.0.5", "10", "1800"},
{"URL", "xyz", "https://google.com", "10", "1799"},
},
"",
responseGetHostsSuccess1,
responseSetHostsSuccess1,
},
{
"Test:Success:2",
"example.com",
[]host{
{"A", "@", "10.0.0.2", "10", "1200"},
{"A", "www", "10.0.0.3", "10", "60"},
},
"",
responseGetHostsSuccess2,
responseSetHostsSuccess2,
},
{
"Test:Error:BadApiKey:1",
"test.example.com",
nil,
"Namecheap error: API Key is invalid or API access has not been enabled [1011102]",
responseGetHostsErrorBadApiKey1,
"",
},
}
var responseGetHostsSuccess1 = `
namecheap.domains.dns.getHosts
PHX01SBAPI01
--5:00
3.338
`
var responseSetHostsSuccess1 = `
namecheap.domains.dns.setHosts
PHX01SBAPI01
--5:00
2.347
`
var responseGetHostsSuccess2 = `
namecheap.domains.dns.getHosts
PHX01SBAPI01
--5:00
3.338
`
var responseSetHostsSuccess2 = `
namecheap.domains.dns.setHosts
PHX01SBAPI01
--5:00
2.347
`
var responseGetHostsErrorBadApiKey1 = `
API Key is invalid or API access has not been enabled
PHX01SBAPI01
--5:00
0
`
var responseGetTlds = `
namecheap.domains.getTldList
Most recognized top level domain
PHX01SBAPI01
--5:00
0.004
`