Repository: ctreminiom/go-atlassian
Pull request #177 (2023-03-11 05:24:20)

:white_check_mark: Added the test-cases for the service declaration.


Patch:
diff --git a/pkg/infra/models/errors.go b/pkg/infra/models/errors.go
index 86ccaa4..b209699 100644
--- a/pkg/infra/models/errors.go
+++ b/pkg/infra/models/errors.go
@@ -74,6 +74,7 @@ var (
 	ErrNoOperatorError                     = errors.New("jira: no operation set")
 	ErrNoEditValueError                    = errors.New("jira: no update operation value set")
 	ErrNoCustomFieldError                  = errors.New("jira: no custom-fields set")
+	ErrNoCustomFieldIDError                = errors.New("jira: no custom-field id set")
 	ErrNoWorkflowStatusesError             = errors.New("jira: no workflow statuses set")
 	ErrNoWorkflowScopeError                = errors.New("jira: no workflow scope set")
 	ErrNoWorkflowStatusNameOrIdError       = errors.New("jira: no workflow status name or id set")
@@ -131,4 +132,7 @@ var (
 	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/pkg/infra/models/sm_request_field.go b/pkg/infra/models/sm_request_field.go
index 05e2e70..bf89544 100644
--- a/pkg/infra/models/sm_request_field.go
+++ b/pkg/infra/models/sm_request_field.go
@@ -2,7 +2,6 @@ package models
 
 import (
 	"encoding/json"
-	"fmt"
 	"github.com/imdario/mergo"
 	"time"
 )
@@ -45,7 +44,7 @@ type CustomerRequestFields struct{ Fields []map[string]interface{} }
 func (c *CustomerRequestFields) Attachments(attachments []string) error {
 
 	if len(attachments) == 0 {
-		return fmt.Errorf("error, please provide a valid attachments values")
+		return ErrNoAttachmentIdsError
 	}
 
 	var fieldNode = map[string]interface{}{}
@@ -61,7 +60,7 @@ func (c *CustomerRequestFields) Attachments(attachments []string) error {
 func (c *CustomerRequestFields) Labels(labels []string) error {
 
 	if len(labels) == 0 {
-		return fmt.Errorf("error, please provide a valid labels values")
+		return ErrNoLabelsError
 	}
 
 	var fieldNode = map[string]interface{}{}
@@ -77,7 +76,7 @@ func (c *CustomerRequestFields) Labels(labels []string) error {
 func (c *CustomerRequestFields) Components(components []string) error {
 
 	if len(components) == 0 {
-		return fmt.Errorf("error, please provide a valid components values")
+		return ErrNoComponentsError
 	}
 
 	var componentNode []map[string]interface{}
@@ -99,14 +98,14 @@ func (c *CustomerRequestFields) Components(components []string) error {
 	return nil
 }
 
-func (c *CustomerRequestFields) Groups(customFieldID string, groups []string) (err error) {
+func (c *CustomerRequestFields) Groups(customFieldID string, groups []string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(groups) == 0 {
-		return fmt.Errorf("error, please provide a valid groups value")
+		return ErrNoGroupsNameError
 	}
 
 	var groupsNode []map[string]interface{}
@@ -125,17 +124,17 @@ func (c *CustomerRequestFields) Groups(customFieldID string, groups []string) (e
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Group(customFieldID, group string) (err error) {
+func (c *CustomerRequestFields) Group(customFieldID, group string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(group) == 0 {
-		return fmt.Errorf("error, please provide a valid group value")
+		return ErrNoGroupNameError
 	}
 
 	var groupNode = map[string]interface{}{}
@@ -148,17 +147,17 @@ func (c *CustomerRequestFields) Group(customFieldID, group string) (err error) {
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) URL(customFieldID, URL string) (err error) {
+func (c *CustomerRequestFields) URL(customFieldID, URL string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(URL) == 0 {
-		return fmt.Errorf("error, please provide a valid URL value")
+		return ErrNoUrlTypeError
 	}
 
 	var urlNode = map[string]interface{}{}
@@ -168,17 +167,17 @@ func (c *CustomerRequestFields) URL(customFieldID, URL string) (err error) {
 	fieldsNode["requestFieldValues"] = urlNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Text(customFieldID, textValue string) (err error) {
+func (c *CustomerRequestFields) Text(customFieldID, textValue string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(textValue) == 0 {
-		return fmt.Errorf("error, please provide a valid textValue value")
+		return ErrNoTextTypeError
 	}
 
 	var urlNode = map[string]interface{}{}
@@ -188,17 +187,17 @@ func (c *CustomerRequestFields) Text(customFieldID, textValue string) (err error
 	fieldsNode["requestFieldValues"] = urlNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) DateTime(customFieldID string, dateValue time.Time) (err error) {
+func (c *CustomerRequestFields) DateTime(customFieldID string, dateValue time.Time) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if dateValue.IsZero() {
-		return fmt.Errorf("error, please provide a valid dateValue value")
+		return ErrNoDateTimeTypeError
 	}
 
 	var dateNode = map[string]interface{}{}
@@ -208,17 +207,17 @@ func (c *CustomerRequestFields) DateTime(customFieldID string, dateValue time.Ti
 	fieldsNode["requestFieldValues"] = dateNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Date(customFieldID string, dateTimeValue time.Time) (err error) {
+func (c *CustomerRequestFields) Date(customFieldID string, dateTimeValue time.Time) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if dateTimeValue.IsZero() {
-		return fmt.Errorf("error, please provide a valid dateValue value")
+		return ErrNoDateTypeError
 	}
 
 	var dateTimeNode = map[string]interface{}{}
@@ -228,17 +227,17 @@ func (c *CustomerRequestFields) Date(customFieldID string, dateTimeValue time.Ti
 	fieldsNode["requestFieldValues"] = dateTimeNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) MultiSelect(customFieldID string, options []string) (err error) {
+func (c *CustomerRequestFields) MultiSelect(customFieldID string, options []string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(options) == 0 {
-		return fmt.Errorf("error, please provide a valid options value")
+		return ErrNoMultiSelectTypeError
 	}
 
 	var groupsNode []map[string]interface{}
@@ -257,17 +256,17 @@ func (c *CustomerRequestFields) MultiSelect(customFieldID string, options []stri
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Select(customFieldID string, option string) (err error) {
+func (c *CustomerRequestFields) Select(customFieldID string, option string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(option) == 0 {
-		return fmt.Errorf("error, please provide a valid option value")
+		return ErrNoSelectTypeError
 	}
 
 	var selectNode = map[string]interface{}{}
@@ -280,17 +279,17 @@ func (c *CustomerRequestFields) Select(customFieldID string, option string) (err
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) RadioButton(customFieldID, button string) (err error) {
+func (c *CustomerRequestFields) RadioButton(customFieldID, button string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(button) == 0 {
-		return fmt.Errorf("error, please provide a button option value")
+		return ErrNoButtonTypeError
 	}
 
 	var selectNode = map[string]interface{}{}
@@ -303,17 +302,17 @@ func (c *CustomerRequestFields) RadioButton(customFieldID, button string) (err e
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) User(customFieldID string, accountID string) (err error) {
+func (c *CustomerRequestFields) User(customFieldID string, accountID string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(accountID) == 0 {
-		return fmt.Errorf("error, please provide a accountID option value")
+		return ErrNoUserTypeError
 	}
 
 	var userNode = map[string]interface{}{}
@@ -326,17 +325,17 @@ func (c *CustomerRequestFields) User(customFieldID string, accountID string) (er
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Users(customFieldID string, accountIDs []string) (err error) {
+func (c *CustomerRequestFields) Users(customFieldID string, accountIDs []string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(accountIDs) == 0 {
-		return fmt.Errorf("error, please provide a accountIDs value")
+		return ErrNoMultiUserTypeError
 	}
 
 	var accountsNode []map[string]interface{}
@@ -355,13 +354,13 @@ func (c *CustomerRequestFields) Users(customFieldID string, accountIDs []string)
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Number(customFieldID string, numberValue float64) (err error) {
+func (c *CustomerRequestFields) Number(customFieldID string, numberValue float64) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	var urlNode = map[string]interface{}{}
@@ -371,17 +370,17 @@ func (c *CustomerRequestFields) Number(customFieldID string, numberValue float64
 	fieldsNode["requestFieldValues"] = urlNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) CheckBox(customFieldID string, options []string) (err error) {
+func (c *CustomerRequestFields) CheckBox(customFieldID string, options []string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(options) == 0 {
-		return fmt.Errorf("error, please provide a valid options value")
+		return ErrNoCheckBoxTypeError
 	}
 
 	var groupsNode []map[string]interface{}
@@ -400,21 +399,21 @@ func (c *CustomerRequestFields) CheckBox(customFieldID string, options []string)
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }
 
-func (c *CustomerRequestFields) Cascading(customFieldID, parent, child string) (err error) {
+func (c *CustomerRequestFields) Cascading(customFieldID, parent, child string) error {
 
 	if len(customFieldID) == 0 {
-		return fmt.Errorf("error, please provide a valid customFieldID value")
+		return ErrNoCustomFieldIDError
 	}
 
 	if len(parent) == 0 {
-		return fmt.Errorf("error, please provide a parent value")
+		return ErrNoCascadingParentError
 	}
 
 	if len(child) == 0 {
-		return fmt.Errorf("error, please provide a child value")
+		return ErrNoCascadingChildError
 	}
 
 	var childNode = map[string]interface{}{}
@@ -431,5 +430,5 @@ func (c *CustomerRequestFields) Cascading(customFieldID, parent, child string) (
 	fieldsNode["requestFieldValues"] = fieldNode
 
 	c.Fields = append(c.Fields, fieldsNode)
-	return
+	return nil
 }


Test patch:
diff --git a/jira/internal/application_role_impl_test.go b/jira/internal/application_role_impl_test.go
index aa4eebf..709e97c 100644
--- a/jira/internal/application_role_impl_test.go
+++ b/jira/internal/application_role_impl_test.go
@@ -362,3 +362,56 @@ func TestApplicationRoleService_Gets(t *testing.T) {
 		})
 	}
 }
+
+func TestNewApplicationRoleService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewApplicationRoleService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/attachment_impl_test.go b/jira/internal/attachment_impl_test.go
index 6311af6..2a568da 100644
--- a/jira/internal/attachment_impl_test.go
+++ b/jira/internal/attachment_impl_test.go
@@ -919,3 +919,56 @@ func Test_internalIssueAttachmentServiceImpl_Download(t *testing.T) {
 		})
 	}
 }
+
+func TestNewIssueAttachmentService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueAttachmentService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/dashboard_impl_test.go b/jira/internal/dashboard_impl_test.go
index 792f75c..71d930a 100644
--- a/jira/internal/dashboard_impl_test.go
+++ b/jira/internal/dashboard_impl_test.go
@@ -6,11 +6,9 @@ import (
 	"errors"
 	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
 	"github.com/ctreminiom/go-atlassian/service"
-	"github.com/ctreminiom/go-atlassian/service/jira"
 	"github.com/ctreminiom/go-atlassian/service/mocks"
 	"github.com/stretchr/testify/assert"
 	"net/http"
-	"reflect"
 	"testing"
 )
 
@@ -1173,27 +1171,53 @@ func TestDashboardService_Delete(t *testing.T) {
 }
 
 func TestNewDashboardService(t *testing.T) {
+
 	type args struct {
 		client  service.Client
 		version string
 	}
-	tests := []struct {
+
+	testCases := []struct {
 		name    string
 		args    args
-		want    jira.DashboardConnector
 		wantErr bool
+		err     error
 	}{
-		// TODO: Add test cases.
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := NewDashboardService(tt.args.client, tt.args.version)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("NewDashboardService() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("NewDashboardService() got = %v, want %v", got, tt.want)
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewDashboardService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
 			}
 		})
 	}
diff --git a/jira/internal/field_configuration_impl_test.go b/jira/internal/field_configuration_impl_test.go
index 2de6f57..36f5103 100644
--- a/jira/internal/field_configuration_impl_test.go
+++ b/jira/internal/field_configuration_impl_test.go
@@ -682,3 +682,56 @@ func Test_internalIssueFieldConfigServiceImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func TestNewIssueFieldConfigurationService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldConfigurationService(testCase.args.client, testCase.args.version, nil, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/field_configuration_item_impl_test.go b/jira/internal/field_configuration_item_impl_test.go
index 7f167dd..ab7aba1 100644
--- a/jira/internal/field_configuration_item_impl_test.go
+++ b/jira/internal/field_configuration_item_impl_test.go
@@ -443,3 +443,56 @@ func Test_internalIssueFieldConfigItemServiceImpl_Update(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewIssueFieldConfigurationItemService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldConfigurationItemService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/field_configuration_scheme_test.go b/jira/internal/field_configuration_scheme_test.go
index 1bac907..d1c63c3 100644
--- a/jira/internal/field_configuration_scheme_test.go
+++ b/jira/internal/field_configuration_scheme_test.go
@@ -1460,3 +1460,56 @@ func Test_internalIssueFieldConfigSchemeServiceImpl_Unlink(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewIssueFieldConfigurationSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldConfigurationSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/field_context_option_impl_test.go b/jira/internal/field_context_option_impl_test.go
index 0366eaf..c126d75 100644
--- a/jira/internal/field_context_option_impl_test.go
+++ b/jira/internal/field_context_option_impl_test.go
@@ -1013,3 +1013,56 @@ func Test_internalIssueFieldContextOptionServiceImpl_Order(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewIssueFieldContextOptionService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldContextOptionService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/field_impl_test.go b/jira/internal/field_impl_test.go
index 6d8903e..52a429d 100644
--- a/jira/internal/field_impl_test.go
+++ b/jira/internal/field_impl_test.go
@@ -680,3 +680,56 @@ func Test_internalIssueFieldServiceImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewIssueFieldService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldService(testCase.args.client, testCase.args.version, nil, nil, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/field_trash_impl_test.go b/jira/internal/field_trash_impl_test.go
index 5f65481..80c2288 100644
--- a/jira/internal/field_trash_impl_test.go
+++ b/jira/internal/field_trash_impl_test.go
@@ -485,3 +485,56 @@ func Test_internalFieldTrashServiceImpl_Restore(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewIssueFieldTrashService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewIssueFieldTrashService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/filter_impl_test.go b/jira/internal/filter_impl_test.go
index bf353a3..08f54d5 100644
--- a/jira/internal/filter_impl_test.go
+++ b/jira/internal/filter_impl_test.go
@@ -1212,3 +1212,56 @@ func TestFilterService_Change(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewFilterService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewFilterService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/filter_share_impl_test.go b/jira/internal/filter_share_impl_test.go
index 9ccd248..f7efa28 100644
--- a/jira/internal/filter_share_impl_test.go
+++ b/jira/internal/filter_share_impl_test.go
@@ -933,3 +933,56 @@ func TestFilterShareService_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewFilterShareService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewFilterShareService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/group_impl_test.go b/jira/internal/group_impl_test.go
index 83ed9ef..1773d8b 100644
--- a/jira/internal/group_impl_test.go
+++ b/jira/internal/group_impl_test.go
@@ -959,3 +959,56 @@ func Test_internalGroupServiceImpl_Members(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewGroupService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewGroupService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/issue_impl_test.go b/jira/internal/issue_impl_test.go
new file mode 100644
index 0000000..b953367
--- /dev/null
+++ b/jira/internal/issue_impl_test.go
@@ -0,0 +1,62 @@
+package internal
+
+import (
+	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/ctreminiom/go-atlassian/service"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewIssueService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, got2, err := NewIssueService(testCase.args.client, testCase.args.version, &IssueServices{})
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+				assert.NotEqual(t, got2, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/jql_impl_test.go b/jira/internal/jql_impl_test.go
index e3fe501..e9cdf85 100644
--- a/jira/internal/jql_impl_test.go
+++ b/jira/internal/jql_impl_test.go
@@ -187,3 +187,56 @@ func Test_internalJQLServiceImpl_Parse(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewJQLService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewJQLService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/label_impl_test.go b/jira/internal/label_impl_test.go
index 47948bc..685afd1 100644
--- a/jira/internal/label_impl_test.go
+++ b/jira/internal/label_impl_test.go
@@ -147,3 +147,56 @@ func Test_internalLabelServiceImpl_Gets(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewLabelService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewLabelService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/link_impl_test.go b/jira/internal/link_impl_test.go
new file mode 100644
index 0000000..df382cf
--- /dev/null
+++ b/jira/internal/link_impl_test.go
@@ -0,0 +1,62 @@
+package internal
+
+import (
+	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/ctreminiom/go-atlassian/service"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func Test_NewLinkService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, got1, err := NewLinkService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+				assert.NotEqual(t, got1, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/link_type_impl_test.go b/jira/internal/link_type_impl_test.go
index bd83b95..77d3f8b 100644
--- a/jira/internal/link_type_impl_test.go
+++ b/jira/internal/link_type_impl_test.go
@@ -738,3 +738,56 @@ func Test_internalLinkTypeImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewLinkTypeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewLinkTypeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/metadata_impl_test.go b/jira/internal/metadata_impl_test.go
index bf7e11c..7081c73 100644
--- a/jira/internal/metadata_impl_test.go
+++ b/jira/internal/metadata_impl_test.go
@@ -324,3 +324,56 @@ func Test_internalMetadataImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewMetadataService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewMetadataService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/myself_impl_test.go b/jira/internal/myself_impl_test.go
index afb980b..b73ce76 100644
--- a/jira/internal/myself_impl_test.go
+++ b/jira/internal/myself_impl_test.go
@@ -144,3 +144,56 @@ func Test_internalMySelfImpl_Details(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewMySelfService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewMySelfService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/permission_impl_test.go b/jira/internal/permission_impl_test.go
index 66435c6..f87b62a 100644
--- a/jira/internal/permission_impl_test.go
+++ b/jira/internal/permission_impl_test.go
@@ -505,3 +505,56 @@ func Test_internalPermissionImpl_Projects(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewPermissionService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewPermissionService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/permission_scheme_grant_impl_test.go b/jira/internal/permission_scheme_grant_impl_test.go
index 8bfa806..12d4fc1 100644
--- a/jira/internal/permission_scheme_grant_impl_test.go
+++ b/jira/internal/permission_scheme_grant_impl_test.go
@@ -649,3 +649,56 @@ func TestPermissionSchemeGrantService_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewPermissionSchemeGrantService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewPermissionSchemeGrantService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/permission_scheme_impl_test.go b/jira/internal/permission_scheme_impl_test.go
index 004557d..dce9b57 100644
--- a/jira/internal/permission_scheme_impl_test.go
+++ b/jira/internal/permission_scheme_impl_test.go
@@ -770,3 +770,56 @@ func TestPermissionSchemeService_Update(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewPermissionSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewPermissionSchemeService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/priority_impl_test.go b/jira/internal/priority_impl_test.go
index f62b233..82ab7d1 100644
--- a/jira/internal/priority_impl_test.go
+++ b/jira/internal/priority_impl_test.go
@@ -285,3 +285,56 @@ func Test_internalPriorityImpl_Get(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewPriorityService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewPriorityService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_category_impl_test.go b/jira/internal/project_category_impl_test.go
index ae6f5a5..79491f1 100644
--- a/jira/internal/project_category_impl_test.go
+++ b/jira/internal/project_category_impl_test.go
@@ -745,3 +745,56 @@ func Test_internalProjectCategoryImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectCategoryService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectCategoryService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_component_impl_test.go b/jira/internal/project_component_impl_test.go
index d167cfc..306189c 100644
--- a/jira/internal/project_component_impl_test.go
+++ b/jira/internal/project_component_impl_test.go
@@ -911,3 +911,56 @@ func Test_internalProjectComponentImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectComponentService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectCategoryService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_feature_impl_test.go b/jira/internal/project_feature_impl_test.go
index de8e1c6..f33f7ed 100644
--- a/jira/internal/project_feature_impl_test.go
+++ b/jira/internal/project_feature_impl_test.go
@@ -333,3 +333,56 @@ func Test_internalProjectFeatureImpl_Gets(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectFeatureService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectFeatureService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_impl_test.go b/jira/internal/project_impl_test.go
index da64c45..9f1aa19 100644
--- a/jira/internal/project_impl_test.go
+++ b/jira/internal/project_impl_test.go
@@ -1503,3 +1503,56 @@ func Test_internalProjectImpl_NotificationScheme(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectService(testCase.args.client, testCase.args.version, &ProjectChildServices{})
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_permission_scheme_impl_test.go b/jira/internal/project_permission_scheme_impl_test.go
index 0e70b91..82ed2e6 100644
--- a/jira/internal/project_permission_scheme_impl_test.go
+++ b/jira/internal/project_permission_scheme_impl_test.go
@@ -467,3 +467,56 @@ func Test_internalProjectPermissionSchemeImpl_Assign(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectPermissionSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectPermissionSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_property_impl_test.go b/jira/internal/project_property_impl_test.go
index 0e9a175..bcdd7bc 100644
--- a/jira/internal/project_property_impl_test.go
+++ b/jira/internal/project_property_impl_test.go
@@ -652,3 +652,56 @@ func Test_internalProjectPropertyImpl_Set(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectPropertyService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectPropertyService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_role_actor_impl_test.go b/jira/internal/project_role_actor_impl_test.go
index 2df498b..35458de 100644
--- a/jira/internal/project_role_actor_impl_test.go
+++ b/jira/internal/project_role_actor_impl_test.go
@@ -361,3 +361,56 @@ func Test_internalProjectRoleActorImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectRoleActorService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectRoleActorService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_role_impl_test.go b/jira/internal/project_role_impl_test.go
index b016b25..e0d303a 100644
--- a/jira/internal/project_role_impl_test.go
+++ b/jira/internal/project_role_impl_test.go
@@ -768,3 +768,56 @@ func Test_internalProjectRoleImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectRoleService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectRoleService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_type_impl_test.go b/jira/internal/project_type_impl_test.go
index 57a07ec..cc0e5d0 100644
--- a/jira/internal/project_type_impl_test.go
+++ b/jira/internal/project_type_impl_test.go
@@ -561,3 +561,56 @@ func Test_internalProjectTypeImpl_Accessible(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectTypeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectTypeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_validator_impl_test.go b/jira/internal/project_validator_impl_test.go
index 43af441..b300d4d 100644
--- a/jira/internal/project_validator_impl_test.go
+++ b/jira/internal/project_validator_impl_test.go
@@ -442,3 +442,56 @@ func Test_internalProjectValidatorImpl_Name(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectValidatorService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectValidatorService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/project_version_impl_test.go b/jira/internal/project_version_impl_test.go
index c302d1d..885babc 100644
--- a/jira/internal/project_version_impl_test.go
+++ b/jira/internal/project_version_impl_test.go
@@ -1248,3 +1248,56 @@ func Test_internalProjectVersionImpl_Update(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewProjectVersionService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewProjectVersionService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/resolution_impl_test.go b/jira/internal/resolution_impl_test.go
index 784a723..c0aeb40 100644
--- a/jira/internal/resolution_impl_test.go
+++ b/jira/internal/resolution_impl_test.go
@@ -284,3 +284,56 @@ func Test_internalResolutionImpl_Get(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewResolutionService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewResolutionService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/screen_impl_test.go b/jira/internal/screen_impl_test.go
index 54d9764..f0f24aa 100644
--- a/jira/internal/screen_impl_test.go
+++ b/jira/internal/screen_impl_test.go
@@ -1069,3 +1069,56 @@ func Test_internalScreenImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewScreenService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewScreenService(testCase.args.client, testCase.args.version, nil, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/screen_scheme_impl_test.go b/jira/internal/screen_scheme_impl_test.go
index f434fbb..245b62f 100644
--- a/jira/internal/screen_scheme_impl_test.go
+++ b/jira/internal/screen_scheme_impl_test.go
@@ -636,3 +636,56 @@ func Test_internalScreenSchemeImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewScreenSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewScreenSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/screen_tab_field_impl_test.go b/jira/internal/screen_tab_field_impl_test.go
index cb5d78b..242be85 100644
--- a/jira/internal/screen_tab_field_impl_test.go
+++ b/jira/internal/screen_tab_field_impl_test.go
@@ -730,3 +730,56 @@ func Test_internalScreenTabFieldImpl_Move(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewScreenTabFieldService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewScreenTabFieldService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/screen_tab_impl_test.go b/jira/internal/screen_tab_impl_test.go
index ad247d6..d1e7f47 100644
--- a/jira/internal/screen_tab_impl_test.go
+++ b/jira/internal/screen_tab_impl_test.go
@@ -848,3 +848,56 @@ func Test_internalScreenTabImpl_Move(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewScreenTabService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewScreenTabService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/search_impl_test.go b/jira/internal/search_impl_test.go
new file mode 100644
index 0000000..e8e0a63
--- /dev/null
+++ b/jira/internal/search_impl_test.go
@@ -0,0 +1,61 @@
+package internal
+
+import (
+	model "github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/ctreminiom/go-atlassian/service"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func Test_NewSearchService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, _, err := NewSearchService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/server_impl_test.go b/jira/internal/server_impl_test.go
index 53d1575..baa0626 100644
--- a/jira/internal/server_impl_test.go
+++ b/jira/internal/server_impl_test.go
@@ -140,3 +140,56 @@ func Test_internalServerServiceImpl_Info(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewServerService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewServerService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/task_impl_test.go b/jira/internal/task_impl_test.go
index c7cc52e..848a43b 100644
--- a/jira/internal/task_impl_test.go
+++ b/jira/internal/task_impl_test.go
@@ -297,3 +297,56 @@ func Test_internalTaskServiceImpl_Cancel(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewTaskService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewTaskService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/type_impl_test.go b/jira/internal/type_impl_test.go
index 74d4c06..6905c72 100644
--- a/jira/internal/type_impl_test.go
+++ b/jira/internal/type_impl_test.go
@@ -871,3 +871,56 @@ func Test_internalTypeImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewTypeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewTypeService(testCase.args.client, testCase.args.version, nil, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/type_scheme_impl_test.go b/jira/internal/type_scheme_impl_test.go
index d7a82e7..6b8d2f2 100644
--- a/jira/internal/type_scheme_impl_test.go
+++ b/jira/internal/type_scheme_impl_test.go
@@ -1356,3 +1356,56 @@ func Test_internalTypeSchemeImpl_Assign(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewTypeSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewTypeSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/type_screen_scheme_impl_test.go b/jira/internal/type_screen_scheme_impl_test.go
index 2f99bc1..b69c526 100644
--- a/jira/internal/type_screen_scheme_impl_test.go
+++ b/jira/internal/type_screen_scheme_impl_test.go
@@ -1659,3 +1659,56 @@ func Test_internalTypeScreenSchemeImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewTypeScreenSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewTypeScreenSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/user_impl_test.go b/jira/internal/user_impl_test.go
index 57eb585..08bdb76 100644
--- a/jira/internal/user_impl_test.go
+++ b/jira/internal/user_impl_test.go
@@ -883,3 +883,56 @@ func Test_internalUserImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewUserService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewUserService(testCase.args.client, testCase.args.version, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/user_search_impl_test.go b/jira/internal/user_search_impl_test.go
index e862a31..597212c 100644
--- a/jira/internal/user_search_impl_test.go
+++ b/jira/internal/user_search_impl_test.go
@@ -489,3 +489,56 @@ func Test_internalUserSearchImpl_Check(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewUserSearchService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewUserSearchService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/vote_impl_test.go b/jira/internal/vote_impl_test.go
index 7b538c9..2ac4b09 100644
--- a/jira/internal/vote_impl_test.go
+++ b/jira/internal/vote_impl_test.go
@@ -443,3 +443,56 @@ func Test_internalVoteImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewVoteService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewVoteService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/watcher_impl_test.go b/jira/internal/watcher_impl_test.go
index 12d5933..18d7bcc 100644
--- a/jira/internal/watcher_impl_test.go
+++ b/jira/internal/watcher_impl_test.go
@@ -459,3 +459,56 @@ func Test_internalWatcherImpl_Delete(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWatcherService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWatcherService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/workflow_impl_test.go b/jira/internal/workflow_impl_test.go
index 1824b1f..83311af 100644
--- a/jira/internal/workflow_impl_test.go
+++ b/jira/internal/workflow_impl_test.go
@@ -482,3 +482,56 @@ func Test_internalWorkflowImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWorkflowService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWorkflowService(testCase.args.client, testCase.args.version, nil, nil)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/workflow_scheme_impl_test.go b/jira/internal/workflow_scheme_impl_test.go
index 4be9b4c..31ff2bf 100644
--- a/jira/internal/workflow_scheme_impl_test.go
+++ b/jira/internal/workflow_scheme_impl_test.go
@@ -1082,3 +1082,56 @@ func Test_internalWorkflowSchemeImpl_Create(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWorkflowSchemeService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWorkflowSchemeService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/workflow_status_impl_test.go b/jira/internal/workflow_status_impl_test.go
index f9a08ac..d970d27 100644
--- a/jira/internal/workflow_status_impl_test.go
+++ b/jira/internal/workflow_status_impl_test.go
@@ -1102,3 +1102,56 @@ func Test_internalWorkflowStatusImpl_Get(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWorkflowStatusService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWorkflowStatusService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/worklog_impl_adf_test.go b/jira/internal/worklog_impl_adf_test.go
index d4d27a9..4927145 100644
--- a/jira/internal/worklog_impl_adf_test.go
+++ b/jira/internal/worklog_impl_adf_test.go
@@ -1447,3 +1447,56 @@ func Test_internalWorklogAdfImpl_Update(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWorklogADFService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWorklogADFService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/jira/internal/worklog_impl_rich_text_test.go b/jira/internal/worklog_impl_rich_text_test.go
index 02eb931..f348578 100644
--- a/jira/internal/worklog_impl_rich_text_test.go
+++ b/jira/internal/worklog_impl_rich_text_test.go
@@ -1419,3 +1419,56 @@ func Test_internalWorklogRichTextImpl_Update(t *testing.T) {
 		})
 	}
 }
+
+func Test_NewWorklogRichTextService(t *testing.T) {
+
+	type args struct {
+		client  service.Client
+		version string
+	}
+
+	testCases := []struct {
+		name    string
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name: "when the parameters are correct",
+			args: args{
+				client:  nil,
+				version: "3",
+			},
+			wantErr: false,
+		},
+
+		{
+			name: "when the version is not provided",
+			args: args{
+				client:  nil,
+				version: "",
+			},
+			wantErr: true,
+			err:     model.ErrNoVersionProvided,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewWorklogRichTextService(testCase.args.client, testCase.args.version)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, got, nil)
+			}
+		})
+	}
+}
diff --git a/pkg/infra/models/sm_request_field_test.go b/pkg/infra/models/sm_request_field_test.go
new file mode 100644
index 0000000..91a4976
--- /dev/null
+++ b/pkg/infra/models/sm_request_field_test.go
@@ -0,0 +1,1173 @@
+package models
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestCustomerRequestFields_Attachments(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		attachments []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				attachments: []string{"uuid-sample"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the attachments are not provided",
+			fields: fields{},
+			args: args{
+				attachments: nil,
+			},
+			wantErr: true,
+			err:     ErrNoAttachmentIdsError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Attachments(testCase.args.attachments)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Labels(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		labels []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				labels: []string{"label-sample"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the labels are not provided",
+			fields: fields{},
+			args: args{
+				labels: nil,
+			},
+			wantErr: true,
+			err:     ErrNoLabelsError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Labels(testCase.args.labels)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Components(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		components []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				components: []string{"component-sample"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the components are not provided",
+			fields: fields{},
+			args: args{
+				components: nil,
+			},
+			wantErr: true,
+			err:     ErrNoComponentsError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Components(testCase.args.components)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Groups(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		groups        []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				groups:        []string{"group-sample"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				groups:        []string{"group-sample"},
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the groups are not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				groups:        nil,
+			},
+			wantErr: true,
+			err:     ErrNoGroupsNameError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Groups(testCase.args.customFieldID, testCase.args.groups)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Group(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		group         string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				group:         "group-sample",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				group:         "group-sample",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the group is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				group:         "",
+			},
+			wantErr: true,
+			err:     ErrNoGroupNameError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Group(testCase.args.customFieldID, testCase.args.group)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_URL(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		url           string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				url:           "url-sample",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				url:           "url-sample",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the url is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				url:           "",
+			},
+			wantErr: true,
+			err:     ErrNoUrlTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.URL(testCase.args.customFieldID, testCase.args.url)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Text(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		textValue     string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				textValue:     "text-sample",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				textValue:     "url-sample",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the text is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				textValue:     "",
+			},
+			wantErr: true,
+			err:     ErrNoTextTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Text(testCase.args.customFieldID, testCase.args.textValue)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_DateTime(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		dateValue     time.Time
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				dateValue:     time.Now().AddDate(0, -1, 0),
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				dateValue:     time.Now().AddDate(0, -1, 0),
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the date-time is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+			},
+			wantErr: true,
+			err:     ErrNoDateTimeTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.DateTime(testCase.args.customFieldID, testCase.args.dateValue)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Date(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		dateValue     time.Time
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				dateValue:     time.Now().AddDate(0, -1, 0),
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				dateValue:     time.Now().AddDate(0, -1, 0),
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the date-time is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+			},
+			wantErr: true,
+			err:     ErrNoDateTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Date(testCase.args.customFieldID, testCase.args.dateValue)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_MultiSelect(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		options       []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				options:       []string{"option-1"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				options:       []string{"option-1"},
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the groups are not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				options:       nil,
+			},
+			wantErr: true,
+			err:     ErrNoMultiSelectTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.MultiSelect(testCase.args.customFieldID, testCase.args.options)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Select(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		option        string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				option:        "option-sample",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				option:        "option-sample",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the group is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				option:        "",
+			},
+			wantErr: true,
+			err:     ErrNoSelectTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Select(testCase.args.customFieldID, testCase.args.option)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_RadioButton(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		option        string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				option:        "option-sample",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				option:        "option-sample",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the group is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				option:        "",
+			},
+			wantErr: true,
+			err:     ErrNoButtonTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.RadioButton(testCase.args.customFieldID, testCase.args.option)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_User(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		accountID     string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				accountID:     "account-id-sample-uuid",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				accountID:     "account-id-sample-uuid",
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the group is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				accountID:     "",
+			},
+			wantErr: true,
+			err:     ErrNoUserTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.User(testCase.args.customFieldID, testCase.args.accountID)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Users(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		accountIDs    []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				accountIDs:    []string{"account-id-sample-uuid"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				accountIDs:    []string{"account-id-sample-uuid"},
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the group is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				accountIDs:    nil,
+			},
+			wantErr: true,
+			err:     ErrNoMultiUserTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Users(testCase.args.customFieldID, testCase.args.accountIDs)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Number(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		numberValue   float64
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				numberValue:   10000.232,
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				numberValue:   10000.232,
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Number(testCase.args.customFieldID, testCase.args.numberValue)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_CheckBox(t *testing.T) {
+
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		options       []string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				options:       []string{"option-1"},
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the customfield is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				options:       []string{"option-1"},
+			},
+			wantErr: true,
+			err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the groups are not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10000",
+				options:       nil,
+			},
+			wantErr: true,
+			err:     ErrNoCheckBoxTypeError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.CheckBox(testCase.args.customFieldID, testCase.args.options)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}
+
+func TestCustomerRequestFields_Cascading(t *testing.T) {
+	type fields struct {
+		Fields []map[string]interface{}
+	}
+	type args struct {
+		customFieldID string
+		parent        string
+		child         string
+	}
+	testCases := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		Err     error
+	}{
+		{
+			name:   "when the parameters are correct",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10001",
+				parent:        "America",
+				child:         "US",
+			},
+			wantErr: false,
+		},
+
+		{
+			name:   "when the custom-field is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "",
+				parent:        "America",
+				child:         "US",
+			},
+			wantErr: true,
+			Err:     ErrNoCustomFieldIDError,
+		},
+
+		{
+			name:   "when the parent value is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10001",
+				parent:        "",
+				child:         "US",
+			},
+			wantErr: true,
+			Err:     ErrNoCascadingParentError,
+		},
+
+		{
+			name:   "when the child value is not provided",
+			fields: fields{},
+			args: args{
+				customFieldID: "customfield_10001",
+				parent:        "America",
+				child:         "",
+			},
+			wantErr: true,
+			Err:     ErrNoCascadingChildError,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			c := &CustomerRequestFields{
+				Fields: testCase.fields.Fields,
+			}
+
+			err := c.Cascading(testCase.args.customFieldID, testCase.args.parent, testCase.args.child)
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+				assert.EqualError(t, err, testCase.Err.Error())
+
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}