Repository: ctreminiom/go-atlassian
Pull request #219 (2023-06-18 17:00:15)

:art: Improved the Jira Agile HTTP Client implementation.
1. Created a new interface called *Connector* with only two methods.

2. Replacing the Client interface with 6 methods.

3. Added the possibility to return a dedicated error based on the http response on the Call method.

4. Changed the client interface from Client to Connector on the agile services.

5. Removed the unnecessary code from the service implementations.


Patch:
diff --git a/jira/agile/api_client_impl.go b/jira/agile/api_client_impl.go
index ee661ff..000f2ec 100644
--- a/jira/agile/api_client_impl.go
+++ b/jira/agile/api_client_impl.go
@@ -5,12 +5,11 @@ import (
 	"context"
 	"encoding/json"
 	"github.com/ctreminiom/go-atlassian/jira/agile/internal"
-	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
 	"github.com/ctreminiom/go-atlassian/service/common"
 	"io"
 	"net/http"
 	"net/url"
-	"reflect"
 	"strings"
 )
 
@@ -20,38 +19,27 @@ func New(httpClient common.HttpClient, site string) (*Client, error) {
 		httpClient = http.DefaultClient
 	}
 
+	if site == "" {
+		return nil, model.ErrNoSiteError
+	}
+
 	if !strings.HasSuffix(site, "/") {
 		site += "/"
 	}
 
-	siteAsURL, err := url.Parse(site)
+	u, err := url.Parse(site)
 	if err != nil {
 		return nil, err
 	}
 
 	client := &Client{
 		HTTP: httpClient,
-		Site: siteAsURL,
-	}
-
-	boardService, err := internal.NewBoardService(client, "1.0")
-	if err != nil {
-		return nil, err
-	}
-
-	epicService, err := internal.NewEpicService(client, "1.0")
-	if err != nil {
-		return nil, err
-	}
-
-	sprintService, err := internal.NewSprintService(client, "1.0")
-	if err != nil {
-		return nil, err
+		Site: u,
 	}
 
-	client.Board = boardService
-	client.Epic = epicService
-	client.Sprint = sprintService
+	client.Board = internal.NewBoardService(client, "1.0")
+	client.Epic = internal.NewEpicService(client, "1.0")
+	client.Sprint = internal.NewSprintService(client, "1.0")
 	client.Backlog = internal.NewBoardBacklogService(client, "1.0")
 	client.Auth = internal.NewAuthenticationService(client)
 
@@ -68,54 +56,63 @@ type Client struct {
 	Sprint  *internal.SprintService
 }
 
-func (c *Client) NewFormRequest(ctx context.Context, method, apiEndpoint, contentType string, payload io.Reader) (*http.Request, error) {
-	return nil, nil
-}
-
-func (c *Client) NewRequest(ctx context.Context, method, apiEndpoint string, payload io.Reader) (*http.Request, error) {
+func (c *Client) NewRequest(ctx context.Context, method, urlStr, type_ string, body interface{}) (*http.Request, error) {
 
-	relativePath, err := url.Parse(apiEndpoint)
+	rel, err := url.Parse(urlStr)
 	if err != nil {
 		return nil, err
 	}
 
-	var endpoint = c.Site.ResolveReference(relativePath).String()
+	u := c.Site.ResolveReference(rel)
+
+	buf := new(bytes.Buffer)
+	if body != nil {
+		err := json.NewEncoder(buf).Encode(body)
+		if err != nil {
+			return nil, err
+		}
+	}
 
-	request, err := http.NewRequestWithContext(ctx, method, endpoint, payload)
+	req, err := http.NewRequestWithContext(ctx, method, u.String(), buf)
 	if err != nil {
 		return nil, err
 	}
+	req.Header.Set("Accept", "application/json")
 
-	request.Header.Set("Accept", "application/json")
+	if body != nil && type_ == "" {
+		req.Header.Set("Content-Type", "application/json")
+	}
 
-	if payload != nil {
-		request.Header.Set("Content-Type", "application/json")
+	if body != nil && type_ != "" {
+		req.Header.Set("Content-Type", type_)
 	}
 
 	if c.Auth.HasBasicAuth() {
-		request.SetBasicAuth(c.Auth.GetBasicAuth())
+		req.SetBasicAuth(c.Auth.GetBasicAuth())
 	}
 
 	if c.Auth.HasUserAgent() {
-		request.Header.Set("User-Agent", c.Auth.GetUserAgent())
+		req.Header.Set("User-Agent", c.Auth.GetUserAgent())
 	}
 
-	return request, nil
+	return req, nil
 }
 
-func (c *Client) Call(request *http.Request, structure interface{}) (*models.ResponseScheme, error) {
+func (c *Client) Call(request *http.Request, structure interface{}) (*model.ResponseScheme, error) {
 
 	response, err := c.HTTP.Do(request)
 	if err != nil {
 		return nil, err
 	}
 
-	return c.TransformTheHTTPResponse(response, structure)
+	return c.processResponse(response, structure)
 }
 
-func (c *Client) TransformTheHTTPResponse(response *http.Response, structure interface{}) (*models.ResponseScheme, error) {
+func (c *Client) processResponse(response *http.Response, structure interface{}) (*model.ResponseScheme, error) {
+
+	defer response.Body.Close()
 
-	responseTransformed := &models.ResponseScheme{
+	res := &model.ResponseScheme{
 		Response: response,
 		Code:     response.StatusCode,
 		Endpoint: response.Request.URL.String(),
@@ -124,39 +121,39 @@ func (c *Client) TransformTheHTTPResponse(response *http.Response, structure int
 
 	responseAsBytes, err := io.ReadAll(response.Body)
 	if err != nil {
-		return responseTransformed, err
+		return res, err
 	}
 
-	responseTransformed.Bytes.Write(responseAsBytes)
+	res.Bytes.Write(responseAsBytes)
+
+	wasSuccess := response.StatusCode >= 200 && response.StatusCode < 300
 
-	var wasSuccess = response.StatusCode >= 200 && response.StatusCode < 300
 	if !wasSuccess {
-		return responseTransformed, models.ErrInvalidStatusCodeError
-	}
 
-	if structure != nil {
-		if err = json.Unmarshal(responseAsBytes, &structure); err != nil {
-			return responseTransformed, err
-		}
-	}
+		switch response.StatusCode {
 
-	return responseTransformed, nil
-}
+		case http.StatusNotFound:
+			return res, model.ErrNotFound
 
-func (c *Client) TransformStructToReader(structure interface{}) (io.Reader, error) {
+		case http.StatusUnauthorized:
+			return res, model.ErrUnauthorized
 
-	if structure == nil {
-		return nil, models.ErrNilPayloadError
-	}
+		case http.StatusInternalServerError:
+			return res, model.ErrInternalError
+
+		case http.StatusBadRequest:
+			return res, model.ErrBadRequestError
 
-	if reflect.ValueOf(structure).Type().Kind() == reflect.Struct {
-		return nil, models.ErrNonPayloadPointerError
+		default:
+			return res, model.ErrInvalidStatusCodeError
+		}
 	}
 
-	structureAsBodyBytes, err := json.Marshal(structure)
-	if err != nil {
-		return nil, err
+	if structure != nil {
+		if err = json.Unmarshal(responseAsBytes, &structure); err != nil {
+			return res, err
+		}
 	}
 
-	return bytes.NewReader(structureAsBodyBytes), nil
+	return res, nil
 }
diff --git a/jira/agile/internal/authentication_impl.go b/jira/agile/internal/authentication_impl.go
index 0300b0c..2bbe9ab 100644
--- a/jira/agile/internal/authentication_impl.go
+++ b/jira/agile/internal/authentication_impl.go
@@ -5,12 +5,12 @@ import (
 	"github.com/ctreminiom/go-atlassian/service/common"
 )
 
-func NewAuthenticationService(client service.Client) common.Authentication {
+func NewAuthenticationService(client service.Connector) common.Authentication {
 	return &AuthenticationService{c: client}
 }
 
 type AuthenticationService struct {
-	c service.Client
+	c service.Connector
 
 	basicAuthProvided bool
 	mail, token       string
diff --git a/jira/agile/internal/board_backlog_impl.go b/jira/agile/internal/board_backlog_impl.go
index a53a436..546ba95 100644
--- a/jira/agile/internal/board_backlog_impl.go
+++ b/jira/agile/internal/board_backlog_impl.go
@@ -9,7 +9,7 @@ import (
 	"net/http"
 )
 
-func NewBoardBacklogService(client service.Client, version string) *BoardBacklogService {
+func NewBoardBacklogService(client service.Connector, version string) *BoardBacklogService {
 
 	return &BoardBacklogService{
 		internalClient: &internalBoardBacklogImpl{c: client, version: version},
@@ -49,29 +49,22 @@ func (b *BoardBacklogService) MoveTo(ctx context.Context, boardID int, payload *
 }
 
 type internalBoardBacklogImpl struct {
-	c       service.Client
+	c       service.Connector
 	version string
 }
 
 func (i *internalBoardBacklogImpl) Move(ctx context.Context, issues []string) (*model.ResponseScheme, error) {
 
-	payload := struct {
-		Issues []string `json:"issues"`
-	}{Issues: issues}
+	payload := map[string]interface{}{"issues": issues}
 
-	reader, err := i.c.TransformStructToReader(&payload)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/backlog/issue", i.version)
+	url := fmt.Sprintf("rest/agile/%v/backlog/issue", i.version)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
 
 func (i *internalBoardBacklogImpl) MoveTo(ctx context.Context, boardID int, payload *model.BoardBacklogPayloadScheme) (*model.ResponseScheme, error) {
@@ -80,17 +73,12 @@ func (i *internalBoardBacklogImpl) MoveTo(ctx context.Context, boardID int, payl
 		return nil, model.ErrNoBoardIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/backlog/%v/issue", i.version, boardID)
+	url := fmt.Sprintf("rest/agile/%v/backlog/%v/issue", i.version, boardID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
diff --git a/jira/agile/internal/board_impl.go b/jira/agile/internal/board_impl.go
index e23d808..ccd5518 100644
--- a/jira/agile/internal/board_impl.go
+++ b/jira/agile/internal/board_impl.go
@@ -12,15 +12,11 @@ import (
 	"strings"
 )
 
-func NewBoardService(client service.Client, version string) (*BoardService, error) {
-
-	if version == "" {
-		return nil, model.ErrNoVersionProvided
-	}
+func NewBoardService(client service.Connector, version string) *BoardService {
 
 	return &BoardService{
 		internalClient: &internalBoardImpl{c: client, version: version},
-	}, nil
+	}
 }
 
 type BoardService struct {
@@ -241,7 +237,7 @@ func (b *BoardService) Gets(ctx context.Context, opts *model.GetBoardsOptions, s
 }
 
 type internalBoardImpl struct {
-	c       service.Client
+	c       service.Connector
 	version string
 }
 
@@ -251,43 +247,38 @@ func (i *internalBoardImpl) Get(ctx context.Context, boardID int) (*model.BoardS
 		return nil, nil, model.ErrNoBoardIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v", i.version, boardID)
+	url := fmt.Sprintf("rest/agile/%v/board/%v", i.version, boardID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	boards := new(model.BoardScheme)
-	response, err := i.c.Call(request, boards)
+	res, err := i.c.Call(req, boards)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return boards, response, nil
+	return boards, res, nil
 }
 
 func (i *internalBoardImpl) Create(ctx context.Context, payload *model.BoardPayloadScheme) (*model.BoardScheme, *model.ResponseScheme, error) {
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/board", i.version)
+	url := fmt.Sprintf("rest/agile/%v/board", i.version)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	board := new(model.BoardScheme)
-	response, err := i.c.Call(request, board)
+	res, err := i.c.Call(req, board)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return board, response, nil
+	return board, res, nil
 }
 
 func (i *internalBoardImpl) Filter(ctx context.Context, filterID, startAt, maxResults int) (*model.BoardPageScheme, *model.ResponseScheme, error) {
@@ -300,20 +291,20 @@ func (i *internalBoardImpl) Filter(ctx context.Context, filterID, startAt, maxRe
 	params.Add("startAt", strconv.Itoa(startAt))
 	params.Add("maxResults", strconv.Itoa(maxResults))
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/filter/%v?%v", i.version, filterID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/filter/%v?%v", i.version, filterID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardPageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Backlog(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -343,20 +334,20 @@ func (i *internalBoardImpl) Backlog(ctx context.Context, boardID int, opts *mode
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/backlog?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/backlog?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	issues := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, issues)
+	page := new(model.BoardIssuePageScheme)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return issues, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Configuration(ctx context.Context, boardID int) (*model.BoardConfigurationScheme, *model.ResponseScheme, error) {
@@ -365,20 +356,20 @@ func (i *internalBoardImpl) Configuration(ctx context.Context, boardID int) (*mo
 		return nil, nil, model.ErrNoBoardIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/configuration", i.version, boardID)
+	url := fmt.Sprintf("rest/agile/%v/board/%v/configuration", i.version, boardID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	configuration := new(model.BoardConfigurationScheme)
-	response, err := i.c.Call(request, configuration)
+	conf := new(model.BoardConfigurationScheme)
+	res, err := i.c.Call(req, conf)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return configuration, response, nil
+	return conf, res, nil
 }
 
 func (i *internalBoardImpl) Epics(ctx context.Context, boardID, startAt, maxResults int, done bool) (*model.BoardEpicPageScheme, *model.ResponseScheme, error) {
@@ -392,20 +383,20 @@ func (i *internalBoardImpl) Epics(ctx context.Context, boardID, startAt, maxResu
 	params.Add("maxResults", strconv.Itoa(maxResults))
 	params.Add("done", fmt.Sprintf("%t", done))
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/epic?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/epic?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	epics := new(model.BoardEpicPageScheme)
-	response, err := i.c.Call(request, epics)
+	page := new(model.BoardEpicPageScheme)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return epics, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) IssuesWithoutEpic(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -437,20 +428,20 @@ func (i *internalBoardImpl) IssuesWithoutEpic(ctx context.Context, boardID int,
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/epic/none/issue?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/epic/none/issue?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) IssuesByEpic(ctx context.Context, boardID, epicID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -486,20 +477,20 @@ func (i *internalBoardImpl) IssuesByEpic(ctx context.Context, boardID, epicID in
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/epic/%v/issue?%v", i.version, boardID, epicID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/epic/%v/issue?%v", i.version, boardID, epicID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Issues(ctx context.Context, boardID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -532,20 +523,20 @@ func (i *internalBoardImpl) Issues(ctx context.Context, boardID int, opts *model
 
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/issue?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/issue?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Move(ctx context.Context, boardID int, payload *model.BoardMovementPayloadScheme) (*model.ResponseScheme, error) {
@@ -554,24 +545,14 @@ func (i *internalBoardImpl) Move(ctx context.Context, boardID int, payload *mode
 		return nil, model.ErrNoBoardIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/issue", i.version, boardID)
+	url := fmt.Sprintf("rest/agile/%v/board/%v/issue", i.version, boardID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, err
 	}
 
-	response, err := i.c.Call(request, nil)
-	if err != nil {
-		return response, err
-	}
-
-	return response, nil
+	return i.c.Call(req, nil)
 }
 
 func (i *internalBoardImpl) Projects(ctx context.Context, boardID, startAt, maxResults int) (*model.BoardProjectPageScheme, *model.ResponseScheme, error) {
@@ -584,20 +565,20 @@ func (i *internalBoardImpl) Projects(ctx context.Context, boardID, startAt, maxR
 	params.Add("startAt", strconv.Itoa(startAt))
 	params.Add("maxResults", strconv.Itoa(maxResults))
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/project?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/project?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardProjectPageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Sprints(ctx context.Context, boardID, startAt, maxResults int, states []string) (*model.BoardSprintPageScheme, *model.ResponseScheme, error) {
@@ -611,20 +592,20 @@ func (i *internalBoardImpl) Sprints(ctx context.Context, boardID, startAt, maxRe
 	params.Add("maxResults", strconv.Itoa(maxResults))
 	params.Add("state", strings.Join(states, ","))
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/sprint?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/sprint?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardSprintPageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) IssuesBySprint(ctx context.Context, boardID, sprintID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -660,20 +641,20 @@ func (i *internalBoardImpl) IssuesBySprint(ctx context.Context, boardID, sprintI
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/sprint/%v/issue?%v", i.version, boardID, sprintID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/sprint/%v/issue?%v", i.version, boardID, sprintID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Versions(ctx context.Context, boardID, startAt, maxResults int, released bool) (*model.BoardVersionPageScheme, *model.ResponseScheme, error) {
@@ -687,20 +668,20 @@ func (i *internalBoardImpl) Versions(ctx context.Context, boardID, startAt, maxR
 	params.Add("maxResults", strconv.Itoa(maxResults))
 	params.Add("released", fmt.Sprintf("%t", released))
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v/version?%v", i.version, boardID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board/%v/version?%v", i.version, boardID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardVersionPageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalBoardImpl) Delete(ctx context.Context, boardID int) (*model.ResponseScheme, error) {
@@ -709,19 +690,14 @@ func (i *internalBoardImpl) Delete(ctx context.Context, boardID int) (*model.Res
 		return nil, model.ErrNoBoardIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board/%v", i.version, boardID)
+	url := fmt.Sprintf("rest/agile/%v/board/%v", i.version, boardID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodDelete, endpoint, nil)
+	request, err := i.c.NewRequest(ctx, http.MethodDelete, url, "", nil)
 	if err != nil {
 		return nil, err
 	}
 
-	response, err := i.c.Call(request, nil)
-	if err != nil {
-		return response, err
-	}
-
-	return response, nil
+	return i.c.Call(request, nil)
 }
 
 func (i *internalBoardImpl) Gets(ctx context.Context, opts *model.GetBoardsOptions, startAt, maxResults int) (*model.BoardPageScheme, *model.ResponseScheme, error) {
@@ -773,18 +749,18 @@ func (i *internalBoardImpl) Gets(ctx context.Context, opts *model.GetBoardsOptio
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/board?%v", i.version, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/board?%v", i.version, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardPageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
diff --git a/jira/agile/internal/epic_impl.go b/jira/agile/internal/epic_impl.go
index 5f8214c..8a8f994 100644
--- a/jira/agile/internal/epic_impl.go
+++ b/jira/agile/internal/epic_impl.go
@@ -12,15 +12,11 @@ import (
 	"strings"
 )
 
-func NewEpicService(client service.Client, version string) (*EpicService, error) {
-
-	if version == "" {
-		return nil, model.ErrNoVersionProvided
-	}
+func NewEpicService(client service.Connector, version string) *EpicService {
 
 	return &EpicService{
 		internalClient: &internalEpicImpl{c: client, version: version},
-	}, nil
+	}
 }
 
 type EpicService struct {
@@ -72,7 +68,7 @@ func (e *EpicService) Move(ctx context.Context, epicIdOrKey string, issues []str
 }
 
 type internalEpicImpl struct {
-	c       service.Client
+	c       service.Connector
 	version string
 }
 
@@ -82,20 +78,20 @@ func (i *internalEpicImpl) Get(ctx context.Context, epicIdOrKey string) (*model.
 		return nil, nil, model.ErrNoEpicIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/epic/%v", i.version, epicIdOrKey)
+	url := fmt.Sprintf("rest/agile/%v/epic/%v", i.version, epicIdOrKey)
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	epic := new(model.EpicScheme)
-	response, err := i.c.Call(request, epic)
+	res, err := i.c.Call(req, epic)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return epic, response, nil
+	return epic, res, nil
 }
 
 func (i *internalEpicImpl) Issues(ctx context.Context, epicIdOrKey string, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.BoardIssuePageScheme, *model.ResponseScheme, error) {
@@ -125,20 +121,20 @@ func (i *internalEpicImpl) Issues(ctx context.Context, epicIdOrKey string, opts
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/epic/%v/issue?%v", i.version, epicIdOrKey, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/epic/%v/issue?%v", i.version, epicIdOrKey, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.BoardIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalEpicImpl) Move(ctx context.Context, epicIdOrKey string, issues []string) (*model.ResponseScheme, error) {
@@ -147,17 +143,13 @@ func (i *internalEpicImpl) Move(ctx context.Context, epicIdOrKey string, issues
 		return nil, model.ErrNoEpicIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(map[string]interface{}{"issues": issues})
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/epic/%v/issue", i.version, epicIdOrKey)
+	payload := map[string]interface{}{"issues": issues}
+	url := fmt.Sprintf("rest/agile/%v/epic/%v/issue", i.version, epicIdOrKey)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
diff --git a/jira/agile/internal/sprint_impl.go b/jira/agile/internal/sprint_impl.go
index beda1b2..b7b1c30 100644
--- a/jira/agile/internal/sprint_impl.go
+++ b/jira/agile/internal/sprint_impl.go
@@ -12,15 +12,11 @@ import (
 	"strings"
 )
 
-func NewSprintService(client service.Client, version string) (*SprintService, error) {
-
-	if version == "" {
-		return nil, model.ErrNoVersionProvided
-	}
+func NewSprintService(client service.Connector, version string) *SprintService {
 
 	return &SprintService{
 		internalClient: &internalSprintImpl{c: client, version: version},
-	}, nil
+	}
 }
 
 type SprintService struct {
@@ -133,7 +129,7 @@ func (s *SprintService) Move(ctx context.Context, sprintID int, payload *model.S
 }
 
 type internalSprintImpl struct {
-	c       service.Client
+	c       service.Connector
 	version string
 }
 
@@ -143,19 +139,14 @@ func (i *internalSprintImpl) Move(ctx context.Context, sprintID int, payload *mo
 		return nil, model.ErrNoSprintIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("/rest/agile/%v/sprint/%v/issue", i.version, sprintID)
+	url := fmt.Sprintf("/rest/agile/%v/sprint/%v/issue", i.version, sprintID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
 
 func (i *internalSprintImpl) Get(ctx context.Context, sprintID int) (*model.SprintScheme, *model.ResponseScheme, error) {
@@ -164,43 +155,38 @@ func (i *internalSprintImpl) Get(ctx context.Context, sprintID int) (*model.Spri
 		return nil, nil, model.ErrNoSprintIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	sprint := new(model.SprintScheme)
-	response, err := i.c.Call(request, sprint)
+	res, err := i.c.Call(req, sprint)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return sprint, response, nil
+	return sprint, res, nil
 }
 
 func (i *internalSprintImpl) Create(ctx context.Context, payload *model.SprintPayloadScheme) (*model.SprintScheme, *model.ResponseScheme, error) {
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint", i.version)
+	url := fmt.Sprintf("rest/agile/%v/sprint", i.version)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	sprint := new(model.SprintScheme)
-	response, err := i.c.Call(request, sprint)
+	res, err := i.c.Call(req, sprint)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return sprint, response, nil
+	return sprint, res, nil
 }
 
 func (i *internalSprintImpl) Update(ctx context.Context, sprintID int, payload *model.SprintPayloadScheme) (*model.SprintScheme, *model.ResponseScheme, error) {
@@ -209,25 +195,20 @@ func (i *internalSprintImpl) Update(ctx context.Context, sprintID int, payload *
 		return nil, nil, model.ErrNoSprintIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPut, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPut, url, "", payload)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	sprint := new(model.SprintScheme)
-	response, err := i.c.Call(request, sprint)
+	res, err := i.c.Call(req, sprint)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return sprint, response, nil
+	return sprint, res, nil
 }
 
 func (i *internalSprintImpl) Path(ctx context.Context, sprintID int, payload *model.SprintPayloadScheme) (*model.SprintScheme, *model.ResponseScheme, error) {
@@ -236,25 +217,20 @@ func (i *internalSprintImpl) Path(ctx context.Context, sprintID int, payload *mo
 		return nil, nil, model.ErrNoSprintIDError
 	}
 
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, nil, err
-	}
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
-
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", payload)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	sprint := new(model.SprintScheme)
-	response, err := i.c.Call(request, sprint)
+	res, err := i.c.Call(req, sprint)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return sprint, response, nil
+	return sprint, res, nil
 }
 
 func (i *internalSprintImpl) Delete(ctx context.Context, sprintID int) (*model.ResponseScheme, error) {
@@ -263,14 +239,14 @@ func (i *internalSprintImpl) Delete(ctx context.Context, sprintID int) (*model.R
 		return nil, model.ErrNoSprintIDError
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodDelete, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodDelete, url, "", nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
 
 func (i *internalSprintImpl) Issues(ctx context.Context, sprintID int, opts *model.IssueOptionScheme, startAt, maxResults int) (*model.SprintIssuePageScheme, *model.ResponseScheme, error) {
@@ -302,20 +278,20 @@ func (i *internalSprintImpl) Issues(ctx context.Context, sprintID int, opts *mod
 		}
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v/issue?%v", i.version, sprintID, params.Encode())
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v/issue?%v", i.version, sprintID, params.Encode())
 
-	request, err := i.c.NewRequest(ctx, http.MethodGet, endpoint, nil)
+	req, err := i.c.NewRequest(ctx, http.MethodGet, url, "", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	page := new(model.SprintIssuePageScheme)
-	response, err := i.c.Call(request, page)
+	res, err := i.c.Call(req, page)
 	if err != nil {
-		return nil, response, err
+		return nil, res, err
 	}
 
-	return page, response, nil
+	return page, res, nil
 }
 
 func (i *internalSprintImpl) Start(ctx context.Context, sprintID int) (*model.ResponseScheme, error) {
@@ -324,23 +300,14 @@ func (i *internalSprintImpl) Start(ctx context.Context, sprintID int) (*model.Re
 		return nil, model.ErrNoSprintIDError
 	}
 
-	payload := model.SprintPayloadScheme{
-		State: "Active",
-	}
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	reader, err := i.c.TransformStructToReader(payload)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", &model.SprintPayloadScheme{State: "Active"})
 	if err != nil {
 		return nil, err
 	}
 
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
-
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
-	if err != nil {
-		return nil, err
-	}
-
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
 
 func (i *internalSprintImpl) Close(ctx context.Context, sprintID int) (*model.ResponseScheme, error) {
@@ -349,21 +316,12 @@ func (i *internalSprintImpl) Close(ctx context.Context, sprintID int) (*model.Re
 		return nil, model.ErrNoSprintIDError
 	}
 
-	payload := model.SprintPayloadScheme{
-		State: "Closed",
-	}
-
-	reader, err := i.c.TransformStructToReader(payload)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
+	url := fmt.Sprintf("rest/agile/%v/sprint/%v", i.version, sprintID)
 
-	request, err := i.c.NewRequest(ctx, http.MethodPost, endpoint, reader)
+	req, err := i.c.NewRequest(ctx, http.MethodPost, url, "", &model.SprintPayloadScheme{State: "Closed"})
 	if err != nil {
 		return nil, err
 	}
 
-	return i.c.Call(request, nil)
+	return i.c.Call(req, nil)
 }
diff --git a/pkg/infra/models/errors.go b/pkg/infra/models/errors.go
index 4555374..fdef517 100644
--- a/pkg/infra/models/errors.go
+++ b/pkg/infra/models/errors.go
@@ -129,24 +129,31 @@ var (
 	ErrNoIssueTypeSchemeIDError            = errors.New("jira: no issue type scheme id set")
 	ErrNoTaskIDError                       = errors.New("atlassian: no task id set")
 	ErrNoApprovalIDError                   = errors.New("jira: no approval id set")
-	ErrInvalidStatusCodeError              = errors.New("client: invalid http response status, please refer the response.body for more details")
-	ErrNilPayloadError                     = errors.New("client: please provide the necessary payload struct")
-	ErrNonPayloadPointerError              = errors.New("client: please provide a valid payload struct pointer (&)")
-	ErrNoFieldInformationError             = errors.New("custom-field: please provide a buffer with a valid fields object")
-	ErrNoCustomFieldUnmarshalError         = errors.New("custom-field: no valid json provided")
-	ErrNoMultiSelectTypeError              = errors.New("custom-field: no multiselect type found")
-	ErrNoUrlTypeError                      = errors.New("custom-field: no url type set")
-	ErrNoTextTypeError                     = errors.New("custom-field: no text type set")
-	ErrNoDateTimeTypeError                 = errors.New("custom-field: no date-time type set")
-	ErrNoDateTypeError                     = errors.New("custom-field: no date type set")
-	ErrNoSelectTypeError                   = errors.New("custom-field: no select type set")
-	ErrNoButtonTypeError                   = errors.New("custom-field: no button type set")
-	ErrNoUserTypeError                     = errors.New("custom-field: no user type set")
-	ErrNoMultiUserTypeError                = errors.New("custom-field: no multi-user type set")
-	ErrNoCheckBoxTypeError                 = errors.New("custom-field: no check-box type set")
-	ErrNoCascadingParentError              = errors.New("custom-field: no cascading parent value set")
-	ErrNoCascadingChildError               = errors.New("custom-field: no cascading child value set")
-	ErrNoAttachmentIdsError                = errors.New("sm: no attachment id's set")
-	ErrNoLabelsError                       = errors.New("sm: no label names set")
-	ErrNoComponentsError                   = errors.New("sm: no components set")
+
+	ErrInvalidStatusCodeError = errors.New("client: invalid http response status, please refer the response.body for more details")
+	ErrNotFound               = errors.New("client: no atlassian resource found")
+	ErrUnauthorized           = errors.New("client: atlassian insufficient permissions")
+	ErrInternalError          = errors.New("client: atlassian internal error")
+	ErrBadRequestError        = errors.New("client: atlassian invalid payload")
+	ErrNoSiteError            = errors.New("client: no atlassian site set")
+
+	ErrNilPayloadError             = errors.New("client: please provide the necessary payload struct")
+	ErrNonPayloadPointerError      = errors.New("client: please provide a valid payload struct pointer (&)")
+	ErrNoFieldInformationError     = errors.New("custom-field: please provide a buffer with a valid fields object")
+	ErrNoCustomFieldUnmarshalError = errors.New("custom-field: no valid json provided")
+	ErrNoMultiSelectTypeError      = errors.New("custom-field: no multiselect type found")
+	ErrNoUrlTypeError              = errors.New("custom-field: no url type set")
+	ErrNoTextTypeError             = errors.New("custom-field: no text type set")
+	ErrNoDateTimeTypeError         = errors.New("custom-field: no date-time type set")
+	ErrNoDateTypeError             = errors.New("custom-field: no date type set")
+	ErrNoSelectTypeError           = errors.New("custom-field: no select type set")
+	ErrNoButtonTypeError           = errors.New("custom-field: no button type set")
+	ErrNoUserTypeError             = errors.New("custom-field: no user type set")
+	ErrNoMultiUserTypeError        = errors.New("custom-field: no multi-user type set")
+	ErrNoCheckBoxTypeError         = errors.New("custom-field: no check-box type set")
+	ErrNoCascadingParentError      = errors.New("custom-field: no cascading parent value set")
+	ErrNoCascadingChildError       = errors.New("custom-field: no cascading child value set")
+	ErrNoAttachmentIdsError        = errors.New("sm: no attachment id's set")
+	ErrNoLabelsError               = errors.New("sm: no label names set")
+	ErrNoComponentsError           = errors.New("sm: no components set")
 )
diff --git a/service/http.go b/service/http.go
index 42ea60d..89e1cc5 100644
--- a/service/http.go
+++ b/service/http.go
@@ -14,3 +14,8 @@ type Client interface {
 	TransformTheHTTPResponse(response *http.Response, structure interface{}) (*models.ResponseScheme, error)
 	TransformStructToReader(structure interface{}) (io.Reader, error)
 }
+
+type Connector interface {
+	NewRequest(ctx context.Context, method, urlStr, type_ string, body interface{}) (*http.Request, error)
+	Call(request *http.Request, structure interface{}) (*models.ResponseScheme, error)
+}
diff --git a/service/mocks/Connector.go b/service/mocks/Connector.go
new file mode 100644
index 0000000..2399b9a
--- /dev/null
+++ b/service/mocks/Connector.go
@@ -0,0 +1,83 @@
+// Code generated by mockery v2.30.1. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+	http "net/http"
+
+	mock "github.com/stretchr/testify/mock"
+
+	models "github.com/ctreminiom/go-atlassian/pkg/infra/models"
+)
+
+// Connector is an autogenerated mock type for the Connector type
+type Connector struct {
+	mock.Mock
+}
+
+// Call provides a mock function with given fields: request, structure
+func (_m *Connector) Call(request *http.Request, structure interface{}) (*models.ResponseScheme, error) {
+	ret := _m.Called(request, structure)
+
+	var r0 *models.ResponseScheme
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*http.Request, interface{}) (*models.ResponseScheme, error)); ok {
+		return rf(request, structure)
+	}
+	if rf, ok := ret.Get(0).(func(*http.Request, interface{}) *models.ResponseScheme); ok {
+		r0 = rf(request, structure)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*models.ResponseScheme)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*http.Request, interface{}) error); ok {
+		r1 = rf(request, structure)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewRequest provides a mock function with given fields: ctx, method, urlStr, type_, body
+func (_m *Connector) NewRequest(ctx context.Context, method string, urlStr string, type_ string, body interface{}) (*http.Request, error) {
+	ret := _m.Called(ctx, method, urlStr, type_, body)
+
+	var r0 *http.Request
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, interface{}) (*http.Request, error)); ok {
+		return rf(ctx, method, urlStr, type_, body)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, interface{}) *http.Request); ok {
+		r0 = rf(ctx, method, urlStr, type_, body)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*http.Request)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, interface{}) error); ok {
+		r1 = rf(ctx, method, urlStr, type_, body)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// NewConnector creates a new instance of Connector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewConnector(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Connector {
+	mock := &Connector{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}


Test patch:
diff --git a/jira/agile/api_client_impl_test.go b/jira/agile/api_client_impl_test.go
index 4cc9d71..4f0115f 100644
--- a/jira/agile/api_client_impl_test.go
+++ b/jira/agile/api_client_impl_test.go
@@ -3,15 +3,13 @@ package agile
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"github.com/ctreminiom/go-atlassian/jira/agile/internal"
-	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
 	"github.com/ctreminiom/go-atlassian/service/common"
 	"github.com/ctreminiom/go-atlassian/service/mocks"
 	"github.com/stretchr/testify/assert"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"strings"
@@ -22,31 +20,58 @@ func TestClient_Call(t *testing.T) {
 
 	expectedResponse := &http.Response{
 		StatusCode: http.StatusOK,
-		Body:       ioutil.NopCloser(strings.NewReader("Hello, world!")),
+		Body:       io.NopCloser(strings.NewReader("Hello, world!")),
 		Request: &http.Request{
 			Method: http.MethodGet,
 			URL:    &url.URL{},
 		},
 	}
 
-	nonExpectedResponse := &http.Response{
+	badRequestResponse := &http.Response{
 		StatusCode: http.StatusBadRequest,
-		Body:       ioutil.NopCloser(strings.NewReader("Hello, world!")),
+		Body:       io.NopCloser(strings.NewReader("Hello, world!")),
 		Request: &http.Request{
 			Method: http.MethodGet,
 			URL:    &url.URL{},
 		},
 	}
 
-	type fields struct {
-		HTTP           common.HttpClient
-		Site           *url.URL
-		Authentication common.Authentication
-		Board          *internal.BoardService
-		Epic           *internal.EpicService
-		Sprint         *internal.SprintService
+	internalServerResponse := &http.Response{
+		StatusCode: http.StatusInternalServerError,
+		Body:       io.NopCloser(strings.NewReader("Hello, world!")),
+		Request: &http.Request{
+			Method: http.MethodGet,
+			URL:    &url.URL{},
+		},
+	}
+
+	unauthorizedResponse := &http.Response{
+		StatusCode: http.StatusUnauthorized,
+		Body:       io.NopCloser(strings.NewReader("Hello, world!")),
+		Request: &http.Request{
+			Method: http.MethodGet,
+			URL:    &url.URL{},
+		},
+	}
+
+	notFoundResponse := &http.Response{
+		StatusCode: http.StatusNotFound,
+		Body:       io.NopCloser(strings.NewReader("Hello, world!")),
+		Request: &http.Request{
+			Method: http.MethodGet,
+			URL:    &url.URL{},
+		},
 	}
 
+	type fields struct {
+		HTTP    common.HttpClient
+		Site    *url.URL
+		Auth    common.Authentication
+		Board   *internal.BoardService
+		Backlog *internal.BoardBacklogService
+		Epic    *internal.EpicService
+		Sprint  *internal.SprintService
+	}
 	type args struct {
 		request   *http.Request
 		structure interface{}
@@ -55,9 +80,9 @@ func TestClient_Call(t *testing.T) {
 	testCases := []struct {
 		name    string
 		fields  fields
-		on      func(*fields)
 		args    args
-		want    *models.ResponseScheme
+		on      func(*fields)
+		want    *model.ResponseScheme
 		wantErr bool
 		Err     error
 	}{
@@ -76,7 +101,7 @@ func TestClient_Call(t *testing.T) {
 				request:   nil,
 				structure: nil,
 			},
-			want: &models.ResponseScheme{
+			want: &model.ResponseScheme{
 				Response: expectedResponse,
 				Code:     http.StatusOK,
 				Method:   http.MethodGet,
@@ -86,13 +111,13 @@ func TestClient_Call(t *testing.T) {
 		},
 
 		{
-			name: "when the response status is not valid",
+			name: "when the response status is a bad request",
 			on: func(fields *fields) {
 
 				client := mocks.NewHttpClient(t)
 
 				client.On("Do", (*http.Request)(nil)).
-					Return(nonExpectedResponse, nil)
+					Return(badRequestResponse, nil)
 
 				fields.HTTP = client
 			},
@@ -100,34 +125,92 @@ func TestClient_Call(t *testing.T) {
 				request:   nil,
 				structure: nil,
 			},
-			want: &models.ResponseScheme{
-				Response: nonExpectedResponse,
+			want: &model.ResponseScheme{
+				Response: badRequestResponse,
 				Code:     http.StatusBadRequest,
 				Method:   http.MethodGet,
 				Bytes:    *bytes.NewBufferString("Hello, world!"),
 			},
 			wantErr: true,
-			Err:     models.ErrInvalidStatusCodeError,
+			Err:     model.ErrBadRequestError,
 		},
 
 		{
-			name: "when the http callback cannot be executed",
+			name: "when the response status is an internal service error",
 			on: func(fields *fields) {
 
 				client := mocks.NewHttpClient(t)
 
 				client.On("Do", (*http.Request)(nil)).
-					Return(nil, errors.New("error, unable to execute the http call"))
+					Return(internalServerResponse, nil)
 
 				fields.HTTP = client
 			},
+			args: args{
+				request:   nil,
+				structure: nil,
+			},
+			want: &model.ResponseScheme{
+				Response: internalServerResponse,
+				Code:     http.StatusInternalServerError,
+				Method:   http.MethodGet,
+				Bytes:    *bytes.NewBufferString("Hello, world!"),
+			},
 			wantErr: true,
-			Err:     errors.New("error, unable to execute the http call"),
+			Err:     model.ErrInternalError,
 		},
-	}
 
-	for _, testCase := range testCases {
+		{
+			name: "when the response status is a not found",
+			on: func(fields *fields) {
 
+				client := mocks.NewHttpClient(t)
+
+				client.On("Do", (*http.Request)(nil)).
+					Return(notFoundResponse, nil)
+
+				fields.HTTP = client
+			},
+			args: args{
+				request:   nil,
+				structure: nil,
+			},
+			want: &model.ResponseScheme{
+				Response: notFoundResponse,
+				Code:     http.StatusNotFound,
+				Method:   http.MethodGet,
+				Bytes:    *bytes.NewBufferString("Hello, world!"),
+			},
+			wantErr: true,
+			Err:     model.ErrNotFound,
+		},
+
+		{
+			name: "when the response status is unauthorized",
+			on: func(fields *fields) {
+
+				client := mocks.NewHttpClient(t)
+
+				client.On("Do", (*http.Request)(nil)).
+					Return(unauthorizedResponse, nil)
+
+				fields.HTTP = client
+			},
+			args: args{
+				request:   nil,
+				structure: nil,
+			},
+			want: &model.ResponseScheme{
+				Response: unauthorizedResponse,
+				Code:     http.StatusUnauthorized,
+				Method:   http.MethodGet,
+				Bytes:    *bytes.NewBufferString("Hello, world!"),
+			},
+			wantErr: true,
+			Err:     model.ErrUnauthorized,
+		},
+	}
+	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 
 			if testCase.on != nil {
@@ -137,7 +220,6 @@ func TestClient_Call(t *testing.T) {
 			c := &Client{
 				HTTP:   testCase.fields.HTTP,
 				Site:   testCase.fields.Site,
-				Auth:   testCase.fields.Authentication,
 				Board:  testCase.fields.Board,
 				Epic:   testCase.fields.Epic,
 				Sprint: testCase.fields.Sprint,
@@ -157,61 +239,125 @@ func TestClient_Call(t *testing.T) {
 				assert.NoError(t, err)
 				assert.Equal(t, got, testCase.want)
 			}
+
 		})
 	}
 }
 
-func TestNew(t *testing.T) {
+func TestClient_NewRequest(t *testing.T) {
 
-	mockClient, err := New(http.DefaultClient, "https://ctreminiom.atlassian.net")
+	authMocked := internal.NewAuthenticationService(nil)
+	authMocked.SetBasicAuth("mail", "token")
+	authMocked.SetUserAgent("firefox")
+
+	siteAsURL, err := url.Parse("https://ctreminiom.atlassian.net")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	mockClient.Auth.SetBasicAuth("test", "test")
-	mockClient.Auth.SetUserAgent("aaa")
+	requestMocked, err := http.NewRequestWithContext(context.TODO(),
+		http.MethodGet,
+		"https://ctreminiom.atlassian.net/rest/2/issue/attachment",
+		bytes.NewReader([]byte("Hello World")),
+	)
+
+	if err != nil {
+		t.Fatal(err)
+	}
 
-	mockClient2, _ := New(nil, " https://zhidao.baidu.com/special/view?id=sd&preview=1")
+	requestMocked.Header.Set("Accept", "application/json")
+	requestMocked.Header.Set("Content-Type", "application/json")
+
+	type fields struct {
+		HTTP common.HttpClient
+		Auth common.Authentication
+		Site *url.URL
+	}
 
 	type args struct {
-		httpClient common.HttpClient
-		site       string
+		ctx    context.Context
+		method string
+		urlStr string
+		type_  string
+		body   interface{}
 	}
 
 	testCases := []struct {
 		name    string
+		fields  fields
 		args    args
-		on      func(*args)
-		want    *Client
+		want    *http.Request
 		wantErr bool
-		Err     error
 	}{
 		{
 			name: "when the parameters are correct",
+			fields: fields{
+				HTTP: http.DefaultClient,
+				Auth: authMocked,
+				Site: siteAsURL,
+			},
 			args: args{
-				httpClient: http.DefaultClient,
-				site:       "https://ctreminiom.atlassian.net",
+				ctx:    context.TODO(),
+				method: http.MethodGet,
+				urlStr: "rest/2/issue/attachment",
+				type_:  "",
+				body:   bytes.NewReader([]byte("Hello World")),
 			},
-			want:    mockClient,
+			want:    requestMocked,
 			wantErr: false,
 		},
 
 		{
-			name: "when the site url is not valid",
+			name: "when the url cannot be parsed",
+			fields: fields{
+				HTTP: http.DefaultClient,
+				Auth: internal.NewAuthenticationService(nil),
+				Site: siteAsURL,
+			},
 			args: args{
-				httpClient: http.DefaultClient,
-				site:       " https://zhidao.baidu.com/special/view?id=sd&preview=1",
+				ctx:    context.TODO(),
+				method: http.MethodGet,
+				urlStr: " https://zhidao.baidu.com/special/view?id=49105a24626975510000&preview=1",
+				body:   bytes.NewReader([]byte("Hello World")),
 			},
-			want:    mockClient2,
+			want:    nil,
+			wantErr: true,
+		},
+
+		{
+			name: "when the request cannot be created",
+			fields: fields{
+				HTTP: http.DefaultClient,
+				Auth: internal.NewAuthenticationService(nil),
+				Site: siteAsURL,
+			},
+			args: args{
+				ctx:    nil,
+				method: http.MethodGet,
+				urlStr: "rest/2/issue/attachment",
+				body:   bytes.NewReader([]byte("Hello World")),
+			},
+			want:    requestMocked,
 			wantErr: true,
-			Err:     errors.New("parse \" https://zhidao.baidu.com/special/view?id=sd&preview=1/\": first path segment in URL cannot contain colon"),
 		},
 	}
 
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 
-			gotClient, err := New(testCase.args.httpClient, testCase.args.site)
+			c := &Client{
+				HTTP: testCase.fields.HTTP,
+				Auth: testCase.fields.Auth,
+				Site: testCase.fields.Site,
+			}
+
+			got, err := c.NewRequest(
+				testCase.args.ctx,
+				testCase.args.method,
+				testCase.args.urlStr,
+				testCase.args.type_,
+				testCase.args.body,
+			)
 
 			if testCase.wantErr {
 
@@ -220,18 +366,16 @@ func TestNew(t *testing.T) {
 				}
 
 				assert.Error(t, err)
-				assert.EqualError(t, err, testCase.Err.Error())
-
 			} else {
 				assert.NoError(t, err)
-				assert.NotEqual(t, gotClient, nil)
+				assert.NotEqual(t, got, nil)
 			}
 
 		})
 	}
 }
 
-func TestClient_TransformTheHTTPResponse(t *testing.T) {
+func TestClient_processResponse(t *testing.T) {
 
 	expectedJsonResponse := `
 	{
@@ -243,7 +387,7 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 
 	expectedResponse := &http.Response{
 		StatusCode: http.StatusOK,
-		Body:       ioutil.NopCloser(strings.NewReader(expectedJsonResponse)),
+		Body:       io.NopCloser(strings.NewReader(expectedJsonResponse)),
 		Request: &http.Request{
 			Method: http.MethodGet,
 			URL:    &url.URL{},
@@ -258,7 +402,6 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 		Epic           *internal.EpicService
 		Sprint         *internal.SprintService
 	}
-
 	type args struct {
 		response  *http.Response
 		structure interface{}
@@ -268,7 +411,7 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 		name    string
 		fields  fields
 		args    args
-		want    *models.ResponseScheme
+		want    *model.ResponseScheme
 		wantErr bool
 		Err     error
 	}{
@@ -277,9 +420,9 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 			fields: fields{},
 			args: args{
 				response:  expectedResponse,
-				structure: models.BoardScheme{},
+				structure: model.BoardScheme{},
 			},
-			want: &models.ResponseScheme{
+			want: &model.ResponseScheme{
 				Response: expectedResponse,
 				Code:     http.StatusOK,
 				Method:   http.MethodGet,
@@ -288,9 +431,9 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 			wantErr: false,
 		},
 	}
-
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
+
 			c := &Client{
 				HTTP:   testCase.fields.HTTP,
 				Site:   testCase.fields.Site,
@@ -300,7 +443,7 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 				Sprint: testCase.fields.Sprint,
 			}
 
-			got, err := c.TransformTheHTTPResponse(testCase.args.response, testCase.args.structure)
+			got, err := c.processResponse(testCase.args.response, testCase.args.structure)
 
 			if testCase.wantErr {
 
@@ -315,91 +458,74 @@ func TestClient_TransformTheHTTPResponse(t *testing.T) {
 				assert.NoError(t, err)
 				assert.NotEqual(t, got, nil)
 			}
+
 		})
 	}
 }
 
-func TestClient_TransformStructToReader(t *testing.T) {
-
-	expectedBytes, err := json.Marshal(&models.BoardScheme{
-		Name: "BoardConnector Sample",
-		Type: "Scrum",
-	})
+func TestNew(t *testing.T) {
 
+	mockClient, err := New(http.DefaultClient, "https://ctreminiom.atlassian.net")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	type fields struct {
-		HTTP           common.HttpClient
-		Site           *url.URL
-		Authentication common.Authentication
-		Board          *internal.BoardService
-		Epic           *internal.EpicService
-		Sprint         *internal.SprintService
-	}
+	mockClient.Auth.SetBasicAuth("test", "test")
+	mockClient.Auth.SetUserAgent("aaa")
+
+	invalidURLClientMocked, _ := New(nil, " https://zhidao.baidu.com/special/view?id=sd&preview=1")
+
+	noURLClientMocked, _ := New(nil, "")
 
 	type args struct {
-		structure interface{}
+		httpClient common.HttpClient
+		site       string
 	}
 
 	testCases := []struct {
 		name    string
-		fields  fields
 		args    args
-		want    io.Reader
+		want    *Client
 		wantErr bool
 		Err     error
 	}{
+
 		{
 			name: "when the parameters are correct",
 			args: args{
-				structure: &models.BoardScheme{
-					Name: "BoardConnector Sample",
-					Type: "Scrum",
-				},
+				httpClient: http.DefaultClient,
+				site:       "https://ctreminiom.atlassian.net",
 			},
-			want:    bytes.NewReader(expectedBytes),
+			want:    mockClient,
 			wantErr: false,
 		},
 
 		{
-			name: "when the payload provided is not a pointer",
+			name: "when the site url are not provided",
 			args: args{
-				structure: models.BoardScheme{
-					Name: "BoardConnector Sample",
-					Type: "Scrum",
-				},
+				httpClient: http.DefaultClient,
+				site:       "",
 			},
-			want:    bytes.NewReader(expectedBytes),
+			want:    noURLClientMocked,
 			wantErr: true,
-			Err:     models.ErrNonPayloadPointerError,
+			Err:     model.ErrNoSiteError,
 		},
-
 		{
-			name: "when the payload is not provided",
+			name: "when the site url is not valid",
 			args: args{
-				structure: nil,
+				httpClient: http.DefaultClient,
+				site:       " https://zhidao.baidu.com/special/view?id=sd&preview=1",
 			},
-			want:    bytes.NewReader(expectedBytes),
+			want:    invalidURLClientMocked,
 			wantErr: true,
-			Err:     models.ErrNilPayloadError,
+			Err:     errors.New("parse \" https://zhidao.baidu.com/special/view?id=sd&preview=1/\": first path segment in URL cannot contain colon"),
 		},
 	}
 
 	for _, testCase := range testCases {
-
 		t.Run(testCase.name, func(t *testing.T) {
-			c := &Client{
-				HTTP:   testCase.fields.HTTP,
-				Site:   testCase.fields.Site,
-				Auth:   testCase.fields.Authentication,
-				Board:  testCase.fields.Board,
-				Epic:   testCase.fields.Epic,
-				Sprint: testCase.fields.Sprint,
-			}
 
-			got, err := c.TransformStructToReader(testCase.args.structure)
+			gotClient, err := New(testCase.args.httpClient, testCase.args.site)
 
 			if testCase.wantErr {
 
@@ -412,127 +538,7 @@ func TestClient_TransformStructToReader(t *testing.T) {
 
 			} else {
 				assert.NoError(t, err)
-				assert.NotEqual(t, got, nil)
-			}
-		})
-	}
-}
-
-func TestClient_NewRequest(t *testing.T) {
-
-	authMocked := internal.NewAuthenticationService(nil)
-	authMocked.SetBasicAuth("mail", "token")
-	authMocked.SetUserAgent("firefox")
-
-	siteAsURL, err := url.Parse("https://ctreminiom.atlassian.net")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	requestMocked, err := http.NewRequestWithContext(context.TODO(),
-		http.MethodGet,
-		"https://ctreminiom.atlassian.net/rest/2/issue/attachment",
-		bytes.NewReader([]byte("Hello World")),
-	)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	requestMocked.Header.Set("Accept", "application/json")
-	requestMocked.Header.Set("Content-Type", "application/json")
-
-	type fields struct {
-		HTTP common.HttpClient
-		Auth common.Authentication
-		Site *url.URL
-	}
-
-	type args struct {
-		ctx         context.Context
-		method      string
-		apiEndpoint string
-		payload     io.Reader
-	}
-
-	testCases := []struct {
-		name    string
-		fields  fields
-		args    args
-		want    *http.Request
-		wantErr bool
-	}{
-		{
-			name: "when the parameters are correct",
-			fields: fields{
-				HTTP: http.DefaultClient,
-				Auth: authMocked,
-				Site: siteAsURL,
-			},
-			args: args{
-				ctx:         context.TODO(),
-				method:      http.MethodGet,
-				apiEndpoint: "rest/2/issue/attachment",
-				payload:     bytes.NewReader([]byte("Hello World")),
-			},
-			want:    requestMocked,
-			wantErr: false,
-		},
-
-		{
-			name: "when the url cannot be parsed",
-			fields: fields{
-				HTTP: http.DefaultClient,
-				Auth: internal.NewAuthenticationService(nil),
-				Site: siteAsURL,
-			},
-			args: args{
-				ctx:         context.TODO(),
-				method:      http.MethodGet,
-				apiEndpoint: " https://zhidao.baidu.com/special/view?id=49105a24626975510000&preview=1",
-				payload:     bytes.NewReader([]byte("Hello World")),
-			},
-			want:    nil,
-			wantErr: true,
-		},
-
-		{
-			name: "when the request cannot be created",
-			fields: fields{
-				HTTP: http.DefaultClient,
-				Auth: internal.NewAuthenticationService(nil),
-				Site: siteAsURL,
-			},
-			args: args{
-				ctx:         nil,
-				method:      http.MethodGet,
-				apiEndpoint: "rest/2/issue/attachment",
-				payload:     bytes.NewReader([]byte("Hello World")),
-			},
-			want:    requestMocked,
-			wantErr: true,
-		},
-	}
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			c := &Client{
-				HTTP: testCase.fields.HTTP,
-				Auth: testCase.fields.Auth,
-				Site: testCase.fields.Site,
-			}
-
-			got, err := c.NewRequest(testCase.args.ctx, testCase.args.method, testCase.args.apiEndpoint, testCase.args.payload)
-
-			if testCase.wantErr {
-
-				if err != nil {
-					t.Logf("error returned: %v", err.Error())
-				}
-
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.NotEqual(t, got, nil)
+				assert.NotEqual(t, gotClient, nil)
 			}
 		})
 	}
diff --git a/jira/agile/internal/authentication_impl_test.go b/jira/agile/internal/authentication_impl_test.go
index 33b541e..052f346 100644
--- a/jira/agile/internal/authentication_impl_test.go
+++ b/jira/agile/internal/authentication_impl_test.go
@@ -12,7 +12,7 @@ import (
 func TestAuthenticationService_GetBasicAuth(t *testing.T) {
 
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -28,7 +28,7 @@ func TestAuthenticationService_GetBasicAuth(t *testing.T) {
 		{
 			name: "when the basic auth is already set",
 			fields: fields{
-				c:     mocks.NewClient(t),
+				c:     mocks.NewConnector(t),
 				mail:  "mail",
 				token: "token",
 			},
@@ -62,7 +62,7 @@ func TestAuthenticationService_GetBasicAuth(t *testing.T) {
 
 func TestAuthenticationService_GetUserAgent(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -77,7 +77,7 @@ func TestAuthenticationService_GetUserAgent(t *testing.T) {
 		{
 			name: "when the user agent is already set",
 			fields: fields{
-				c:     mocks.NewClient(t),
+				c:     mocks.NewConnector(t),
 				agent: "firefox-09",
 			},
 			want: "firefox-09",
@@ -102,7 +102,7 @@ func TestAuthenticationService_GetUserAgent(t *testing.T) {
 
 func TestAuthenticationService_HasBasicAuth(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -117,7 +117,7 @@ func TestAuthenticationService_HasBasicAuth(t *testing.T) {
 		{
 			name: "when the params are correct",
 			fields: fields{
-				c:                 mocks.NewClient(t),
+				c:                 mocks.NewConnector(t),
 				basicAuthProvided: true,
 			},
 			want: true,
@@ -143,7 +143,7 @@ func TestAuthenticationService_HasBasicAuth(t *testing.T) {
 
 func TestAuthenticationService_HasUserAgent(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -184,10 +184,10 @@ func TestAuthenticationService_HasUserAgent(t *testing.T) {
 
 func TestNewAuthenticationService(t *testing.T) {
 
-	clientMocked := mocks.NewClient(t)
+	clientMocked := mocks.NewConnector(t)
 
 	type args struct {
-		client service.Client
+		client service.Connector
 	}
 	testCases := []struct {
 		name string
@@ -214,7 +214,7 @@ func TestNewAuthenticationService(t *testing.T) {
 func TestAuthenticationService_SetUserAgent(t *testing.T) {
 
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -254,7 +254,7 @@ func TestAuthenticationService_SetUserAgent(t *testing.T) {
 func TestAuthenticationService_SetBasicAuth(t *testing.T) {
 
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -297,7 +297,7 @@ func TestAuthenticationService_SetBasicAuth(t *testing.T) {
 func TestAuthenticationService_HasSetExperimentalFlag(t *testing.T) {
 
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -335,7 +335,7 @@ func TestAuthenticationService_HasSetExperimentalFlag(t *testing.T) {
 
 func TestAuthenticationService_GetBearerToken(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -350,7 +350,7 @@ func TestAuthenticationService_GetBearerToken(t *testing.T) {
 		{
 			name: "when the parameters are correct",
 			fields: fields{
-				c:     mocks.NewClient(t),
+				c:     mocks.NewConnector(t),
 				token: "token-sample",
 			},
 			want: "token-sample",
@@ -373,7 +373,7 @@ func TestAuthenticationService_GetBearerToken(t *testing.T) {
 
 func TestAuthenticationService_SetBearerToken(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
@@ -415,7 +415,7 @@ func TestAuthenticationService_SetBearerToken(t *testing.T) {
 
 func TestAuthenticationService_SetExperimentalFlag(t *testing.T) {
 	type fields struct {
-		c                 service.Client
+		c                 service.Connector
 		basicAuthProvided bool
 		mail              string
 		token             string
diff --git a/jira/agile/internal/board_backlog_impl_test.go b/jira/agile/internal/board_backlog_impl_test.go
index 3c55660..769a286 100644
--- a/jira/agile/internal/board_backlog_impl_test.go
+++ b/jira/agile/internal/board_backlog_impl_test.go
@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
@@ -14,14 +13,10 @@ import (
 
 func Test_internalBoardBacklogImpl_Move(t *testing.T) {
 
-	payloadMocked := &struct {
-		Issues []string `json:"issues"`
-	}{
-		Issues: []string{"DUMMY-1", "12323"},
-	}
+	payloadMocked := map[string]interface{}{"issues": []string{"DUMMY-1", "12323"}}
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -45,17 +40,14 @@ func Test_internalBoardBacklogImpl_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -75,27 +67,24 @@ func Test_internalBoardBacklogImpl_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					nil).
-					Return(&model.ResponseScheme{}, errors.New("error, unable to execute the http call"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("error, unable to execute the http call"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -107,17 +96,14 @@ func Test_internalBoardBacklogImpl_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -166,7 +152,7 @@ func Test_internalBoardBacklogImpl_MoveTo(t *testing.T) {
 	}
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -192,17 +178,14 @@ func Test_internalBoardBacklogImpl_MoveTo(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/56/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -223,17 +206,14 @@ func Test_internalBoardBacklogImpl_MoveTo(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/56/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -256,17 +236,14 @@ func Test_internalBoardBacklogImpl_MoveTo(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/backlog/56/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
diff --git a/jira/agile/internal/board_impl_test.go b/jira/agile/internal/board_impl_test.go
index 2a7caf2..1f8db83 100644
--- a/jira/agile/internal/board_impl_test.go
+++ b/jira/agile/internal/board_impl_test.go
@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
@@ -15,7 +14,7 @@ import (
 func Test_BoardService_Get(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -39,12 +38,13 @@ func Test_BoardService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -65,23 +65,24 @@ func Test_BoardService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("error, unable to execute the http call"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("error, unable to execute the http call"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -93,12 +94,13 @@ func Test_BoardService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -115,7 +117,7 @@ func Test_BoardService_Get(t *testing.T) {
 				boardId: 0,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -130,10 +132,9 @@ func Test_BoardService_Get(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Get(testCase.args.ctx, testCase.args.boardId)
+			gotResult, gotResponse, err := boardService.Get(testCase.args.ctx, testCase.args.boardId)
 
 			if testCase.wantErr {
 
@@ -155,8 +156,14 @@ func Test_BoardService_Get(t *testing.T) {
 
 func Test_BoardService_Create(t *testing.T) {
 
+	payloadMocked := &model.BoardPayloadScheme{
+		Name:     "BoardConnector Name Sample",
+		Type:     "scrum",
+		FilterID: 1002,
+	}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -175,30 +182,19 @@ func Test_BoardService_Create(t *testing.T) {
 		{
 			name: "when the parameters are correct",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.BoardPayloadScheme{
-					Name:     "BoardConnector Name Sample",
-					Type:     "scrum",
-					FilterID: 1002,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardPayloadScheme{
-						Name:     "BoardConnector Name Sample",
-						Type:     "scrum",
-						FilterID: 1002,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -213,30 +209,19 @@ func Test_BoardService_Create(t *testing.T) {
 		{
 			name: "when the api cannot be executed",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.BoardPayloadScheme{
-					Name:     "BoardConnector Name Sample",
-					Type:     "scrum",
-					FilterID: 1002,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardPayloadScheme{
-						Name:     "BoardConnector Name Sample",
-						Type:     "scrum",
-						FilterID: 1002,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -253,55 +238,24 @@ func Test_BoardService_Create(t *testing.T) {
 		{
 			name: "when the request cannot be created",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.BoardPayloadScheme{
-					Name:     "BoardConnector Name Sample",
-					Type:     "scrum",
-					FilterID: 1002,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardPayloadScheme{
-						Name:     "BoardConnector Name Sample",
-						Type:     "scrum",
-						FilterID: 1002,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board",
-					bytes.NewReader([]byte{})).
-					Return(&http.Request{}, errors.New("unable to create the http request"))
+					"",
+					payloadMocked).
+					Return(&http.Request{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("unable to create the http request"),
-			wantErr: true,
-		},
-
-		{
-			name: "when the payload is not provided",
-			args: args{
-				ctx:     context.Background(),
-				payload: nil,
-			},
-			on: func(fields *fields) {
-
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					(*model.BoardPayloadScheme)(nil)).
-					Return(nil, errors.New("client: no payload provided"))
-
-				fields.c = client
-			},
-			Err:     errors.New("client: no payload provided"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 	}
@@ -313,10 +267,9 @@ func Test_BoardService_Create(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Create(testCase.args.ctx, testCase.args.payload)
+			gotResult, gotResponse, err := boardService.Create(testCase.args.ctx, testCase.args.payload)
 
 			if testCase.wantErr {
 
@@ -338,8 +291,9 @@ func Test_BoardService_Create(t *testing.T) {
 }
 
 func Test_BoardService_Backlog(t *testing.T) {
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -374,12 +328,13 @@ func Test_BoardService_Backlog(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/backlog?expand=changelogs+&fields=status%2Cdescription&jql=project+%3D+ACA&maxResults=50&startAt=0&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -408,12 +363,13 @@ func Test_BoardService_Backlog(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/backlog?expand=changelogs+&fields=status%2Cdescription&jql=project+%3D+ACA&maxResults=50&startAt=0&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -444,12 +400,13 @@ func Test_BoardService_Backlog(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/backlog?expand=changelogs+&fields=status%2Cdescription&jql=project+%3D+ACA&maxResults=50&startAt=0&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -473,7 +430,7 @@ func Test_BoardService_Backlog(t *testing.T) {
 				},
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -487,10 +444,9 @@ func Test_BoardService_Backlog(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Backlog(testCase.args.ctx, testCase.args.boardId, testCase.args.opts, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Backlog(testCase.args.ctx, testCase.args.boardId, testCase.args.opts, testCase.args.startAt,
 				testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -513,7 +469,7 @@ func Test_BoardService_Backlog(t *testing.T) {
 
 func Test_BoardService_Configuration(t *testing.T) {
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -537,12 +493,13 @@ func Test_BoardService_Configuration(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/configuration",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -563,23 +520,24 @@ func Test_BoardService_Configuration(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/configuration",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardConfigurationScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -591,12 +549,13 @@ func Test_BoardService_Configuration(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/configuration",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -612,7 +571,7 @@ func Test_BoardService_Configuration(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -626,10 +585,9 @@ func Test_BoardService_Configuration(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Configuration(testCase.args.ctx, testCase.args.boardId)
+			gotResult, gotResponse, err := boardService.Configuration(testCase.args.ctx, testCase.args.boardId)
 
 			if testCase.wantErr {
 
@@ -652,7 +610,7 @@ func Test_BoardService_Configuration(t *testing.T) {
 func Test_BoardService_Epics(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -682,12 +640,13 @@ func Test_BoardService_Epics(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/epic?done=false&maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -711,23 +670,24 @@ func Test_BoardService_Epics(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/epic?done=false&maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardEpicPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -742,12 +702,13 @@ func Test_BoardService_Epics(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1001/epic?done=false&maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -763,7 +724,7 @@ func Test_BoardService_Epics(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -777,10 +738,9 @@ func Test_BoardService_Epics(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Epics(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Epics(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
 				testCase.args.maxResults, testCase.args.done)
 
 			if testCase.wantErr {
@@ -804,7 +764,7 @@ func Test_BoardService_Epics(t *testing.T) {
 func Test_BoardService_Delete(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -828,12 +788,13 @@ func Test_BoardService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/board/1001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -854,23 +815,24 @@ func Test_BoardService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/board/1001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					nil).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -882,12 +844,13 @@ func Test_BoardService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/board/1001",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -903,7 +866,7 @@ func Test_BoardService_Delete(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -917,10 +880,9 @@ func Test_BoardService_Delete(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResponse, err := service.Delete(testCase.args.ctx, testCase.args.boardId)
+			gotResponse, err := boardService.Delete(testCase.args.ctx, testCase.args.boardId)
 
 			if testCase.wantErr {
 
@@ -942,7 +904,7 @@ func Test_BoardService_Delete(t *testing.T) {
 func Test_BoardService_Filter(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -970,12 +932,13 @@ func Test_BoardService_Filter(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/filter/1001?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -998,23 +961,24 @@ func Test_BoardService_Filter(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/filter/1001?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1028,12 +992,13 @@ func Test_BoardService_Filter(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/filter/1001?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -1049,7 +1014,7 @@ func Test_BoardService_Filter(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoFilterIDError,
 			wantErr: true,
@@ -1063,10 +1028,9 @@ func Test_BoardService_Filter(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Filter(testCase.args.ctx, testCase.args.filterId, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Filter(testCase.args.ctx, testCase.args.filterId, testCase.args.startAt,
 				testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -1090,7 +1054,7 @@ func Test_BoardService_Filter(t *testing.T) {
 func Test_BoardService_Gets(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1117,12 +1081,13 @@ func Test_BoardService_Gets(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1156,7 +1121,7 @@ func Test_BoardService_Gets(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
@@ -1164,6 +1129,7 @@ func Test_BoardService_Gets(t *testing.T) {
 					"rest/agile/1.0/board?accountIdLocation=uuid-sample&expand=issues&filterId=100&includePrivate=true&"+
 						"maxResults=50&name=Sample+Name&negateLocationFiltering=true&orderBy=issues&projectKeyOrId=DUMMY&proj"+
 						"ectLocation=uuid-sample&startAt=0&type=scrum",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1185,23 +1151,24 @@ func Test_BoardService_Gets(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1214,12 +1181,13 @@ func Test_BoardService_Gets(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -1237,10 +1205,9 @@ func Test_BoardService_Gets(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Gets(testCase.args.ctx, testCase.args.opts, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Gets(testCase.args.ctx, testCase.args.opts, testCase.args.startAt,
 				testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -1264,7 +1231,7 @@ func Test_BoardService_Gets(t *testing.T) {
 func Test_BoardService_Issues(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1293,12 +1260,13 @@ func Test_BoardService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1327,12 +1295,13 @@ func Test_BoardService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/issue?expand=orders&fields=fields&jql=project+%3D+DUMMY&maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1355,23 +1324,24 @@ func Test_BoardService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardIssuePageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1385,12 +1355,13 @@ func Test_BoardService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -1408,7 +1379,7 @@ func Test_BoardService_Issues(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -1422,10 +1393,9 @@ func Test_BoardService_Issues(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Issues(testCase.args.ctx, testCase.args.boardId, testCase.args.opts,
+			gotResult, gotResponse, err := boardService.Issues(testCase.args.ctx, testCase.args.boardId, testCase.args.opts,
 				testCase.args.startAt, testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -1449,7 +1419,7 @@ func Test_BoardService_Issues(t *testing.T) {
 func Test_BoardService_IssuesByEpic(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1480,12 +1450,13 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1515,12 +1486,13 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/102/issue?expand=orders&fields=fields&jql=project+%3D+DUMMY&maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1544,23 +1516,24 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardIssuePageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1575,12 +1548,13 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -1598,7 +1572,7 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -1613,7 +1587,7 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoEpicIDError,
 			wantErr: true,
@@ -1627,10 +1601,9 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.IssuesByEpic(testCase.args.ctx, testCase.args.boardId, testCase.args.epicId,
+			gotResult, gotResponse, err := boardService.IssuesByEpic(testCase.args.ctx, testCase.args.boardId, testCase.args.epicId,
 				testCase.args.opts, testCase.args.startAt, testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -1654,7 +1627,7 @@ func Test_BoardService_IssuesByEpic(t *testing.T) {
 func Test_BoardService_IssuesBySprint(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1685,12 +1658,13 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1720,12 +1694,13 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint/102/issue?expand=orders&fields=fields&jql=project+%3D+DUMMY&maxResults=50&startAt=0&validateQuery=false",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1749,23 +1724,24 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardIssuePageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1780,12 +1756,13 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint/102/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -1803,7 +1780,7 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -1818,7 +1795,7 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -1832,10 +1809,9 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.IssuesBySprint(testCase.args.ctx, testCase.args.boardId, testCase.args.sprintId,
+			gotResult, gotResponse, err := boardService.IssuesBySprint(testCase.args.ctx, testCase.args.boardId, testCase.args.sprintId,
 				testCase.args.opts, testCase.args.startAt, testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -1859,7 +1835,7 @@ func Test_BoardService_IssuesBySprint(t *testing.T) {
 func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1888,12 +1864,13 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/none/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1922,12 +1899,13 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/none/issue?expand=orders&fields=fields&jql=project+%3D+DUMMY&maxResults=50&startAt=0&validateQuery=false",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -1950,23 +1928,24 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/none/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardIssuePageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -1980,12 +1959,13 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/epic/none/issue?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -2003,7 +1983,7 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -2017,10 +1997,9 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.IssuesWithoutEpic(testCase.args.ctx, testCase.args.boardId, testCase.args.opts,
+			gotResult, gotResponse, err := boardService.IssuesWithoutEpic(testCase.args.ctx, testCase.args.boardId, testCase.args.opts,
 				testCase.args.startAt, testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -2043,8 +2022,14 @@ func Test_BoardService_IssuesWithoutEpic(t *testing.T) {
 
 func Test_BoardService_Move(t *testing.T) {
 
+	payloadMocked := &model.BoardMovementPayloadScheme{
+		Issues:            []string{"PR-1", "10001", "PR-3"},
+		RankBeforeIssue:   "PR-4",
+		RankCustomFieldID: 10521,
+	}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -2066,28 +2051,18 @@ func Test_BoardService_Move(t *testing.T) {
 			args: args{
 				ctx:     context.Background(),
 				boardId: 1000,
-				payload: &model.BoardMovementPayloadScheme{
-					Issues:            []string{"PR-1", "10001", "PR-3"},
-					RankBeforeIssue:   "PR-4",
-					RankCustomFieldID: 10521,
-				},
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardMovementPayloadScheme{
-						Issues:            []string{"PR-1", "10001", "PR-3"},
-						RankBeforeIssue:   "PR-4",
-						RankCustomFieldID: 10521,
-					}).Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board/1000/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -2104,38 +2079,28 @@ func Test_BoardService_Move(t *testing.T) {
 			args: args{
 				ctx:     context.Background(),
 				boardId: 1000,
-				payload: &model.BoardMovementPayloadScheme{
-					Issues:            []string{"PR-1", "10001", "PR-3"},
-					RankBeforeIssue:   "PR-4",
-					RankCustomFieldID: 10521,
-				},
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardMovementPayloadScheme{
-						Issues:            []string{"PR-1", "10001", "PR-3"},
-						RankBeforeIssue:   "PR-4",
-						RankCustomFieldID: 10521,
-					}).Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board/1000/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					nil).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -2144,28 +2109,18 @@ func Test_BoardService_Move(t *testing.T) {
 			args: args{
 				ctx:     context.Background(),
 				boardId: 1000,
-				payload: &model.BoardMovementPayloadScheme{
-					Issues:            []string{"PR-1", "10001", "PR-3"},
-					RankBeforeIssue:   "PR-4",
-					RankCustomFieldID: 10521,
-				},
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.BoardMovementPayloadScheme{
-						Issues:            []string{"PR-1", "10001", "PR-3"},
-						RankBeforeIssue:   "PR-4",
-						RankCustomFieldID: 10521,
-					}).Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/board/1000/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
 				fields.c = client
@@ -2179,14 +2134,10 @@ func Test_BoardService_Move(t *testing.T) {
 			args: args{
 				ctx:     context.Background(),
 				boardId: 0,
-				payload: &model.BoardMovementPayloadScheme{
-					Issues:            []string{"PR-1", "10001", "PR-3"},
-					RankBeforeIssue:   "PR-4",
-					RankCustomFieldID: 10521,
-				},
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -2200,10 +2151,9 @@ func Test_BoardService_Move(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResponse, err := service.Move(testCase.args.ctx, testCase.args.boardId, testCase.args.payload)
+			gotResponse, err := boardService.Move(testCase.args.ctx, testCase.args.boardId, testCase.args.payload)
 
 			if testCase.wantErr {
 
@@ -2225,7 +2175,7 @@ func Test_BoardService_Move(t *testing.T) {
 func Test_BoardService_Projects(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -2251,12 +2201,13 @@ func Test_BoardService_Projects(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/project?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -2279,23 +2230,24 @@ func Test_BoardService_Projects(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/project?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardProjectPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -2309,12 +2261,13 @@ func Test_BoardService_Projects(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/project?maxResults=50&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -2332,7 +2285,7 @@ func Test_BoardService_Projects(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -2346,10 +2299,9 @@ func Test_BoardService_Projects(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Projects(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Projects(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
 				testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -2373,7 +2325,7 @@ func Test_BoardService_Projects(t *testing.T) {
 func Test_BoardService_Sprints(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -2401,12 +2353,13 @@ func Test_BoardService_Sprints(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint?maxResults=50&startAt=0&state=active",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -2430,23 +2383,24 @@ func Test_BoardService_Sprints(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint?maxResults=50&startAt=0&state=active",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardSprintPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -2461,12 +2415,13 @@ func Test_BoardService_Sprints(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/sprint?maxResults=50&startAt=0&state=active",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -2484,7 +2439,7 @@ func Test_BoardService_Sprints(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -2498,10 +2453,9 @@ func Test_BoardService_Sprints(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Sprints(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Sprints(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
 				testCase.args.maxResults, testCase.args.states)
 
 			if testCase.wantErr {
@@ -2525,7 +2479,7 @@ func Test_BoardService_Sprints(t *testing.T) {
 func Test_BoardService_Versions(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -2553,12 +2507,13 @@ func Test_BoardService_Versions(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/version?maxResults=50&released=true&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -2582,12 +2537,13 @@ func Test_BoardService_Versions(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/version?maxResults=50&released=false&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -2611,23 +2567,24 @@ func Test_BoardService_Versions(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/version?maxResults=50&released=true&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
 					&http.Request{},
 					&model.BoardVersionPageScheme{}).
-					Return(&model.ResponseScheme{}, errors.New("client: no http response found"))
+					Return(&model.ResponseScheme{}, model.ErrNotFound)
 
 				fields.c = client
 			},
-			Err:     errors.New("client: no http response found"),
+			Err:     model.ErrNotFound,
 			wantErr: true,
 		},
 
@@ -2642,12 +2599,13 @@ func Test_BoardService_Versions(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/board/1000/version?maxResults=50&released=true&startAt=0",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("client: no http request created"))
 
@@ -2665,7 +2623,7 @@ func Test_BoardService_Versions(t *testing.T) {
 				maxResults: 50,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoBoardIDError,
 			wantErr: true,
@@ -2679,10 +2637,9 @@ func Test_BoardService_Versions(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewBoardService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			boardService := NewBoardService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Versions(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
+			gotResult, gotResponse, err := boardService.Versions(testCase.args.ctx, testCase.args.boardId, testCase.args.startAt,
 				testCase.args.maxResults, testCase.args.released)
 
 			if testCase.wantErr {
diff --git a/jira/agile/internal/epic_impl_test.go b/jira/agile/internal/epic_impl_test.go
index 1c4a2b5..6188d1a 100644
--- a/jira/agile/internal/epic_impl_test.go
+++ b/jira/agile/internal/epic_impl_test.go
@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
@@ -15,7 +14,7 @@ import (
 func Test_EpicService_Get(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -39,12 +38,13 @@ func Test_EpicService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -65,12 +65,13 @@ func Test_EpicService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -93,12 +94,13 @@ func Test_EpicService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -115,7 +117,7 @@ func Test_EpicService_Get(t *testing.T) {
 				epicIdOrKey: "",
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoEpicIDError,
 			wantErr: true,
@@ -130,10 +132,9 @@ func Test_EpicService_Get(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewEpicService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			epicService := NewEpicService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Get(testCase.args.ctx, testCase.args.epicIdOrKey)
+			gotResult, gotResponse, err := epicService.Get(testCase.args.ctx, testCase.args.epicIdOrKey)
 
 			if testCase.wantErr {
 
@@ -156,7 +157,7 @@ func Test_EpicService_Get(t *testing.T) {
 func Test_EpicService_Issues(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -191,12 +192,13 @@ func Test_EpicService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1/issue?expand=changelogs&fields=status%2Csummary&jql=project+%3D+EPIC&maxResults=50&startAt=10&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -225,12 +227,13 @@ func Test_EpicService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1/issue?expand=changelogs&fields=status%2Csummary&jql=project+%3D+EPIC&maxResults=50&startAt=10&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -261,12 +264,13 @@ func Test_EpicService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/epic/EPIC-1/issue?expand=changelogs&fields=status%2Csummary&jql=project+%3D+EPIC&maxResults=50&startAt=10&validateQuery=true",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -283,7 +287,7 @@ func Test_EpicService_Issues(t *testing.T) {
 				epicIdOrKey: "",
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoEpicIDError,
 			wantErr: true,
@@ -298,10 +302,9 @@ func Test_EpicService_Issues(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewEpicService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			epicService := NewEpicService(testCase.fields.c, "1.0")
 
-			gotResult, gotResponse, err := service.Issues(testCase.args.ctx, testCase.args.epicIdOrKey, testCase.args.opts,
+			gotResult, gotResponse, err := epicService.Issues(testCase.args.ctx, testCase.args.epicIdOrKey, testCase.args.opts,
 				testCase.args.startAt, testCase.args.maxResults)
 
 			if testCase.wantErr {
@@ -324,8 +327,10 @@ func Test_EpicService_Issues(t *testing.T) {
 
 func Test_EpicService_Move(t *testing.T) {
 
+	payloadMocked := map[string]interface{}{"issues": []string{"EPIC-10"}}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -351,17 +356,14 @@ func Test_EpicService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					map[string]interface{}{"issues": []string{"EPIC-10"}}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/epic/EPIC-1/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -382,17 +384,14 @@ func Test_EpicService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					map[string]interface{}{"issues": []string{"EPIC-10"}}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/epic/EPIC-1/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -415,17 +414,14 @@ func Test_EpicService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					map[string]interface{}{"issues": []string{"EPIC-10"}}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/epic/EPIC-1/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -441,7 +437,7 @@ func Test_EpicService_Move(t *testing.T) {
 				epicIdOrKey: "",
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoEpicIDError,
 			wantErr: true,
@@ -456,10 +452,9 @@ func Test_EpicService_Move(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			service, err := NewEpicService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			epicService := NewEpicService(testCase.fields.c, "1.0")
 
-			gotResponse, err := service.Move(testCase.args.ctx, testCase.args.epicIdOrKey, testCase.args.issues)
+			gotResponse, err := epicService.Move(testCase.args.ctx, testCase.args.epicIdOrKey, testCase.args.issues)
 
 			if testCase.wantErr {
 
diff --git a/jira/agile/internal/sprint_impl_test.go b/jira/agile/internal/sprint_impl_test.go
index 2450279..0b1504a 100644
--- a/jira/agile/internal/sprint_impl_test.go
+++ b/jira/agile/internal/sprint_impl_test.go
@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
@@ -15,7 +14,7 @@ import (
 func Test_SprintService_Get(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -39,12 +38,13 @@ func Test_SprintService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -65,12 +65,13 @@ func Test_SprintService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -93,12 +94,13 @@ func Test_SprintService_Get(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -115,7 +117,7 @@ func Test_SprintService_Get(t *testing.T) {
 				sprintId: 0,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -130,8 +132,7 @@ func Test_SprintService_Get(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResult, gotResponse, err := sprintService.Get(testCase.args.ctx, testCase.args.sprintId)
 
@@ -155,8 +156,15 @@ func Test_SprintService_Get(t *testing.T) {
 
 func Test_SprintService_Create(t *testing.T) {
 
+	payloadMocked := &model.SprintPayloadScheme{
+		Name:          "Board Name Sample",
+		StartDate:     "2015-04-20T01:22:00.000+10:00",
+		EndDate:       "2015-04-11T15:22:00.000+10:00",
+		OriginBoardID: 5,
+	}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -175,32 +183,19 @@ func Test_SprintService_Create(t *testing.T) {
 		{
 			name: "when the parameters are correct",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -215,32 +210,19 @@ func Test_SprintService_Create(t *testing.T) {
 		{
 			name: "when the api cannot be executed",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -257,32 +239,19 @@ func Test_SprintService_Create(t *testing.T) {
 		{
 			name: "when the request cannot be created",
 			args: args{
-				ctx: context.Background(),
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				ctx:     context.Background(),
+				payload: payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -290,26 +259,6 @@ func Test_SprintService_Create(t *testing.T) {
 			Err:     errors.New("unable to create the http request"),
 			wantErr: true,
 		},
-
-		{
-			name: "when the payload is not provided",
-			args: args{
-				ctx:     context.Background(),
-				payload: nil,
-			},
-			on: func(fields *fields) {
-
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					(*model.SprintPayloadScheme)(nil)).
-					Return(nil, errors.New("client: no payload provided"))
-
-				fields.c = client
-			},
-			Err:     errors.New("client: no payload provided"),
-			wantErr: true,
-		},
 	}
 
 	for _, testCase := range testCases {
@@ -319,8 +268,7 @@ func Test_SprintService_Create(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResult, gotResponse, err := sprintService.Create(testCase.args.ctx, testCase.args.payload)
 
@@ -345,8 +293,15 @@ func Test_SprintService_Create(t *testing.T) {
 
 func Test_SprintService_Update(t *testing.T) {
 
+	payloadMocked := &model.SprintPayloadScheme{
+		Name:          "Board Name Sample",
+		StartDate:     "2015-04-20T01:22:00.000+10:00",
+		EndDate:       "2015-04-11T15:22:00.000+10:00",
+		OriginBoardID: 5,
+	}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -368,31 +323,18 @@ func Test_SprintService_Update(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPut,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -409,31 +351,18 @@ func Test_SprintService_Update(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPut,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -452,31 +381,18 @@ func Test_SprintService_Update(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPut,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -484,27 +400,6 @@ func Test_SprintService_Update(t *testing.T) {
 			Err:     errors.New("unable to create the http request"),
 			wantErr: true,
 		},
-
-		{
-			name: "when the payload is not provided",
-			args: args{
-				ctx:      context.Background(),
-				sprintId: 1001,
-				payload:  nil,
-			},
-			on: func(fields *fields) {
-
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					(*model.SprintPayloadScheme)(nil)).
-					Return(nil, errors.New("client: no payload provided"))
-
-				fields.c = client
-			},
-			Err:     errors.New("client: no payload provided"),
-			wantErr: true,
-		},
 	}
 
 	for _, testCase := range testCases {
@@ -514,8 +409,7 @@ func Test_SprintService_Update(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResult, gotResponse, err := sprintService.Update(testCase.args.ctx, testCase.args.sprintId, testCase.args.payload)
 
@@ -540,8 +434,15 @@ func Test_SprintService_Update(t *testing.T) {
 
 func Test_SprintService_Path(t *testing.T) {
 
+	payloadMocked := &model.SprintPayloadScheme{
+		Name:          "Board Name Sample",
+		StartDate:     "2015-04-20T01:22:00.000+10:00",
+		EndDate:       "2015-04-11T15:22:00.000+10:00",
+		OriginBoardID: 5,
+	}
+
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -563,31 +464,18 @@ func Test_SprintService_Path(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -604,31 +492,18 @@ func Test_SprintService_Path(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -647,31 +522,18 @@ func Test_SprintService_Path(t *testing.T) {
 			args: args{
 				ctx:      context.Background(),
 				sprintId: 1001,
-				payload: &model.SprintPayloadScheme{
-					Name:          "Board Name Sample",
-					StartDate:     "2015-04-20T01:22:00.000+10:00",
-					EndDate:       "2015-04-11T15:22:00.000+10:00",
-					OriginBoardID: 5,
-				},
+				payload:  payloadMocked,
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					&model.SprintPayloadScheme{
-						Name:          "Board Name Sample",
-						StartDate:     "2015-04-20T01:22:00.000+10:00",
-						EndDate:       "2015-04-11T15:22:00.000+10:00",
-						OriginBoardID: 5,
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -679,27 +541,6 @@ func Test_SprintService_Path(t *testing.T) {
 			Err:     errors.New("unable to create the http request"),
 			wantErr: true,
 		},
-
-		{
-			name: "when the payload is not provided",
-			args: args{
-				ctx:      context.Background(),
-				sprintId: 1001,
-				payload:  nil,
-			},
-			on: func(fields *fields) {
-
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					(*model.SprintPayloadScheme)(nil)).
-					Return(nil, errors.New("client: no payload provided"))
-
-				fields.c = client
-			},
-			Err:     errors.New("client: no payload provided"),
-			wantErr: true,
-		},
 	}
 
 	for _, testCase := range testCases {
@@ -709,8 +550,7 @@ func Test_SprintService_Path(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResult, gotResponse, err := sprintService.Path(testCase.args.ctx, testCase.args.sprintId, testCase.args.payload)
 
@@ -736,7 +576,7 @@ func Test_SprintService_Path(t *testing.T) {
 func Test_SprintService_Delete(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -760,12 +600,13 @@ func Test_SprintService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/sprint/1001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -784,7 +625,7 @@ func Test_SprintService_Delete(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -798,12 +639,13 @@ func Test_SprintService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/sprint/1001",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -826,12 +668,13 @@ func Test_SprintService_Delete(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodDelete,
 					"rest/agile/1.0/sprint/1001",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -849,8 +692,7 @@ func Test_SprintService_Delete(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResponse, err := sprintService.Delete(testCase.args.ctx, testCase.args.sprintId)
 
@@ -875,7 +717,7 @@ func Test_SprintService_Delete(t *testing.T) {
 func Test_SprintService_Issues(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -909,12 +751,13 @@ func Test_SprintService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001/issue?expand=changelog&fields=summary%2Cstatus&jql=project+%3D+ABC&maxResults=50&startAt=100",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -943,12 +786,13 @@ func Test_SprintService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001/issue?expand=changelog&fields=summary%2Cstatus&jql=project+%3D+ABC&maxResults=50&startAt=100",
+					"",
 					nil).
 					Return(&http.Request{}, nil)
 
@@ -979,12 +823,13 @@ func Test_SprintService_Issues(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodGet,
 					"rest/agile/1.0/sprint/10001/issue?expand=changelog&fields=summary%2Cstatus&jql=project+%3D+ABC&maxResults=50&startAt=100",
+					"",
 					nil).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
@@ -1001,7 +846,7 @@ func Test_SprintService_Issues(t *testing.T) {
 				sprintId: 0,
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -1016,8 +861,7 @@ func Test_SprintService_Issues(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResult, gotResponse, err := sprintService.Issues(testCase.args.ctx, testCase.args.sprintId, testCase.args.opts,
 				testCase.args.startAt, testCase.args.maxResults)
@@ -1043,7 +887,7 @@ func Test_SprintService_Issues(t *testing.T) {
 func Test_SprintService_Start(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1067,19 +911,14 @@ func Test_SprintService_Start(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Active",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Active"}).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1097,7 +936,7 @@ func Test_SprintService_Start(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -1111,19 +950,14 @@ func Test_SprintService_Start(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Active",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Active"}).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1145,19 +979,14 @@ func Test_SprintService_Start(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Active",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Active"}).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -1174,8 +1003,7 @@ func Test_SprintService_Start(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResponse, err := sprintService.Start(testCase.args.ctx, testCase.args.sprintId)
 
@@ -1200,7 +1028,7 @@ func Test_SprintService_Start(t *testing.T) {
 func Test_SprintService_Close(t *testing.T) {
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1224,19 +1052,14 @@ func Test_SprintService_Close(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Closed",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Closed"}).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1254,7 +1077,7 @@ func Test_SprintService_Close(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -1268,19 +1091,14 @@ func Test_SprintService_Close(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Closed",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Closed"}).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1302,19 +1120,14 @@ func Test_SprintService_Close(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					model.SprintPayloadScheme{
-						State: "Closed",
-					}).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"rest/agile/1.0/sprint/1001",
-					bytes.NewReader([]byte{})).
+					"",
+					&model.SprintPayloadScheme{State: "Closed"}).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -1331,8 +1144,7 @@ func Test_SprintService_Close(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResponse, err := sprintService.Close(testCase.args.ctx, testCase.args.sprintId)
 
@@ -1364,7 +1176,7 @@ func Test_SprintService_Move(t *testing.T) {
 	}
 
 	type fields struct {
-		c service.Client
+		c service.Connector
 	}
 
 	type args struct {
@@ -1390,17 +1202,14 @@ func Test_SprintService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"/rest/agile/1.0/sprint/1001/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1418,7 +1227,7 @@ func Test_SprintService_Move(t *testing.T) {
 				ctx: context.Background(),
 			},
 			on: func(fields *fields) {
-				fields.c = mocks.NewClient(t)
+				fields.c = mocks.NewConnector(t)
 			},
 			Err:     model.ErrNoSprintIDError,
 			wantErr: true,
@@ -1433,17 +1242,14 @@ func Test_SprintService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"/rest/agile/1.0/sprint/1001/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, nil)
 
 				client.On("Call",
@@ -1466,17 +1272,14 @@ func Test_SprintService_Move(t *testing.T) {
 			},
 			on: func(fields *fields) {
 
-				client := mocks.NewClient(t)
-
-				client.On("TransformStructToReader",
-					payloadMocked).
-					Return(bytes.NewReader([]byte{}), nil)
+				client := mocks.NewConnector(t)
 
 				client.On("NewRequest",
 					context.Background(),
 					http.MethodPost,
 					"/rest/agile/1.0/sprint/1001/issue",
-					bytes.NewReader([]byte{})).
+					"",
+					payloadMocked).
 					Return(&http.Request{}, errors.New("unable to create the http request"))
 
 				fields.c = client
@@ -1493,8 +1296,7 @@ func Test_SprintService_Move(t *testing.T) {
 				testCase.on(&testCase.fields)
 			}
 
-			sprintService, err := NewSprintService(testCase.fields.c, "1.0")
-			assert.NoError(t, err)
+			sprintService := NewSprintService(testCase.fields.c, "1.0")
 
 			gotResponse, err := sprintService.Move(testCase.args.ctx, testCase.args.sprintId, testCase.args.payload)
 
@@ -1511,7 +1313,6 @@ func Test_SprintService_Move(t *testing.T) {
 				assert.NoError(t, err)
 				assert.NotEqual(t, gotResponse, nil)
 			}
-
 		})
 	}
 }