You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficcontrol.apache.org by ra...@apache.org on 2022/06/29 22:34:55 UTC

[trafficcontrol] branch master updated: Refactor Federations Tests (#6915)

This is an automated email from the ASF dual-hosted git repository.

rawlin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficcontrol.git


The following commit(s) were added to refs/heads/master by this push:
     new aef0b23227 Refactor Federations Tests (#6915)
aef0b23227 is described below

commit aef0b2322764703fa38001e3806e0de668c72164
Author: Eric Holguin <14...@users.noreply.github.com>
AuthorDate: Wed Jun 29 16:34:50 2022 -0600

    Refactor Federations Tests (#6915)
    
    * Initial refactor
    
    * Additional refactoring to federation tests
    
    * federations refactor
    
    * Federations v4 tests refactor
    
    * Federations v3 tests refactor
    
    * Fix nil map
---
 traffic_ops/testing/api/v3/cdn_federations_test.go | 239 +++++++
 traffic_ops/testing/api/v3/cdnfederations_test.go  | 334 ---------
 .../api/v3/federation_deliveryservices_test.go     | 122 ++++
 .../api/v3/federation_federation_resolvers_test.go | 157 +++++
 .../testing/api/v3/federation_users_test.go        | 305 ++++-----
 traffic_ops/testing/api/v3/federations_test.go     | 454 ++++++-------
 traffic_ops/testing/api/v3/tc-fixtures.json        |   8 +
 traffic_ops/testing/api/v3/withobjs_test.go        |   4 +
 traffic_ops/testing/api/v4/cdn_federations_test.go | 301 +++++++++
 traffic_ops/testing/api/v4/cdnfederations_test.go  | 503 --------------
 .../api/v4/federation_deliveryservices_test.go     | 215 ++++++
 .../api/v4/federation_federation_resolvers_test.go | 158 +++++
 .../testing/api/v4/federation_users_test.go        | 559 ++++++---------
 traffic_ops/testing/api/v4/federations_test.go     | 751 ++++++---------------
 traffic_ops/testing/api/v4/withobjs_test.go        |   4 +
 15 files changed, 2015 insertions(+), 2099 deletions(-)

diff --git a/traffic_ops/testing/api/v3/cdn_federations_test.go b/traffic_ops/testing/api/v3/cdn_federations_test.go
new file mode 100644
index 0000000000..d6c1c913df
--- /dev/null
+++ b/traffic_ops/testing/api/v3/cdn_federations_test.go
@@ -0,0 +1,239 @@
+package v3
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/apache/trafficcontrol/lib/go-rfc"
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
+)
+
+var fedIDs = make(map[string]int)
+
+// All prerequisite Federations are associated to this cdn and this xmlID
+var cdnName = "cdn1"
+var xmlId = "ds1"
+
+func TestCDNFederations(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations}, func() {
+
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V3TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {tomorrow}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"OK when VALID ID parameter": {
+					ClientSession: TOSession,
+					RequestParams: url.Values{"id": {strconv.Itoa(GetFederationID(t, "the.cname.com.")())}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"SORTED by CNAME when ORDERBY=CNAME parameter": {
+					ClientSession: TOSession,
+					RequestParams: url.Values{"orderby": {"cname"}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationCNameSort()),
+				},
+			},
+			"PUT": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"cname":       "new.cname.",
+						"ttl":         34,
+						"description": "updated",
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationUpdateFields(map[string]interface{}{"CName": "new.cname."})),
+				},
+				"PRECONDITION FAILED when updating with IMS & IUS Headers": {
+					EndpointId:     GetFederationID(t, "booya.com."),
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfUnmodifiedSince: {currentTimeRFC}},
+					RequestBody: map[string]interface{}{
+						"cname":       "booya.com.",
+						"ttl":         34,
+						"description": "fooya",
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusPreconditionFailed)),
+				},
+				"PRECONDITION FAILED when updating with IFMATCH ETAG Header": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"cname":       "new.cname.",
+						"ttl":         34,
+						"description": "updated",
+					},
+					RequestHeaders: http.Header{rfc.IfMatch: {rfc.ETag(currentTime)}},
+					Expectations:   utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusPreconditionFailed)),
+				},
+			},
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {currentTimeRFC}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					var fedID int
+					cdnFederation := tc.CDNFederation{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &cdnFederation)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							if name == "OK when VALID ID parameter" {
+								if val, ok := testCase.RequestParams["id"]; ok {
+									id, err := strconv.Atoi(val[0])
+									assert.RequireNoError(t, err, "Failed to convert ID to an integer.")
+									fedID = id
+								}
+								resp, reqInf, err := testCase.ClientSession.GetCDNFederationsByIDWithHdr(cdnName, fedID, testCase.RequestHeaders)
+								for _, check := range testCase.Expectations {
+									check(t, reqInf, resp, tc.Alerts{}, err)
+								}
+							} else {
+								resp, reqInf, err := testCase.ClientSession.GetCDNFederationsByNameWithHdr(cdnName, testCase.RequestHeaders)
+								for _, check := range testCase.Expectations {
+									check(t, reqInf, resp.Response, resp.Alerts, err)
+								}
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.CreateCDNFederationByName(cdnFederation, cdnName)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "PUT":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.UpdateCDNFederationsByIDWithHdr(cdnFederation, cdnName, testCase.EndpointId(), testCase.RequestHeaders)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "DELETE":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.DeleteCDNFederationByID(cdnName, testCase.EndpointId())
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts.Alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func validateCDNFederationUpdateFields(expectedResp map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected CDN Federation response to not be nil.")
+		CDNFederationResp := resp.(tc.CDNFederation)
+		for field, expected := range expectedResp {
+			switch field {
+			case "CName":
+				assert.RequireNotNil(t, CDNFederationResp.CName, "Expected CName to not be nil.")
+				assert.Equal(t, expected, *CDNFederationResp.CName, "Expected CName to be %v, but got %s", expected, *CDNFederationResp.CName)
+			default:
+				t.Errorf("Expected field: %v, does not exist in response", field)
+			}
+		}
+	}
+}
+
+func validateCDNFederationCNameSort() utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, alerts tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected CDN Federation response to not be nil.")
+		var federationCNames []string
+		CDNFederationResp := resp.([]tc.CDNFederation)
+		for _, CDNFederation := range CDNFederationResp {
+			assert.RequireNotNil(t, CDNFederation.CName, "Expected CDN Federation CName to not be nil.")
+			federationCNames = append(federationCNames, *CDNFederation.CName)
+		}
+		assert.Equal(t, true, sort.StringsAreSorted(federationCNames), "List is not sorted by their names: %v", federationCNames)
+	}
+}
+
+func GetFederationID(t *testing.T, cname string) func() int {
+	return func() int {
+		ID, ok := fedIDs[cname]
+		assert.RequireEqual(t, true, ok, "Expected to find Federation CName: %s to have associated ID", cname)
+		return ID
+	}
+}
+
+func setFederationID(t *testing.T, cdnFederation tc.CDNFederation) {
+	assert.RequireNotNil(t, cdnFederation.CName, "Federation CName was nil after posting.")
+	assert.RequireNotNil(t, cdnFederation.ID, "Federation ID was nil after posting.")
+	fedIDs[*cdnFederation.CName] = *cdnFederation.ID
+}
+
+func CreateTestCDNFederations(t *testing.T) {
+	for _, federation := range testData.Federations {
+		dsResp, _, err := TOSession.GetDeliveryServiceByXMLIDNullableWithHdr(*federation.DeliveryServiceIDs.XmlId, nil)
+		assert.RequireNoError(t, err, "Could not get Delivery Service by XML ID: %v", err)
+		assert.RequireEqual(t, 1, len(dsResp), "Expected one Delivery Service, but got %d", len(dsResp))
+		assert.RequireNotNil(t, dsResp[0].CDNName, "Expected Delivery Service CDN Name to not be nil.")
+
+		resp, _, err := TOSession.CreateCDNFederationByName(federation, *dsResp[0].CDNName)
+		assert.NoError(t, err, "Could not create CDN Federations: %v - alerts: %+v", err, resp.Alerts)
+
+		// Need to save the ids, otherwise the other tests won't be able to reference the federations
+		setFederationID(t, resp.Response)
+		assert.RequireNotNil(t, resp.Response.ID, "Federation ID was nil after posting.")
+		assert.RequireNotNil(t, dsResp[0].ID, "Delivery Service ID was nil.")
+		_, err = TOSession.CreateFederationDeliveryServices(*resp.Response.ID, []int{*dsResp[0].ID}, false)
+		assert.NoError(t, err, "Could not create Federation Delivery Service: %v", err)
+	}
+}
+
+func DeleteTestCDNFederations(t *testing.T) {
+	for _, id := range fedIDs {
+		resp, _, err := TOSession.DeleteCDNFederationByID(cdnName, id)
+		assert.NoError(t, err, "Cannot delete federation #%d: %v - alerts: %+v", id, err, resp.Alerts)
+	}
+	data, _, _ := TOSession.GetCDNFederationsByNameWithHdr(cdnName, nil)
+	assert.Equal(t, 0, len(data.Response), "expected federation to be deleted")
+	fedIDs = make(map[string]int) // reset the global variable for the next test
+}
diff --git a/traffic_ops/testing/api/v3/cdnfederations_test.go b/traffic_ops/testing/api/v3/cdnfederations_test.go
deleted file mode 100644
index a920bc8ffb..0000000000
--- a/traffic_ops/testing/api/v3/cdnfederations_test.go
+++ /dev/null
@@ -1,334 +0,0 @@
-package v3
-
-/*
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import (
-	"encoding/json"
-	"net/http"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/apache/trafficcontrol/lib/go-rfc"
-	"github.com/apache/trafficcontrol/lib/go-tc"
-)
-
-var fedIDs []int
-
-func TestCDNFederations(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, DeliveryServices, CDNFederations}, func() {
-		SortTestCDNFederations(t)
-		UpdateTestCDNFederations(t)
-		GetTestCDNFederations(t)
-		currentTime := time.Now().UTC().Add(-5 * time.Second)
-		time := currentTime.Format(time.RFC1123)
-		var header http.Header
-		header = make(map[string][]string)
-		header.Set(rfc.IfUnmodifiedSince, time)
-		UpdateTestCDNFederationsWithHeaders(t, header)
-		header = make(map[string][]string)
-		etag := rfc.ETag(currentTime)
-		header.Set(rfc.IfMatch, etag)
-		UpdateTestCDNFederationsWithHeaders(t, header)
-	})
-}
-
-func UpdateTestCDNFederationsWithHeaders(t *testing.T, h http.Header) {
-	for _, id := range fedIDs {
-		fed, _, err := TOSession.GetCDNFederationsByIDWithHdr("cdn1", id, h)
-		if err != nil {
-			t.Errorf("cannot GET federation by id: %v", err)
-		}
-		if fed != nil && len(fed.Response) > 0 {
-			expectedCName := "new.cname."
-			fed.Response[0].CName = &expectedCName
-			_, reqInf, err := TOSession.UpdateCDNFederationsByIDWithHdr(fed.Response[0], "cdn1", id, h)
-			if err == nil {
-				t.Errorf("Expected an error saying precondition failed, but got none")
-			}
-			if reqInf.StatusCode != http.StatusPreconditionFailed {
-				t.Errorf("Expected status code 412, got %v", reqInf.StatusCode)
-			}
-		}
-	}
-}
-
-func TestFederationFederationResolvers(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, DeliveryServices, CDNFederations, FederationResolvers}, func() {
-		AssignTestFederationFederationResolvers(t)
-		GetTestFederationFederationResolvers(t)
-	})
-}
-
-func CreateTestCDNFederations(t *testing.T) {
-
-	// Every federation is associated with a cdn
-	for i, f := range testData.Federations {
-
-		// CDNs test data and Federations test data are not naturally parallel
-		if i >= len(testData.CDNs) {
-			break
-		}
-
-		data, _, err := TOSession.CreateCDNFederationByName(f, "cdn1")
-		if err != nil {
-			t.Errorf("could not POST federations: " + err.Error())
-		}
-		bytes, _ := json.Marshal(data)
-		t.Logf("POST Response: %s\n", bytes)
-
-		// need to save the ids, otherwise the other tests won't be able to reference the federations
-		if data.Response.ID == nil {
-			t.Error("Federation id is nil after posting")
-		} else {
-			fedIDs = append(fedIDs, *data.Response.ID)
-			resp, _, err := TOSession.GetDeliveryServiceByXMLIDNullable("ds1")
-			if err != nil {
-				t.Errorf("could not get delivery service by xml ID: %v", err)
-			}
-			if len(resp) != 1 {
-				t.Fatalf("expected one response for delivery service, but got %d", len(resp))
-			}
-			_, err = TOSession.CreateFederationDeliveryServices(*data.Response.ID, []int{*resp[0].ID}, false)
-			if err != nil {
-				t.Errorf("could not create federation delivery service: %v", err)
-			}
-		}
-	}
-}
-
-// This test will not work unless a given CDN has more than one federation associated with it.
-func SortTestCDNFederations(t *testing.T) {
-	var sortedList []string
-
-	//Create a new federation under the same CDN
-	cname := "bar.foo."
-	ttl := 50
-	description := "test"
-	f := tc.CDNFederation{ID: nil, CName: &cname, TTL: &ttl, Description: &description, LastUpdated: nil}
-	data, _, err := TOSession.CreateCDNFederationByName(f, "cdn1")
-	if err != nil {
-		t.Errorf("could not POST federations: " + err.Error())
-	}
-	bytes, _ := json.Marshal(data)
-	t.Logf("POST Response: %s\n", bytes)
-	id := *data.Response.ID
-
-	//Get list of federations for one type of cdn
-	opts := http.Header{}
-	opts.Set("orderby", "cname")
-	resp, _, err := TOSession.GetCDNFederationsByNameWithHdr("cdn1", opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v", err.Error())
-	}
-	for i, _ := range resp.Response {
-		sortedList = append(sortedList, *resp.Response[i].CName)
-	}
-
-	// Check if list was sorted
-	res := sort.SliceIsSorted(sortedList, func(p, q int) bool {
-		return sortedList[p] < sortedList[q]
-	})
-	if res != true {
-		t.Errorf("list is not sorted by their names: %v", sortedList)
-	}
-
-	// Delete the newly created federation
-	resp1, _, err1 := TOSession.DeleteCDNFederationByID("cdn1", id)
-	if err != nil {
-		t.Errorf("cannot DELETE federation by id: '%d' %v", id, err1)
-	}
-	bytes, _ = json.Marshal(resp1)
-	t.Logf("DELETE Response: %s\n", bytes)
-}
-
-func UpdateTestCDNFederations(t *testing.T) {
-
-	for _, id := range fedIDs {
-		fed, _, err := TOSession.GetCDNFederationsByID("cdn1", id)
-		if err != nil {
-			t.Errorf("cannot GET federation by id: %v", err)
-		}
-
-		expectedCName := "new.cname."
-		fed.Response[0].CName = &expectedCName
-		resp, _, err := TOSession.UpdateCDNFederationsByID(fed.Response[0], "cdn1", id)
-		if err != nil {
-			t.Errorf("cannot PUT federation by id: %v", err)
-		}
-		bytes, _ := json.Marshal(resp)
-		t.Logf("PUT Response: %s\n", bytes)
-
-		resp2, _, err := TOSession.GetCDNFederationsByID("cdn1", id)
-		if err != nil {
-			t.Errorf("cannot GET federation by id after PUT: %v", err)
-		}
-		bytes, _ = json.Marshal(resp2)
-		t.Logf("GET Response: %s\n", bytes)
-
-		if resp2.Response[0].CName == nil {
-			t.Error("CName is nil after updating")
-		} else if *resp2.Response[0].CName != expectedCName {
-			t.Errorf("results do not match actual: %s, expected: %s", *resp2.Response[0].CName, expectedCName)
-		}
-
-	}
-}
-
-func GetTestCDNFederations(t *testing.T) {
-
-	// TOSession.GetCDNFederationsByName can't be tested until
-	// POST /federations/{{id}}/deliveryservices has been
-	// created. (DELETE cdns/:name/federations/:id may need to
-	// clean up fedIDs connection?)
-
-	for _, id := range fedIDs {
-		data, _, err := TOSession.GetCDNFederationsByID("cdn1", id)
-		if err != nil {
-			t.Errorf("could not GET federations: " + err.Error())
-		}
-		bytes, _ := json.Marshal(data)
-		t.Logf("GET Response: %s\n", bytes)
-	}
-}
-
-func AssignTestFederationFederationResolvers(t *testing.T) {
-	// Setup
-	if len(fedIDs) < 2 {
-		t.Fatal("not enough federations to test")
-	}
-
-	frCnt := len(testData.FederationResolvers)
-	if frCnt < 2 {
-		t.Fatal("not enough federation resolvers to test")
-	}
-
-	frs, _, err := TOSession.GetFederationResolvers()
-	if err != nil {
-		t.Fatalf("Unexpected error getting Federation Resolvers: %v", err)
-	}
-	if len(frs) != frCnt {
-		t.Fatalf("Wrong number of Federation Resolvers from GET, want %d got %d", frCnt, len(frs))
-	}
-
-	frIDs := make([]int, 0, len(frs))
-	for _, fr := range frs {
-		frIDs = append(frIDs, int(*fr.ID))
-	}
-
-	// Test Cases
-	testCases := []struct {
-		description string
-		fedID       int
-		resolverIDs []int
-		replace     bool
-		err         string
-	}{
-		{
-			description: "Successfully assign one federation_resolver to a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[0:0],
-			replace:     false,
-			err:         "",
-		},
-		{
-			description: "Successfully assign multiple federation_resolver to a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[1:frCnt],
-			replace:     false,
-			err:         "",
-		},
-		{
-			description: "Successfully replace all federation_resolver for a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[0:frCnt],
-			replace:     true,
-			err:         "",
-		},
-		{
-			description: "Fail to assign federation_resolver to a federation when federation does not exist",
-			fedID:       -1,
-			resolverIDs: frIDs[0:0],
-			replace:     false,
-			err:         "no such Federation",
-		},
-	}
-
-	for _, c := range testCases {
-		t.Run(c.description, func(t *testing.T) {
-			_, _, err := TOSession.AssignFederationFederationResolver(c.fedID, c.resolverIDs, c.replace)
-
-			if err != nil && !strings.Contains(err.Error(), c.err) {
-				t.Fatalf("error: expected error result %v, want: %v", err, c.err)
-			}
-		})
-	}
-
-}
-
-func GetTestFederationFederationResolvers(t *testing.T) {
-	if len(fedIDs) < 2 {
-		t.Fatal("not enough federations to test")
-	}
-
-	testCases := []struct {
-		description string
-		fedID       int
-		hasRecords  bool
-	}{
-		{
-			description: "successfully get federation_federation_resolvers for a federation with some",
-			fedID:       fedIDs[0],
-			hasRecords:  true,
-		},
-		{
-			description: "successfully get federation_federation_resolvers for a federation without any",
-			fedID:       fedIDs[1],
-			hasRecords:  false,
-		},
-	}
-
-	for _, c := range testCases {
-		t.Run(c.description, func(t *testing.T) {
-			resp, _, err := TOSession.GetFederationFederationResolversByID(c.fedID)
-			if err != nil {
-				t.Fatalf("Error getting federation federation resolvers by federation id: %d, err: %s", c.fedID, err.Error())
-			}
-			if len(resp.Response) == 0 && c.hasRecords {
-				t.Fatalf("expected federation of ID %d to have associated federation resolvers, but had 0", c.fedID)
-			}
-		})
-	}
-}
-
-func DeleteTestCDNFederations(t *testing.T) {
-
-	for _, id := range fedIDs {
-		resp, _, err := TOSession.DeleteCDNFederationByID("cdn1", id)
-		if err != nil {
-			t.Errorf("cannot DELETE federation by id: '%d' %v", id, err)
-		}
-		bytes, err := json.Marshal(resp)
-		t.Logf("DELETE Response: %s\n", bytes)
-
-		data, _, err := TOSession.GetCDNFederationsByID("cdn1", id)
-		if len(data.Response) != 0 {
-			t.Error("expected federation to be deleted")
-		}
-	}
-	fedIDs = nil // reset the global variable for the next test
-}
diff --git a/traffic_ops/testing/api/v3/federation_deliveryservices_test.go b/traffic_ops/testing/api/v3/federation_deliveryservices_test.go
new file mode 100644
index 0000000000..c9c58bae7d
--- /dev/null
+++ b/traffic_ops/testing/api/v3/federation_deliveryservices_test.go
@@ -0,0 +1,122 @@
+package v3
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/lib/go-util"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+)
+
+func TestFederationsDeliveryServices(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Tenants, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationDeliveryServices}, func() {
+
+		methodTests := utils.V3TestCase{
+			"GET": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1)),
+				},
+			},
+			"DELETE": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestParams: url.Values{"dsID": {strconv.Itoa(GetDeliveryServiceId(t, "ds1")())}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when LAST DELIVERY SERVICE": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestParams: url.Values{"dsID": {strconv.Itoa(GetDeliveryServiceId(t, "ds2")())}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					var dsID int
+					fedDS := tc.FederationDSPost{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &fedDS)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationDeliveryServicesWithHdr(testCase.EndpointId(), testCase.RequestHeaders)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp, tc.Alerts{}, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							reqInf, err := testCase.ClientSession.CreateFederationDeliveryServices(testCase.EndpointId(), fedDS.DSIDs, *fedDS.Replace)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, tc.Alerts{}, err)
+							}
+						})
+					case "DELETE":
+						t.Run(name, func(t *testing.T) {
+							if val, ok := testCase.RequestParams["dsID"]; ok {
+								id, err := strconv.Atoi(val[0])
+								assert.RequireNoError(t, err, "Failed to convert dsID to an integer.")
+								dsID = id
+							}
+							alerts, reqInf, err := testCase.ClientSession.DeleteFederationDeliveryService(testCase.EndpointId(), dsID)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func CreateTestFederationDeliveryServices(t *testing.T) {
+	// Prerequisite Federation Delivery Services
+	federationDS := map[string]tc.FederationDSPost{
+		"the.cname.com.": {
+			DSIDs:   []int{GetDeliveryServiceId(t, "ds1")(), GetDeliveryServiceId(t, "ds2")(), GetDeliveryServiceId(t, "ds3")(), GetDeliveryServiceId(t, "ds4")()},
+			Replace: util.BoolPtr(true),
+		},
+		"google.com.": {
+			DSIDs:   []int{GetDeliveryServiceId(t, "ds1")()},
+			Replace: util.BoolPtr(true),
+		},
+	}
+
+	for federation, fedDS := range federationDS {
+		_, err := TOSession.CreateFederationDeliveryServices(GetFederationID(t, federation)(), fedDS.DSIDs, *fedDS.Replace)
+		assert.RequireNoError(t, err, "Creating federations delivery services: %v", err)
+	}
+}
diff --git a/traffic_ops/testing/api/v3/federation_federation_resolvers_test.go b/traffic_ops/testing/api/v3/federation_federation_resolvers_test.go
new file mode 100644
index 0000000000..0c7eee5915
--- /dev/null
+++ b/traffic_ops/testing/api/v3/federation_federation_resolvers_test.go
@@ -0,0 +1,157 @@
+package v3
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+)
+
+func TestFederationFederationResolvers(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationResolvers, FederationFederationResolvers}, func() {
+
+		methodTests := utils.V3TestCase{
+			"GET": {
+				"OK when VALID request AND RESOLVERS ASSIGNED": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1)),
+				},
+				"OK when VALID request AND NO RESOLVERS ASSIGNED": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseHasLength(0)),
+				},
+			},
+			"POST": {
+				"OK when ASSIGNING ONE FEDERATION RESOLVER": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "1.2.3.4")()},
+						"replace":     false,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when ASSIGNING MULTIPLE FEDERATION RESOLVERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{
+							GetFederationResolverID(t, "1.2.3.4")(),
+							GetFederationResolverID(t, "0.0.0.0/12")(),
+							GetFederationResolverID(t, "::f1d0:f00d/123")(),
+						},
+						"replace": false,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when REPLACING ALL FEDERATION RESOLVERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "dead::babe")()},
+						"replace":     true,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when FEDERATION DOESNT EXIST": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "1.2.3.4")()},
+						"replace":     false,
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					frAssignment := tc.AssignFederationResolversRequest{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &frAssignment)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationFederationResolversByID(testCase.EndpointId())
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.AssignFederationFederationResolver(testCase.EndpointId(), frAssignment.FedResolverIDs, frAssignment.Replace)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func CreateTestFederationFederationResolvers(t *testing.T) {
+	// Prerequisite Federation Federation Resolvers
+	federationFederationResolvers := map[string]tc.AssignFederationResolversRequest{
+		"booya.com.": {
+			FedResolverIDs: []int{
+				GetFederationResolverID(t, "1.2.3.4")(),
+				GetFederationResolverID(t, "0.0.0.0/12")(),
+				GetFederationResolverID(t, "::f1d0:f00d/123")(),
+				GetFederationResolverID(t, "dead::babe")(),
+			},
+			Replace: false,
+		},
+	}
+
+	for cname, federationFederationResolver := range federationFederationResolvers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.AssignFederationFederationResolver(fedID, federationFederationResolver.FedResolverIDs, federationFederationResolver.Replace)
+		assert.RequireNoError(t, err, "Assigning resolvers %v to federation %d: %v - alerts: %+v", federationFederationResolver.FedResolverIDs, fedID, err, resp.Alerts)
+	}
+}
+
+func DeleteTestFederationFederationResolvers(t *testing.T) {
+	// Prerequisite Federation Federation Resolvers
+	federationFederationResolvers := map[string]tc.AssignFederationResolversRequest{
+		"booya.com.": {
+			FedResolverIDs: []int{},
+			Replace:        true,
+		},
+	}
+
+	for cname, federationFederationResolver := range federationFederationResolvers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.AssignFederationFederationResolver(fedID, federationFederationResolver.FedResolverIDs, federationFederationResolver.Replace)
+		assert.RequireNoError(t, err, "Assigning resolvers %v to federation %d: %v - alerts: %+v", federationFederationResolver.FedResolverIDs, fedID, err, resp.Alerts)
+	}
+}
diff --git a/traffic_ops/testing/api/v3/federation_users_test.go b/traffic_ops/testing/api/v3/federation_users_test.go
index 1fdcf8c5e5..c328ef5e8e 100644
--- a/traffic_ops/testing/api/v3/federation_users_test.go
+++ b/traffic_ops/testing/api/v3/federation_users_test.go
@@ -16,196 +16,161 @@ package v3
 */
 
 import (
+	"encoding/json"
 	"net/http"
 	"testing"
 	"time"
 
 	"github.com/apache/trafficcontrol/lib/go-rfc"
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/lib/go-util"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
 )
 
 func TestFederationUsers(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, DeliveryServices, CDNFederations, FederationUsers}, func() {
-		currentTime := time.Now().UTC().Add(-5 * time.Second)
-		time := currentTime.Format(time.RFC1123)
-		var header http.Header
-		header = make(map[string][]string)
-		header.Set(rfc.IfModifiedSince, time)
-		CreateTestInvalidFederationUsers(t)
-		GetTestInvalidFederationIDUsers(t)
-		CreateTestValidFederationUsers(t)
-		GetTestValidFederationIDUsersIMSAfterChange(t, header)
+	WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationUsers}, func() {
+
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V3TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					EndpointId:     GetFederationID(t, "the.cname.com."),
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {tomorrow}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"BAD REQUEST when INVALID FEDERATION ID": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+			},
+			"POST": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "readonlyuser")(), GetUserID(t, "disalloweduser")()}, "replace": false},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when REPLACING USERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "readonlyuser")()}, "replace": true},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when ADDING USER": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "disalloweduser")()}, "replace": false},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when INVALID FEDERATION ID": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{}, "replace": false},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+				"BAD REQUEST when INVALID USER ID": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{-1}, "replace": false},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+			},
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					EndpointId:     GetFederationID(t, "the.cname.com."),
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {currentTimeRFC}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					federationUser := tc.FederationUserPost{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &federationUser)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationUsersWithHdr(testCase.EndpointId(), testCase.RequestHeaders)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp, tc.Alerts{}, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.CreateFederationUsers(testCase.EndpointId(), federationUser.IDs, *federationUser.Replace)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
 	})
 }
 
-func GetTestValidFederationIDUsersIMSAfterChange(t *testing.T, header http.Header) {
-	_, reqInf, err := TOSession.GetFederationUsersWithHdr(fedIDs[0], header)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v", err)
-	}
-	if reqInf.StatusCode != http.StatusOK {
-		t.Fatalf("Expected 200 status code, got %v", reqInf.StatusCode)
-	}
-	currentTime := time.Now().UTC()
-	currentTime = currentTime.Add(1 * time.Second)
-	timeStr := currentTime.Format(time.RFC1123)
-	header.Set(rfc.IfModifiedSince, timeStr)
-	_, reqInf, err = TOSession.GetFederationUsersWithHdr(fedIDs[0], header)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v", err)
-	}
-	if reqInf.StatusCode != http.StatusNotModified {
-		t.Fatalf("Expected 304 status code, got %v", reqInf.StatusCode)
+func GetUserID(t *testing.T, username string) func() int {
+	return func() int {
+		users, _, err := TOSession.GetUserByUsernameWithHdr(username, nil)
+		assert.RequireNoError(t, err, "Get Users Request failed with error:", err)
+		assert.RequireEqual(t, 1, len(users), "Expected response object length 1, but got %d", len(users))
+		assert.RequireNotNil(t, users[0].ID, "Expected ID to not be nil.")
+		return *users[0].ID
 	}
 }
 
 func CreateTestFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	fedID := fedIDs[0]
-
-	// Get Users
-	users, _, err := TOSession.GetUsers()
-	if err != nil {
-		t.Fatalf("getting users: " + err.Error())
-	}
-	if len(users) < 3 {
-		t.Fatal("need > 3 users to create federation users")
-	}
-
-	u1 := users[0].ID
-	u2 := users[1].ID
-	u3 := users[2].ID
-
-	// Associate one user to federation
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*u1}, false)
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %v: %v", []int{*u1}, fedID, err.Error())
-	}
-
-	fedUsers, _, err := TOSession.GetFederationUsers(fedID)
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v", fedID, err.Error())
-	}
-	if len(fedUsers) != 1 {
-		t.Errorf("federation users expected 1, actual: %+v", len(fedUsers))
-	}
-
-	// Associate two users to federation and replace first one
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*u2, *u3}, true)
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %v: %v", []int{*u2, *u3}, fedID, err.Error())
-	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID)
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v", fedID, err.Error())
-	}
-	if len(fedUsers) != 2 {
-		t.Errorf("federation users expected 2, actual: %+v", len(fedUsers))
-	}
-
-	// Associate one more user to federation
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*u1}, false)
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %v: %v", []int{*u1}, fedID, err.Error())
-	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID)
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v", fedID, err.Error())
-	}
-	if len(fedUsers) != 3 {
-		t.Errorf("federation users expected 2, actual: %+v", len(fedUsers))
-	}
-}
-
-func GetTestInvalidFederationIDUsers(t *testing.T) {
-	_, _, err := TOSession.GetFederationUsers(-1)
-	if err == nil {
-		t.Fatalf("expected to get an error when requesting federation users for a non-existent federation")
-	}
-}
-
-func CreateTestValidFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	fedID := fedIDs[0]
-
-	// Get Users
-	users, _, err := TOSession.GetUsers()
-	if err != nil {
-		t.Fatalf("getting users: " + err.Error())
-	}
-	if len(users) == 0 {
-		t.Fatal("need at least 1 user to test invalid federation user create")
-	}
-
-	// Associate with invalid federdation id
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*users[0].ID}, false)
-	if err == nil {
-		t.Error("expected to get error back from associating non existent federation id")
-	}
-}
-func CreateTestInvalidFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	fedID := fedIDs[0]
-
-	// Get Users
-	users, _, err := TOSession.GetUsers()
-	if err != nil {
-		t.Fatalf("getting users: " + err.Error())
-	}
-	if len(users) == 0 {
-		t.Fatal("need at least 1 user to test invalid federation user create")
-	}
-
-	// Associate with invalid federdation id
-	_, _, err = TOSession.CreateFederationUsers(-1, []int{*users[0].ID}, false)
-	if err == nil {
-		t.Error("expected to get error back from associating non existent federation id")
-	}
-
-	// Associate with invalid user id
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{-1}, false)
-	if err == nil {
-		t.Error("expected to get error back from associating non existent user id")
+	// Prerequisite Federation Users
+	federationUsers := map[string]tc.FederationUserPost{
+		"the.cname.com.": {
+			IDs:     []int{GetUserID(t, "admin")(), GetUserID(t, "adminuser")(), GetUserID(t, "disalloweduser")(), GetUserID(t, "readonlyuser")()},
+			Replace: util.BoolPtr(false),
+		},
+		"booya.com.": {
+			IDs:     []int{GetUserID(t, "adminuser")()},
+			Replace: util.BoolPtr(false),
+		},
+	}
+
+	for cname, federationUser := range federationUsers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.CreateFederationUsers(fedID, federationUser.IDs, *federationUser.Replace)
+		assert.RequireNoError(t, err, "Assigning users %v to federation %d: %v - alerts: %+v", federationUser.IDs, fedID, err, resp.Alerts)
 	}
 }
 
 func DeleteTestFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	fedID := fedIDs[0]
-
-	fedUsers, _, err := TOSession.GetFederationUsers(fedID)
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v", fedID, err.Error())
-	}
-	if len(fedUsers) != 3 {
-		t.Errorf("federation users expected 3, actual: %+v", len(fedUsers))
-	}
-
-	for _, fedUser := range fedUsers {
-		_, _, err = TOSession.DeleteFederationUser(fedID, *fedUser.ID)
-		if err != nil {
-			t.Fatalf("deleting user %v from federation %v: %v", *fedUser.ID, fedID, err.Error())
+	for _, fedID := range fedIDs {
+		fedUsers, _, err := TOSession.GetFederationUsersWithHdr(fedID, nil)
+		assert.RequireNoError(t, err, "Error getting users for federation %d: %v", fedID, err)
+		for _, fedUser := range fedUsers {
+			if fedUser.ID == nil {
+				t.Error("Traffic Ops returned a representation of a relationship between a user and a Federation that had null or undefined ID")
+				continue
+			}
+			alerts, _, err := TOSession.DeleteFederationUser(fedID, *fedUser.ID)
+			assert.NoError(t, err, "Error deleting user #%d from federation #%d: %v - alerts: %+v", *fedUser.ID, fedID, err, alerts.Alerts)
 		}
 	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID)
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v", fedID, err.Error())
-	}
-	if len(fedUsers) != 0 {
-		t.Errorf("federation users expected 0, actual: %+v", len(fedUsers))
+	for _, fedID := range fedIDs {
+		fedUsers, _, err := TOSession.GetFederationUsersWithHdr(fedID, nil)
+		assert.NoError(t, err, "Error getting users for federation %d: %v", fedID, err)
+		assert.Equal(t, 0, len(fedUsers), "Federation users expected 0, actual: %+v", len(fedUsers))
 	}
 }
diff --git a/traffic_ops/testing/api/v3/federations_test.go b/traffic_ops/testing/api/v3/federations_test.go
index 8dd4191ea5..6ae514be90 100644
--- a/traffic_ops/testing/api/v3/federations_test.go
+++ b/traffic_ops/testing/api/v3/federations_test.go
@@ -16,253 +16,255 @@ package v3
 */
 
 import (
-	"errors"
-	"fmt"
+	"encoding/json"
 	"net/http"
 	"testing"
 	"time"
 
 	"github.com/apache/trafficcontrol/lib/go-rfc"
 	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
 )
 
 func TestFederations(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Tenants, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, DeliveryServices, CDNFederations}, func() {
-		PostDeleteTestFederationsDeliveryServices(t)
-		GetTestFederations(t)
-		GetTestFederationsIMS(t)
-		AddFederationResolversForCurrentUserTest(t)
-		RemoveFederationResolversForCurrentUserTest(t)
-	})
-}
-
-func GetTestFederationsIMS(t *testing.T) {
-	var header http.Header
-	header = make(map[string][]string)
-	futureTime := time.Now().AddDate(0, 0, 1)
-	time := futureTime.Format(time.RFC1123)
-	header.Set(rfc.IfModifiedSince, time)
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	_, reqInf, err := TOSession.AllFederationsWithHdr(header)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v", err)
-	}
-	if reqInf.StatusCode != http.StatusNotModified {
-		t.Fatalf("Expected 304 status code, got %v", reqInf.StatusCode)
-	}
-}
-
-func GetTestFederations(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	feds, _, err := TOSession.AllFederations()
-	if err != nil {
-		t.Errorf("getting federations: " + err.Error())
-	}
-
-	if len(feds) < 1 {
-		t.Errorf("expected atleast 1 federation, but got none")
-	}
-	fed := feds[0]
-
-	if len(fed.Mappings) < 1 {
-		t.Error("federation mappings expected <0, actual: 0")
-	}
-
-	mapping := fed.Mappings[0]
-	if mapping.CName == nil {
-		t.Error("federation mapping expected cname, actual: nil")
-	}
-	if mapping.TTL == nil {
-		t.Error("federation mapping expected ttl, actual: nil")
-	}
-
-	matched := false
-	for _, testFed := range testData.Federations {
-		if testFed.CName == nil {
-			t.Error("test federation missing cname!")
-		}
-		if testFed.TTL == nil {
-			t.Error("test federation missing ttl!")
-		}
-
-		if *mapping.CName != *testFed.CName {
-			continue
+	WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationDeliveryServices, FederationUsers}, func() {
+
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V3TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {tomorrow}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1),
+						validateAllFederationsFields([]map[string]interface{}{
+							{
+								"DeliveryService": "ds1",
+								"Mappings": []map[string]interface{}{
+									{
+										"CName": "the.cname.com.",
+										"TTL":   48,
+									},
+									{
+										"CName": "booya.com.",
+										"TTL":   34,
+									},
+									{
+										"CName": "google.com.",
+										"TTL":   30,
+									},
+								},
+							},
+						})),
+				},
+			},
+			"POST": {
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "ds1",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"0.0.0.0"},
+									"resolve6": []string{"::1"},
+								},
+							},
+							{
+								"deliveryService": "ds2",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"1234::/110"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"CONFLICT when INVALID DELIVERY SERVICE": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "aoeuhtns",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"dead::beef", "f1d0::f00d/82"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)),
+				},
+			},
+			"PUT": {
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "ds1",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"192.0.2.0/25", "192.0.2.128/25"},
+									"resolve6": []string{"2001:db8::/33", "2001:db8:8000::/33"},
+								},
+							},
+							{
+								"deliveryService": "ds2",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"192.0.2.0/25", "192.0.2.128/25"},
+									"resolve6": []string{"2001:db8::/33", "2001:db8:8000::/33"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationsUpdateFields([]map[string]interface{}{
+							{
+								"DeliveryService": "ds1",
+								"Resolve4":        []string{"192.0.2.0/25", "192.0.2.128/25"},
+								"Resolve6":        []string{"2001:db8::/33", "2001:db8:8000::/33"},
+							},
+							{
+								"DeliveryService": "ds2",
+								"Resolve4":        []string{"192.0.2.0/25", "192.0.2.128/25"},
+								"Resolve6":        []string{"2001:db8::/33", "2001:db8:8000::/33"},
+							},
+						})),
+				},
+				"CONFLICT when INVALID DELIVERY SERVICE": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "aoeuhtns",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"dead::beef", "f1d0::f00d/82"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)),
+				},
+			},
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					ClientSession:  TOSession,
+					RequestHeaders: http.Header{rfc.IfModifiedSince: {currentTimeRFC}},
+					Expectations:   utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+			},
 		}
-		matched = true
 
-		if *mapping.TTL != *testFed.TTL {
-			t.Errorf("federation mapping ttl expected: %v, actual: %v", *testFed.TTL, *mapping.TTL)
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					federation := tc.DeliveryServiceFederationResolverMappingRequest{}
+
+					if testCase.RequestBody != nil {
+						for _, federationRequest := range testCase.RequestBody {
+							dat, err := json.Marshal(federationRequest)
+							assert.RequireNoError(t, err, "Error occurred when marshalling request body: %v", err)
+							err = json.Unmarshal(dat, &federation)
+							assert.RequireNoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+						}
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.AllFederationsWithHdr(testCase.RequestHeaders)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp, tc.Alerts{}, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.AddFederationResolverMappingsForCurrentUser(federation)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					case "PUT":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.ReplaceFederationResolverMappingsForCurrentUser(federation)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
 		}
-	}
-	if !matched {
-		t.Errorf("federation mapping expected to match test data, actual: cname %v not in test data", *mapping.CName)
-	}
-}
-
-func createFederationToDeliveryServiceAssociation() (int, tc.DeliveryServiceNullable, tc.DeliveryServiceNullable, error) {
-	dses, _, err := TOSession.GetDeliveryServicesNullable()
-	if err != nil {
-		return -1, tc.DeliveryServiceNullable{}, tc.DeliveryServiceNullable{}, fmt.Errorf("cannot GET DeliveryServices: %v - %v", err, dses)
-	}
-	if len(dses) == 0 {
-		return -1, tc.DeliveryServiceNullable{}, tc.DeliveryServiceNullable{}, errors.New("no delivery services, must have at least 1 ds to test federations deliveryservices")
-	}
-	ds := dses[0]
-	ds1 := dses[1]
-
-	if len(fedIDs) == 0 {
-		return -1, ds, ds1, errors.New("no federations, must have at least 1 federation to test federations deliveryservices")
-	}
-	fedID := fedIDs[0]
-
-	_, err = TOSession.CreateFederationDeliveryServices(fedID, []int{*ds.ID, *ds1.ID}, true)
-	if err != nil {
-		err = fmt.Errorf("creating federations delivery services: %v", err)
-	}
-
-	return fedID, ds, ds1, err
 
+		t.Run("DELETE/OK when VALID request", func(t *testing.T) {
+			alerts, reqInf, err := TOSession.DeleteFederationResolverMappingsForCurrentUser()
+			for _, check := range utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)) {
+				check(t, reqInf, nil, alerts, err)
+			}
+		})
+
+		t.Run("DELETE/CONFLICT when NO FEDERATION RESOLVERS", func(t *testing.T) {
+			alerts, reqInf, err := TOSession.DeleteFederationResolverMappingsForCurrentUser()
+			for _, check := range utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)) {
+				check(t, reqInf, nil, alerts, err)
+			}
+		})
+	})
 }
 
-func PostDeleteTestFederationsDeliveryServices(t *testing.T) {
-	fedID, ds, ds1, err := createFederationToDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	// Test get created Federation Delivery Services
-	fedDSes, _, err := TOSession.GetFederationDeliveryServices(fedID)
-	if err != nil {
-		t.Fatalf("cannot GET Federation DeliveryServices: %v", err)
-	}
-	if len(fedDSes) != 2 {
-		t.Fatalf("two Federation DeliveryService expected for Federation %v, %v was returned", fedID, len(fedDSes))
-	}
-
-	// Delete one of the Delivery Services from the Federation
-	_, _, err = TOSession.DeleteFederationDeliveryService(fedID, *ds.ID)
-	if err != nil {
-		t.Fatalf("cannot Delete Federation %v DeliveryService %v: %v", fedID, ds.ID, err)
-	}
-
-	// Make sure it is deleted
-
-	// Test get created Federation Delivery Services
-	fedDSes, _, err = TOSession.GetFederationDeliveryServices(fedID)
-	if err != nil {
-		t.Fatalf("cannot GET Federation DeliveryServices: %v", err)
-	}
-	if len(fedDSes) != 1 {
-		t.Fatalf("one Federation DeliveryService expected for Federation %v, %v was returned", fedID, len(fedDSes))
-	}
-
-	// Attempt to delete the last one which should fail as you cannot remove the last
-	_, _, err = TOSession.DeleteFederationDeliveryService(fedID, *ds1.ID)
-	if err == nil {
-		t.Fatal("expected to receive error from attempting to delete last Delivery Service from a Federation")
-	}
-}
-
-func RemoveFederationResolversForCurrentUserTest(t *testing.T) {
-	if len(testData.Federations) < 1 {
-		t.Fatal("No test Federations, deleting resolvers cannot be tested!")
-	}
-
-	alerts, _, err := TOSession.DeleteFederationResolverMappingsForCurrentUser()
-	if err != nil {
-		t.Fatalf("Unexpected error deleting Federation Resolvers for current user: %v", err)
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.SuccessLevel.String() {
-			t.Logf("Success message from current user Federation Resolver deletion: %s", a.Text)
-		} else {
-			t.Errorf("Unexpected %s from deleting Federation Resolvers for current user: %s", a.Level, a.Text)
+func validateFederationFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected Federation response to not be nil.")
+		federationResp := resp.([]tc.AllDeliveryServiceFederationsMapping)
+		for _, expectedFed := range expectedResp {
+			for _, federation := range federationResp {
+				if federation.DeliveryService.String() == expectedFed["DeliveryService"] {
+					assert.RequireEqual(t, 1, len(federation.Mappings), "expected 1 mapping, got %d", len(federation.Mappings))
+					assert.Exactly(t, expectedFed["Resolve4"], federation.Mappings[0].Resolve4, "checking federation resolver mappings, expected: %+v, actual: %+v", expectedFed["Resolve4"], federation.Mappings[0].Resolve4)
+					assert.Exactly(t, expectedFed["Resolve6"], federation.Mappings[0].Resolve6, "checking federation resolver mappings, expected: %+v, actual: %+v", expectedFed["Resolve6"], federation.Mappings[0].Resolve6)
+				}
+			}
 		}
 	}
-
-	// Now try deleting Federation Resolvers when there are none.
-	_, _, err = TOSession.DeleteFederationResolverMappingsForCurrentUser()
-	if err != nil {
-		t.Logf("Received expected error deleting Federation Resolvers for current user: %v", err)
-	} else {
-		t.Error("Expected an error deleting zero Federation Resolvers, but didn't get one.")
-	}
 }
 
-func AddFederationResolversForCurrentUserTest(t *testing.T) {
-	fedID, ds, ds1, err := createFederationToDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	// need to assign myself the federation to set its mappings
-	me, _, err := TOSession.GetUserCurrent()
-	if err != nil {
-		t.Fatalf("Couldn't figure out who I am: %v", err)
-	}
-	if me.ID == nil {
-		t.Fatal("Current user has no ID, cannot continue.")
-	}
-
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*me.ID}, false)
-	if err != nil {
-		t.Fatalf("Failed to assign federation to current user: %v", err)
-	}
-
-	mappings := tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{"0.0.0.0"},
-				Resolve6: []string{"::1"},
-			},
-		},
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds1.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{"1.2.3.4/28"},
-				Resolve6: []string{"1234::/110"},
-			},
-		},
-	}
-
-	alerts, _, err := TOSession.AddFederationResolverMappingsForCurrentUser(mappings)
-	if err != nil {
-		t.Fatalf("Unexpected error adding Federation Resolver mappings for the current user: %v", err)
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.SuccessLevel.String() {
-			t.Logf("Received expected success alert from adding Federation Resolver mappings for the current user: %s", a.Text)
-		} else {
-			t.Errorf("Unexpected %s from adding Federation Resolver mappings for the current user: %s", a.Level, a.Text)
-		}
-	}
-
-	mappings = tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: "aoeuhtns",
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{},
-				Resolve6: []string{"dead::beef", "f1d0::f00d/82"},
-			},
-		},
+func validateFederationsUpdateFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		federation, _, err := TOSession.FederationsWithHdr(nil)
+		assert.RequireNoError(t, err, "Error getting Federations: %v", err)
+		assert.RequireGreaterOrEqual(t, len(federation), 1, "Expected one Federation returned Got: %d", len(federation))
+		validateFederationFields(expectedResp)(t, toclientlib.ReqInf{}, federation, tc.Alerts{}, nil)
 	}
+}
 
-	alerts, _, err = TOSession.AddFederationResolverMappingsForCurrentUser(mappings)
-	if err == nil {
-		t.Fatal("Expected error adding Federation Resolver mappings for the current user, but didn't get one")
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level != tc.SuccessLevel.String() {
-			t.Logf("Received expected %s from adding Federation Resolver mappings for the current user: %s", a.Level, a.Text)
-		} else {
-			t.Errorf("Unexpected success from adding Federation Resolver mappings for the current user: %s", a.Text)
+func validateAllFederationsFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected All Federations response to not be nil.")
+		allFederationResp := resp.([]tc.AllDeliveryServiceFederationsMapping)
+		for _, expected := range expectedResp {
+			for _, allFed := range allFederationResp {
+				if allFed.DeliveryService.String() == expected["DeliveryService"] {
+					for _, mapping := range allFed.Mappings {
+						for _, expectedMapping := range expected["Mappings"].([]map[string]interface{}) {
+							assert.RequireNotNil(t, mapping.CName, "Expected CName to not be nil.")
+							if expectedMapping["CName"] == *mapping.CName {
+								assert.RequireNotNil(t, mapping.TTL, "Expected TTL to not be nil.")
+								assert.Equal(t, expectedMapping["TTL"], *mapping.TTL, "Expected TTL to be %v, but got %s", expected, allFed.Mappings[0].TTL)
+							}
+						}
+					}
+				}
+			}
 		}
 	}
 }
diff --git a/traffic_ops/testing/api/v3/tc-fixtures.json b/traffic_ops/testing/api/v3/tc-fixtures.json
index c5f43782d0..70ceccc4e2 100644
--- a/traffic_ops/testing/api/v3/tc-fixtures.json
+++ b/traffic_ops/testing/api/v3/tc-fixtures.json
@@ -1589,6 +1589,14 @@
             {
                 "xmlId": "ds1"
             }
+        },
+        {
+            "cname": "google.com.",
+            "ttl": 30,
+            "description": "google",
+            "deliveryService": {
+                "xmlId": "ds1"
+            }
         }
     ],
     "federation_resolvers": [
diff --git a/traffic_ops/testing/api/v3/withobjs_test.go b/traffic_ops/testing/api/v3/withobjs_test.go
index f13f2d51f5..464eadf672 100644
--- a/traffic_ops/testing/api/v3/withobjs_test.go
+++ b/traffic_ops/testing/api/v3/withobjs_test.go
@@ -55,7 +55,9 @@ const (
 	DeliveryServicesRequiredCapabilities
 	DeliveryServiceServerAssignments
 	Divisions
+	FederationDeliveryServices
 	FederationResolvers
+	FederationFederationResolvers
 	FederationUsers
 	Origins
 	Parameters
@@ -100,8 +102,10 @@ var withFuncs = map[TCObj]TCObjFuncs{
 	DeliveryServicesRequiredCapabilities:  {CreateTestDeliveryServicesRequiredCapabilities, DeleteTestDeliveryServicesRequiredCapabilities},
 	DeliveryServiceServerAssignments:      {CreateTestDeliveryServiceServerAssignments, DeleteTestDeliveryServiceServers},
 	Divisions:                             {CreateTestDivisions, DeleteTestDivisions},
+	FederationDeliveryServices:            {CreateTestFederationDeliveryServices, DeleteTestCDNFederations},
 	FederationUsers:                       {CreateTestFederationUsers, DeleteTestFederationUsers},
 	FederationResolvers:                   {CreateTestFederationResolvers, DeleteTestFederationResolvers},
+	FederationFederationResolvers:         {CreateTestFederationFederationResolvers, DeleteTestFederationFederationResolvers},
 	Origins:                               {CreateTestOrigins, DeleteTestOrigins},
 	Parameters:                            {CreateTestParameters, DeleteTestParameters},
 	PhysLocations:                         {CreateTestPhysLocations, DeleteTestPhysLocations},
diff --git a/traffic_ops/testing/api/v4/cdn_federations_test.go b/traffic_ops/testing/api/v4/cdn_federations_test.go
new file mode 100644
index 0000000000..145cc4701d
--- /dev/null
+++ b/traffic_ops/testing/api/v4/cdn_federations_test.go
@@ -0,0 +1,301 @@
+package v4
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/apache/trafficcontrol/lib/go-rfc"
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
+	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
+)
+
+var fedIDs = make(map[string]int)
+
+// All prerequisite Federations are associated to this cdn and this xmlID
+var cdnName = "cdn1"
+var xmlId = "ds1"
+
+func TestCDNFederations(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations}, func() {
+
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V4TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {tomorrow}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"OK when VALID ID parameter": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"id": {strconv.Itoa(GetFederationID(t, "the.cname.com.")())}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseHasLength(1)),
+				},
+				"SORTED by CNAME when ORDERBY=CNAME parameter": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"cname"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationCNameSort()),
+				},
+				"SORTED when ORDERBY=ID and SORTORDER=DESC": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "sortOrder": {"desc"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationIDDescSort()),
+				},
+				"FIRST RESULT when LIMIT=1": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationPagination("limit")),
+				},
+				"SECOND RESULT when LIMIT=1 OFFSET=1": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}, "offset": {"1"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationPagination("offset")),
+				},
+				"SECOND RESULT when LIMIT=1 PAGE=2": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}, "page": {"2"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationPagination("page")),
+				},
+				"BAD REQUEST when INVALID LIMIT parameter": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"-2"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID OFFSET parameter": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "offset": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID PAGE parameter": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "page": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+			},
+			"PUT": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"cname":       "new.cname.",
+						"ttl":         34,
+						"description": "updated",
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateCDNFederationUpdateFields(map[string]interface{}{"CName": "new.cname."})),
+				},
+				"PRECONDITION FAILED when updating with IMS & IUS Headers": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfUnmodifiedSince: {currentTimeRFC}}},
+					RequestBody: map[string]interface{}{
+						"cname":       "booya.com.",
+						"ttl":         34,
+						"description": "fooya",
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusPreconditionFailed)),
+				},
+				"PRECONDITION FAILED when updating with IFMATCH ETAG Header": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"cname":       "new.cname.",
+						"ttl":         34,
+						"description": "updated",
+					},
+					RequestOpts:  client.RequestOptions{Header: http.Header{rfc.IfMatch: {rfc.ETag(currentTime)}}},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusPreconditionFailed)),
+				},
+			},
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {currentTimeRFC}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					cdnFederation := tc.CDNFederation{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &cdnFederation)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetCDNFederationsByName(cdnName, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.CreateCDNFederation(cdnFederation, cdnName, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "PUT":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.UpdateCDNFederation(cdnFederation, cdnName, testCase.EndpointId(), testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "DELETE":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.DeleteCDNFederation(cdnName, testCase.EndpointId(), testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts.Alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func validateCDNFederationUpdateFields(expectedResp map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected CDN Federation response to not be nil.")
+		CDNFederationResp := resp.(tc.CDNFederation)
+		for field, expected := range expectedResp {
+			switch field {
+			case "CName":
+				assert.RequireNotNil(t, CDNFederationResp.CName, "Expected CName to not be nil.")
+				assert.Equal(t, expected, *CDNFederationResp.CName, "Expected CName to be %v, but got %s", expected, *CDNFederationResp.CName)
+			default:
+				t.Errorf("Expected field: %v, does not exist in response", field)
+			}
+		}
+	}
+}
+
+func validateCDNFederationPagination(paginationParam string) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		paginationResp := resp.([]tc.CDNFederation)
+
+		opts := client.NewRequestOptions()
+		opts.QueryParameters.Set("orderby", "id")
+		respBase, _, err := TOSession.GetCDNFederationsByName(cdnName, opts)
+		assert.RequireNoError(t, err, "Cannot get Federation Users: %v - alerts: %+v", err, respBase.Alerts)
+
+		CDNfederations := respBase.Response
+		assert.RequireGreaterOrEqual(t, len(CDNfederations), 3, "Need at least 3 CDN Federations in Traffic Ops to test pagination support, found: %d", len(CDNfederations))
+		switch paginationParam {
+		case "limit:":
+			assert.Exactly(t, CDNfederations[:1], paginationResp, "expected GET CDN Federations with limit = 1 to return first result")
+		case "offset":
+			assert.Exactly(t, CDNfederations[1:2], paginationResp, "expected GET CDN Federations with limit = 1, offset = 1 to return second result")
+		case "page":
+			assert.Exactly(t, CDNfederations[1:2], paginationResp, "expected GET CDN Federations with limit = 1, page = 2 to return second result")
+		}
+	}
+}
+
+func validateCDNFederationCNameSort() utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, alerts tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected CDN Federation response to not be nil.")
+		var federationCNames []string
+		CDNFederationResp := resp.([]tc.CDNFederation)
+		for _, CDNFederation := range CDNFederationResp {
+			assert.RequireNotNil(t, CDNFederation.CName, "Expected CDN Federation CName to not be nil.")
+			federationCNames = append(federationCNames, *CDNFederation.CName)
+		}
+		assert.Equal(t, true, sort.StringsAreSorted(federationCNames), "List is not sorted by their names: %v", federationCNames)
+	}
+}
+
+func validateCDNFederationIDDescSort() utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, alerts tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected CDN Federation response to not be nil.")
+		var CDNFederationIDs []int
+		CDNFederationResp := resp.([]tc.CDNFederation)
+		for _, federation := range CDNFederationResp {
+			CDNFederationIDs = append([]int{*federation.ID}, CDNFederationIDs...)
+		}
+		assert.Equal(t, true, sort.IntsAreSorted(CDNFederationIDs), "List is not sorted by their ids: %v", CDNFederationIDs)
+	}
+}
+
+func GetFederationID(t *testing.T, cname string) func() int {
+	return func() int {
+		ID, ok := fedIDs[cname]
+		assert.RequireEqual(t, true, ok, "Expected to find Federation CName: %s to have associated ID", cname)
+		return ID
+	}
+}
+
+func setFederationID(t *testing.T, cdnFederation tc.CDNFederation) {
+	assert.RequireNotNil(t, cdnFederation.CName, "Federation CName was nil after posting.")
+	assert.RequireNotNil(t, cdnFederation.ID, "Federation ID was nil after posting.")
+	fedIDs[*cdnFederation.CName] = *cdnFederation.ID
+}
+
+func CreateTestCDNFederations(t *testing.T) {
+	for _, federation := range testData.Federations {
+		opts := client.NewRequestOptions()
+		opts.QueryParameters.Set("xmlId", *federation.DeliveryServiceIDs.XmlId)
+		dsResp, _, err := TOSession.GetDeliveryServices(opts)
+		assert.RequireNoError(t, err, "Could not get Delivery Service by XML ID: %v", err)
+		assert.RequireEqual(t, 1, len(dsResp.Response), "Expected one Delivery Service, but got %d", len(dsResp.Response))
+		assert.RequireNotNil(t, dsResp.Response[0].CDNName, "Expected Delivery Service CDN Name to not be nil.")
+
+		resp, _, err := TOSession.CreateCDNFederation(federation, *dsResp.Response[0].CDNName, client.RequestOptions{})
+		assert.NoError(t, err, "Could not create CDN Federations: %v - alerts: %+v", err, resp.Alerts)
+
+		// Need to save the ids, otherwise the other tests won't be able to reference the federations
+		setFederationID(t, resp.Response)
+		assert.RequireNotNil(t, resp.Response.ID, "Federation ID was nil after posting.")
+		assert.RequireNotNil(t, dsResp.Response[0].ID, "Delivery Service ID was nil.")
+		_, _, err = TOSession.CreateFederationDeliveryServices(*resp.Response.ID, []int{*dsResp.Response[0].ID}, false, client.NewRequestOptions())
+		assert.NoError(t, err, "Could not create Federation Delivery Service: %v", err)
+	}
+}
+
+func DeleteTestCDNFederations(t *testing.T) {
+	opts := client.NewRequestOptions()
+	for _, id := range fedIDs {
+		resp, _, err := TOSession.DeleteCDNFederation(cdnName, id, opts)
+		assert.NoError(t, err, "Cannot delete federation #%d: %v - alerts: %+v", id, err, resp.Alerts)
+
+		opts.QueryParameters.Set("id", strconv.Itoa(id))
+		data, _, err := TOSession.GetCDNFederationsByName(cdnName, opts)
+		assert.Equal(t, 0, len(data.Response), "expected federation to be deleted")
+	}
+	fedIDs = make(map[string]int) // reset the global variable for the next test
+}
diff --git a/traffic_ops/testing/api/v4/cdnfederations_test.go b/traffic_ops/testing/api/v4/cdnfederations_test.go
deleted file mode 100644
index 38ceea0b3b..0000000000
--- a/traffic_ops/testing/api/v4/cdnfederations_test.go
+++ /dev/null
@@ -1,503 +0,0 @@
-package v4
-
-/*
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import (
-	"net/http"
-	"net/url"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/apache/trafficcontrol/lib/go-rfc"
-	"github.com/apache/trafficcontrol/lib/go-tc"
-	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
-)
-
-var fedIDs []int
-
-func TestCDNFederations(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations}, func() {
-		SortTestCDNFederations(t)
-		SortTestCDNFederationsDesc(t)
-		UpdateTestCDNFederations(t)
-		GetTestCDNFederations(t)
-		GetTestCDNFederationsIMS(t)
-		currentTime := time.Now().UTC().Add(-5 * time.Second)
-		time := currentTime.Format(time.RFC1123)
-		var header http.Header
-		header = make(map[string][]string)
-		header.Set(rfc.IfUnmodifiedSince, time)
-		UpdateTestCDNFederationsWithHeaders(t, header)
-		header = make(map[string][]string)
-		etag := rfc.ETag(currentTime)
-		header.Set(rfc.IfMatch, etag)
-		UpdateTestCDNFederationsWithHeaders(t, header)
-		GetTestPaginationSupportCdnFederation(t)
-	})
-}
-
-func UpdateTestCDNFederationsWithHeaders(t *testing.T, h http.Header) {
-	opts := client.NewRequestOptions()
-	opts.Header = h
-	for _, id := range fedIDs {
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		fed, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("cannot GET federation by id: %v - alerts: %+v", err, fed.Alerts)
-		}
-		if len(fed.Response) > 0 {
-			expectedCName := "new.cname."
-			fed.Response[0].CName = &expectedCName
-			_, reqInf, err := TOSession.UpdateCDNFederation(fed.Response[0], "cdn1", id, opts)
-			if err == nil {
-				t.Errorf("Expected an error saying precondition failed, but got none")
-			}
-			if reqInf.StatusCode != http.StatusPreconditionFailed {
-				t.Errorf("Expected status code 412, got %v", reqInf.StatusCode)
-			}
-		}
-	}
-}
-
-func TestFederationFederationResolvers(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationResolvers}, func() {
-		AssignTestFederationFederationResolvers(t)
-		GetTestFederationFederationResolvers(t)
-	})
-}
-
-func CreateTestCDNFederations(t *testing.T) {
-
-	// Every federation is associated with a cdn
-	for i, f := range testData.Federations {
-
-		// CDNs test data and Federations test data are not naturally parallel
-		if i >= len(testData.CDNs) {
-			break
-		}
-		opts := client.NewRequestOptions()
-		opts.QueryParameters.Set("xmlId", "ds1")
-		resp, _, err := TOSession.GetDeliveryServices(opts)
-		if err != nil {
-			t.Errorf("could not get delivery service by xml ID: %v", err)
-		}
-		if len(resp.Response) != 1 {
-			t.Fatalf("expected one response for delivery service, but got %d", len(resp.Response))
-		}
-		data, _, err := TOSession.CreateCDNFederation(f, "cdn1", client.RequestOptions{})
-		if err != nil {
-			t.Errorf("could not create CDN Federations: %v - alerts: %+v", err, data.Alerts)
-		}
-
-		// need to save the ids, otherwise the other tests won't be able to reference the federations
-		if data.Response.ID == nil {
-			t.Error("Federation id is nil after posting")
-		} else {
-			fedIDs = append(fedIDs, *data.Response.ID)
-			_, _, err = TOSession.CreateFederationDeliveryServices(*data.Response.ID, []int{*resp.Response[0].ID}, false, client.NewRequestOptions())
-			if err != nil {
-				t.Errorf("could not create federation delivery service: %v", err)
-			}
-		}
-	}
-}
-
-// This test will not work unless a given CDN has more than one federation associated with it.
-func SortTestCDNFederations(t *testing.T) {
-	var sortedList []string
-
-	//Create a new federation under the same CDN
-	cname := "bar.foo."
-	ttl := 50
-	description := "test"
-	f := tc.CDNFederation{ID: nil, CName: &cname, TTL: &ttl, Description: &description, LastUpdated: nil}
-	data, _, err := TOSession.CreateCDNFederation(f, "cdn1", client.RequestOptions{})
-	if err != nil {
-		t.Errorf("could not create CDN Federations: %v - alerts: %+v", err, data.Alerts)
-	}
-	id := *data.Response.ID
-
-	//Get list of federations for one type of cdn
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "cname")
-	resp, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v - alerts: %+v", err, resp.Alerts)
-	}
-	for i := range resp.Response {
-		if resp.Response[i].CName == nil {
-			t.Fatalf("Federation resolver CName is nil, so sorting can't be tested")
-		}
-		sortedList = append(sortedList, *resp.Response[i].CName)
-	}
-
-	// Check if list was sorted
-	res := sort.SliceIsSorted(sortedList, func(p, q int) bool {
-		return sortedList[p] < sortedList[q]
-	})
-	if res != true {
-		t.Errorf("list is not sorted by their CName: %v", sortedList)
-	}
-
-	// Delete the newly created federation
-	resp1, _, err := TOSession.DeleteCDNFederation("cdn1", id, client.RequestOptions{})
-	if err != nil {
-		t.Errorf("cannot delete federation #%d: %v - alerts: %+v", id, err, resp1.Alerts)
-	}
-}
-
-func SortTestCDNFederationsDesc(t *testing.T) {
-
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "id")
-	resp, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got error in CDN Federation default ordering %v - alerts: %+v", err, resp.Alerts)
-	}
-	respAsc := resp.Response
-	if len(respAsc) < 1 {
-		t.Fatal("Need at least one CDN Federation in Traffic Ops to test CDN Federation sort ordering")
-	}
-	opts.QueryParameters.Set("sortOrder", "desc")
-	resp, _, err = TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Errorf("Expected no error, but got error in CDN Federation with Descending ordering: %v - alerts: %+v", err, resp.Alerts)
-	}
-	respDesc := resp.Response
-	if len(respDesc) < 1 {
-		t.Fatal("Need at least one CDN Federation in Traffic Ops to test CDN Federation sort ordering")
-	}
-	if len(respAsc) != len(respDesc) {
-		t.Fatalf("Traffic Ops returned %d CDN Federation using default sort order, but %d CDN Federation when sort order was explicitly set to descending", len(respAsc), len(respDesc))
-	}
-	for start, end := 0, len(respDesc)-1; start < end; start, end = start+1, end-1 {
-		respDesc[start], respDesc[end] = respDesc[end], respDesc[start]
-	}
-	if respDesc[0].ID == nil || respAsc[0].ID == nil {
-		t.Fatalf("Response ID is nil in CDN Test federation")
-	}
-	if *respDesc[0].ID != *respAsc[0].ID {
-		t.Errorf("CDN Federation responses are not equal after reversal: Asc: %d - Desc: %d", *respDesc[0].ID, *respAsc[0].ID)
-	}
-}
-
-func UpdateTestCDNFederations(t *testing.T) {
-	opts := client.NewRequestOptions()
-	for _, id := range fedIDs {
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		fed, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("cannot get federation by id: %v - alerts: %+v", err, fed.Alerts)
-			continue
-		}
-		if len(fed.Response) < 1 {
-			t.Error("Response from Traffic Ops included no Federations")
-			continue
-		}
-
-		expectedCName := "new.cname."
-		fed.Response[0].CName = &expectedCName
-		resp, _, err := TOSession.UpdateCDNFederation(fed.Response[0], "cdn1", id, client.RequestOptions{})
-		if err != nil {
-			t.Errorf("cannot update federation by id: %v - alerts: %+v", err, resp.Alerts)
-		}
-
-		resp2, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("cannot get federation by id after update: %v - alerts: %+v", err, resp2.Alerts)
-		}
-		if len(resp2.Response) < 1 {
-			t.Error("cannot get federation by id after update: Federation not found in Traffic Ops response")
-		}
-
-		if resp2.Response[0].CName == nil {
-			t.Error("CName is nil after updating")
-		} else if *resp2.Response[0].CName != expectedCName {
-			t.Errorf("results do not match actual: %s, expected: %s", *resp2.Response[0].CName, expectedCName)
-		}
-
-	}
-}
-
-func GetTestCDNFederations(t *testing.T) {
-
-	// TOSession.GetCDNFederationsByName can't be tested until
-	// POST /federations/{{id}}/deliveryservices has been
-	// created. (DELETE cdns/:name/federations/:id may need to
-	// clean up fedIDs connection?)
-
-	opts := client.NewRequestOptions()
-	for _, id := range fedIDs {
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		data, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("could not get federations: %v - alerts: %+v", err, data.Alerts)
-		}
-	}
-}
-
-func GetTestCDNFederationsIMS(t *testing.T) {
-	futureTime := time.Now().AddDate(0, 0, 1)
-	fmtFutureTime := futureTime.Format(time.RFC1123)
-	opts := client.NewRequestOptions()
-	opts.Header.Set(rfc.IfModifiedSince, fmtFutureTime)
-	for _, id := range fedIDs {
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		data, reqInf, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("could not get federations: %v - alerts: %+v", err, data.Alerts)
-		}
-		if reqInf.StatusCode != http.StatusNotModified {
-			t.Fatalf("Expected 304 status code, got %v", reqInf.StatusCode)
-		}
-	}
-
-	pastTime := time.Now().AddDate(0, 0, -1)
-	fmtPastTime := pastTime.Format(time.RFC1123)
-	opts = client.NewRequestOptions()
-	opts.Header.Set(rfc.IfModifiedSince, fmtPastTime)
-	for _, id := range fedIDs {
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		data, reqInf, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if err != nil {
-			t.Errorf("could not get federations: %v - alerts: %+v", err, data.Alerts)
-		}
-		if reqInf.StatusCode != http.StatusOK {
-			t.Fatalf("Expected 200 status code, got %v", reqInf.StatusCode)
-		}
-	}
-}
-
-func AssignTestFederationFederationResolvers(t *testing.T) {
-	// Setup
-	if len(fedIDs) < 2 {
-		t.Fatal("not enough federations to test")
-	}
-
-	frCnt := len(testData.FederationResolvers)
-	if frCnt < 2 {
-		t.Fatal("not enough federation resolvers to test")
-	}
-
-	frs, _, err := TOSession.GetFederationResolvers(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Unexpected error getting Federation Resolvers: %v - alerts: %+v", err, frs.Alerts)
-	}
-	if len(frs.Response) != frCnt {
-		t.Fatalf("Wrong number of Federation Resolvers from GET, want %d got %d", frCnt, len(frs.Response))
-	}
-
-	frIDs := make([]int, 0, len(frs.Response))
-	for _, fr := range frs.Response {
-		if fr.ID == nil {
-			// Because we need 'frCnt' resolver ids, this is not recoverable
-			t.Fatal("Traffic Ops returned a representation for a Federation Resolver with null or undefined ID")
-		}
-		frIDs = append(frIDs, int(*fr.ID))
-	}
-
-	// Test Cases
-	testCases := []struct {
-		description string
-		fedID       int
-		resolverIDs []int
-		replace     bool
-		err         string
-	}{
-		{
-			description: "Successfully assign one federation_resolver to a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[0:0],
-			replace:     false,
-			err:         "",
-		},
-		{
-			description: "Successfully assign multiple federation_resolver to a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[1:frCnt],
-			replace:     false,
-			err:         "",
-		},
-		{
-			description: "Successfully replace all federation_resolver for a federation",
-			fedID:       fedIDs[0],
-			resolverIDs: frIDs[0:frCnt],
-			replace:     true,
-			err:         "",
-		},
-		{
-			description: "Fail to assign federation_resolver to a federation when federation does not exist",
-			fedID:       -1,
-			resolverIDs: frIDs[0:0],
-			replace:     false,
-			err:         "no such Federation",
-		},
-	}
-
-	for _, c := range testCases {
-		t.Run(c.description, func(t *testing.T) {
-			resp, _, err := TOSession.AssignFederationFederationResolver(c.fedID, c.resolverIDs, c.replace, client.RequestOptions{})
-			if err != nil {
-				if c.err == "" {
-					t.Errorf("Unexpected error assigning Federation Resolvers to Federation: %v - alerts: %+v", err, resp.Alerts)
-					return
-				}
-				found := false
-				for _, alert := range resp.Alerts.Alerts {
-					if alert.Level == tc.ErrorLevel.String() && strings.Contains(alert.Text, c.err) {
-						found = true
-					}
-				}
-				if !found {
-					t.Errorf("Expected to find an error-level alert relating to '%s', but didn't - err: %v - alerts: %+v", c.err, err, resp.Alerts)
-				}
-			} else if c.err != "" {
-				t.Errorf("Expected to get an error assigning Federation Resolvers to Federation, but didn't - alerts: %+v", resp.Alerts)
-			}
-		})
-	}
-
-}
-
-func GetTestFederationFederationResolvers(t *testing.T) {
-	if len(fedIDs) < 2 {
-		t.Fatal("not enough federations to test")
-	}
-
-	testCases := []struct {
-		description string
-		fedID       int
-		hasRecords  bool
-	}{
-		{
-			description: "successfully get federation_federation_resolvers for a federation with some",
-			fedID:       fedIDs[0],
-			hasRecords:  true,
-		},
-		{
-			description: "successfully get federation_federation_resolvers for a federation without any",
-			fedID:       fedIDs[1],
-			hasRecords:  false,
-		},
-	}
-
-	for _, c := range testCases {
-		t.Run(c.description, func(t *testing.T) {
-			resp, _, err := TOSession.GetFederationFederationResolvers(c.fedID, client.RequestOptions{})
-			if err != nil {
-				t.Fatalf("Error getting federation federation resolvers by federation id %d: %v - alerts: %+v", c.fedID, err, resp.Alerts)
-			}
-			if len(resp.Response) == 0 && c.hasRecords {
-				t.Fatalf("expected federation of ID %d to have associated federation resolvers, but had 0", c.fedID)
-			}
-		})
-	}
-}
-
-func DeleteTestCDNFederations(t *testing.T) {
-	opts := client.NewRequestOptions()
-	for _, id := range fedIDs {
-		resp, _, err := TOSession.DeleteCDNFederation("cdn1", id, opts)
-		if err != nil {
-			t.Errorf("cannot delete federation #%d: %v - alerts: %+v", id, err, resp.Alerts)
-		}
-
-		opts.QueryParameters.Set("id", strconv.Itoa(id))
-		data, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-		if len(data.Response) != 0 {
-			t.Error("expected federation to be deleted")
-		}
-		opts.QueryParameters.Del("id")
-	}
-	fedIDs = nil // reset the global variable for the next test
-}
-
-func GetTestPaginationSupportCdnFederation(t *testing.T) {
-
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "id")
-	resp, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("cannot Get CDN Federation by name: %v - alerts: %+v", err, resp.Alerts)
-	}
-	cdnFederation := resp.Response
-	if len(cdnFederation) < 3 {
-		t.Fatalf("Need at least 3 CDN Federation by name in Traffic Ops to test pagination support, found: %d", len(cdnFederation))
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	cdnFederationWithLimit, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("cannot Get CDN Federation by name with Limit: %v - alerts: %+v", err, cdnFederationWithLimit.Alerts)
-	}
-	if !reflect.DeepEqual(cdnFederation[:1], cdnFederationWithLimit.Response) {
-		t.Error("expected GET CDN Federation by name with limit = 1 to return first result")
-	}
-
-	opts.QueryParameters.Set("offset", "1")
-	cdnFederationWithOffset, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("cannot Get CDN Federation by name with Limit and Offset: %v - alerts: %+v", err, cdnFederationWithOffset.Alerts)
-	}
-	if !reflect.DeepEqual(cdnFederation[1:2], cdnFederationWithOffset.Response) {
-		t.Error("expected GET CDN Federation by name with limit = 1, offset = 1 to return second result")
-	}
-
-	opts.QueryParameters.Del("offset")
-	opts.QueryParameters.Set("page", "2")
-	cdnFederationWithPage, _, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err != nil {
-		t.Fatalf("cannot Get CDN Federation by name with Limit and Page: %v - alerts: %+v", err, cdnFederationWithPage.Alerts)
-	}
-	if !reflect.DeepEqual(cdnFederation[1:2], cdnFederationWithPage.Response) {
-		t.Error("expected GET CDN Federation by name with limit = 1, page = 2 to return second result")
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "-2")
-	resp, reqInf, err := TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err == nil {
-		t.Error("expected GET CDN Federation by name to return an error when limit is not bigger than -1")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("offset", "0")
-	resp, reqInf, err = TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err == nil {
-		t.Error("expected GET CDN Federation by name to return an error when offset is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("page", "0")
-	resp, reqInf, err = TOSession.GetCDNFederationsByName("cdn1", opts)
-	if err == nil {
-		t.Error("expected GET CDN Federation by name to return an error when page is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-}
diff --git a/traffic_ops/testing/api/v4/federation_deliveryservices_test.go b/traffic_ops/testing/api/v4/federation_deliveryservices_test.go
new file mode 100644
index 0000000000..54fe87907d
--- /dev/null
+++ b/traffic_ops/testing/api/v4/federation_deliveryservices_test.go
@@ -0,0 +1,215 @@
+package v4
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"testing"
+
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/lib/go-util"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
+	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
+)
+
+func TestFederationsDeliveryServices(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Tenants, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationDeliveryServices}, func() {
+
+		methodTests := utils.V4TestCase{
+			"GET": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1)),
+				},
+				"SORTED when ORDERBY=DSID parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"dsID"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateFederationDeliveryServicesSort(false)),
+				},
+				"SORTED when ORDERBY=DSID and SORTORDER=DESC parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"dsID"}, "sortOrder": {"desc"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateFederationDeliveryServicesSort(true)),
+				},
+				"FIRST RESULT when LIMIT=1": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"dsID"}, "limit": {"1"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationDeliveryServicesPagination(GetFederationID(t, "the.cname.com.")(), "limit")),
+				},
+				"SECOND RESULT when LIMIT=1 OFFSET=1": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"dsID"}, "limit": {"1"}, "offset": {"1"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationDeliveryServicesPagination(GetFederationID(t, "the.cname.com.")(), "offset")),
+				},
+				"SECOND RESULT when LIMIT=1 PAGE=2": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"dsID"}, "limit": {"1"}, "page": {"2"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationDeliveryServicesPagination(GetFederationID(t, "the.cname.com.")(), "page")),
+				},
+				"BAD REQUEST when INVALID LIMIT parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"-2"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID OFFSET parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "offset": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID PAGE parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "page": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+			},
+			"DELETE": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"dsID": {strconv.Itoa(GetDeliveryServiceId(t, "ds1")())}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when LAST DELIVERY SERVICE": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"dsID": {strconv.Itoa(GetDeliveryServiceId(t, "ds2")())}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					var dsID int
+					fedDS := tc.FederationDSPost{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &fedDS)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationDeliveryServices(testCase.EndpointId(), testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.CreateFederationDeliveryServices(testCase.EndpointId(), fedDS.DSIDs, *fedDS.Replace, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					case "DELETE":
+						t.Run(name, func(t *testing.T) {
+							if val, ok := testCase.RequestOpts.QueryParameters["dsID"]; ok {
+								id, err := strconv.Atoi(val[0])
+								assert.RequireNoError(t, err, "Failed to convert dsID to an integer.")
+								dsID = id
+							}
+							alerts, reqInf, err := testCase.ClientSession.DeleteFederationDeliveryService(testCase.EndpointId(), dsID, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func validateFederationDeliveryServicesSort(desc bool) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, alerts tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected Federation DeliveryServices response to not be nil.")
+		var federationDSIDs []int
+		federationDSResp := resp.([]tc.FederationDeliveryServiceNullable)
+		for _, federationDS := range federationDSResp {
+			if desc {
+				federationDSIDs = append([]int{*federationDS.ID}, federationDSIDs...)
+			} else {
+				federationDSIDs = append(federationDSIDs, *federationDS.ID)
+			}
+		}
+		assert.Equal(t, true, sort.IntsAreSorted(federationDSIDs), "List is not sorted by their ids: %v", federationDSIDs)
+	}
+}
+
+func validateFederationDeliveryServicesPagination(fedID int, paginationParam string) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected Federation DeliveryServices response to not be nil.")
+		paginationResp := resp.([]tc.FederationDeliveryServiceNullable)
+
+		opts := client.NewRequestOptions()
+		opts.QueryParameters.Set("orderby", "dsID")
+		respBase, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
+		assert.RequireNoError(t, err, "Cannot get Federation DeliveryServices: %v - alerts: %+v", err, respBase.Alerts)
+
+		federationDS := respBase.Response
+		assert.RequireGreaterOrEqual(t, len(federationDS), 3, "Need at least 3 Federation DeliveryServices in Traffic Ops to test pagination support, found: %d", len(federationDS))
+		switch paginationParam {
+		case "limit:":
+			assert.Exactly(t, federationDS[:1], paginationResp, "expected GET Federation DeliveryServices with limit = 1 to return first result")
+		case "offset":
+			assert.Exactly(t, federationDS[1:2], paginationResp, "expected GET Federation DeliveryServices with limit = 1, offset = 1 to return second result")
+		case "page":
+			assert.Exactly(t, federationDS[1:2], paginationResp, "expected GET Federation DeliveryServices with limit = 1, page = 2 to return second result")
+		}
+	}
+}
+
+func CreateTestFederationDeliveryServices(t *testing.T) {
+	// Prerequisite Federation Delivery Services
+	federationDS := map[string]tc.FederationDSPost{
+		"the.cname.com.": {
+			DSIDs:   []int{GetDeliveryServiceId(t, "ds1")(), GetDeliveryServiceId(t, "ds2")(), GetDeliveryServiceId(t, "ds3")(), GetDeliveryServiceId(t, "ds4")()},
+			Replace: util.BoolPtr(true),
+		},
+		"google.com.": {
+			DSIDs:   []int{GetDeliveryServiceId(t, "ds1")()},
+			Replace: util.BoolPtr(true),
+		},
+	}
+
+	for federation, fedDS := range federationDS {
+		alerts, _, err := TOSession.CreateFederationDeliveryServices(GetFederationID(t, federation)(), fedDS.DSIDs, *fedDS.Replace, client.RequestOptions{})
+		assert.RequireNoError(t, err, "Creating federations delivery services: %v - alerts: %+v", err, alerts.Alerts)
+	}
+}
diff --git a/traffic_ops/testing/api/v4/federation_federation_resolvers_test.go b/traffic_ops/testing/api/v4/federation_federation_resolvers_test.go
new file mode 100644
index 0000000000..5c6fc2a8f7
--- /dev/null
+++ b/traffic_ops/testing/api/v4/federation_federation_resolvers_test.go
@@ -0,0 +1,158 @@
+package v4
+
+/*
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
+)
+
+func TestFederationFederationResolvers(t *testing.T) {
+	WithObjs(t, []TCObj{CDNs, Types, Parameters, Profiles, Tenants, CacheGroups, Statuses, Divisions, Regions, PhysLocations, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationResolvers, FederationFederationResolvers}, func() {
+
+		methodTests := utils.V4TestCase{
+			"GET": {
+				"OK when VALID request AND RESOLVERS ASSIGNED": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1)),
+				},
+				"OK when VALID request AND NO RESOLVERS ASSIGNED": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseHasLength(0)),
+				},
+			},
+			"POST": {
+				"OK when ASSIGNING ONE FEDERATION RESOLVER": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "1.2.3.4")()},
+						"replace":     false,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when ASSIGNING MULTIPLE FEDERATION RESOLVERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{
+							GetFederationResolverID(t, "1.2.3.4")(),
+							GetFederationResolverID(t, "0.0.0.0/12")(),
+							GetFederationResolverID(t, "::f1d0:f00d/123")(),
+						},
+						"replace": false,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when REPLACING ALL FEDERATION RESOLVERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "dead::babe")()},
+						"replace":     true,
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when FEDERATION DOESNT EXIST": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"resolverIDs": []int{GetFederationResolverID(t, "1.2.3.4")()},
+						"replace":     false,
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+			},
+		}
+
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					frAssignment := tc.AssignFederationResolversRequest{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &frAssignment)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationFederationResolvers(testCase.EndpointId(), testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.AssignFederationFederationResolver(testCase.EndpointId(), frAssignment.FedResolverIDs, frAssignment.Replace, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
+}
+
+func CreateTestFederationFederationResolvers(t *testing.T) {
+	// Prerequisite Federation Federation Resolvers
+	federationFederationResolvers := map[string]tc.AssignFederationResolversRequest{
+		"booya.com.": {
+			FedResolverIDs: []int{
+				GetFederationResolverID(t, "1.2.3.4")(),
+				GetFederationResolverID(t, "0.0.0.0/12")(),
+				GetFederationResolverID(t, "::f1d0:f00d/123")(),
+				GetFederationResolverID(t, "dead::babe")(),
+			},
+			Replace: false,
+		},
+	}
+
+	for cname, federationFederationResolver := range federationFederationResolvers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.AssignFederationFederationResolver(fedID, federationFederationResolver.FedResolverIDs, federationFederationResolver.Replace, client.RequestOptions{})
+		assert.RequireNoError(t, err, "Assigning resolvers %v to federation %d: %v - alerts: %+v", federationFederationResolver.FedResolverIDs, fedID, err, resp.Alerts)
+	}
+}
+
+func DeleteTestFederationFederationResolvers(t *testing.T) {
+	// Prerequisite Federation Federation Resolvers
+	federationFederationResolvers := map[string]tc.AssignFederationResolversRequest{
+		"booya.com.": {
+			FedResolverIDs: []int{},
+			Replace:        true,
+		},
+	}
+
+	for cname, federationFederationResolver := range federationFederationResolvers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.AssignFederationFederationResolver(fedID, federationFederationResolver.FedResolverIDs, federationFederationResolver.Replace, client.RequestOptions{})
+		assert.RequireNoError(t, err, "Assigning resolvers %v to federation %d: %v - alerts: %+v", federationFederationResolver.FedResolverIDs, fedID, err, resp.Alerts)
+	}
+}
diff --git a/traffic_ops/testing/api/v4/federation_users_test.go b/traffic_ops/testing/api/v4/federation_users_test.go
index 39687ef19a..ada72a01d1 100644
--- a/traffic_ops/testing/api/v4/federation_users_test.go
+++ b/traffic_ops/testing/api/v4/federation_users_test.go
@@ -16,373 +16,254 @@ package v4
 */
 
 import (
+	"encoding/json"
 	"net/http"
 	"net/url"
-	"reflect"
 	"sort"
 	"testing"
 	"time"
 
 	"github.com/apache/trafficcontrol/lib/go-rfc"
+	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/lib/go-util"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
 	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
 )
 
 func TestFederationUsers(t *testing.T) {
 	WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationUsers}, func() {
-		currentTime := time.Now().UTC().Add(-5 * time.Second)
-		time := currentTime.Format(time.RFC1123)
-		var header http.Header
-		header = make(map[string][]string)
-		header.Set(rfc.IfModifiedSince, time)
-		CreateTestInvalidFederationUsers(t)
-		GetTestInvalidFederationIDUsers(t)
-		CreateTestValidFederationUsers(t)
-		GetTestValidFederationIDUsersIMSAfterChange(t, header)
-		GetTestPaginationSupportFedUsers(t)
-		SortTestFederationUsers(t)
-		SortTestFederationsUsersDesc(t)
-	})
-}
-
-func GetTestValidFederationIDUsersIMSAfterChange(t *testing.T, header http.Header) {
-	if len(fedIDs) < 1 {
-		t.Fatal("Need at least one Federation ID to test Federation ID Users change")
-	}
-	opts := client.RequestOptions{Header: header}
-	resp, reqInf, err := TOSession.GetFederationUsers(fedIDs[0], opts)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v - alerts: %+v", err, resp.Alerts)
-	}
-	if reqInf.StatusCode != http.StatusOK {
-		t.Fatalf("Expected 200 status code, got %v", reqInf.StatusCode)
-	}
-	currentTime := time.Now().UTC()
-	currentTime = currentTime.Add(1 * time.Second)
-	timeStr := currentTime.Format(time.RFC1123)
-	opts.Header.Set(rfc.IfModifiedSince, timeStr)
-	resp, reqInf, err = TOSession.GetFederationUsers(fedIDs[0], opts)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v - alerts: %+v", err, resp.Alerts)
-	}
-	if reqInf.StatusCode != http.StatusNotModified {
-		t.Fatalf("Expected 304 status code, got %v", reqInf.StatusCode)
-	}
-}
-
-func CreateTestFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	if len(fedIDs) < 1 {
-		t.Fatal("need at least one stored Federation ID to test Federations")
-	}
-	fedID := fedIDs[0]
 
-	// Get Users
-	users, _, err := TOSession.GetUsers(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("getting users: %v - alerts: %+v", err, users.Alerts)
-	}
-	if len(users.Response) < 3 {
-		t.Fatal("need > 3 users to create federation users")
-	}
-
-	u1 := users.Response[0].ID
-	u2 := users.Response[1].ID
-	u3 := users.Response[2].ID
-	if u1 == nil || u2 == nil || u3 == nil {
-		t.Fatal("Traffic Ops returned at least one representation of a relationship between a user and a Federation that had a null or undefined ID")
-	}
-
-	// Associate one user to federation
-	resp, _, err := TOSession.CreateFederationUsers(fedID, []int{*u1}, false, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %d: %v - alerts: %+v", []int{*u1}, fedID, err, resp.Alerts)
-	}
-
-	fedUsers, _, err := TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("gettings users for federation %v: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
-	}
-	if len(fedUsers.Response) != 1 {
-		t.Errorf("federation users expected 1, actual: %d", len(fedUsers.Response))
-	}
-
-	// Associate two users to federation and replace first one
-	resp, _, err = TOSession.CreateFederationUsers(fedID, []int{*u2, *u3}, true, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %d: %v - alerts: %+v", []int{*u2, *u3}, fedID, err, resp.Alerts)
-	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("gettings users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
-	}
-	if len(fedUsers.Response) != 2 {
-		t.Errorf("federation users expected 2, actual: %d", len(fedUsers.Response))
-	}
-
-	// Associate one more user to federation
-	resp, _, err = TOSession.CreateFederationUsers(fedID, []int{*u1}, false, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("assigning users %v to federation %d: %v - alerts: %+v", []int{*u1}, fedID, err, resp.Alerts)
-	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("gettings users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
-	}
-	if len(fedUsers.Response) != 3 {
-		t.Errorf("federation users expected 2, actual: %d", len(fedUsers.Response))
-	}
-}
-
-func GetTestInvalidFederationIDUsers(t *testing.T) {
-	_, _, err := TOSession.GetFederationUsers(-1, client.RequestOptions{})
-	if err == nil {
-		t.Fatalf("expected to get an error when requesting federation users for a non-existent federation")
-	}
-}
-
-func CreateTestValidFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	if len(fedIDs) < 1 {
-		t.Fatal("need at least one stored Federation ID to test Federations")
-	}
-	fedID := fedIDs[0]
-
-	// Get Users
-	users, _, err := TOSession.GetUsers(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("getting users: %v - alerts: %+v", err, users.Alerts)
-	}
-	if len(users.Response) == 0 {
-		t.Fatal("need at least 1 user to test invalid federation user create")
-	}
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V4TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {tomorrow}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"BAD REQUEST when INVALID FEDERATION ID": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+				"SORTED by ID when ORDERBY=USERID parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"userID"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateFederationUserIDSort(false)),
+				},
+				"VALID when SORTORDER param is DESC": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"userID"}, "sortOrder": {"desc"}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), validateFederationUserIDSort(true)),
+				},
+				"FIRST RESULT when LIMIT=1": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationUsersPagination(GetFederationID(t, "the.cname.com.")(), "limit")),
+				},
+				"SECOND RESULT when LIMIT=1 OFFSET=1": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}, "offset": {"1"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationUsersPagination(GetFederationID(t, "the.cname.com.")(), "offset")),
+				},
+				"SECOND RESULT when LIMIT=1 PAGE=2": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"orderby": {"id"}, "limit": {"1"}, "page": {"2"}}},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationUsersPagination(GetFederationID(t, "the.cname.com.")(), "page")),
+				},
+				"BAD REQUEST when INVALID LIMIT parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"-2"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID OFFSET parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "offset": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+				"BAD REQUEST when INVALID PAGE parameter": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{QueryParameters: url.Values{"limit": {"1"}, "page": {"0"}}},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+				},
+			},
+			"POST": {
+				"OK when VALID request": {
+					EndpointId:    GetFederationID(t, "google.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "readonlyuser")(), GetUserID(t, "disalloweduser")()}, "replace": false},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when REPLACING USERS": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "readonlyuser")()}, "replace": true},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"OK when ADDING USER": {
+					EndpointId:    GetFederationID(t, "booya.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{GetUserID(t, "disalloweduser")()}, "replace": false},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"BAD REQUEST when INVALID FEDERATION ID": {
+					EndpointId:    func() int { return -1 },
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{}, "replace": false},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+				"BAD REQUEST when INVALID USER ID": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestBody:   map[string]interface{}{"userIds": []int{-1}, "replace": false},
+					Expectations:  utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+				},
+			},
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					EndpointId:    GetFederationID(t, "the.cname.com."),
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {currentTimeRFC}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+			},
+		}
 
-	// Associate with invalid federdation id
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{*users.Response[0].ID}, false, client.RequestOptions{})
-	if err == nil {
-		t.Error("expected to get error back from associating non existent federation id")
-	}
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					federationUser := tc.FederationUserPost{}
+
+					if testCase.RequestBody != nil {
+						dat, err := json.Marshal(testCase.RequestBody)
+						assert.NoError(t, err, "Error occurred when marshalling request body: %v", err)
+						err = json.Unmarshal(dat, &federationUser)
+						assert.NoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.GetFederationUsers(testCase.EndpointId(), testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.CreateFederationUsers(testCase.EndpointId(), federationUser.IDs, *federationUser.Replace, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	})
 }
-func CreateTestInvalidFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	if len(fedIDs) < 1 {
-		t.Fatal("need at least one stored Federation ID to test Federations")
-	}
-	fedID := fedIDs[0]
-
-	// Get Users
-	users, _, err := TOSession.GetUsers(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("getting users: %v - alerts: %+v", err, users.Alerts)
-	}
-	if len(users.Response) == 0 {
-		t.Fatal("need at least 1 user to test invalid federation user create")
-	}
-	if users.Response[0].ID == nil {
-		t.Fatal("Traffic Ops returned a representation of a user with null or undefined ID")
-	}
 
-	// Associate with invalid federdation id
-	_, _, err = TOSession.CreateFederationUsers(-1, []int{*users.Response[0].ID}, false, client.RequestOptions{})
-	if err == nil {
-		t.Error("expected to get error back from associating non existent federation id")
-	}
-
-	// Associate with invalid user id
-	_, _, err = TOSession.CreateFederationUsers(fedID, []int{-1}, false, client.RequestOptions{})
-	if err == nil {
-		t.Error("expected to get error back from associating non existent user id")
+func validateFederationUsersPagination(federationID int, paginationParam string) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		paginationResp := resp.([]tc.FederationUser)
+
+		opts := client.NewRequestOptions()
+		opts.QueryParameters.Set("orderby", "id")
+		respBase, _, err := TOSession.GetFederationUsers(federationID, opts)
+		assert.RequireNoError(t, err, "Cannot get Federation Users: %v - alerts: %+v", err, respBase.Alerts)
+
+		federationUsers := respBase.Response
+		assert.RequireGreaterOrEqual(t, len(federationUsers), 3, "Need at least 3 Federation Users in Traffic Ops to test pagination support, found: %d", len(federationUsers))
+		switch paginationParam {
+		case "limit:":
+			assert.Exactly(t, federationUsers[:1], paginationResp, "expected GET Federation Users with limit = 1 to return first result")
+		case "offset":
+			assert.Exactly(t, federationUsers[1:2], paginationResp, "expected GET Federation Users with limit = 1, offset = 1 to return second result")
+		case "page":
+			assert.Exactly(t, federationUsers[1:2], paginationResp, "expected GET Federation Users with limit = 1, page = 2 to return second result")
+		}
 	}
 }
 
-func DeleteTestFederationUsers(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	if len(fedIDs) < 1 {
-		t.Fatal("need at least one stored Federation ID to test Federations")
-	}
-	fedID := fedIDs[0]
-
-	fedUsers, _, err := TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("gettings users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
-	}
-	if len(fedUsers.Response) != 3 {
-		t.Errorf("federation users expected 3, actual: %d", len(fedUsers.Response))
-	}
-
-	for _, fedUser := range fedUsers.Response {
-		if fedUser.ID == nil {
-			t.Error("Traffic Ops returned a representation of a relationship between a user and a Federation that had null or undefined ID")
-			continue
+func validateFederationUserIDSort(desc bool) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, alerts tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected Federation User response to not be nil.")
+		var federationUserIDs []int
+		federationUserResp := resp.([]tc.FederationUser)
+		for _, fedUser := range federationUserResp {
+			if desc {
+				federationUserIDs = append([]int{*fedUser.ID}, federationUserIDs...)
+			} else {
+				federationUserIDs = append(federationUserIDs, *fedUser.ID)
+			}
 		}
-		alerts, _, err := TOSession.DeleteFederationUser(fedID, *fedUser.ID, client.RequestOptions{})
-		if err != nil {
-			t.Fatalf("deleting user #%d from federation #%d: %v - alerts: %+v", *fedUser.ID, fedID, err, alerts.Alerts)
-		}
-	}
-
-	fedUsers, _, err = TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("gettings users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
-	}
-	if len(fedUsers.Response) != 0 {
-		t.Errorf("federation users expected 0, actual: %+v", len(fedUsers.Response))
+		assert.Equal(t, true, sort.IntsAreSorted(federationUserIDs), "List is not sorted by their ids: %v", federationUserIDs)
 	}
 }
 
-func GetTestPaginationSupportFedUsers(t *testing.T) {
-
-	if len(fedIDs) < 1 {
-		t.Fatal("need at least one stored Federation ID to test Federations")
-	}
-	fedID := fedIDs[0]
-
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "userID")
-	resp, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot get Federation #%d Users: %v - alerts: %+v", fedID, err, resp.Alerts)
-	}
-	fedUser := resp.Response
-	if len(fedUser) < 3 {
-		t.Fatalf("Need at least 3 Federation users in Traffic Ops to test pagination support, found: %d", len(fedUser))
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	fedUserWithLimit, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation user with Limit: %v - alerts: %+v", err, fedUserWithLimit.Alerts)
-	}
-	if !reflect.DeepEqual(fedUser[:1], fedUserWithLimit.Response) {
-		t.Error("expected GET Federation user with limit = 1 to return first result")
-	}
-
-	opts.QueryParameters.Set("offset", "1")
-	fedUserWithOffset, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation user with Limit and Offset: %v - alerts: %+v", err, fedUserWithOffset.Alerts)
-	}
-	if !reflect.DeepEqual(fedUser[1:2], fedUserWithOffset.Response) {
-		t.Error("expected GET Federation user with limit = 1, offset = 1 to return second result")
-	}
-
-	opts.QueryParameters.Del("offset")
-	opts.QueryParameters.Set("page", "2")
-	fedUserWithPage, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation user with Limit and Page: %v - alerts: %+v", err, fedUserWithPage.Alerts)
-	}
-	if !reflect.DeepEqual(fedUser[1:2], fedUserWithPage.Response) {
-		t.Error("expected GET Federation user with limit = 1, page = 2 to return second result")
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "-2")
-	resp, reqInf, err := TOSession.GetFederationUsers(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation user to return an error when limit is not bigger than -1")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("offset", "0")
-	resp, reqInf, err = TOSession.GetFederationUsers(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation user to return an error when offset is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("page", "0")
-	resp, reqInf, err = TOSession.GetFederationUsers(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation user to return an error when page is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
+func GetUserID(t *testing.T, username string) func() int {
+	return func() int {
+		opts := client.NewRequestOptions()
+		opts.QueryParameters.Set("username", username)
+		users, _, err := TOSession.GetUsers(opts)
+		assert.RequireNoError(t, err, "Get Users Request failed with error:", err)
+		assert.RequireEqual(t, 1, len(users.Response), "Expected response object length 1, but got %d", len(users.Response))
+		assert.RequireNotNil(t, users.Response[0].ID, "Expected ID to not be nil.")
+		return *users.Response[0].ID
 	}
 }
 
-func SortTestFederationUsers(t *testing.T) {
-	var sortedList []int
-	if len(fedIDs) == 0 {
-		t.Fatalf("no federations, must have at least 1 federation to test federations users")
-	}
-	fedID := fedIDs[0]
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "userID")
-	resp, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v - alerts: %+v", err, resp.Alerts)
-	}
-	for _, fedUser := range resp.Response {
-		if fedUser.ID == nil {
-			t.Fatalf("Federation users ID is nil, so sorting can't be tested")
-		}
-		sortedList = append(sortedList, *fedUser.ID)
-	}
-	res := sort.SliceIsSorted(sortedList, func(p, q int) bool {
-		return sortedList[p] < sortedList[q]
-	})
-	if res != true {
-		t.Errorf("list is not sorted by their User ID: %v", sortedList)
+func CreateTestFederationUsers(t *testing.T) {
+	// Prerequisite Federation Users
+	federationUsers := map[string]tc.FederationUserPost{
+		"the.cname.com.": {
+			IDs:     []int{GetUserID(t, "admin")(), GetUserID(t, "adminuser")(), GetUserID(t, "disalloweduser")(), GetUserID(t, "readonlyuser")()},
+			Replace: util.BoolPtr(false),
+		},
+		"booya.com.": {
+			IDs:     []int{GetUserID(t, "adminuser")()},
+			Replace: util.BoolPtr(false),
+		},
+	}
+
+	for cname, federationUser := range federationUsers {
+		fedID := GetFederationID(t, cname)()
+		resp, _, err := TOSession.CreateFederationUsers(fedID, federationUser.IDs, *federationUser.Replace, client.RequestOptions{})
+		assert.RequireNoError(t, err, "Assigning users %v to federation %d: %v - alerts: %+v", federationUser.IDs, fedID, err, resp.Alerts)
 	}
 }
 
-func SortTestFederationsUsersDesc(t *testing.T) {
-
-	if len(fedIDs) == 0 {
-		t.Fatalf("no federations, must have at least 1 federation to test federations users")
-	}
-	fedID := fedIDs[0]
-
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "userID")
-	resp, _, err := TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got error in Federation users default ordering %v - alerts: %+v", err, resp.Alerts)
-	}
-	respAsc := resp.Response
-	if len(respAsc) < 1 {
-		t.Fatal("Need at least one Federation users in Traffic Ops to test Federation users sort ordering")
-	}
-	opts.QueryParameters.Set("sortOrder", "desc")
-	resp, _, err = TOSession.GetFederationUsers(fedID, opts)
-	if err != nil {
-		t.Errorf("Expected no error, but got error in Federation users with Descending ordering: %v - alerts: %+v", err, resp.Alerts)
-	}
-	respDesc := resp.Response
-	if len(respDesc) < 1 {
-		t.Fatal("Need at least one Federation users in Traffic Ops to test Federation users sort ordering")
-	}
-	if len(respAsc) != len(respDesc) {
-		t.Fatalf("Traffic Ops returned %d Federation users using default sort order, but %d Federation users when sort order was explicitly set to descending", len(respAsc), len(respDesc))
-	}
-	for start, end := 0, len(respDesc)-1; start < end; start, end = start+1, end-1 {
-		respDesc[start], respDesc[end] = respDesc[end], respDesc[start]
-	}
-	if respDesc[0].ID == nil || respAsc[0].ID == nil {
-		t.Fatalf("Response ID is nil in federation users")
-	}
-	if *respDesc[0].ID != *respAsc[0].ID {
-		t.Errorf("Federation users responses are not equal after reversal: Asc: %d - Desc: %d", *respDesc[0].ID, *respAsc[0].ID)
+func DeleteTestFederationUsers(t *testing.T) {
+	for _, fedID := range fedIDs {
+		fedUsers, _, err := TOSession.GetFederationUsers(fedID, client.RequestOptions{})
+		assert.RequireNoError(t, err, "Error getting users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
+		for _, fedUser := range fedUsers.Response {
+			if fedUser.ID == nil {
+				t.Error("Traffic Ops returned a representation of a relationship between a user and a Federation that had null or undefined ID")
+				continue
+			}
+			alerts, _, err := TOSession.DeleteFederationUser(fedID, *fedUser.ID, client.RequestOptions{})
+			assert.NoError(t, err, "Error deleting user #%d from federation #%d: %v - alerts: %+v", *fedUser.ID, fedID, err, alerts.Alerts)
+		}
+		fedUsers, _, err = TOSession.GetFederationUsers(fedID, client.RequestOptions{})
+		assert.NoError(t, err, "Error getting users for federation %d: %v - alerts: %+v", fedID, err, fedUsers.Alerts)
+		assert.Equal(t, 0, len(fedUsers.Response), "Federation users expected 0, actual: %+v", len(fedUsers.Response))
 	}
 }
diff --git a/traffic_ops/testing/api/v4/federations_test.go b/traffic_ops/testing/api/v4/federations_test.go
index 5cea3e7a1d..72f2543477 100644
--- a/traffic_ops/testing/api/v4/federations_test.go
+++ b/traffic_ops/testing/api/v4/federations_test.go
@@ -16,560 +16,257 @@ package v4
 */
 
 import (
-	"errors"
-	"fmt"
+	"encoding/json"
 	"net/http"
-	"net/url"
-	"reflect"
-	"sort"
 	"testing"
 	"time"
 
 	"github.com/apache/trafficcontrol/lib/go-rfc"
 	"github.com/apache/trafficcontrol/lib/go-tc"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/assert"
+	"github.com/apache/trafficcontrol/traffic_ops/testing/api/utils"
+	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
 	client "github.com/apache/trafficcontrol/traffic_ops/v4-client"
 )
 
 func TestFederations(t *testing.T) {
-	WithObjs(t, []TCObj{CDNs, Types, Tenants, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations}, func() {
-		PostDeleteTestFederationsDeliveryServices(t)
-		GetTestFederations(t)
-		GetTestFederationsIMS(t)
-		AddFederationResolversForCurrentUserTest(t)
-		ReplaceFederationResolversForCurrentUserTest(t)
-		RemoveFederationResolversForCurrentUserTest(t)
-		GetTestPaginationSupportFedDeliveryServices(t)
-		SortTestFederationDs(t)
-		SortTestFederationsDsDesc(t)
-	})
-}
-
-func GetTestFederationsIMS(t *testing.T) {
-	futureTime := time.Now().AddDate(0, 0, 1)
-	fmtFutureTime := futureTime.Format(time.RFC1123)
-
-	opts := client.NewRequestOptions()
-	opts.Header.Set(rfc.IfModifiedSince, fmtFutureTime)
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	resp, reqInf, err := TOSession.AllFederations(opts)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v - alerts: %+v", err, resp.Alerts)
-	}
-	if reqInf.StatusCode != http.StatusNotModified {
-		t.Fatalf("Expected 304 status code, got %v", reqInf.StatusCode)
-	}
-
-	pastTime := time.Now().AddDate(0, 0, -1)
-	fmtPastTime := pastTime.Format(time.RFC1123)
-
-	opts = client.NewRequestOptions()
-	opts.Header.Set(rfc.IfModifiedSince, fmtPastTime)
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	resp, reqInf, err = TOSession.AllFederations(opts)
-	if err != nil {
-		t.Fatalf("No error expected, but got: %v - alerts: %+v", err, resp.Alerts)
-	}
-	if reqInf.StatusCode != http.StatusOK {
-		t.Fatalf("Expected 200 status code, got %v", reqInf.StatusCode)
-	}
-}
-
-func GetTestFederations(t *testing.T) {
-	if len(testData.Federations) == 0 {
-		t.Error("no federations test data")
-	}
-
-	feds, _, err := TOSession.AllFederations(client.RequestOptions{})
-	if err != nil {
-		t.Errorf("getting federations: %v - alerts: %+v", err, feds.Alerts)
-	}
-
-	if len(feds.Response) < 1 {
-		t.Errorf("expected atleast 1 federation, but got none")
-	}
-	fed := feds.Response[0]
-
-	if len(fed.Mappings) < 1 {
-		t.Fatal("federation mappings expected > 1, actual: 0")
-	}
-
-	mapping := fed.Mappings[0]
-	if mapping.CName == nil {
-		t.Fatal("federation mapping expected cname, actual: nil")
-	}
-	if mapping.TTL == nil {
-		t.Fatal("federation mapping expected ttl, actual: nil")
-	}
-
-	matched := false
-	for _, testFed := range testData.Federations {
-		if testFed.CName == nil {
-			t.Error("test federation missing cname!")
-			continue
-		}
-		if testFed.TTL == nil {
-			t.Error("test federation missing ttl!")
-			continue
-		}
-
-		if *mapping.CName != *testFed.CName {
-			continue
-		}
-		matched = true
-
-		if *mapping.TTL != *testFed.TTL {
-			t.Errorf("federation mapping ttl expected: %v, actual: %v", *testFed.TTL, *mapping.TTL)
-		}
-	}
-	if !matched {
-		t.Errorf("federation mapping expected to match test data, actual: cname %v not in test data", *mapping.CName)
-	}
-}
-
-func createFederationToDeliveryServiceAssociation() (int, tc.DeliveryServiceV4, tc.DeliveryServiceV4, error) {
-	var ds tc.DeliveryServiceV4
-	var ds1 tc.DeliveryServiceV4
-	dses, _, err := TOSession.GetDeliveryServices(client.RequestOptions{})
-	if err != nil {
-		return -1, ds, ds1, fmt.Errorf("cannot get Delivery Services: %v - alerts: %+v", err, dses.Alerts)
-	}
-	if len(dses.Response) < 2 {
-		return -1, ds, ds1, errors.New("no delivery services, must have at least 2 Delivery Services to test federations deliveryservices")
-	}
-	ds = dses.Response[0]
-	ds1 = dses.Response[1]
-	if ds.ID == nil || ds1.ID == nil {
-		return -1, ds, ds1, errors.New("Traffic Ops returned at least one representation of a Delivery Service that had a null or undefined ID")
-	}
-
-	if len(fedIDs) == 0 {
-		return -1, ds, ds1, errors.New("no federations, must have at least 1 federation to test federations deliveryservices")
-	}
-	fedID := fedIDs[0]
-
-	alerts, _, err := TOSession.CreateFederationDeliveryServices(fedID, []int{*ds.ID, *ds1.ID}, true, client.RequestOptions{})
-	if err != nil {
-		err = fmt.Errorf("creating federations delivery services: %v - alerts: %+v", err, alerts.Alerts)
-	}
-
-	return fedID, ds, ds1, err
-
-}
-
-func createFederationToMultipleDeliveryServiceAssociation() (int, tc.DeliveryServiceV4, tc.DeliveryServiceV4, tc.DeliveryServiceV4, error) {
-	var ds tc.DeliveryServiceV4
-	var ds1 tc.DeliveryServiceV4
-	var ds2 tc.DeliveryServiceV4
-	dses, _, err := TOSession.GetDeliveryServices(client.RequestOptions{})
-	if err != nil {
-		return -1, ds, ds1, ds2, fmt.Errorf("cannot get Delivery Services: %v - alerts: %+v", err, dses.Alerts)
-	}
-	if len(dses.Response) < 3 {
-		return -1, ds, ds1, ds2, errors.New("no delivery services, must have at least 3 Delivery Services to test federations deliveryservices")
-	}
-	ds = dses.Response[0]
-	ds1 = dses.Response[1]
-	ds2 = dses.Response[2]
-	if ds.ID == nil || ds1.ID == nil || ds2.ID == nil {
-		return -1, ds, ds1, ds2, errors.New("Traffic Ops returned at least one representation of a Delivery Service that had a null or undefined ID")
-	}
-
-	if len(fedIDs) == 0 {
-		return -1, ds, ds1, ds2, errors.New("no federations, must have at least 1 federation to test federations deliveryservices")
-	}
-	fedID := fedIDs[1]
-
-	alerts, _, err := TOSession.CreateFederationDeliveryServices(fedID, []int{*ds.ID, *ds1.ID, *ds2.ID}, true, client.RequestOptions{})
-	if err != nil {
-		err = fmt.Errorf("creating federations delivery services: %v - alerts: %+v", err, alerts.Alerts)
-	}
-
-	return fedID, ds, ds1, ds2, err
-
-}
-
-func PostDeleteTestFederationsDeliveryServices(t *testing.T) {
-	fedID, ds, ds1, err := createFederationToDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	// Test get created Federation Delivery Services
-	fedDSes, _, err := TOSession.GetFederationDeliveryServices(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("cannot get Federation #%d Delivery Services: %v - alerts: %+v", fedID, err, fedDSes.Alerts)
-	}
-	if len(fedDSes.Response) != 2 {
-		t.Fatalf("two Federation DeliveryService expected for Federation %d, %d was returned", fedID, len(fedDSes.Response))
-	}
-
-	// Delete one of the Delivery Services from the Federation
-	alerts, _, err := TOSession.DeleteFederationDeliveryService(fedID, *ds.ID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("cannot Delete Federation #%d Delivery Service #%d: %v - alerts: %+v", fedID, ds.ID, err, alerts.Alerts)
-	}
-
-	// Make sure it is deleted
-
-	// Test get created Federation Delivery Services
-	fedDSes, _, err = TOSession.GetFederationDeliveryServices(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("cannot get Federation Delivery Services: %v - alerts: %+v", err, fedDSes.Alerts)
-	}
-	if len(fedDSes.Response) != 1 {
-		t.Fatalf("one Federation Delivery Service expected for Federation #%d, %d was returned", fedID, len(fedDSes.Response))
-	}
-
-	// Attempt to delete the last one which should fail as you cannot remove the last
-	_, _, err = TOSession.DeleteFederationDeliveryService(fedID, *ds1.ID, client.RequestOptions{})
-	if err == nil {
-		t.Fatal("expected to receive error from attempting to delete last Delivery Service from a Federation")
-	}
-}
-
-func RemoveFederationResolversForCurrentUserTest(t *testing.T) {
-	if len(testData.Federations) < 1 {
-		t.Fatal("No test Federations, deleting resolvers cannot be tested!")
-	}
-
-	alerts, _, err := TOSession.DeleteFederationResolverMappingsForCurrentUser(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Unexpected error deleting Federation Resolvers for current user: %v - alerts: %+v", err, alerts)
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.ErrorLevel.String() {
-			t.Errorf("Unexpected error-level alert from deleting Federation Resolvers for current user: %s", a.Text)
-		}
-	}
-
-	// Now try deleting Federation Resolvers when there are none.
-	_, _, err = TOSession.DeleteFederationResolverMappingsForCurrentUser(client.RequestOptions{})
-	if err != nil {
-		t.Logf("Received expected error deleting Federation Resolvers for current user: %v", err)
-	} else {
-		t.Error("Expected an error deleting zero Federation Resolvers, but didn't get one.")
-	}
-}
-
-func AddFederationResolversForCurrentUserTest(t *testing.T) {
-	fedID, ds, ds1, err := createFederationToDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	// need to assign myself the federation to set its mappings
-	me, _, err := TOSession.GetUserCurrent(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Couldn't figure out who I am: %v - alerts: %+v", err, me.Alerts)
-	}
-	if me.Response.ID == nil {
-		t.Fatal("Current user has no ID, cannot continue.")
-	}
-
-	alerts, _, err := TOSession.CreateFederationUsers(fedID, []int{*me.Response.ID}, false, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Failed to assign Federation to current user: %v - alerts: %+v", err, alerts.Alerts)
-	}
-
-	mappings := tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{"0.0.0.0"},
-				Resolve6: []string{"::1"},
-			},
-		},
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds1.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{"1.2.3.4/28"},
-				Resolve6: []string{"1234::/110"},
+	WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, Topologies, ServiceCategories, DeliveryServices, CDNFederations, FederationDeliveryServices, FederationUsers}, func() {
+
+		currentTime := time.Now().UTC().Add(-15 * time.Second)
+		currentTimeRFC := currentTime.Format(time.RFC1123)
+		tomorrow := currentTime.AddDate(0, 0, 1).Format(time.RFC1123)
+
+		methodTests := utils.V4TestCase{
+			"GET": {
+				"NOT MODIFIED when NO CHANGES made": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {tomorrow}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusNotModified)),
+				},
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK), utils.ResponseLengthGreaterOrEqual(1),
+						validateAllFederationsFields([]map[string]interface{}{
+							{
+								"DeliveryService": "ds1",
+								"Mappings": []map[string]interface{}{
+									{
+										"CName": "the.cname.com.",
+										"TTL":   48,
+									},
+									{
+										"CName": "booya.com.",
+										"TTL":   34,
+									},
+									{
+										"CName": "google.com.",
+										"TTL":   30,
+									},
+								},
+							},
+						})),
+				},
 			},
-		},
-	}
-
-	alerts, _, err = TOSession.AddFederationResolverMappingsForCurrentUser(mappings, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Unexpected error adding Federation Resolver mappings for the current user: %v - alerts: %+v", err, alerts.Alerts)
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.ErrorLevel.String() {
-			t.Errorf("Unexpected error-level alert from adding Federation Resolver mappings for the current user: %s", a.Text)
-		}
-	}
-
-	mappings = tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: "aoeuhtns",
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{},
-				Resolve6: []string{"dead::beef", "f1d0::f00d/82"},
+			"POST": {
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "ds1",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"0.0.0.0"},
+									"resolve6": []string{"::1"},
+								},
+							},
+							{
+								"deliveryService": "ds2",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"1234::/110"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
+				"CONFLICT when INVALID DELIVERY SERVICE": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "aoeuhtns",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"dead::beef", "f1d0::f00d/82"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)),
+				},
 			},
-		},
-	}
-
-	alerts, _, err = TOSession.AddFederationResolverMappingsForCurrentUser(mappings, client.RequestOptions{})
-	if err == nil {
-		t.Fatal("Expected error adding Federation Resolver mappings for the current user, but didn't get one")
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.SuccessLevel.String() {
-			t.Errorf("Unexpected success from adding Federation Resolver mappings for the current user: %s", a.Text)
-		}
-	}
-}
-
-func ReplaceFederationResolversForCurrentUserTest(t *testing.T) {
-	fedID, ds, ds1, err := createFederationToDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	// need to assign myself the federation to set its mappings
-	me, _, err := TOSession.GetUserCurrent(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Couldn't figure out who I am: %v - alerts: %+v", err, me.Alerts)
-	}
-	if me.Response.ID == nil {
-		t.Fatal("Current user has no ID, cannot continue.")
-	}
-
-	fedUsers, _, err := TOSession.GetFederationUsers(fedID, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("unexpected error getting federation users: %v", err)
-	}
-	foundFedUser := false
-	for _, fedUser := range fedUsers.Response {
-		if *fedUser.ID == *me.Response.ID {
-			foundFedUser = true
-			break
-		}
-	}
-	if !foundFedUser {
-		alerts, _, err := TOSession.CreateFederationUsers(fedID, []int{*me.Response.ID}, false, client.RequestOptions{})
-		if err != nil {
-			t.Fatalf("Failed to assign Federation to current user: %v - alerts: %+v", err, alerts.Alerts)
-		}
-	}
-	expectedResolve4 := []string{"192.0.2.0/25", "192.0.2.128/25"}
-	expectedResolve6 := []string{"2001:db8::/33", "2001:db8:8000::/33"}
-	sort.Strings(expectedResolve4)
-	sort.Strings(expectedResolve6)
-
-	mappings := tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: expectedResolve4,
-				Resolve6: expectedResolve6,
+			"PUT": {
+				"OK when VALID request": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "ds1",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"192.0.2.0/25", "192.0.2.128/25"},
+									"resolve6": []string{"2001:db8::/33", "2001:db8:8000::/33"},
+								},
+							},
+							{
+								"deliveryService": "ds2",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"192.0.2.0/25", "192.0.2.128/25"},
+									"resolve6": []string{"2001:db8::/33", "2001:db8:8000::/33"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+						validateFederationsUpdateFields([]map[string]interface{}{
+							{
+								"DeliveryService": "ds1",
+								"Resolve4":        []string{"192.0.2.0/25", "192.0.2.128/25"},
+								"Resolve6":        []string{"2001:db8::/33", "2001:db8:8000::/33"},
+							},
+							{
+								"DeliveryService": "ds2",
+								"Resolve4":        []string{"192.0.2.0/25", "192.0.2.128/25"},
+								"Resolve6":        []string{"2001:db8::/33", "2001:db8:8000::/33"},
+							},
+						})),
+				},
+				"CONFLICT when INVALID DELIVERY SERVICE": {
+					ClientSession: TOSession,
+					RequestBody: map[string]interface{}{
+						"federations": []map[string]interface{}{
+							{
+								"deliveryService": "aoeuhtns",
+								"mappings": map[string]interface{}{
+									"resolve4": []string{"1.2.3.4/28"},
+									"resolve6": []string{"dead::beef", "f1d0::f00d/82"},
+								},
+							},
+						},
+					},
+					Expectations: utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)),
+				},
 			},
-		},
-		// for the purpose of this test, it's important that at least two different mappings have the same resolvers
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: *ds1.XMLID,
-			Mappings: tc.ResolverMapping{
-				Resolve4: expectedResolve4,
-				Resolve6: expectedResolve6,
+			"GET AFTER CHANGES": {
+				"OK when CHANGES made": {
+					ClientSession: TOSession,
+					RequestOpts:   client.RequestOptions{Header: http.Header{rfc.IfModifiedSince: {currentTimeRFC}}},
+					Expectations:  utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)),
+				},
 			},
-		},
-	}
+		}
 
-	alerts, _, err := TOSession.ReplaceFederationResolverMappingsForCurrentUser(mappings, client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("Unexpected error replacing Federation Resolver mappings for the current user: %v - alerts: %+v", err, alerts.Alerts)
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.ErrorLevel.String() {
-			t.Errorf("Unexpected error-level alert from replacing Federation Resolver mappings for the current user: %s", a.Text)
+		for method, testCases := range methodTests {
+			t.Run(method, func(t *testing.T) {
+				for name, testCase := range testCases {
+					federation := tc.DeliveryServiceFederationResolverMappingRequest{}
+
+					if testCase.RequestBody != nil {
+						for _, federationRequest := range testCase.RequestBody {
+							dat, err := json.Marshal(federationRequest)
+							assert.RequireNoError(t, err, "Error occurred when marshalling request body: %v", err)
+							err = json.Unmarshal(dat, &federation)
+							assert.RequireNoError(t, err, "Error occurred when unmarshalling request body: %v", err)
+						}
+					}
+
+					switch method {
+					case "GET", "GET AFTER CHANGES":
+						t.Run(name, func(t *testing.T) {
+							resp, reqInf, err := testCase.ClientSession.AllFederations(testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, resp.Response, resp.Alerts, err)
+							}
+						})
+					case "POST":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.AddFederationResolverMappingsForCurrentUser(federation, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					case "PUT":
+						t.Run(name, func(t *testing.T) {
+							alerts, reqInf, err := testCase.ClientSession.ReplaceFederationResolverMappingsForCurrentUser(federation, testCase.RequestOpts)
+							for _, check := range testCase.Expectations {
+								check(t, reqInf, nil, alerts, err)
+							}
+						})
+					}
+				}
+			})
 		}
-	}
 
-	feds, _, err := TOSession.Federations(client.RequestOptions{})
-	if err != nil {
-		t.Fatalf("unexpected error getting federations: %v", err)
-	}
-	for _, fed := range feds.Response {
-		if fed.DeliveryService.String() == *ds.XMLID || fed.DeliveryService.String() == *ds1.XMLID {
-			if len(fed.Mappings) != 1 {
-				t.Fatalf("expected 1 mapping, got %d", len(fed.Mappings))
-			}
-			sort.Strings(fed.Mappings[0].Resolve4)
-			sort.Strings(fed.Mappings[0].Resolve6)
-			if !reflect.DeepEqual(expectedResolve4, fed.Mappings[0].Resolve4) {
-				t.Errorf("checking federation resolver mappings, expected: %+v, actual: %+v", expectedResolve4, fed.Mappings[0].Resolve4)
+		t.Run("DELETE/OK when VALID request", func(t *testing.T) {
+			alerts, reqInf, err := TOSession.DeleteFederationResolverMappingsForCurrentUser(client.RequestOptions{})
+			for _, check := range utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK)) {
+				check(t, reqInf, nil, alerts, err)
 			}
-			if !reflect.DeepEqual(expectedResolve6, fed.Mappings[0].Resolve6) {
-				t.Errorf("checking federation resolver mappings, expected: %+v, actual: %+v", expectedResolve6, fed.Mappings[0].Resolve6)
-			}
-		}
-	}
+		})
 
-	mappings = tc.DeliveryServiceFederationResolverMappingRequest{
-		tc.DeliveryServiceFederationResolverMapping{
-			DeliveryService: "aoeuhtns",
-			Mappings: tc.ResolverMapping{
-				Resolve4: []string{},
-				Resolve6: []string{"dead::beef", "f1d0::f00d/82"},
-			},
-		},
-	}
+		t.Run("DELETE/CONFLICT when NO FEDERATION RESOLVERS", func(t *testing.T) {
+			alerts, reqInf, err := TOSession.DeleteFederationResolverMappingsForCurrentUser(client.RequestOptions{})
+			for _, check := range utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusConflict)) {
+				check(t, reqInf, nil, alerts, err)
+			}
+		})
+	})
+}
 
-	alerts, _, err = TOSession.ReplaceFederationResolverMappingsForCurrentUser(mappings, client.RequestOptions{})
-	if err == nil {
-		t.Fatal("Expected error replacing Federation Resolver mappings for the current user, but didn't get one")
-	}
-	for _, a := range alerts.Alerts {
-		if a.Level == tc.SuccessLevel.String() {
-			t.Errorf("Unexpected success from replacing Federation Resolver mappings for the current user: %s", a.Text)
+func validateFederationFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected Federation response to not be nil.")
+		federationResp := resp.([]tc.AllDeliveryServiceFederationsMapping)
+		for _, expectedFed := range expectedResp {
+			for _, federation := range federationResp {
+				if federation.DeliveryService.String() == expectedFed["DeliveryService"] {
+					assert.RequireEqual(t, 1, len(federation.Mappings), "expected 1 mapping, got %d", len(federation.Mappings))
+					assert.Exactly(t, expectedFed["Resolve4"], federation.Mappings[0].Resolve4, "checking federation resolver mappings, expected: %+v, actual: %+v", expectedFed["Resolve4"], federation.Mappings[0].Resolve4)
+					assert.Exactly(t, expectedFed["Resolve6"], federation.Mappings[0].Resolve6, "checking federation resolver mappings, expected: %+v, actual: %+v", expectedFed["Resolve6"], federation.Mappings[0].Resolve6)
+				}
+			}
 		}
 	}
 }
 
-func GetTestPaginationSupportFedDeliveryServices(t *testing.T) {
-
-	fedID, _, _, _, err := createFederationToMultipleDeliveryServiceAssociation()
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "dsID")
-	resp, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot get Federation #%d Delivery Services: %v - alerts: %+v", fedID, err, resp.Alerts)
-	}
-	fedDs := resp.Response
-	if len(fedDs) < 3 {
-		t.Fatalf("Need at least 3 Federation Delivery services in Traffic Ops to test pagination support, found: %d", len(fedDs))
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	fedDsWithLimit, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation deliveryservices with Limit: %v - alerts: %+v", err, fedDsWithLimit.Alerts)
-	}
-	if !reflect.DeepEqual(fedDs[:1], fedDsWithLimit.Response) {
-		t.Error("expected GET Federation deliveryservices with limit = 1 to return first result")
-	}
-
-	opts.QueryParameters.Set("offset", "1")
-	fedDsWithOffset, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation deliveryservices with Limit and Offset: %v - alerts: %+v", err, fedDsWithOffset.Alerts)
-	}
-	if !reflect.DeepEqual(fedDs[1:2], fedDsWithOffset.Response) {
-		t.Error("expected GET Federation deliveryservices with limit = 1, offset = 1 to return second result")
-	}
-
-	opts.QueryParameters.Del("offset")
-	opts.QueryParameters.Set("page", "2")
-	fedDsWithPage, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("cannot Get Federation deliveryservices with Limit and Page: %v - alerts: %+v", err, fedDsWithPage.Alerts)
-	}
-	if !reflect.DeepEqual(fedDs[1:2], fedDsWithPage.Response) {
-		t.Error("expected GET Federation deliveryservices with limit = 1, page = 2 to return second result")
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "-2")
-	resp, reqInf, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation deliveryservices to return an error when limit is not bigger than -1")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("offset", "0")
-	resp, reqInf, err = TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation deliveryservices to return an error when offset is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
-	}
-
-	opts.QueryParameters = url.Values{}
-	opts.QueryParameters.Set("limit", "1")
-	opts.QueryParameters.Set("page", "0")
-	resp, reqInf, err = TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err == nil {
-		t.Error("expected GET Federation deliveryservices to return an error when page is not a positive integer")
-	}
-	if reqInf.StatusCode != http.StatusBadRequest {
-		t.Fatalf("Expected 400 status code, got %v", reqInf.StatusCode)
+func validateFederationsUpdateFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		opts := client.NewRequestOptions()
+		federation, _, err := TOSession.Federations(opts)
+		assert.RequireNoError(t, err, "Error getting Federations: %v - alerts: %+v", err, federation.Alerts)
+		assert.RequireGreaterOrEqual(t, len(federation.Response), 1, "Expected one Federation returned Got: %d", len(federation.Response))
+		validateFederationFields(expectedResp)(t, toclientlib.ReqInf{}, federation.Response, tc.Alerts{}, nil)
 	}
 }
 
-func SortTestFederationDs(t *testing.T) {
-	var sortedList []int
-	if len(fedIDs) == 0 {
-		t.Fatalf("no federations, must have at least 1 federation to test federations deliveryservices")
-	}
-	fedID := fedIDs[1]
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "dsID")
-	resp, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v - alerts: %+v", err, resp.Alerts)
-	}
-	for _, fedDs := range resp.Response {
-		if fedDs.ID == nil {
-			t.Fatalf("Federation Deliveryservices ID is nil, so sorting can't be tested")
+func validateAllFederationsFields(expectedResp []map[string]interface{}) utils.CkReqFunc {
+	return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _ tc.Alerts, _ error) {
+		assert.RequireNotNil(t, resp, "Expected All Federations response to not be nil.")
+		allFederationResp := resp.([]tc.AllDeliveryServiceFederationsMapping)
+		for _, expected := range expectedResp {
+			for _, allFed := range allFederationResp {
+				if allFed.DeliveryService.String() == expected["DeliveryService"] {
+					for _, mapping := range allFed.Mappings {
+						for _, expectedMapping := range expected["Mappings"].([]map[string]interface{}) {
+							assert.RequireNotNil(t, mapping.CName, "Expected CName to not be nil.")
+							if expectedMapping["CName"] == *mapping.CName {
+								assert.RequireNotNil(t, mapping.TTL, "Expected TTL to not be nil.")
+								assert.Equal(t, expectedMapping["TTL"], *mapping.TTL, "Expected TTL to be %v, but got %s", expected, allFed.Mappings[0].TTL)
+							}
+						}
+					}
+				}
+			}
 		}
-		sortedList = append(sortedList, *fedDs.ID)
-	}
-	res := sort.SliceIsSorted(sortedList, func(p, q int) bool {
-		return sortedList[p] < sortedList[q]
-	})
-	if res != true {
-		t.Errorf("list is not sorted by their DS ID: %v", sortedList)
-	}
-}
-
-func SortTestFederationsDsDesc(t *testing.T) {
-
-	if len(fedIDs) == 0 {
-		t.Fatalf("no federations, must have at least 1 federation to test federations deliveryservices")
-	}
-	fedID := fedIDs[1]
-
-	opts := client.NewRequestOptions()
-	opts.QueryParameters.Set("orderby", "dsID")
-	resp, _, err := TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Fatalf("Expected no error, but got error in Federation DS default ordering %v - alerts: %+v", err, resp.Alerts)
-	}
-	respAsc := resp.Response
-	if len(respAsc) < 1 {
-		t.Fatal("Need at least one Federation DS in Traffic Ops to test Federation DS sort ordering")
-	}
-	opts.QueryParameters.Set("sortOrder", "desc")
-	resp, _, err = TOSession.GetFederationDeliveryServices(fedID, opts)
-	if err != nil {
-		t.Errorf("Expected no error, but got error in Federation DS with Descending ordering: %v - alerts: %+v", err, resp.Alerts)
-	}
-	respDesc := resp.Response
-	if len(respDesc) < 1 {
-		t.Fatal("Need at least one Federation DS in Traffic Ops to test Federation DS sort ordering")
-	}
-	if len(respAsc) != len(respDesc) {
-		t.Fatalf("Traffic Ops returned %d Federation DS using default sort order, but %d Federation DS when sort order was explicitly set to descending", len(respAsc), len(respDesc))
-	}
-	for start, end := 0, len(respDesc)-1; start < end; start, end = start+1, end-1 {
-		respDesc[start], respDesc[end] = respDesc[end], respDesc[start]
-	}
-	if respDesc[0].ID == nil || respAsc[0].ID == nil {
-		t.Fatalf("Response ID is nil in federation deliveryservices")
-	}
-	if *respDesc[0].ID != *respAsc[0].ID {
-		t.Errorf("Federation DS responses are not equal after reversal: Asc: %d - Desc: %d", *respDesc[0].ID, *respAsc[0].ID)
 	}
 }
diff --git a/traffic_ops/testing/api/v4/withobjs_test.go b/traffic_ops/testing/api/v4/withobjs_test.go
index a13e0b6a25..feb77b15d4 100644
--- a/traffic_ops/testing/api/v4/withobjs_test.go
+++ b/traffic_ops/testing/api/v4/withobjs_test.go
@@ -56,7 +56,9 @@ const (
 	DeliveryServicesRequiredCapabilities
 	DeliveryServiceServerAssignments
 	Divisions
+	FederationDeliveryServices
 	FederationResolvers
+	FederationFederationResolvers
 	FederationUsers
 	Origins
 	Parameters
@@ -102,8 +104,10 @@ var withFuncs = map[TCObj]TCObjFuncs{
 	DeliveryServicesRequiredCapabilities:  {CreateTestDeliveryServicesRequiredCapabilities, DeleteTestDeliveryServicesRequiredCapabilities},
 	DeliveryServiceServerAssignments:      {CreateTestDeliveryServiceServerAssignments, DeleteTestDeliveryServiceServers},
 	Divisions:                             {CreateTestDivisions, DeleteTestDivisions},
+	FederationDeliveryServices:            {CreateTestFederationDeliveryServices, DeleteTestCDNFederations},
 	FederationUsers:                       {CreateTestFederationUsers, DeleteTestFederationUsers},
 	FederationResolvers:                   {CreateTestFederationResolvers, DeleteTestFederationResolvers},
+	FederationFederationResolvers:         {CreateTestFederationFederationResolvers, DeleteTestFederationFederationResolvers},
 	Origins:                               {CreateTestOrigins, DeleteTestOrigins},
 	Parameters:                            {CreateTestParameters, DeleteTestParameters},
 	PhysLocations:                         {CreateTestPhysLocations, DeleteTestPhysLocations},