diff --git a/http_test.go b/http_test.go
index 8befade..6958f6e 100644
--- a/http_test.go
+++ b/http_test.go
@@ -4,195 +4,191 @@ import (
 	"context"
 	"github.com/jarcoal/httpmock"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
 	"io/ioutil"
 	"net/http"
 	"testing"
 )
 
-func Test_HTTP_RequestBuilder_BuildUriWithoutQueryParams(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
-	uri, err := builder.buildUri("qwerty", nil)
-	assert.NotEmpty(t, uri)
-	assert.Nil(t, err)
-	assert.Equal(t, SandboxAPIUrl+"/qwerty", uri.String())
+type HttpRequestBuilderTestSuite struct {
+	suite.Suite
+	cfg      *Config
+	ctx      context.Context
+	testable *RequestBuilder
 }
 
-func Test_HTTP_RequestBuilder_BuildUriWithQueryParams(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
+func (suite *HttpRequestBuilderTestSuite) SetupTest() {
+	suite.cfg = BuildStubConfig()
+	suite.ctx = context.Background()
+	suite.testable = &RequestBuilder{cfg: suite.cfg}
+}
+
+func (suite *HttpRequestBuilderTestSuite) TestBuildUriWithoutQueryParams() {
+	uri, err := suite.testable.buildUri("qwerty", nil)
+	assert.NotEmpty(suite.T(), uri)
+	assert.Nil(suite.T(), err)
+	assert.Equal(suite.T(), SandboxAPIUrl+"/qwerty", uri.String())
+}
 
+func (suite *HttpRequestBuilderTestSuite) TestBuildUriWithQueryParams() {
 	data := make(map[string]interface{})
 	data["foo"] = "bar"
 	data["bar"] = "baz"
 
-	uri, err := builder.buildUri("qwerty", data)
-	assert.NotEmpty(t, uri)
-	assert.Nil(t, err)
-	assert.Equal(t, SandboxAPIUrl+"/qwerty?bar=baz&foo=bar", uri.String())
+	uri, err := suite.testable.buildUri("qwerty", data)
+	assert.NotEmpty(suite.T(), uri)
+	assert.Nil(suite.T(), err)
+	assert.Equal(suite.T(), SandboxAPIUrl+"/qwerty?bar=baz&foo=bar", uri.String())
 }
 
-func Test_HTTP_RequestBuilder_BuildHeaders(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
-
-	headers := builder.buildHeaders()
-	assert.NotEmpty(t, headers)
-	assert.Equal(t, "application/json", headers.Get("Content-Type"))
-	assert.Equal(t, cfg.SecretKey, headers.Get("secret-key"))
+func (suite *HttpRequestBuilderTestSuite) TestBuildHeaders() {
+	headers := suite.testable.buildHeaders()
+	assert.NotEmpty(suite.T(), headers)
+	assert.Equal(suite.T(), "application/json", headers.Get("Content-Type"))
+	assert.Equal(suite.T(), suite.cfg.SecretKey, headers.Get("secret-key"))
 }
 
-func Test_HTTP_RequestBuilder_BuildBody(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
-
+func (suite *HttpRequestBuilderTestSuite) TestBuildBody() {
 	data := make(map[string]interface{})
 	data["foo"] = "bar"
 	data["bar"] = "baz"
 
-	body, _ := builder.buildBody(data)
-	assert.NotEmpty(t, body)
+	body, _ := suite.testable.buildBody(data)
+	assert.NotEmpty(suite.T(), body)
 }
 
-func Test_HTTP_RequestBuilder_BuildAuthParams(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
-
+func (suite *HttpRequestBuilderTestSuite) TestBuildAuthParams() {
 	data := make(map[string]interface{})
 	data["foo"] = "bar"
 	data["bar"] = "baz"
 
-	result := builder.buildAuthParams(data)
-	assert.Equal(t, data["foo"], result["foo"])
-	assert.Equal(t, data["bar"], result["bar"])
-	assert.Equal(t, cfg.PublicKey, result["api_key"])
+	result := suite.testable.buildAuthParams(data)
+	assert.Equal(suite.T(), data["foo"], result["foo"])
+	assert.Equal(suite.T(), data["bar"], result["bar"])
+	assert.Equal(suite.T(), suite.cfg.PublicKey, result["api_key"])
 }
 
-func Test_HTTP_RequestBuilder_BuildAuthParamsEmpty(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
-
-	result := builder.buildAuthParams(nil)
-	assert.Equal(t, cfg.PublicKey, result["api_key"])
+func (suite *HttpRequestBuilderTestSuite) TestBuildAuthParamsEmpty() {
+	result := suite.testable.buildAuthParams(nil)
+	assert.Equal(suite.T(), suite.cfg.PublicKey, result["api_key"])
 }
 
-func Test_HTTP_RequestBuilder_BuildRequestGET(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
+func (suite *HttpRequestBuilderTestSuite) TestBuildRequestGET() {
+	result, err := suite.testable.BuildRequest(suite.ctx, "get", "foo", map[string]interface{}{"foo": "bar"}, map[string]interface{}{"foo": "bar"})
+	assert.NoError(suite.T(), err)
+	assert.Equal(suite.T(), http.MethodGet, result.Method)
+	assert.Equal(suite.T(), "https://sandbox.dusupay.com/foo?api_key=PublicKey&foo=bar", result.URL.String())
+	assert.Equal(suite.T(), "application/json", result.Header.Get("Content-Type"))
+	assert.Equal(suite.T(), suite.cfg.SecretKey, result.Header.Get("secret-key"))
+	assert.Nil(suite.T(), result.Body)
+}
 
-	ctx := context.Background()
-	result, err := builder.BuildRequest(ctx, "get", "foo", map[string]interface{}{"foo": "bar"}, map[string]interface{}{"foo": "bar"})
-	assert.NoError(t, err)
-	assert.Equal(t, http.MethodGet, result.Method)
-	assert.Equal(t, "https://sandbox.dusupay.com/foo?api_key=PublicKey&foo=bar", result.URL.String())
-	assert.Equal(t, "application/json", result.Header.Get("Content-Type"))
-	assert.Equal(t, cfg.SecretKey, result.Header.Get("secret-key"))
-	assert.Nil(t, result.Body)
+func (suite *HttpRequestBuilderTestSuite) TestBuildRequestPOST() {
+	result, err := suite.testable.BuildRequest(suite.ctx, "post", "foo", map[string]interface{}{"foo": "bar"}, map[string]interface{}{"foo": "bar"})
+	assert.NoError(suite.T(), err)
+	assert.Equal(suite.T(), http.MethodPost, result.Method)
+	assert.Equal(suite.T(), "https://sandbox.dusupay.com/foo?foo=bar", result.URL.String())
+	assert.Equal(suite.T(), "application/json", result.Header.Get("Content-Type"))
+	assert.Equal(suite.T(), suite.cfg.SecretKey, result.Header.Get("secret-key"))
+	assert.NotEmpty(suite.T(), result.Body)
 }
 
-func Test_HTTP_RequestBuilder_BuildRequestPOST(t *testing.T) {
-	cfg := BuildStubConfig()
-	builder := RequestBuilder{cfg: cfg}
+func TestHttpRequestBuilderTestSuite(t *testing.T) {
+	suite.Run(t, new(HttpRequestBuilderTestSuite))
+}
 
-	ctx := context.Background()
-	result, err := builder.BuildRequest(ctx, "post", "foo", map[string]interface{}{"foo": "bar"}, map[string]interface{}{"foo": "bar"})
-	assert.NoError(t, err)
-	assert.Equal(t, http.MethodPost, result.Method)
-	assert.Equal(t, "https://sandbox.dusupay.com/foo?foo=bar", result.URL.String())
-	assert.Equal(t, "application/json", result.Header.Get("Content-Type"))
-	assert.Equal(t, cfg.SecretKey, result.Header.Get("secret-key"))
-	assert.NotEmpty(t, result.Body)
+type HttpTestSuite struct {
+	suite.Suite
 }
 
-func Test_HTTP_IsEmptyObjectResponseDataEmptyObject(t *testing.T) {
+func (suite *HttpTestSuite) TestIsEmptyObjectResponseDataEmptyObject() {
 	data := "{}"
-	assert.True(t, isEmptyObjectResponseData([]byte(data)))
+	assert.True(suite.T(), isEmptyObjectResponseData([]byte(data)))
 }
 
-func Test_HTTP_IsEmptyObjectResponseDataFilledObject(t *testing.T) {
+func (suite *HttpTestSuite) TestIsEmptyObjectResponseDataFilledObject() {
 	data := `{"foo":"bar"}`
-	assert.False(t, isEmptyObjectResponseData([]byte(data)))
+	assert.False(suite.T(), isEmptyObjectResponseData([]byte(data)))
 }
 
-func Test_HTTP_IsEmptyObjectResponseDataEmptyArray(t *testing.T) {
+func (suite *HttpTestSuite) TestIsEmptyObjectResponseDataEmptyArray() {
 	data := "[]"
-	assert.False(t, isEmptyObjectResponseData([]byte(data)))
+	assert.False(suite.T(), isEmptyObjectResponseData([]byte(data)))
+}
+
+func (suite *HttpTestSuite) TestResponseBodyIsSuccess() {
+	rsp := &ResponseBody{Code: http.StatusAccepted}
+	assert.True(suite.T(), rsp.IsSuccess())
+	rsp.Code = http.StatusMultipleChoices
+	assert.False(suite.T(), rsp.IsSuccess())
+	rsp.Code = http.StatusBadRequest
+	assert.False(suite.T(), rsp.IsSuccess())
 }
 
-func Test_HTTP_NewHttpTransport(t *testing.T) {
-	cfg := BuildStubConfig()
-	transport := NewHttpTransport(cfg, nil)
-	assert.NotEmpty(t, transport)
+func TestHttpTestSuite(t *testing.T) {
+	suite.Run(t, new(HttpTestSuite))
 }
 
-func Test_HTTP_Transport_SendRequestSuccess(t *testing.T) {
+type HttpTransportTestSuite struct {
+	suite.Suite
+	cfg      *Config
+	ctx      context.Context
+	testable *Transport
+}
+
+func (suite *HttpTransportTestSuite) SetupTest() {
+	suite.cfg = BuildStubConfig()
+	suite.ctx = context.Background()
+	suite.testable = NewHttpTransport(suite.cfg, &http.Client{})
 	httpmock.Activate()
-	defer httpmock.DeactivateAndReset()
+}
 
-	cfg := BuildStubConfig()
-	transport := BuildStubHttpTransport()
+func (suite *HttpTransportTestSuite) TearDownTest() {
+	httpmock.DeactivateAndReset()
+}
 
+func (suite *HttpTransportTestSuite) TestSendRequestSuccess() {
 	body, _ := LoadStubResponseData("stubs/merchants/balance/success.json")
-	httpmock.RegisterResponder(http.MethodGet, cfg.Uri+"/foo?api_key=PublicKey", httpmock.NewBytesResponder(http.StatusOK, body))
+	httpmock.RegisterResponder(http.MethodGet, suite.cfg.Uri+"/foo?api_key=PublicKey", httpmock.NewBytesResponder(http.StatusOK, body))
 
-	ctx := context.Background()
-	resp, err := transport.SendRequest(ctx, http.MethodGet, "foo", nil, nil)
+	resp, err := suite.testable.SendRequest(suite.ctx, http.MethodGet, "foo", nil, nil)
 
-	assert.NoError(t, err)
-	assert.NotEmpty(t, resp)
+	assert.NoError(suite.T(), err)
+	assert.NotEmpty(suite.T(), resp)
 
 	defer resp.Body.Close()
 	bodyRsp, _ := ioutil.ReadAll(resp.Body)
-	assert.Equal(t, body, bodyRsp)
+	assert.Equal(suite.T(), body, bodyRsp)
 }
 
-func Test_HTTP_Transport_Get(t *testing.T) {
-	httpmock.Activate()
-	defer httpmock.DeactivateAndReset()
-
-	cfg := BuildStubConfig()
-	transport := BuildStubHttpTransport()
-
+func (suite *HttpTransportTestSuite) TestGet() {
 	body, _ := LoadStubResponseData("stubs/merchants/balance/success.json")
-	httpmock.RegisterResponder(http.MethodGet, cfg.Uri+"/foo?api_key=PublicKey", httpmock.NewBytesResponder(http.StatusOK, body))
+	httpmock.RegisterResponder(http.MethodGet, suite.cfg.Uri+"/foo?api_key=PublicKey", httpmock.NewBytesResponder(http.StatusOK, body))
 
-	ctx := context.Background()
-	resp, err := transport.Get(ctx, "foo", nil)
+	resp, err := suite.testable.Get(suite.ctx, "foo", nil)
 
-	assert.NoError(t, err)
-	assert.NotEmpty(t, resp)
+	assert.NoError(suite.T(), err)
+	assert.NotEmpty(suite.T(), resp)
 
 	defer resp.Body.Close()
 	bodyRsp, _ := ioutil.ReadAll(resp.Body)
-	assert.Equal(t, body, bodyRsp)
+	assert.Equal(suite.T(), body, bodyRsp)
 }
 
-func Test_HTTP_Transport_Post(t *testing.T) {
-	httpmock.Activate()
-	defer httpmock.DeactivateAndReset()
-
-	cfg := BuildStubConfig()
-	transport := BuildStubHttpTransport()
-
+func (suite *HttpTransportTestSuite) TestPost() {
 	body, _ := LoadStubResponseData("stubs/merchants/balance/success.json")
-	httpmock.RegisterResponder(http.MethodPost, cfg.Uri+"/foo", httpmock.NewBytesResponder(http.StatusOK, body))
+	httpmock.RegisterResponder(http.MethodPost, suite.cfg.Uri+"/foo", httpmock.NewBytesResponder(http.StatusOK, body))
 
-	ctx := context.Background()
-	resp, err := transport.Post(ctx, "foo", nil, nil)
+	resp, err := suite.testable.Post(suite.ctx, "foo", nil, nil)
 
-	assert.NoError(t, err)
-	assert.NotEmpty(t, resp)
+	assert.NoError(suite.T(), err)
+	assert.NotEmpty(suite.T(), resp)
 
 	defer resp.Body.Close()
 	bodyRsp, _ := ioutil.ReadAll(resp.Body)
-	assert.Equal(t, body, bodyRsp)
+	assert.Equal(suite.T(), body, bodyRsp)
 }
 
-func Test_HTTP_ResponseBody_IsSuccess(t *testing.T) {
-	rsp := &ResponseBody{Code: http.StatusAccepted}
-	assert.True(t, rsp.IsSuccess())
-	rsp.Code = http.StatusMultipleChoices
-	assert.False(t, rsp.IsSuccess())
-	rsp.Code = http.StatusBadRequest
-	assert.False(t, rsp.IsSuccess())
+func TestHttpTransportTestSuite(t *testing.T) {
+	suite.Run(t, new(HttpTransportTestSuite))
 }
diff --git a/payouts_test.go b/payouts_test.go
index b59320a..78874a9 100644
--- a/payouts_test.go
+++ b/payouts_test.go
@@ -14,7 +14,7 @@ type PayoutsTestSuite struct {
 	suite.Suite
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidSuccess() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidSuccess() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
@@ -29,7 +29,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidSuccess() {
 	assert.NoError(suite.T(), request.isValid())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyCurrency() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyCurrency() {
 	request := PayoutRequest{
 		Amount:            100,
 		Method:            TransactionMethodBank,
@@ -42,7 +42,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyCurrency() {
 	assert.Equal(suite.T(), `parameter "currency" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyAmount() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyAmount() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Method:            TransactionMethodBank,
@@ -55,7 +55,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyAmount() {
 	assert.Equal(suite.T(), `parameter "amount" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyMethod() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyMethod() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
@@ -68,7 +68,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyMethod() {
 	assert.Equal(suite.T(), `parameter "method" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyProviderId() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyProviderId() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
@@ -81,7 +81,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyProviderId() {
 	assert.Equal(suite.T(), `parameter "provider_id" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyMerchantReference() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyMerchantReference() {
 	request := PayoutRequest{
 		Currency:   CurrencyCodeKES,
 		Amount:     100,
@@ -94,7 +94,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyMerchantReference(
 	assert.Equal(suite.T(), `parameter "merchant_reference" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyNarration() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyNarration() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
@@ -107,7 +107,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyNarration() {
 	assert.Equal(suite.T(), `parameter "narration" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyAccountNumber() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyAccountNumber() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
@@ -121,7 +121,7 @@ func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyAccountNumber() {
 	assert.Equal(suite.T(), `parameter "account_number" is empty`, result.Error())
 }
 
-func (suite *PayoutsTestSuite) TestPayoutsRequest_IsValidEmptyAccountName() {
+func (suite *PayoutsTestSuite) TestPayoutsRequestIsValidEmptyAccountName() {
 	request := PayoutRequest{
 		Currency:          CurrencyCodeKES,
 		Amount:            100,
diff --git a/resource_test.go b/resource_test.go
deleted file mode 100644
index bcd4628..0000000
--- a/resource_test.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package dusupay
-
-//func Test_Resource_NewResourceAbstract(t *testing.T) {
-//	config := BuildStubConfig()
-//	transport := NewHttpTransport(config, nil)
-//	resource := NewResourceAbstract(transport, config)
-//	assert.NotEmpty(t, resource)
-//}