Repository: ctreminiom/go-atlassian
Pull request #95 (2022-01-05 07:41:23)

:building_construction: Parsed more structures on the Confluence Spac…
…eScheme


Patch:
diff --git a/jira/mocks/create-field-configuration-scheme.json b/jira/mocks/create-field-configuration-scheme.json
new file mode 100644
index 0000000..d300c99
--- /dev/null
+++ b/jira/mocks/create-field-configuration-scheme.json
@@ -0,0 +1,5 @@
+{
+  "id": "10002",
+  "name": "Field Configuration Scheme for software related projects",
+  "description": "We can use this one for software projects."
+}
\ No newline at end of file
diff --git a/jira/mocks/get-field-configuration-mapping.json b/jira/mocks/get-field-configuration-mapping.json
new file mode 100644
index 0000000..bd7c957
--- /dev/null
+++ b/jira/mocks/get-field-configuration-mapping.json
@@ -0,0 +1,33 @@
+{
+  "maxResults": 100,
+  "startAt": 0,
+  "total": 5,
+  "isLast": true,
+  "values": [
+    {
+      "fieldConfigurationSchemeId": "10020",
+      "issueTypeId": "10000",
+      "fieldConfigurationId": "10010"
+    },
+    {
+      "fieldConfigurationSchemeId": "10020",
+      "issueTypeId": "10001",
+      "fieldConfigurationId": "10010"
+    },
+    {
+      "fieldConfigurationSchemeId": "10021",
+      "issueTypeId": "10002",
+      "fieldConfigurationId": "10000"
+    },
+    {
+      "fieldConfigurationSchemeId": "10022",
+      "issueTypeId": "default",
+      "fieldConfigurationId": "10011"
+    },
+    {
+      "fieldConfigurationSchemeId": "10023",
+      "issueTypeId": "default",
+      "fieldConfigurationId": "10000"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/jira/mocks/get-field-configuration-schemes-projects.json b/jira/mocks/get-field-configuration-schemes-projects.json
new file mode 100644
index 0000000..eca2576
--- /dev/null
+++ b/jira/mocks/get-field-configuration-schemes-projects.json
@@ -0,0 +1,26 @@
+{
+  "maxResults": 50,
+  "startAt": 0,
+  "total": 5,
+  "isLast": true,
+  "values": [
+    {
+      "projectIds": [
+        "10",
+        "11"
+      ]
+    },
+    {
+      "fieldConfigurationScheme": {
+        "id": "10002",
+        "name": "Field Configuration Scheme for software related projects",
+        "description": "We can use this one for software projects."
+      },
+      "projectIds": [
+        "12",
+        "13",
+        "14"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/jira/mocks/get-field-configuration-schemes.json b/jira/mocks/get-field-configuration-schemes.json
new file mode 100644
index 0000000..7bc69f8
--- /dev/null
+++ b/jira/mocks/get-field-configuration-schemes.json
@@ -0,0 +1,23 @@
+{
+  "maxResults": 10,
+  "startAt": 0,
+  "total": 3,
+  "isLast": true,
+  "values": [
+    {
+      "id": "10000",
+      "name": "Field Configuration Scheme for Bugs",
+      "description": "This field configuration scheme is for bugs only."
+    },
+    {
+      "id": "10001",
+      "name": "Field Configuration Scheme for software related projects",
+      "description": "We can use this one for software projects."
+    },
+    {
+      "id": "10002",
+      "name": "Field Configuration Scheme for Epics",
+      "description": "Use this one for Epic issue type."
+    }
+  ]
+}
\ No newline at end of file
diff --git a/jira/v2/issueFieldConfiguration.go b/jira/v2/issueFieldConfiguration.go
index a24e069..b27f288 100644
--- a/jira/v2/issueFieldConfiguration.go
+++ b/jira/v2/issueFieldConfiguration.go
@@ -9,11 +9,14 @@ import (
 	"strconv"
 )
 
-type FieldConfigurationService struct{ client *Client }
+type FieldConfigurationService struct {
+	client *Client
+	Item   *FieldConfigurationItemService
+	Scheme *FieldConfigurationSchemeService
+}
 
 // Gets Returns a paginated list of all field configurations.
 // Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-all-field-configurations
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfiguration-get
 func (f *FieldConfigurationService) Gets(ctx context.Context, ids []int, isDefault bool, startAt, maxResults int) (
 	result *models.FieldConfigurationPageScheme, response *ResponseScheme, err error) {
 
@@ -45,55 +48,35 @@ func (f *FieldConfigurationService) Gets(ctx context.Context, ids []int, isDefau
 	return
 }
 
-// Items Returns a paginated list of all fields for a configuration.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-items
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfiguration-id-fields-get
-func (f *FieldConfigurationService) Items(ctx context.Context, fieldConfigurationID, startAt, maxResults int) (
-	result *models.FieldConfigurationItemPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
+// Create creates a field configuration. The field configuration is created with the same field properties as the
+// default configuration, with all the fields being optional.
+// This operation can only create configurations for use in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#create-field-configuration
+func (f *FieldConfigurationService) Create(ctx context.Context, name, description string) (result *models.FieldConfigurationScheme,
+	response *ResponseScheme, err error) {
 
-	var endpoint = fmt.Sprintf("rest/api/2/fieldconfiguration/%v/fields?%v", fieldConfigurationID, params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return
+	if name == "" {
+		return nil, nil, models.ErrNoFieldConfigurationNameError
 	}
 
-	request.Header.Set("Accept", "application/json")
-
-	response, err = f.client.call(request, &result)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// Schemes Returns a paginated list of field configuration schemes.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-all-field-configuration-schemes
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfigurationscheme-get
-func (f *FieldConfigurationService) Schemes(ctx context.Context, IDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationSchemePageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, id := range IDs {
-		params.Add("id", strconv.Itoa(id))
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
 	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := "rest/api/2/fieldconfiguration"
 
-	var endpoint = fmt.Sprintf("rest/api/2/fieldconfigurationscheme?%v", params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
 
 	response, err = f.client.call(request, &result)
 	if err != nil {
@@ -103,60 +86,41 @@ func (f *FieldConfigurationService) Schemes(ctx context.Context, IDs []int, star
 	return
 }
 
-// IssueTypeItems Returns a paginated list of field configuration issue type items.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-issue-type-items
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfigurationscheme-mapping-get
-func (f *FieldConfigurationService) IssueTypeItems(ctx context.Context, fieldConfigIDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationIssueTypeItemPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, id := range fieldConfigIDs {
-		params.Add("fieldConfigurationSchemeId", strconv.Itoa(id))
-	}
+// Update updates a field configuration. The name and the description provided in the request override the existing values.
+// This operation can only update configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#update-field-configuration
+func (f *FieldConfigurationService) Update(ctx context.Context, fieldConfigurationID int, name, description string) (
+	response *ResponseScheme, err error) {
 
-	var endpoint = fmt.Sprintf("rest/api/2/fieldconfigurationscheme/mapping?%v", params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
 	}
-	request.Header.Set("Accept", "application/json")
 
-	response, err = f.client.call(request, &result)
-	if err != nil {
-		return
+	if name == "" {
+		return nil, models.ErrNoFieldConfigurationNameError
 	}
 
-	return
-}
-
-// SchemesByProject Returns a paginated list of field configuration schemes and, for each scheme, a list of the projects that use it.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-schemes-for-projects
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfigurationscheme-project-get
-func (f *FieldConfigurationService) SchemesByProject(ctx context.Context, projectIDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationSchemeProjectPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, projectID := range projectIDs {
-		params.Add("projectId", strconv.Itoa(projectID))
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
 	}
 
-	var endpoint = fmt.Sprintf("rest/api/2/fieldconfigurationscheme/project?%v", params.Encode())
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfiguration/%v", fieldConfigurationID)
 
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
 
-	response, err = f.client.call(request, &result)
+	response, err = f.client.call(request, nil)
 	if err != nil {
 		return
 	}
@@ -164,33 +128,24 @@ func (f *FieldConfigurationService) SchemesByProject(ctx context.Context, projec
 	return
 }
 
-// Assign assigns a field configuration scheme to a project.
-// If the field configuration scheme ID is null, the operation assigns the default field configuration scheme.
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issue-field-configurations/#api-rest-api-2-fieldconfigurationscheme-project-put
-func (f *FieldConfigurationService) Assign(ctx context.Context, fieldConfigurationSchemeID, projectID string) (response *ResponseScheme, err error) {
-
-	if len(projectID) == 0 {
-		return nil, models.ErrNoProjectIDError
-	}
+// Delete deletes a field configuration.
+// This operation can only delete configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#delete-field-configuration
+func (f *FieldConfigurationService) Delete(ctx context.Context, fieldConfigurationID int) (response *ResponseScheme, err error) {
 
-	payload := struct {
-		SchemeID  string `json:"fieldConfigurationSchemeId,omitempty"`
-		ProjectID string `json:"projectId,omitempty"`
-	}{
-		SchemeID:  fieldConfigurationSchemeID,
-		ProjectID: projectID,
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
 	}
 
-	payloadAsReader, _ := transformStructToReader(&payload)
-	var endpoint = "rest/api/2/fieldconfigurationscheme/project"
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfiguration/%v", fieldConfigurationID)
 
-	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	request, err := f.client.newRequest(ctx, http.MethodDelete, endpoint, nil)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
-	request.Header.Set("Content-Type", "application/json")
 
 	response, err = f.client.call(request, nil)
 	if err != nil {
diff --git a/jira/v2/issueFieldConfigurationItem.go b/jira/v2/issueFieldConfigurationItem.go
new file mode 100644
index 0000000..b202a67
--- /dev/null
+++ b/jira/v2/issueFieldConfigurationItem.go
@@ -0,0 +1,77 @@
+package v2
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+type FieldConfigurationItemService struct{ client *Client }
+
+// Gets Returns a paginated list of all fields for a configuration.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/items#get-field-configuration-items
+func (f *FieldConfigurationItemService) Gets(ctx context.Context, fieldConfigurationID, startAt, maxResults int) (
+	result *models.FieldConfigurationItemPageScheme, response *ResponseScheme, err error) {
+
+	if fieldConfigurationID == 0 {
+		return nil, nil, models.ErrNoFieldConfigurationIDError
+	}
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	var endpoint = fmt.Sprintf("rest/api/2/fieldconfiguration/%v/fields?%v", fieldConfigurationID, params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Update updates fields in a field configuration. The properties of the field configuration fields provided
+// override the existing values.
+// This operation can only update field configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/items#update-field-configuration-items
+func (f *FieldConfigurationItemService) Update(ctx context.Context, fieldConfigurationID int, payload *models.UpdateFieldConfigurationItemPayloadScheme) (
+	response *ResponseScheme, err error) {
+
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
+	}
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfiguration/%v/fields", fieldConfigurationID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
diff --git a/jira/v2/issueFieldConfigurationScheme.go b/jira/v2/issueFieldConfigurationScheme.go
new file mode 100644
index 0000000..a596af6
--- /dev/null
+++ b/jira/v2/issueFieldConfigurationScheme.go
@@ -0,0 +1,309 @@
+package v2
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+type FieldConfigurationSchemeService struct{ client *Client }
+
+// Gets returns a paginated list of field configuration schemes.
+// Only field configuration schemes used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-schemes
+func (f *FieldConfigurationSchemeService) Gets(ctx context.Context, ids []int, startAt, maxResults int) (
+	result *models.FieldConfigurationSchemePageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, id := range ids {
+		params.Add("id", strconv.Itoa(id))
+	}
+
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfigurationscheme?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Create creates a field configuration scheme.
+// This operation can only create field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#create-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Create(ctx context.Context, name, description string) (
+	result *models.FieldConfigurationSchemeScheme, response *ResponseScheme, err error) {
+
+	if name == "" {
+		return nil, nil, models.ErrNoFieldConfigurationSchemeNameError
+	}
+
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
+	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := "rest/api/2/fieldconfigurationscheme"
+
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Mapping returns a paginated list of field configuration issue type items.
+// Only items used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-scheme-mapping
+func (f *FieldConfigurationSchemeService) Mapping(ctx context.Context, fieldConfigIDs []int, startAt, maxResults int) (
+	result *models.FieldConfigurationIssueTypeItemPageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, id := range fieldConfigIDs {
+		params.Add("fieldConfigurationSchemeId", strconv.Itoa(id))
+	}
+
+	var endpoint = fmt.Sprintf("rest/api/2/fieldconfigurationscheme/mapping?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Project returns a paginated list of field configuration schemes and, for each scheme, a list of the projects that use it.
+// The list is sorted by field configuration scheme ID. The first item contains the list of project IDs assigned to the default field configuration scheme.
+// Only field configuration schemes used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-schemes-by-project
+func (f *FieldConfigurationSchemeService) Project(ctx context.Context, projectIDs []int, startAt, maxResults int) (
+	result *models.FieldConfigurationSchemeProjectPageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, projectID := range projectIDs {
+		params.Add("projectId", strconv.Itoa(projectID))
+	}
+
+	var endpoint = fmt.Sprintf("rest/api/2/fieldconfigurationscheme/project?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Assign assigns a field configuration scheme to a project. If the field configuration scheme ID is null,
+// the operation assigns the default field configuration scheme.
+// Field configuration schemes can only be assigned to classic projects.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#assign-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Assign(ctx context.Context, payload *models.FieldConfigurationSchemeAssignPayload) (
+	response *ResponseScheme, err error) {
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := "rest/api/2/fieldconfigurationscheme/project"
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Update updates a field configuration scheme.
+// This operation can only update field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#update-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Update(ctx context.Context, schemeID int, name, description string) (
+	response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	if name == "" {
+		return nil, models.ErrNoFieldConfigurationSchemeNameError
+	}
+
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
+	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfigurationscheme/%v", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Delete deletes a field configuration scheme.
+// This operation can only delete field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#delete-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Delete(ctx context.Context, schemeID int) (response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfigurationscheme/%v", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodDelete, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Link assigns issue types to field configurations on field configuration scheme.
+// This operation can only modify field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#assign-issue-types-to-field-configuration
+func (f *FieldConfigurationSchemeService) Link(ctx context.Context, schemeID int, payload *models.FieldConfigurationToIssueTypeMappingPayloadScheme) (
+	response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfigurationscheme/%v/mapping", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return response, err
+}
+
+// Unlink removes issue types from the field configuration scheme.
+// This operation can only modify field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#remove-issue-types-to-field-configuration
+func (f *FieldConfigurationSchemeService) Unlink(ctx context.Context, schemeID int, issueTypeIDs []string) (response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	payload := struct {
+		IssueTypeIds []string `json:"issueTypeIds"`
+	}{
+		IssueTypeIds: issueTypeIDs,
+	}
+
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfigurationscheme/%v/mapping/delete", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
diff --git a/jira/v2/jira.go b/jira/v2/jira.go
index 935858e..41f1ae1 100644
--- a/jira/v2/jira.go
+++ b/jira/v2/jira.go
@@ -88,8 +88,12 @@ func New(httpClient *http.Client, site string) (client *Client, err error) {
 			client: client,
 		},
 		Field: &FieldService{
-			client:        client,
-			Configuration: &FieldConfigurationService{client: client},
+			client: client,
+			Configuration: &FieldConfigurationService{
+				client: client,
+				Item:   &FieldConfigurationItemService{client: client},
+				Scheme: &FieldConfigurationSchemeService{client: client},
+			},
 
 			Context: &FieldContextService{
 				client: client,
diff --git a/jira/v3/issueFieldConfiguration.go b/jira/v3/issueFieldConfiguration.go
index ff8c46e..68f1e75 100644
--- a/jira/v3/issueFieldConfiguration.go
+++ b/jira/v3/issueFieldConfiguration.go
@@ -9,11 +9,14 @@ import (
 	"strconv"
 )
 
-type FieldConfigurationService struct{ client *Client }
+type FieldConfigurationService struct {
+	client *Client
+	Item   *FieldConfigurationItemService
+	Scheme *FieldConfigurationSchemeService
+}
 
 // Gets Returns a paginated list of all field configurations.
 // Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-all-field-configurations
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfiguration-get
 func (f *FieldConfigurationService) Gets(ctx context.Context, ids []int, isDefault bool, startAt, maxResults int) (
 	result *models.FieldConfigurationPageScheme, response *ResponseScheme, err error) {
 
@@ -45,55 +48,35 @@ func (f *FieldConfigurationService) Gets(ctx context.Context, ids []int, isDefau
 	return
 }
 
-// Items Returns a paginated list of all fields for a configuration.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-items
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfiguration-id-fields-get
-func (f *FieldConfigurationService) Items(ctx context.Context, fieldConfigurationID, startAt, maxResults int) (
-	result *models.FieldConfigurationItemPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
+// Create creates a field configuration. The field configuration is created with the same field properties as the
+// default configuration, with all the fields being optional.
+// This operation can only create configurations for use in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#create-field-configuration
+func (f *FieldConfigurationService) Create(ctx context.Context, name, description string) (result *models.FieldConfigurationScheme,
+	response *ResponseScheme, err error) {
 
-	var endpoint = fmt.Sprintf("rest/api/3/fieldconfiguration/%v/fields?%v", fieldConfigurationID, params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return
+	if name == "" {
+		return nil, nil, models.ErrNoFieldConfigurationNameError
 	}
 
-	request.Header.Set("Accept", "application/json")
-
-	response, err = f.client.call(request, &result)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// Schemes Returns a paginated list of field configuration schemes.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-all-field-configuration-schemes
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfigurationscheme-get
-func (f *FieldConfigurationService) Schemes(ctx context.Context, IDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationSchemePageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, id := range IDs {
-		params.Add("id", strconv.Itoa(id))
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
 	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := "rest/api/3/fieldconfiguration"
 
-	var endpoint = fmt.Sprintf("rest/api/3/fieldconfigurationscheme?%v", params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
 
 	response, err = f.client.call(request, &result)
 	if err != nil {
@@ -103,60 +86,41 @@ func (f *FieldConfigurationService) Schemes(ctx context.Context, IDs []int, star
 	return
 }
 
-// IssueTypeItems Returns a paginated list of field configuration issue type items.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-issue-type-items
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfigurationscheme-mapping-get
-func (f *FieldConfigurationService) IssueTypeItems(ctx context.Context, fieldConfigIDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationIssueTypeItemPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, id := range fieldConfigIDs {
-		params.Add("fieldConfigurationSchemeId", strconv.Itoa(id))
-	}
+// Update updates a field configuration. The name and the description provided in the request override the existing values.
+// This operation can only update configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#update-field-configuration
+func (f *FieldConfigurationService) Update(ctx context.Context, fieldConfigurationID int, name, description string) (
+	response *ResponseScheme, err error) {
 
-	var endpoint = fmt.Sprintf("rest/api/3/fieldconfigurationscheme/mapping?%v", params.Encode())
-
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
 	}
-	request.Header.Set("Accept", "application/json")
 
-	response, err = f.client.call(request, &result)
-	if err != nil {
-		return
+	if name == "" {
+		return nil, models.ErrNoFieldConfigurationNameError
 	}
 
-	return
-}
-
-// SchemesByProject Returns a paginated list of field configuration schemes and, for each scheme, a list of the projects that use it.
-// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#get-field-configuration-schemes-for-projects
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfigurationscheme-project-get
-func (f *FieldConfigurationService) SchemesByProject(ctx context.Context, projectIDs []int, startAt, maxResults int) (
-	result *models.FieldConfigurationSchemeProjectPageScheme, response *ResponseScheme, err error) {
-
-	params := url.Values{}
-	params.Add("startAt", strconv.Itoa(startAt))
-	params.Add("maxResults", strconv.Itoa(maxResults))
-
-	for _, projectID := range projectIDs {
-		params.Add("projectId", strconv.Itoa(projectID))
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
 	}
 
-	var endpoint = fmt.Sprintf("rest/api/3/fieldconfigurationscheme/project?%v", params.Encode())
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfiguration/%v", fieldConfigurationID)
 
-	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
 
-	response, err = f.client.call(request, &result)
+	response, err = f.client.call(request, nil)
 	if err != nil {
 		return
 	}
@@ -164,33 +128,24 @@ func (f *FieldConfigurationService) SchemesByProject(ctx context.Context, projec
 	return
 }
 
-// Assign assigns a field configuration scheme to a project.
-// If the field configuration scheme ID is null, the operation assigns the default field configuration scheme.
-// Official Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfigurationscheme-project-put
-func (f *FieldConfigurationService) Assign(ctx context.Context, fieldConfigurationSchemeID, projectID string) (response *ResponseScheme, err error) {
-
-	if len(projectID) == 0 {
-		return nil, models.ErrNoProjectIDError
-	}
+// Delete deletes a field configuration.
+// This operation can only delete configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration#delete-field-configuration
+func (f *FieldConfigurationService) Delete(ctx context.Context, fieldConfigurationID int) (response *ResponseScheme, err error) {
 
-	payload := struct {
-		SchemeID  string `json:"fieldConfigurationSchemeId,omitempty"`
-		ProjectID string `json:"projectId,omitempty"`
-	}{
-		SchemeID:  fieldConfigurationSchemeID,
-		ProjectID: projectID,
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
 	}
 
-	payloadAsReader, _ := transformStructToReader(&payload)
-	var endpoint = "rest/api/3/fieldconfigurationscheme/project"
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfiguration/%v", fieldConfigurationID)
 
-	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	request, err := f.client.newRequest(ctx, http.MethodDelete, endpoint, nil)
 	if err != nil {
 		return
 	}
 
 	request.Header.Set("Accept", "application/json")
-	request.Header.Set("Content-Type", "application/json")
 
 	response, err = f.client.call(request, nil)
 	if err != nil {
diff --git a/jira/v3/issueFieldConfigurationItem.go b/jira/v3/issueFieldConfigurationItem.go
new file mode 100644
index 0000000..9dc9b93
--- /dev/null
+++ b/jira/v3/issueFieldConfigurationItem.go
@@ -0,0 +1,77 @@
+package v3
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+type FieldConfigurationItemService struct{ client *Client }
+
+// Gets Returns a paginated list of all fields for a configuration.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/items#get-field-configuration-items
+func (f *FieldConfigurationItemService) Gets(ctx context.Context, fieldConfigurationID, startAt, maxResults int) (
+	result *models.FieldConfigurationItemPageScheme, response *ResponseScheme, err error) {
+
+	if fieldConfigurationID == 0 {
+		return nil, nil, models.ErrNoFieldConfigurationIDError
+	}
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	var endpoint = fmt.Sprintf("rest/api/2/fieldconfiguration/%v/fields?%v", fieldConfigurationID, params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Update updates fields in a field configuration. The properties of the field configuration fields provided
+// override the existing values.
+// This operation can only update field configurations used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/items#update-field-configuration-items
+func (f *FieldConfigurationItemService) Update(ctx context.Context, fieldConfigurationID int, payload *models.UpdateFieldConfigurationItemPayloadScheme) (
+	response *ResponseScheme, err error) {
+
+	if fieldConfigurationID == 0 {
+		return nil, models.ErrNoFieldConfigurationIDError
+	}
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := fmt.Sprintf("rest/api/2/fieldconfiguration/%v/fields", fieldConfigurationID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
diff --git a/jira/v3/issueFieldConfigurationScheme.go b/jira/v3/issueFieldConfigurationScheme.go
new file mode 100644
index 0000000..e3890e9
--- /dev/null
+++ b/jira/v3/issueFieldConfigurationScheme.go
@@ -0,0 +1,310 @@
+package v3
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+type FieldConfigurationSchemeService struct{ client *Client }
+
+// Gets returns a paginated list of field configuration schemes.
+// Only field configuration schemes used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-schemes
+func (f *FieldConfigurationSchemeService) Gets(ctx context.Context, ids []int, startAt, maxResults int) (
+	result *models.FieldConfigurationSchemePageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, id := range ids {
+		params.Add("id", strconv.Itoa(id))
+	}
+
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfigurationscheme?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Create creates a field configuration scheme.
+// This operation can only create field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#create-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Create(ctx context.Context, name, description string) (
+	result *models.FieldConfigurationSchemeScheme, response *ResponseScheme, err error) {
+
+	if name == "" {
+		return nil, nil, models.ErrNoFieldConfigurationSchemeNameError
+	}
+
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
+	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := "rest/api/3/fieldconfigurationscheme"
+
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Mapping returns a paginated list of field configuration issue type items.
+// Only items used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-scheme-mapping
+func (f *FieldConfigurationSchemeService) Mapping(ctx context.Context, fieldConfigIDs []int, startAt, maxResults int) (
+	result *models.FieldConfigurationIssueTypeItemPageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, id := range fieldConfigIDs {
+		params.Add("fieldConfigurationSchemeId", strconv.Itoa(id))
+	}
+
+	var endpoint = fmt.Sprintf("rest/api/3/fieldconfigurationscheme/mapping?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Project returns a paginated list of field configuration schemes and, for each scheme, a list of the projects that use it.
+// The list is sorted by field configuration scheme ID. The first item contains the list of project IDs assigned to the default field configuration scheme.
+// Only field configuration schemes used in classic projects are returned.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#get-field-configuration-schemes-by-project
+func (f *FieldConfigurationSchemeService) Project(ctx context.Context, projectIDs []int, startAt, maxResults int) (
+	result *models.FieldConfigurationSchemeProjectPageScheme, response *ResponseScheme, err error) {
+
+	params := url.Values{}
+	params.Add("startAt", strconv.Itoa(startAt))
+	params.Add("maxResults", strconv.Itoa(maxResults))
+
+	for _, projectID := range projectIDs {
+		params.Add("projectId", strconv.Itoa(projectID))
+	}
+
+	var endpoint = fmt.Sprintf("rest/api/3/fieldconfigurationscheme/project?%v", params.Encode())
+
+	request, err := f.client.newRequest(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, &result)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Assign assigns a field configuration scheme to a project. If the field configuration scheme ID is null,
+// the operation assigns the default field configuration scheme.
+// Field configuration schemes can only be assigned to classic projects.
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#assign-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Assign(ctx context.Context, payload *models.FieldConfigurationSchemeAssignPayload) (
+	response *ResponseScheme, err error) {
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := "rest/api/3/fieldconfigurationscheme/project"
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Update updates a field configuration scheme.
+// This operation can only update field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#update-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Update(ctx context.Context, schemeID int, name, description string) (
+	response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	if name == "" {
+		return nil, models.ErrNoFieldConfigurationSchemeNameError
+	}
+
+	payload := struct {
+		Name        string `json:"name"`
+		Description string `json:"description,omitempty"`
+	}{
+		Name:        name,
+		Description: description,
+	}
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfigurationscheme/%v", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Delete deletes a field configuration scheme.
+// This operation can only delete field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#delete-field-configuration-scheme
+func (f *FieldConfigurationSchemeService) Delete(ctx context.Context, schemeID int) (response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfigurationscheme/%v", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodDelete, endpoint, nil)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// Link assigns issue types to field configurations on field configuration scheme.
+// This operation can only modify field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#assign-issue-types-to-field-configuration
+func (f *FieldConfigurationSchemeService) Link(ctx context.Context, schemeID int, payload *models.FieldConfigurationToIssueTypeMappingPayloadScheme) (
+	response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	payloadAsReader, err := transformStructToReader(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfigurationscheme/%v/mapping", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPut, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return response, err
+}
+
+// Unlink removes issue types from the field configuration scheme.
+// This operation can only modify field configuration schemes used in company-managed (classic) projects.
+// EXPERIMENTAL
+// Docs: https://docs.go-atlassian.io/jira-software-cloud/issues/fields/configuration/schemes#remove-issue-types-to-field-configuration
+func (f *FieldConfigurationSchemeService) Unlink(ctx context.Context, schemeID int, issueTypeIDs []string) (
+	response *ResponseScheme, err error) {
+
+	if schemeID == 0 {
+		return nil, models.ErrNoFieldConfigurationSchemeIDError
+	}
+
+	payload := struct {
+		IssueTypeIds []string `json:"issueTypeIds"`
+	}{
+		IssueTypeIds: issueTypeIDs,
+	}
+
+	payloadAsReader, _ := transformStructToReader(&payload)
+	endpoint := fmt.Sprintf("rest/api/3/fieldconfigurationscheme/%v/mapping/delete", schemeID)
+
+	request, err := f.client.newRequest(ctx, http.MethodPost, endpoint, payloadAsReader)
+	if err != nil {
+		return
+	}
+
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err = f.client.call(request, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
diff --git a/jira/v3/jira.go b/jira/v3/jira.go
index fe682b8..8df437a 100644
--- a/jira/v3/jira.go
+++ b/jira/v3/jira.go
@@ -90,8 +90,12 @@ func New(httpClient *http.Client, site string) (client *Client, err error) {
 			client: client,
 		},
 		Field: &FieldService{
-			client:        client,
-			Configuration: &FieldConfigurationService{client: client},
+			client: client,
+			Configuration: &FieldConfigurationService{
+				client: client,
+				Item:   &FieldConfigurationItemService{client: client},
+				Scheme: &FieldConfigurationSchemeService{client: client},
+			},
 
 			Context: &FieldContextService{
 				client: client,
diff --git a/jira/v3/mocks/get-field-configuration.json b/jira/v3/mocks/get-field-configuration.json
new file mode 100644
index 0000000..b6d5bbb
--- /dev/null
+++ b/jira/v3/mocks/get-field-configuration.json
@@ -0,0 +1,5 @@
+{
+  "id": 10001,
+  "name": "My Field Configuration",
+  "description": "My field configuration description"
+}
\ No newline at end of file
diff --git a/pkg/infra/models/confluence_content.go b/pkg/infra/models/confluence_content.go
index a62ce2b..c0819d7 100644
--- a/pkg/infra/models/confluence_content.go
+++ b/pkg/infra/models/confluence_content.go
@@ -18,14 +18,15 @@ type ContentPageScheme struct {
 }
 
 type LinkScheme struct {
-	Base     string `json:"base,omitempty"`
-	Context  string `json:"context,omitempty"`
-	Self     string `json:"self,omitempty"`
-	Tinyui   string `json:"tinyui,omitempty"`
-	Editui   string `json:"editui,omitempty"`
-	Webui    string `json:"webui,omitempty"`
-	Download string `json:"download,omitempty"`
-	Next     string `json:"next"`
+	Base       string `json:"base,omitempty"`
+	Context    string `json:"context,omitempty"`
+	Self       string `json:"self,omitempty"`
+	Tinyui     string `json:"tinyui,omitempty"`
+	Editui     string `json:"editui,omitempty"`
+	Webui      string `json:"webui,omitempty"`
+	Download   string `json:"download,omitempty"`
+	Next       string `json:"next"`
+	Collection string `json:"collection"`
 }
 
 type ContentScheme struct {
diff --git a/pkg/infra/models/confluence_space.go b/pkg/infra/models/confluence_space.go
index 8217d9c..80b1a2f 100644
--- a/pkg/infra/models/confluence_space.go
+++ b/pkg/infra/models/confluence_space.go
@@ -1,13 +1,27 @@
 package models
 
 type SpaceScheme struct {
-	ID         int               `json:"id"`
-	Key        string            `json:"key"`
-	Name       string            `json:"name"`
-	Type       string            `json:"type"`
-	Status     string            `json:"status"`
-	Expandable *ExpandableScheme `json:"_expandable"`
-	Links      *LinkScheme       `json:"_links"`
+	ID          int                      `json:"id,omitempty"`
+	Key         string                   `json:"key,omitempty"`
+	Name        string                   `json:"name,omitempty"`
+	Type        string                   `json:"type,omitempty"`
+	Status      string                   `json:"status,omitempty"`
+	HomePage    *ContentScheme           `json:"homepage,omitempty"`
+	Operations  *[]SpaceOperationScheme  `json:"operations,omitempty"`
+	Permissions []*SpacePermissionScheme `json:"permissions,omitempty"`
+	History     *SpaceHistoryScheme      `json:"history,omitempty"`
+	Expandable  *ExpandableScheme        `json:"_expandable,omitempty"`
+	Links       *LinkScheme              `json:"_links,omitempty"`
+}
+
+type SpaceHistoryScheme struct {
+	CreatedDate string             `json:"createdDate,omitempty"`
+	CreatedBy   *ContentUserScheme `json:"createdBy,omitempty"`
+}
+
+type SpaceOperationScheme struct {
+	Operation  string `json:"operation,omitempty"`
+	TargetType string `json:"targetType,omitempty"`
 }
 
 type SpacePageScheme struct {
@@ -51,8 +65,10 @@ type CreateSpaceDescriptionPlainScheme struct {
 }
 
 type SpacePermissionScheme struct {
-	Subject   *SubjectPermissionScheme   `json:"subject,omitempty"`
-	Operation *OperationPermissionScheme `json:"operation,omitempty"`
+	Subject          *SubjectPermissionScheme   `json:"subject,omitempty"`
+	Operation        *OperationPermissionScheme `json:"operation,omitempty"`
+	AnonymousAccess  bool                       `json:"anonymousAccess,omitempty"`
+	UnlicensedAccess bool                       `json:"unlicensedAccess,omitempty"`
 }
 
 type OperationPermissionScheme struct {
@@ -61,12 +77,8 @@ type OperationPermissionScheme struct {
 }
 
 type SubjectPermissionScheme struct {
-	User       *UserPermissionScheme  `json:"user,omitempty"`
-	Group      *GroupPermissionScheme `json:"group,omitempty"`
-	Expandable struct {
-		User  string `json:"user,omitempty"`
-		Group string `json:"group,omitempty"`
-	} `json:"_expandable,omitempty"`
+	User  *UserPermissionScheme  `json:"user,omitempty"`
+	Group *GroupPermissionScheme `json:"group,omitempty"`
 }
 
 type UserPermissionScheme struct {
diff --git a/pkg/infra/models/errors.go b/pkg/infra/models/errors.go
index 6545db8..78ef723 100644
--- a/pkg/infra/models/errors.go
+++ b/pkg/infra/models/errors.go
@@ -41,46 +41,50 @@ var (
 	ErrNoEpicIDError   = errors.New("agile: no epic id set")
 	ErrNoSprintIDError = errors.New("agile: no sprint id set")
 
-	ErrNoApplicationRoleError         = errors.New("jira: no application role key set")
-	ErrNoDashboardIDError             = errors.New("jira: no dashboard id set")
-	ErrNoGroupNameError               = errors.New("jira: no group name set")
-	ErrNoGroupIDError                 = errors.New("jira: no group name set")
-	ErrNoIssueKeyOrIDError            = errors.New("jira: no issue key/id set")
-	ErrNoIssueSchemeError             = errors.New("jira: no jira.IssueScheme set")
-	ErrNoTransitionIDError            = errors.New("jira: no transition id set")
-	ErrNoAttachmentIDError            = errors.New("jira: no attachment id set")
-	ErrNoAttachmentNameError          = errors.New("jira: no attachment filename set")
-	ErrNoReaderError                  = errors.New("jira: no reader set")
-	ErrNoCommentIDError               = errors.New("jira: no comment id set")
-	ErrNoProjectIDError               = errors.New("jira: no project id set")
-	ErrNoFieldIDError                 = errors.New("jira: no field id set")
-	ErrNoFieldContextIDError          = errors.New("jira: no field context id set")
-	ErrNoIssueTypesError              = errors.New("jira: no issue types id's set")
-	ErrNoProjectsError                = errors.New("jira: no projects set")
-	ErrNoContextOptionIDError         = errors.New("jira: no field context option id set")
-	ErrNoTypeIDError                  = errors.New("jira: no link id set")
-	ErrNoLinkTypeIDError              = errors.New("jira: no link type id set")
-	ErrNoPriorityIDError              = errors.New("jira: no priority id set")
-	ErrNoResolutionIDError            = errors.New("jira: no resolution id set")
-	ErrNoJQLError                     = errors.New("jira: no sql set")
-	ErrNoIssueTypeIDError             = errors.New("jira: no issue type id set")
-	ErrNoIssueTypeScreenSchemeIDError = errors.New("jira: no issue type screen scheme id set")
-	ErrNoScreenSchemeIDError          = errors.New("jira: no screen scheme id set")
-	ErrNoAccountIDError               = errors.New("jira: no account id set")
-	ErrNoWorklogIDError               = errors.New("jira: no worklog id set")
-	ErrNpWorklogsError                = errors.New("jira: no worklog's id set")
-	ErrNoPermissionSchemeIDError      = errors.New("jira: no permission scheme id set")
-	ErrNoPermissionGrantIDError       = errors.New("jira: no permission grant id set")
-	ErrNoComponentIDError             = errors.New("jira: no component id set")
-	ErrProjectTypeKeyError            = errors.New("jira: no project type key set")
-	ErrNoProjectNameError             = errors.New("jira: no project name set")
-	ErrNoVersionIDError               = errors.New("jira: no version id set")
-	ErrNoScreenNameError              = errors.New("jira: no screen name set")
-	ErrNoScreenTabNameError           = errors.New("jira: no screen tab name set")
-	ErrNoAccountSliceError            = errors.New("jira: no account id's set")
-	ErrNoProjectKeySliceError         = errors.New("jira: no project key's set")
-	ErrNoWorkflowIDError              = errors.New("jira: no workflow id set")
-	ErrNoWorkflowSchemeIDError        = errors.New("jira: no workflow scheme id set")
-	ErrNoScreenIDError                = errors.New("jira: no screen id set")
-	ErrNoScreenTabIDError             = errors.New("jira: no screen tab id set")
+	ErrNoApplicationRoleError              = errors.New("jira: no application role key set")
+	ErrNoDashboardIDError                  = errors.New("jira: no dashboard id set")
+	ErrNoGroupNameError                    = errors.New("jira: no group name set")
+	ErrNoGroupIDError                      = errors.New("jira: no group name set")
+	ErrNoIssueKeyOrIDError                 = errors.New("jira: no issue key/id set")
+	ErrNoIssueSchemeError                  = errors.New("jira: no jira.IssueScheme set")
+	ErrNoTransitionIDError                 = errors.New("jira: no transition id set")
+	ErrNoAttachmentIDError                 = errors.New("jira: no attachment id set")
+	ErrNoAttachmentNameError               = errors.New("jira: no attachment filename set")
+	ErrNoReaderError                       = errors.New("jira: no reader set")
+	ErrNoCommentIDError                    = errors.New("jira: no comment id set")
+	ErrNoProjectIDError                    = errors.New("jira: no project id set")
+	ErrNoFieldIDError                      = errors.New("jira: no field id set")
+	ErrNoFieldContextIDError               = errors.New("jira: no field context id set")
+	ErrNoIssueTypesError                   = errors.New("jira: no issue types id's set")
+	ErrNoProjectsError                     = errors.New("jira: no projects set")
+	ErrNoContextOptionIDError              = errors.New("jira: no field context option id set")
+	ErrNoTypeIDError                       = errors.New("jira: no link id set")
+	ErrNoLinkTypeIDError                   = errors.New("jira: no link type id set")
+	ErrNoPriorityIDError                   = errors.New("jira: no priority id set")
+	ErrNoResolutionIDError                 = errors.New("jira: no resolution id set")
+	ErrNoJQLError                          = errors.New("jira: no sql set")
+	ErrNoIssueTypeIDError                  = errors.New("jira: no issue type id set")
+	ErrNoIssueTypeScreenSchemeIDError      = errors.New("jira: no issue type screen scheme id set")
+	ErrNoScreenSchemeIDError               = errors.New("jira: no screen scheme id set")
+	ErrNoAccountIDError                    = errors.New("jira: no account id set")
+	ErrNoWorklogIDError                    = errors.New("jira: no worklog id set")
+	ErrNpWorklogsError                     = errors.New("jira: no worklog's id set")
+	ErrNoPermissionSchemeIDError           = errors.New("jira: no permission scheme id set")
+	ErrNoPermissionGrantIDError            = errors.New("jira: no permission grant id set")
+	ErrNoComponentIDError                  = errors.New("jira: no component id set")
+	ErrProjectTypeKeyError                 = errors.New("jira: no project type key set")
+	ErrNoProjectNameError                  = errors.New("jira: no project name set")
+	ErrNoVersionIDError                    = errors.New("jira: no version id set")
+	ErrNoScreenNameError                   = errors.New("jira: no screen name set")
+	ErrNoScreenTabNameError                = errors.New("jira: no screen tab name set")
+	ErrNoAccountSliceError                 = errors.New("jira: no account id's set")
+	ErrNoProjectKeySliceError              = errors.New("jira: no project key's set")
+	ErrNoWorkflowIDError                   = errors.New("jira: no workflow id set")
+	ErrNoWorkflowSchemeIDError             = errors.New("jira: no workflow scheme id set")
+	ErrNoScreenIDError                     = errors.New("jira: no screen id set")
+	ErrNoScreenTabIDError                  = errors.New("jira: no screen tab id set")
+	ErrNoFieldConfigurationNameError       = errors.New("jira: no field configuration name set")
+	ErrNoFieldConfigurationIDError         = errors.New("jira: no field configuration id set")
+	ErrNoFieldConfigurationSchemeNameError = errors.New("jira: no field configuration scheme name set")
+	ErrNoFieldConfigurationSchemeIDError   = errors.New("jira: no field configuration scheme id set")
 )
diff --git a/pkg/infra/models/jira_field_configuration.go b/pkg/infra/models/jira_field_configuration.go
index 0630d82..54d64e6 100644
--- a/pkg/infra/models/jira_field_configuration.go
+++ b/pkg/infra/models/jira_field_configuration.go
@@ -23,50 +23,14 @@ type FieldConfigurationItemPageScheme struct {
 	Values     []*FieldConfigurationItemScheme `json:"values,omitempty"`
 }
 
+type UpdateFieldConfigurationItemPayloadScheme struct {
+	FieldConfigurationItems []*FieldConfigurationItemScheme `json:"fieldConfigurationItems"`
+}
+
 type FieldConfigurationItemScheme struct {
 	ID          string `json:"id,omitempty"`
 	IsHidden    bool   `json:"isHidden,omitempty"`
 	IsRequired  bool   `json:"isRequired,omitempty"`
 	Description string `json:"description,omitempty"`
-}
-
-type FieldConfigurationSchemePageScheme struct {
-	MaxResults int                               `json:"maxResults,omitempty"`
-	StartAt    int                               `json:"startAt,omitempty"`
-	Total      int                               `json:"total,omitempty"`
-	IsLast     bool                              `json:"isLast,omitempty"`
-	Values     []*FieldConfigurationSchemeScheme `json:"values,omitempty"`
-}
-
-type FieldConfigurationSchemeScheme struct {
-	ID          string `json:"id,omitempty"`
-	Name        string `json:"name,omitempty"`
-	Description string `json:"description,omitempty"`
-}
-
-type FieldConfigurationIssueTypeItemPageScheme struct {
-	MaxResults int                                      `json:"maxResults,omitempty"`
-	StartAt    int                                      `json:"startAt,omitempty"`
-	Total      int                                      `json:"total,omitempty"`
-	IsLast     bool                                     `json:"isLast,omitempty"`
-	Values     []*FieldConfigurationIssueTypeItemScheme `json:"values,omitempty"`
-}
-
-type FieldConfigurationIssueTypeItemScheme struct {
-	FieldConfigurationSchemeID string `json:"fieldConfigurationSchemeId,omitempty"`
-	IssueTypeID                string `json:"issueTypeId,omitempty"`
-	FieldConfigurationID       string `json:"fieldConfigurationId,omitempty"`
-}
-
-type FieldConfigurationSchemeProjectPageScheme struct {
-	MaxResults int                                      `json:"maxResults,omitempty"`
-	StartAt    int                                      `json:"startAt,omitempty"`
-	Total      int                                      `json:"total,omitempty"`
-	IsLast     bool                                     `json:"isLast,omitempty"`
-	Values     []*FieldConfigurationSchemeProjectScheme `json:"values,omitempty"`
-}
-
-type FieldConfigurationSchemeProjectScheme struct {
-	ProjectIds               []string                        `json:"projectIds,omitempty"`
-	FieldConfigurationScheme *FieldConfigurationSchemeScheme `json:"fieldConfigurationScheme,omitempty"`
+	Renderer    string `json:"renderer,omitempty"`
 }
diff --git a/pkg/infra/models/jira_field_configuration_scheme.go b/pkg/infra/models/jira_field_configuration_scheme.go
new file mode 100644
index 0000000..08f9613
--- /dev/null
+++ b/pkg/infra/models/jira_field_configuration_scheme.go
@@ -0,0 +1,56 @@
+package models
+
+type FieldConfigurationSchemePageScheme struct {
+	MaxResults int                               `json:"maxResults,omitempty"`
+	StartAt    int                               `json:"startAt,omitempty"`
+	Total      int                               `json:"total,omitempty"`
+	IsLast     bool                              `json:"isLast,omitempty"`
+	Values     []*FieldConfigurationSchemeScheme `json:"values,omitempty"`
+}
+
+type FieldConfigurationSchemeScheme struct {
+	ID          string `json:"id,omitempty"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+}
+
+type FieldConfigurationIssueTypeItemPageScheme struct {
+	MaxResults int                                      `json:"maxResults,omitempty"`
+	StartAt    int                                      `json:"startAt,omitempty"`
+	Total      int                                      `json:"total,omitempty"`
+	IsLast     bool                                     `json:"isLast,omitempty"`
+	Values     []*FieldConfigurationIssueTypeItemScheme `json:"values,omitempty"`
+}
+
+type FieldConfigurationIssueTypeItemScheme struct {
+	FieldConfigurationSchemeID string `json:"fieldConfigurationSchemeId,omitempty"`
+	IssueTypeID                string `json:"issueTypeId,omitempty"`
+	FieldConfigurationID       string `json:"fieldConfigurationId,omitempty"`
+}
+
+type FieldConfigurationSchemeProjectPageScheme struct {
+	MaxResults int                                      `json:"maxResults,omitempty"`
+	StartAt    int                                      `json:"startAt,omitempty"`
+	Total      int                                      `json:"total,omitempty"`
+	IsLast     bool                                     `json:"isLast,omitempty"`
+	Values     []*FieldConfigurationSchemeProjectScheme `json:"values,omitempty"`
+}
+
+type FieldConfigurationSchemeProjectScheme struct {
+	ProjectIds               []string                        `json:"projectIds,omitempty"`
+	FieldConfigurationScheme *FieldConfigurationSchemeScheme `json:"fieldConfigurationScheme,omitempty"`
+}
+
+type FieldConfigurationSchemeAssignPayload struct {
+	FieldConfigurationSchemeID string `json:"fieldConfigurationSchemeId"`
+	ProjectID                  string `json:"projectId"`
+}
+
+type FieldConfigurationToIssueTypeMappingPayloadScheme struct {
+	Mappings []*FieldConfigurationToIssueTypeMappingScheme `json:"mappings,omitempty"`
+}
+
+type FieldConfigurationToIssueTypeMappingScheme struct {
+	IssueTypeID          string `json:"issueTypeId,omitempty"`
+	FieldConfigurationID string `json:"fieldConfigurationId,omitempty"`
+}


Test patch:
diff --git a/jira/v2/issueFieldConfigurationItem_test.go b/jira/v2/issueFieldConfigurationItem_test.go
new file mode 100644
index 0000000..df5a520
--- /dev/null
+++ b/jira/v2/issueFieldConfigurationItem_test.go
@@ -0,0 +1,383 @@
+package v2
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func Test_Field_Configuration_Service_Update(t *testing.T) {
+
+	testCases := []struct {
+		name                 string
+		fieldConfigurationID int
+		payload              *models.UpdateFieldConfigurationItemPayloadScheme
+		mockFile             string
+		wantHTTPMethod       string
+		endpoint             string
+		context              context.Context
+		wantHTTPCodeReturn   int
+		wantErr              bool
+		expectedError        string
+	}{
+		{
+			name:                 "when the parameters are correct",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:                 "when the field configuration id is not provided",
+			fieldConfigurationID: 0,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration id set",
+		},
+
+		{
+			name:                 "when the payload is not provided",
+			fieldConfigurationID: 1000,
+			payload:              nil,
+			wantHTTPMethod:       http.MethodPut,
+			endpoint:             "/rest/api/2/fieldconfiguration/1000/fields",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name:                 "when the request method is incorrect",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodHead,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                 "when the context is not provided",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationItemService{client: mockClient}
+			gotResponse, err := service.Update(testCase.context, testCase.fieldConfigurationID, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Service_Get(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		fieldConfigID      int
+		startAt            int
+		maxResult          int
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration id is not provided",
+			fieldConfigID:      0,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/empty_json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationItemService{client: mockClient}
+			getResult, gotResponse, err := service.Gets(testCase.context, testCase.fieldConfigID, testCase.startAt, testCase.maxResult)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, getResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+
+}
diff --git a/jira/v2/issueFieldConfigurationScheme_test.go b/jira/v2/issueFieldConfigurationScheme_test.go
new file mode 100644
index 0000000..a809acc
--- /dev/null
+++ b/jira/v2/issueFieldConfigurationScheme_test.go
@@ -0,0 +1,1313 @@
+package v2
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func Test_Field_Configuration_Scheme_Service_Assign(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		payload            *models.FieldConfigurationSchemeAssignPayload
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name: "when the parameters are correct",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the payload is not provided",
+			payload:            nil,
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name: "when the request method is incorrect",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name: "when the context is not provided",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Assign(testCase.context, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Create(t *testing.T) {
+
+	testCases := []struct {
+		name                                string
+		fieldConfigurationSchemeDescription string
+		fieldConfigurationSchemeName        string
+		mockFile                            string
+		wantHTTPMethod                      string
+		endpoint                            string
+		context                             context.Context
+		wantHTTPCodeReturn                  int
+		wantErr                             bool
+		expectedError                       string
+	}{
+		{
+			name:                                "when the parameters are correct",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             false,
+		},
+
+		{
+			name:                                "when the field configuration scheme name is not provided",
+			fieldConfigurationSchemeDescription: "field configuration description",
+			fieldConfigurationSchemeName:        "",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme name set",
+		},
+
+		{
+			name:                                "when the response status code is invalid",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusBadRequest,
+			wantErr:                             true,
+			expectedError:                       "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:                                "when the context is not provided",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme",
+			context:                             nil,
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:                                "when the response body is empty",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/empty-json.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Create(testCase.context, testCase.fieldConfigurationSchemeName,
+				testCase.fieldConfigurationSchemeDescription)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Delete(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration scheme id is not provided",
+			schemeID:           0,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Delete(testCase.context, testCase.schemeID)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Gets(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		ids                 []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Gets(testCase.context, testCase.ids, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Link(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		payload            *models.FieldConfigurationToIssueTypeMappingPayloadScheme
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:     "when the parameters are correct",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the paylod is not provided",
+			schemeID:           1000,
+			payload:            nil,
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name:     "when the field configuration scheme id is not provided",
+			schemeID: 0,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:     "when the request method is incorrect",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:     "when the context is not provided",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Link(testCase.context, testCase.schemeID, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Mapping(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		fieldConfigIDs      []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-mapping.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Mapping(testCase.context, testCase.fieldConfigIDs, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Project(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		projectIDs          []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes-projects.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Project(testCase.context, testCase.projectIDs, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Unlink(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		issueTypeIDs       []string
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration scheme id is not provided",
+			schemeID:           0,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/2/fieldconfigurationscheme/1000/mapping/delete",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Unlink(testCase.context, testCase.schemeID, testCase.issueTypeIDs)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Update(t *testing.T) {
+
+	testCases := []struct {
+		name                                string
+		schemeID                            int
+		fieldConfigurationSchemeDescription string
+		fieldConfigurationSchemeName        string
+		mockFile                            string
+		wantHTTPMethod                      string
+		endpoint                            string
+		context                             context.Context
+		wantHTTPCodeReturn                  int
+		wantErr                             bool
+		expectedError                       string
+	}{
+		{
+			name:                                "when the parameters are correct",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             false,
+		},
+
+		{
+			name:                                "when the field configuration scheme id is not provided",
+			schemeID:                            0,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:                                "when the field configuration scheme name is not provided",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration description",
+			fieldConfigurationSchemeName:        "",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme name set",
+		},
+
+		{
+			name:                                "when the response status code is invalid",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusBadRequest,
+			wantErr:                             true,
+			expectedError:                       "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:                                "when the context is not provided",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/2/fieldconfigurationscheme/100",
+			context:                             nil,
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Update(testCase.context, testCase.schemeID, testCase.fieldConfigurationSchemeName,
+				testCase.fieldConfigurationSchemeDescription)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
diff --git a/jira/v2/issueFieldConfiguration_test.go b/jira/v2/issueFieldConfiguration_test.go
index ac4f124..0040287 100644
--- a/jira/v2/issueFieldConfiguration_test.go
+++ b/jira/v2/issueFieldConfiguration_test.go
@@ -211,135 +211,82 @@ func TestFieldConfigurationService_Gets(t *testing.T) {
 	}
 }
 
-func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
+func TestFieldConfigurationService_Create(t *testing.T) {
 
 	testCases := []struct {
-		name               string
-		fieldConfigIDs     []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
+		name                          string
+		fieldConfigurationName        string
+		fieldConfigurationDescription string
+		mockFile                      string
+		wantHTTPMethod                string
+		endpoint                      string
+		context                       context.Context
+		wantHTTPCodeReturn            int
+		wantErr                       bool
+		expectedError                 string
 	}{
 		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheParametersAreCorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheParametersAreIncorrect",
-			fieldConfigIDs:     []int{10000, 10002},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheEndpointIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mappings?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheContextIsNil",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheFieldConfigIDsAreNil",
-			fieldConfigIDs:     nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheRequestMethodIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheStatusCodeIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheResponseBodyLengthIsZero",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheResponseBodyHasADifferentFormat",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
+			name:                          "CreateFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/2/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       false,
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheFieldConfigurationNameIsNotSet",
+			fieldConfigurationName:        "",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/2/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration name set",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodHead,
+			endpoint:                      "/rest/api/2/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/2/fieldconfiguration",
+			context:                       nil,
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheResponseBodyIsEmpty",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/empty_json.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/2/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "unexpected end of JSON input",
 		},
 	}
 
@@ -368,7 +315,7 @@ func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.IssueTypeItems(testCase.context, testCase.fieldConfigIDs, testCase.startAt, testCase.maxResult)
+			getResult, gotResponse, err := service.Create(testCase.context, testCase.fieldConfigurationName, testCase.fieldConfigurationDescription)
 
 			if testCase.wantErr {
 
@@ -376,198 +323,12 @@ func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
-			} else {
-
-				assert.NoError(t, err)
-				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
-
-				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				var endpointToAssert string
-
-				if apiEndpoint.Query().Encode() != "" {
-					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
-				} else {
-					endpointToAssert = apiEndpoint.Path
-				}
-
-				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
-				assert.Equal(t, testCase.endpoint, endpointToAssert)
-
-				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
-			}
-
-		})
-	}
-
-}
-
-func TestFieldConfigurationService_Items(t *testing.T) {
-
-	testCases := []struct {
-		name               string
-		fieldConfigID      int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
-	}{
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreCorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreIncorrect",
-			fieldConfigID:      10001,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheEndpointIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurations/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheContextIsNil",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheRequestMethodIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodPost,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheStatusCodeIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyLengthIsZero",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyHasADifferentFormat",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-
-			//Init a new HTTP mock server
-			mockOptions := mockServerOptions{
-				Endpoint:           testCase.endpoint,
-				MockFilePath:       testCase.mockFile,
-				MethodAccepted:     testCase.wantHTTPMethod,
-				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
-			}
-
-			mockServer, err := startMockServer(&mockOptions)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			defer mockServer.Close()
-
-			//Init the library instance
-			mockClient, err := startMockClient(mockServer.URL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.Items(testCase.context, testCase.fieldConfigID, testCase.startAt, testCase.maxResult)
-
-			if testCase.wantErr {
-
-				if err != nil {
-					t.Logf("error returned: %v", err.Error())
-				}
 
-				assert.Error(t, err)
-
-				if gotResponse != nil {
-					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				}
 			} else {
 
 				assert.NoError(t, err)
@@ -596,130 +357,85 @@ func TestFieldConfigurationService_Items(t *testing.T) {
 
 		})
 	}
-
 }
 
-func TestFieldConfigurationService_Schemes(t *testing.T) {
+func TestFieldConfigurationService_Update(t *testing.T) {
 
 	testCases := []struct {
-		name               string
-		ids                []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
+		name                          string
+		fieldConfigurationID          int
+		fieldConfigurationName        string
+		fieldConfigurationDescription string
+		mockFile                      string
+		wantHTTPMethod                string
+		endpoint                      string
+		context                       context.Context
+		wantHTTPCodeReturn            int
+		wantErr                       bool
+		expectedError                 string
 	}{
 		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreCorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreIncorrect",
-			ids:                []int{10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheEndpointIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationschemes?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheContextIsNil",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheIDsAreNil",
-			ids:                nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheRequestMethodIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheStatusCodeIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyLengthIsZero",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyHasADifferentFormat",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/empty_json.json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
+			name:                          "UpdateFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/2/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       false,
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheFieldConfigurationIDIsNotSet",
+			fieldConfigurationID:          0,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/2/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration id set",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheFieldConfigurationNameIsNotSet",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/2/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration name set",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "../v3/mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodHead,
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/2/fieldconfiguration/1000",
+			context:                       nil,
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "request creation failed: net/http: nil Context",
 		},
 	}
 
@@ -748,7 +464,7 @@ func TestFieldConfigurationService_Schemes(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.Schemes(testCase.context, testCase.ids, testCase.startAt, testCase.maxResult)
+			gotResponse, err := service.Update(testCase.context, testCase.fieldConfigurationID, testCase.fieldConfigurationName, testCase.fieldConfigurationDescription)
 
 			if testCase.wantErr {
 
@@ -756,230 +472,16 @@ func TestFieldConfigurationService_Schemes(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
-			} else {
-
-				assert.NoError(t, err)
-				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
-
-				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				var endpointToAssert string
-
-				if apiEndpoint.Query().Encode() != "" {
-					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
-				} else {
-					endpointToAssert = apiEndpoint.Path
-				}
-
-				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
-				assert.Equal(t, testCase.endpoint, endpointToAssert)
-
-				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
-			}
-
-		})
-	}
-
-}
-
-func TestFieldConfigurationService_SchemesByProject(t *testing.T) {
-
-	testCases := []struct {
-		name               string
-		projectIDs         []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
-	}{
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheParametersAreCorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheParametersAreIncorrect",
-			projectIDs:         []int{10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheEndpointIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationschemes/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheEndpointIsEmpty",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheContextIsNil",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheProjectIDsAreNil",
-			projectIDs:         nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheRequestMethodIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheStatusCodeIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheResponseBodyLengthIsZero",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheResponseBodyHasADifferentFormat",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "../v3/mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/2/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-
-			//Init a new HTTP mock server
-			mockOptions := mockServerOptions{
-				Endpoint:           testCase.endpoint,
-				MockFilePath:       testCase.mockFile,
-				MethodAccepted:     testCase.wantHTTPMethod,
-				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
-			}
-
-			mockServer, err := startMockServer(&mockOptions)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			defer mockServer.Close()
-
-			//Init the library instance
-			mockClient, err := startMockClient(mockServer.URL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.SchemesByProject(testCase.context, testCase.projectIDs, testCase.startAt, testCase.maxResult)
-
-			if testCase.wantErr {
-
-				if err != nil {
-					t.Logf("error returned: %v", err.Error())
-				}
-
-				assert.Error(t, err)
 
-				if gotResponse != nil {
-					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				}
 			} else {
 
 				assert.NoError(t, err)
 				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
 
 				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
 				if err != nil {
@@ -1003,75 +505,61 @@ func TestFieldConfigurationService_SchemesByProject(t *testing.T) {
 
 		})
 	}
-
 }
 
-func TestFieldConfigurationService_Assign(t *testing.T) {
+func TestFieldConfigurationService_Delete(t *testing.T) {
 
 	testCases := []struct {
-		name                       string
-		fieldConfigurationSchemeID string
-		projectID                  string
-		mockFile                   string
-		wantHTTPMethod             string
-		endpoint                   string
-		context                    context.Context
-		wantHTTPCodeReturn         int
-		wantErr                    bool
+		name                 string
+		fieldConfigurationID int
+		mockFile             string
+		wantHTTPMethod       string
+		endpoint             string
+		context              context.Context
+		wantHTTPCodeReturn   int
+		wantErr              bool
+		expectedError        string
 	}{
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheParametersAreCorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/2/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    false,
-		},
-
-		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheProjectIDIsNotProvided",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/2/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/2/fieldconfiguration/1000",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              false,
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheRequestMethodIsIncorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodHead,
-			endpoint:                   "/rest/api/2/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheFieldConfigurationIDIsNotSet",
+			fieldConfigurationID: 0,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/2/fieldconfiguration/1000",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "jira: no field configuration id set",
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheStatusCodeIsIncorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/2/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusBadRequest,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodHead,
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "request failed. Please analyze the request body for more details. Status Code: 405",
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheContextIsNil",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/2/fieldconfigurationscheme/project",
-			context:                    nil,
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/2/fieldconfiguration/1000",
+			context:              nil,
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "request creation failed: net/http: nil Context",
 		},
 	}
 
@@ -1100,7 +588,7 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			gotResponse, err := service.Assign(testCase.context, testCase.fieldConfigurationSchemeID, testCase.projectID)
+			gotResponse, err := service.Delete(testCase.context, testCase.fieldConfigurationID)
 
 			if testCase.wantErr {
 
@@ -1108,11 +596,12 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
+
 			} else {
 
 				assert.NoError(t, err)
@@ -1140,5 +629,4 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 
 		})
 	}
-
 }
diff --git a/jira/v3/issueFieldConfigurationItem_test.go b/jira/v3/issueFieldConfigurationItem_test.go
new file mode 100644
index 0000000..bc06a7b
--- /dev/null
+++ b/jira/v3/issueFieldConfigurationItem_test.go
@@ -0,0 +1,383 @@
+package v3
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func Test_Field_Configuration_Service_Update(t *testing.T) {
+
+	testCases := []struct {
+		name                 string
+		fieldConfigurationID int
+		payload              *models.UpdateFieldConfigurationItemPayloadScheme
+		mockFile             string
+		wantHTTPMethod       string
+		endpoint             string
+		context              context.Context
+		wantHTTPCodeReturn   int
+		wantErr              bool
+		expectedError        string
+	}{
+		{
+			name:                 "when the parameters are correct",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:                 "when the field configuration id is not provided",
+			fieldConfigurationID: 0,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration id set",
+		},
+
+		{
+			name:                 "when the payload is not provided",
+			fieldConfigurationID: 1000,
+			payload:              nil,
+			wantHTTPMethod:       http.MethodPut,
+			endpoint:             "/rest/api/2/fieldconfiguration/1000/fields",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name:                 "when the request method is incorrect",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodHead,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                 "when the context is not provided",
+			fieldConfigurationID: 1000,
+			payload: &models.UpdateFieldConfigurationItemPayloadScheme{
+				FieldConfigurationItems: []*models.FieldConfigurationItemScheme{
+					{
+						ID:          "customfield_10012",
+						IsHidden:    false,
+						Description: "The new description of this item.",
+					},
+					{
+						ID:         "customfield_10011",
+						IsRequired: true,
+					},
+					{
+						ID:          "customfield_10010",
+						IsHidden:    false,
+						IsRequired:  false,
+						Description: "Another new description.",
+						Renderer:    "wiki-renderer",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/2/fieldconfiguration/1000/fields",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationItemService{client: mockClient}
+			gotResponse, err := service.Update(testCase.context, testCase.fieldConfigurationID, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Service_Get(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		fieldConfigID      int
+		startAt            int
+		maxResult          int
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration id is not provided",
+			fieldConfigID:      0,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/get-field-configuration-items.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			fieldConfigID:      10000,
+			startAt:            0,
+			maxResult:          50,
+			mockFile:           "../v3/mocks/empty_json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/2/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationItemService{client: mockClient}
+			getResult, gotResponse, err := service.Gets(testCase.context, testCase.fieldConfigID, testCase.startAt, testCase.maxResult)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, getResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+
+}
diff --git a/jira/v3/issueFieldConfigurationScheme_test.go b/jira/v3/issueFieldConfigurationScheme_test.go
new file mode 100644
index 0000000..08c3167
--- /dev/null
+++ b/jira/v3/issueFieldConfigurationScheme_test.go
@@ -0,0 +1,1313 @@
+package v3
+
+import (
+	"context"
+	"fmt"
+	"github.com/ctreminiom/go-atlassian/pkg/infra/models"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func Test_Field_Configuration_Scheme_Service_Assign(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		payload            *models.FieldConfigurationSchemeAssignPayload
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name: "when the parameters are correct",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the payload is not provided",
+			payload:            nil,
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name: "when the request method is incorrect",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name: "when the context is not provided",
+			payload: &models.FieldConfigurationSchemeAssignPayload{
+				FieldConfigurationSchemeID: "10000",
+				ProjectID:                  "10000",
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Assign(testCase.context, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Create(t *testing.T) {
+
+	testCases := []struct {
+		name                                string
+		fieldConfigurationSchemeDescription string
+		fieldConfigurationSchemeName        string
+		mockFile                            string
+		wantHTTPMethod                      string
+		endpoint                            string
+		context                             context.Context
+		wantHTTPCodeReturn                  int
+		wantErr                             bool
+		expectedError                       string
+	}{
+		{
+			name:                                "when the parameters are correct",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             false,
+		},
+
+		{
+			name:                                "when the field configuration scheme name is not provided",
+			fieldConfigurationSchemeDescription: "field configuration description",
+			fieldConfigurationSchemeName:        "",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme name set",
+		},
+
+		{
+			name:                                "when the response status code is invalid",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusBadRequest,
+			wantErr:                             true,
+			expectedError:                       "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:                                "when the context is not provided",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/create-field-configuration-scheme.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme",
+			context:                             nil,
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:                                "when the response body is empty",
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			mockFile:                            "../mocks/empty-json.json",
+			wantHTTPMethod:                      http.MethodPost,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Create(testCase.context, testCase.fieldConfigurationSchemeName,
+				testCase.fieldConfigurationSchemeDescription)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Delete(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration scheme id is not provided",
+			schemeID:           0,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			schemeID:           1000,
+			wantHTTPMethod:     http.MethodDelete,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Delete(testCase.context, testCase.schemeID)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Gets(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		ids                 []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			ids:                []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=1000&id=1001&id=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Gets(testCase.context, testCase.ids, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Link(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		payload            *models.FieldConfigurationToIssueTypeMappingPayloadScheme
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:     "when the parameters are correct",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the paylod is not provided",
+			schemeID:           1000,
+			payload:            nil,
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "failed to parse the interface pointer, please provide a valid one",
+		},
+
+		{
+			name:     "when the field configuration scheme id is not provided",
+			schemeID: 0,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:     "when the request method is incorrect",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:     "when the context is not provided",
+			schemeID: 1000,
+			payload: &models.FieldConfigurationToIssueTypeMappingPayloadScheme{
+				Mappings: []*models.FieldConfigurationToIssueTypeMappingScheme{
+					{
+						IssueTypeID:          "default",
+						FieldConfigurationID: "10000",
+					},
+					{
+						IssueTypeID:          "10001",
+						FieldConfigurationID: "10002",
+					},
+				},
+			},
+			wantHTTPMethod:     http.MethodPut,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Link(testCase.context, testCase.schemeID, testCase.payload)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Mapping(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		fieldConfigIDs      []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-mapping.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			fieldConfigIDs:     []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=1000&fieldConfigurationSchemeId=1001&fieldConfigurationSchemeId=1002&maxResults=100&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Mapping(testCase.context, testCase.fieldConfigIDs, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Project(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		projectIDs          []int
+		startAt, maxResults int
+		mockFile            string
+		wantHTTPMethod      string
+		endpoint            string
+		context             context.Context
+		wantHTTPCodeReturn  int
+		wantErr             bool
+		expectedError       string
+	}{
+		{
+			name:               "when the parameters are correct",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes-projects.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            false,
+			expectedError:      "",
+		},
+
+		{
+			name:               "when the response status code is invalid",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusBadRequest,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:               "when the context is not provided",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/get-field-configuration-schemes.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:               "when the response body is empty",
+			projectIDs:         []int{1000, 1001, 1002},
+			startAt:            50,
+			maxResults:         100,
+			mockFile:           "../mocks/empty-json.json",
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=100&projectId=1000&projectId=1001&projectId=1002&startAt=50",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusOK,
+			wantErr:            true,
+			expectedError:      "unexpected end of JSON input",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResult, gotResponse, err := service.Project(testCase.context, testCase.projectIDs, testCase.startAt, testCase.maxResults)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+				assert.NotEqual(t, gotResult, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Unlink(t *testing.T) {
+
+	testCases := []struct {
+		name               string
+		schemeID           int
+		issueTypeIDs       []string
+		mockFile           string
+		wantHTTPMethod     string
+		endpoint           string
+		context            context.Context
+		wantHTTPCodeReturn int
+		wantErr            bool
+		expectedError      string
+	}{
+		{
+			name:               "when the parameters are correct",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            false,
+		},
+
+		{
+			name:               "when the field configuration scheme id is not provided",
+			schemeID:           0,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:               "when the request method is incorrect",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodGet,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping/delete",
+			context:            context.Background(),
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:               "when the context is not provided",
+			schemeID:           1000,
+			issueTypeIDs:       []string{"10001", "2"},
+			wantHTTPMethod:     http.MethodPost,
+			endpoint:           "/rest/api/3/fieldconfigurationscheme/1000/mapping/delete",
+			context:            nil,
+			wantHTTPCodeReturn: http.StatusNoContent,
+			wantErr:            true,
+			expectedError:      "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Unlink(testCase.context, testCase.schemeID, testCase.issueTypeIDs)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
+
+func Test_Field_Configuration_Scheme_Service_Update(t *testing.T) {
+
+	testCases := []struct {
+		name                                string
+		schemeID                            int
+		fieldConfigurationSchemeDescription string
+		fieldConfigurationSchemeName        string
+		mockFile                            string
+		wantHTTPMethod                      string
+		endpoint                            string
+		context                             context.Context
+		wantHTTPCodeReturn                  int
+		wantErr                             bool
+		expectedError                       string
+	}{
+		{
+			name:                                "when the parameters are correct",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             false,
+		},
+
+		{
+			name:                                "when the field configuration scheme id is not provided",
+			schemeID:                            0,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme id set",
+		},
+
+		{
+			name:                                "when the field configuration scheme name is not provided",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration description",
+			fieldConfigurationSchemeName:        "",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "jira: no field configuration scheme name set",
+		},
+
+		{
+			name:                                "when the response status code is invalid",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme/100",
+			context:                             context.Background(),
+			wantHTTPCodeReturn:                  http.StatusBadRequest,
+			wantErr:                             true,
+			expectedError:                       "request failed. Please analyze the request body for more details. Status Code: 400",
+		},
+
+		{
+			name:                                "when the context is not provided",
+			schemeID:                            100,
+			fieldConfigurationSchemeDescription: "field configuration name",
+			fieldConfigurationSchemeName:        "field configuration description",
+			wantHTTPMethod:                      http.MethodPut,
+			endpoint:                            "/rest/api/3/fieldconfigurationscheme/100",
+			context:                             nil,
+			wantHTTPCodeReturn:                  http.StatusOK,
+			wantErr:                             true,
+			expectedError:                       "request creation failed: net/http: nil Context",
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		t.Run(testCase.name, func(t *testing.T) {
+
+			//Init a new HTTP mock server
+			mockOptions := mockServerOptions{
+				Endpoint:           testCase.endpoint,
+				MockFilePath:       testCase.mockFile,
+				MethodAccepted:     testCase.wantHTTPMethod,
+				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
+			}
+
+			mockServer, err := startMockServer(&mockOptions)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			defer mockServer.Close()
+
+			//Init the library instance
+			mockClient, err := startMockClient(mockServer.URL)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			service := &FieldConfigurationSchemeService{client: mockClient}
+			gotResponse, err := service.Update(testCase.context, testCase.schemeID, testCase.fieldConfigurationSchemeName,
+				testCase.fieldConfigurationSchemeDescription)
+
+			if testCase.wantErr {
+
+				if err != nil {
+					t.Logf("error returned: %v", err.Error())
+				}
+
+				assert.EqualError(t, err, testCase.expectedError)
+
+				if gotResponse != nil {
+					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				}
+
+			} else {
+
+				assert.NoError(t, err)
+				assert.NotEqual(t, gotResponse, nil)
+
+				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				var endpointToAssert string
+
+				if apiEndpoint.Query().Encode() != "" {
+					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
+				} else {
+					endpointToAssert = apiEndpoint.Path
+				}
+
+				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
+				assert.Equal(t, testCase.endpoint, endpointToAssert)
+
+				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
+				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
+			}
+
+		})
+	}
+}
diff --git a/jira/v3/issueFieldConfiguration_test.go b/jira/v3/issueFieldConfiguration_test.go
index a62adbe..1f22808 100644
--- a/jira/v3/issueFieldConfiguration_test.go
+++ b/jira/v3/issueFieldConfiguration_test.go
@@ -211,135 +211,82 @@ func TestFieldConfigurationService_Gets(t *testing.T) {
 	}
 }
 
-func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
+func TestFieldConfigurationService_Create(t *testing.T) {
 
 	testCases := []struct {
-		name               string
-		fieldConfigIDs     []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
+		name                          string
+		fieldConfigurationName        string
+		fieldConfigurationDescription string
+		mockFile                      string
+		wantHTTPMethod                string
+		endpoint                      string
+		context                       context.Context
+		wantHTTPCodeReturn            int
+		wantErr                       bool
+		expectedError                 string
 	}{
 		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheParametersAreCorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheParametersAreIncorrect",
-			fieldConfigIDs:     []int{10000, 10002},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheEndpointIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mappings?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheContextIsNil",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheFieldConfigIDsAreNil",
-			fieldConfigIDs:     nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheRequestMethodIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheStatusCodeIsIncorrect",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-issue-field-configuration-issue-type-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheResponseBodyLengthIsZero",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsIssueTypeItemsWhenTheResponseBodyHasADifferentFormat",
-			fieldConfigIDs:     []int{10000, 10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/mapping?fieldConfigurationSchemeId=10000&fieldConfigurationSchemeId=10001&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
+			name:                          "CreateFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/3/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       false,
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheFieldConfigurationNameIsNotSet",
+			fieldConfigurationName:        "",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/3/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration name set",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodHead,
+			endpoint:                      "/rest/api/3/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/3/fieldconfiguration",
+			context:                       nil,
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "request creation failed: net/http: nil Context",
+		},
+
+		{
+			name:                          "CreateFieldConfigurationWhenTheResponseBodyIsEmpty",
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/empty_json.json",
+			wantHTTPMethod:                http.MethodPost,
+			endpoint:                      "/rest/api/3/fieldconfiguration",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusOK,
+			wantErr:                       true,
+			expectedError:                 "unexpected end of JSON input",
 		},
 	}
 
@@ -368,7 +315,7 @@ func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.IssueTypeItems(testCase.context, testCase.fieldConfigIDs, testCase.startAt, testCase.maxResult)
+			getResult, gotResponse, err := service.Create(testCase.context, testCase.fieldConfigurationName, testCase.fieldConfigurationDescription)
 
 			if testCase.wantErr {
 
@@ -376,198 +323,12 @@ func TestFieldConfigurationService_IssueTypeItems(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
-			} else {
-
-				assert.NoError(t, err)
-				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
-
-				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				var endpointToAssert string
-
-				if apiEndpoint.Query().Encode() != "" {
-					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
-				} else {
-					endpointToAssert = apiEndpoint.Path
-				}
-
-				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
-				assert.Equal(t, testCase.endpoint, endpointToAssert)
-
-				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
-			}
-
-		})
-	}
-
-}
-
-func TestFieldConfigurationService_Items(t *testing.T) {
-
-	testCases := []struct {
-		name               string
-		fieldConfigID      int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
-	}{
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreCorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreIncorrect",
-			fieldConfigID:      10001,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheEndpointIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurations/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheContextIsNil",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheRequestMethodIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodPost,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheStatusCodeIsIncorrect",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-items.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyLengthIsZero",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyHasADifferentFormat",
-			fieldConfigID:      10000,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfiguration/10000/fields?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-
-			//Init a new HTTP mock server
-			mockOptions := mockServerOptions{
-				Endpoint:           testCase.endpoint,
-				MockFilePath:       testCase.mockFile,
-				MethodAccepted:     testCase.wantHTTPMethod,
-				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
-			}
-
-			mockServer, err := startMockServer(&mockOptions)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			defer mockServer.Close()
-
-			//Init the library instance
-			mockClient, err := startMockClient(mockServer.URL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.Items(testCase.context, testCase.fieldConfigID, testCase.startAt, testCase.maxResult)
-
-			if testCase.wantErr {
-
-				if err != nil {
-					t.Logf("error returned: %v", err.Error())
-				}
 
-				assert.Error(t, err)
-
-				if gotResponse != nil {
-					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				}
 			} else {
 
 				assert.NoError(t, err)
@@ -596,130 +357,85 @@ func TestFieldConfigurationService_Items(t *testing.T) {
 
 		})
 	}
-
 }
 
-func TestFieldConfigurationService_Schemes(t *testing.T) {
+func TestFieldConfigurationService_Update(t *testing.T) {
 
 	testCases := []struct {
-		name               string
-		ids                []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
+		name                          string
+		fieldConfigurationID          int
+		fieldConfigurationName        string
+		fieldConfigurationDescription string
+		mockFile                      string
+		wantHTTPMethod                string
+		endpoint                      string
+		context                       context.Context
+		wantHTTPCodeReturn            int
+		wantErr                       bool
+		expectedError                 string
 	}{
 		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreCorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheParametersAreIncorrect",
-			ids:                []int{10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheEndpointIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationschemes?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheContextIsNil",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheIDsAreNil",
-			ids:                nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheRequestMethodIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheStatusCodeIsIncorrect",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyLengthIsZero",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-		{
-			name:               "GetsFieldConfigurationsItemsWhenTheResponseBodyHasADifferentFormat",
-			ids:                []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/empty_json.json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme?id=10000&maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
+			name:                          "UpdateFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/3/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       false,
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheFieldConfigurationIDIsNotSet",
+			fieldConfigurationID:          0,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/3/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration id set",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheFieldConfigurationNameIsNotSet",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/3/fieldconfiguration/1000",
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "jira: no field configuration name set",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			mockFile:                      "./mocks/get-field-configuration.json",
+			wantHTTPMethod:                http.MethodHead,
+			context:                       context.Background(),
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "request failed. Please analyze the request body for more details. Status Code: 405",
+		},
+
+		{
+			name:                          "UpdateFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationID:          1000,
+			fieldConfigurationName:        "Field Configuration Name Sample",
+			fieldConfigurationDescription: "Field Configuration Name Description",
+			wantHTTPMethod:                http.MethodPut,
+			endpoint:                      "/rest/api/3/fieldconfiguration/1000",
+			context:                       nil,
+			wantHTTPCodeReturn:            http.StatusNoContent,
+			wantErr:                       true,
+			expectedError:                 "request creation failed: net/http: nil Context",
 		},
 	}
 
@@ -748,7 +464,7 @@ func TestFieldConfigurationService_Schemes(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.Schemes(testCase.context, testCase.ids, testCase.startAt, testCase.maxResult)
+			gotResponse, err := service.Update(testCase.context, testCase.fieldConfigurationID, testCase.fieldConfigurationName, testCase.fieldConfigurationDescription)
 
 			if testCase.wantErr {
 
@@ -756,230 +472,16 @@ func TestFieldConfigurationService_Schemes(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
-			} else {
-
-				assert.NoError(t, err)
-				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
-
-				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				var endpointToAssert string
-
-				if apiEndpoint.Query().Encode() != "" {
-					endpointToAssert = fmt.Sprintf("%v?%v", apiEndpoint.Path, apiEndpoint.Query().Encode())
-				} else {
-					endpointToAssert = apiEndpoint.Path
-				}
-
-				t.Logf("HTTP Endpoint Wanted: %v, HTTP Endpoint Returned: %v", testCase.endpoint, endpointToAssert)
-				assert.Equal(t, testCase.endpoint, endpointToAssert)
-
-				t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				assert.Equal(t, gotResponse.Code, testCase.wantHTTPCodeReturn)
-			}
-
-		})
-	}
-
-}
-
-func TestFieldConfigurationService_SchemesByProject(t *testing.T) {
-
-	testCases := []struct {
-		name               string
-		projectIDs         []int
-		startAt            int
-		maxResult          int
-		mockFile           string
-		wantHTTPMethod     string
-		endpoint           string
-		context            context.Context
-		wantHTTPCodeReturn int
-		wantErr            bool
-	}{
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheParametersAreCorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheParametersAreIncorrect",
-			projectIDs:         []int{10001},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheEndpointIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationschemes/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheEndpointIsEmpty",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheContextIsNil",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            nil,
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheProjectIDsAreNil",
-			projectIDs:         nil,
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            false,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheRequestMethodIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodDelete,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheStatusCodeIsIncorrect",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/get-field-configuration-schemes.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusBadRequest,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheResponseBodyLengthIsZero",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-
-		{
-			name:               "GetsFieldConfigurationsSchemesByProjectWhenTheResponseBodyHasADifferentFormat",
-			projectIDs:         []int{10000},
-			startAt:            0,
-			maxResult:          50,
-			mockFile:           "./mocks/empty_json.json",
-			wantHTTPMethod:     http.MethodGet,
-			endpoint:           "/rest/api/3/fieldconfigurationscheme/project?maxResults=50&projectId=10000&startAt=0",
-			context:            context.Background(),
-			wantHTTPCodeReturn: http.StatusOK,
-			wantErr:            true,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-
-			//Init a new HTTP mock server
-			mockOptions := mockServerOptions{
-				Endpoint:           testCase.endpoint,
-				MockFilePath:       testCase.mockFile,
-				MethodAccepted:     testCase.wantHTTPMethod,
-				ResponseCodeWanted: testCase.wantHTTPCodeReturn,
-			}
-
-			mockServer, err := startMockServer(&mockOptions)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			defer mockServer.Close()
-
-			//Init the library instance
-			mockClient, err := startMockClient(mockServer.URL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			service := &FieldConfigurationService{client: mockClient}
-			getResult, gotResponse, err := service.SchemesByProject(testCase.context, testCase.projectIDs, testCase.startAt, testCase.maxResult)
-
-			if testCase.wantErr {
-
-				if err != nil {
-					t.Logf("error returned: %v", err.Error())
-				}
-
-				assert.Error(t, err)
 
-				if gotResponse != nil {
-					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
-				}
 			} else {
 
 				assert.NoError(t, err)
 				assert.NotEqual(t, gotResponse, nil)
-				assert.NotEqual(t, getResult, nil)
 
 				apiEndpoint, err := url.Parse(gotResponse.Endpoint)
 				if err != nil {
@@ -1003,75 +505,61 @@ func TestFieldConfigurationService_SchemesByProject(t *testing.T) {
 
 		})
 	}
-
 }
 
-func TestFieldConfigurationService_Assign(t *testing.T) {
+func TestFieldConfigurationService_Delete(t *testing.T) {
 
 	testCases := []struct {
-		name                       string
-		fieldConfigurationSchemeID string
-		projectID                  string
-		mockFile                   string
-		wantHTTPMethod             string
-		endpoint                   string
-		context                    context.Context
-		wantHTTPCodeReturn         int
-		wantErr                    bool
+		name                 string
+		fieldConfigurationID int
+		mockFile             string
+		wantHTTPMethod       string
+		endpoint             string
+		context              context.Context
+		wantHTTPCodeReturn   int
+		wantErr              bool
+		expectedError        string
 	}{
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheParametersAreCorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/3/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    false,
-		},
-
-		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheProjectIDIsNotProvided",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/3/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheParametersAreCorrect",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/3/fieldconfiguration/1000",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              false,
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheRequestMethodIsIncorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodHead,
-			endpoint:                   "/rest/api/3/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheFieldConfigurationIDIsNotSet",
+			fieldConfigurationID: 0,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/3/fieldconfiguration/1000",
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "jira: no field configuration id set",
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheStatusCodeIsIncorrect",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/3/fieldconfigurationscheme/project",
-			context:                    context.Background(),
-			wantHTTPCodeReturn:         http.StatusBadRequest,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheRequestMethodIsIncorrect",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodHead,
+			context:              context.Background(),
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "request failed. Please analyze the request body for more details. Status Code: 405",
 		},
 
 		{
-			name:                       "AssignFieldConfigurationToProjectWhenTheContextIsNil",
-			fieldConfigurationSchemeID: "1000",
-			projectID:                  "1001",
-			wantHTTPMethod:             http.MethodPut,
-			endpoint:                   "/rest/api/3/fieldconfigurationscheme/project",
-			context:                    nil,
-			wantHTTPCodeReturn:         http.StatusNoContent,
-			wantErr:                    true,
+			name:                 "DeleteFieldConfigurationWhenTheContextIsNotProvided",
+			fieldConfigurationID: 1000,
+			wantHTTPMethod:       http.MethodDelete,
+			endpoint:             "/rest/api/3/fieldconfiguration/1000",
+			context:              nil,
+			wantHTTPCodeReturn:   http.StatusNoContent,
+			wantErr:              true,
+			expectedError:        "request creation failed: net/http: nil Context",
 		},
 	}
 
@@ -1100,7 +588,7 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 			}
 
 			service := &FieldConfigurationService{client: mockClient}
-			gotResponse, err := service.Assign(testCase.context, testCase.fieldConfigurationSchemeID, testCase.projectID)
+			gotResponse, err := service.Delete(testCase.context, testCase.fieldConfigurationID)
 
 			if testCase.wantErr {
 
@@ -1108,11 +596,12 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 					t.Logf("error returned: %v", err.Error())
 				}
 
-				assert.Error(t, err)
+				assert.EqualError(t, err, testCase.expectedError)
 
 				if gotResponse != nil {
 					t.Logf("HTTP Code Wanted: %v, HTTP Code Returned: %v", testCase.wantHTTPCodeReturn, gotResponse.Code)
 				}
+
 			} else {
 
 				assert.NoError(t, err)
@@ -1140,5 +629,4 @@ func TestFieldConfigurationService_Assign(t *testing.T) {
 
 		})
 	}
-
 }