Feature/more testing

authorize.go

@@ -18,14 +18,14 @@ type AuthorizeResponse struct {
 func GetAuthorize(key, user string) (AuthorizeResponse, error) {
 	authorizeResp := AuthorizeResponse{}
 
-	req, err := http.NewRequest("GET", endpoint.Authorize().String(), nil)
+	req, err := http.NewRequest(methodGet, endpoint.Authorize().String(), nil)
 	if err != nil {
 		return authorizeResp, errors.Wrap(err, "error in NewRequest")
 	}
 	req.Header.Set("X-Auth-Key", key)
 	req.Header.Set("X-Auth-User", user)
 
-	resp, err := http.DefaultClient.Do(req)
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		return authorizeResp, errors.Wrap(err, "error in Do")
 	}

authorize_test.go

@@ -0,0 +1,59 @@
+package dozens
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func TestGetAuthorizeWithNewRequestError(t *testing.T) {
+	originalMethodGet := methodGet
+	methodGet = "(" // invalid method
+
+	_, err := GetAuthorize("", "")
+	result := err.Error()
+
+	expected := "error in NewRequest"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', but got '%s'", expected, result)
+	}
+
+	methodGet = originalMethodGet
+}
+
+type mockedErrorClient struct{}
+
+func (c *mockedErrorClient) Do(req *http.Request) (*http.Response, error) {
+	return nil, errors.New("hoge error")
+}
+
+func TestGetAuthorizeWithDoError(t *testing.T) {
+	originalClient := httpClient
+	httpClient = &mockedErrorClient{}
+
+	_, err := GetAuthorize("", "")
+	result := err.Error()
+
+	expected := "error in Do"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', but got '%s'", expected, result)
+	}
+
+	httpClient = originalClient
+}
+
+func TestGetAuthorizeWithReadAllError(t *testing.T) {
+	originalClient := httpClient
+	httpClient = &mockedClient{}
+
+	_, err := GetAuthorize("", "")
+	result := err.Error()
+
+	expected := "error in ReadAll"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', but got '%s'", expected, result)
+	}
+
+	httpClient = originalClient
+}

circle.yml

@@ -20,4 +20,4 @@ test:
   post:
     - mkdir -p $CIRCLE_TEST_REPORTS/golang
     - cat $TEST_FILE | go-junit-report > $CIRCLE_TEST_REPORTS/golang/junit.xml
-    - goveralls -coverprofile=$COVERAGE -service=circle-ci -repotoken=$COVERALLS_TOKEN
+    - cd $REPO_PATH && goveralls -coverprofile=$COVERAGE -service=circle-ci -repotoken=$COVERALLS_TOKEN

record.go

@@ -25,7 +25,7 @@ type record struct {
 func doRecordRequest(req *http.Request) (RecordResponse, error) {
 	recordResp := RecordResponse{[]record{}}
 
-	resp, err := http.DefaultClient.Do(req)
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		return recordResp, errors.Wrap(err, "error in Do")
 	}

record_test.go

@@ -0,0 +1,124 @@
+package dozens
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/jarcoal/httpmock"
+	"github.com/pkg/errors"
+)
+
+func TestDoRecordRequestInvalidRequest(t *testing.T) {
+	_, err := doRecordRequest(&http.Request{})
+	result := err.Error()
+
+	expected := "error in Do"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', but got '%s'", expected, result)
+	}
+}
+
+func TestDoRecordRequestIOError(t *testing.T) {
+	originalClient := httpClient
+	httpClient = &mockedClient{}
+
+	_, err := doRecordRequest(&http.Request{})
+	result := err.Error()
+
+	expected := "error in ReadAll"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', but got '%s'", expected, result)
+	}
+
+	httpClient = originalClient
+}
+
+func TestDoRecordRequestStatusNotOK(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	method := "GET"
+	hogeURL := "http://hoge.com"
+	mockStr := "as a mock"
+	badStatus := http.StatusBadRequest
+
+	httpmock.RegisterResponder(method, hogeURL, httpmock.NewStringResponder(badStatus, mockStr))
+	req, _ := http.NewRequest(method, hogeURL, nil)
+
+	_, err := doRecordRequest(req)
+	result := errors.Cause(err).Error()
+
+	expected := fmt.Sprintf("error body: %s", mockStr)
+	if result != expected {
+		t.Errorf("expected '%s', bug got '%s'", expected, result)
+	}
+}
+
+func TestDoRecordRequestBadJSON(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	method := "GET"
+	hogeURL := "http://hoge.com"
+	badJSON := "{hoge}"
+
+	httpmock.RegisterResponder(method, hogeURL, httpmock.NewStringResponder(http.StatusOK, badJSON))
+	req, _ := http.NewRequest(method, hogeURL, nil)
+
+	_, err := doRecordRequest(req)
+	result := err.Error()
+
+	expected := "error in Decode"
+	if strings.Index(result, expected) != 0 {
+		t.Errorf("expected '%s', bug got '%s'", expected, result)
+	}
+}
+
+func TestDoRecordRequestValidResponse(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	method := "GET"
+	hogeURL := "http://hoge.com"
+
+	expected := `{"record":[{"id":"hoge","name":"fuga","type":"A","prio":"10","content":"192.168.0.1","ttl":"10"}]}`
+	httpmock.RegisterResponder(method, hogeURL, httpmock.NewStringResponder(http.StatusOK, expected))
+	req, _ := http.NewRequest(method, hogeURL, nil)
+
+	resultResp, _ := doRecordRequest(req)
+	result, err := json.Marshal(&resultResp)
+	if err != nil {
+		t.Errorf("error in Marshal: %v", err)
+		return
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected '%+v', bug got '%+v'", expected, string(result))
+	}
+}
+func TestDoRecordRequestEmptyResponse(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	method := "GET"
+	hogeURL := "http://hoge.com"
+
+	emptyResp := `[]`
+	httpmock.RegisterResponder(method, hogeURL, httpmock.NewStringResponder(http.StatusOK, emptyResp))
+	req, _ := http.NewRequest(method, hogeURL, nil)
+
+	resultResp, _ := doRecordRequest(req)
+	result, err := json.Marshal(&resultResp)
+	if err != nil {
+		t.Errorf("error in Marshal: %v", err)
+		return
+	}
+
+	expected := `{"record":[]}`
+	if string(result) != expected {
+		t.Errorf("expected '%+v', bug got '%+v'", expected, string(result))
+	}
+}

request.go

@@ -8,19 +8,23 @@ import (
 	"github.com/pkg/errors"
 )
 
+var methodGet = "GET"
+var methodPost = "POST"
+var methodDelete = "DELETE"
+
 // MakeGet returns request for dozens
 func MakeGet(token string, p endpoint.Endpoint) (*http.Request, error) {
-	return makeRequest("GET", token, p, nil)
+	return makeRequest(methodGet, token, p, nil)
 }
 
 // MakePost returns request for dozens
 func MakePost(token string, p endpoint.Endpoint, body io.Reader) (*http.Request, error) {
-	return makeRequest("POST", token, p, body)
+	return makeRequest(methodPost, token, p, body)
 }
 
 // MakeDelete returns request for dozens
 func MakeDelete(token string, p endpoint.Endpoint) (*http.Request, error) {
-	return makeRequest("DELETE", token, p, nil)
+	return makeRequest(methodDelete, token, p, nil)
 }
 
 func makeRequest(method, token string, p endpoint.Endpoint, body io.Reader) (*http.Request, error) {

request_test.go

@@ -0,0 +1,56 @@
+package dozens
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/delphinus/go-dozens/endpoint"
+)
+
+func TestMakeGet(t *testing.T) {
+	hogeURL, _ := url.Parse("http://hoge.com")
+	p := endpoint.Endpoint{
+		Base:  hogeURL,
+		Chunk: "",
+	}
+	if _, err := MakeGet("", p); err != nil {
+		t.Errorf("MakeGet returned error: %v", err)
+	}
+}
+
+func TestMakePost(t *testing.T) {
+	hogeURL, _ := url.Parse("http://hoge.com")
+	p := endpoint.Endpoint{
+		Base:  hogeURL,
+		Chunk: "",
+	}
+	if _, err := MakePost("", p, nil); err != nil {
+		t.Errorf("MakeGet returned error: %v", err)
+	}
+}
+
+func TestMakeDelete(t *testing.T) {
+	hogeURL, _ := url.Parse("http://hoge.com")
+	p := endpoint.Endpoint{
+		Base:  hogeURL,
+		Chunk: "",
+	}
+	if _, err := MakeDelete("", p); err != nil {
+		t.Errorf("MakeGet returned error: %v", err)
+	}
+}
+
+func TestMakeGetWithError(t *testing.T) {
+	originalMethodGet := methodGet
+	methodGet = "(" // invalid method rune
+
+	p := endpoint.Endpoint{
+		Base:  &url.URL{},
+		Chunk: "",
+	}
+	if _, err := MakeGet("", p); err == nil {
+		t.Errorf("MakeGet did not return error")
+	}
+
+	methodGet = originalMethodGet
+}

zone_test.go

@@ -112,6 +112,6 @@ func TestDoZoneRequestValidResponse(t *testing.T) {
 	}
 
 	if string(result) != expected {
-		t.Errorf("expected '%+v', bug got '%+v'", expected, result)
+		t.Errorf("expected '%+v', bug got '%+v'", expected, string(result))
 	}
 }