TO client api tests for Regions automation (#5748)

* added test case for CacheGroup Pagination functionalites

* added tests for region

* formatted using go gmt

* added tests for get regions by invalid id and name:

* added tests for getregionbydivision

* formatted test using go fmt:

* fixed review comments

* fixed segfault in region pagination function

* updated the error message in sort functionality

Author: dmohan001c

traffic_ops/testing/api/v4/divisions_test.go

@@ -201,7 +201,7 @@ func SortTestDivisionDesc(t *testing.T) {
 			}
 		}
 	} else {
-		t.Errorf("No Response returned from GET Delivery Service using SortOrder")
+		t.Errorf("No Response returned from GET Division using SortOrder")
 	}
 }
 

traffic_ops/testing/api/v4/regions_test.go

@@ -17,6 +17,8 @@ package v4
 
 import (
 	"net/http"
+	"net/url"
+	"reflect"
 	"sort"
 	"strings"
 	"testing"
@@ -36,15 +38,24 @@ func TestRegions(t *testing.T) {
 		header.Set(rfc.IfModifiedSince, time)
 		header.Set(rfc.IfUnmodifiedSince, time)
 		SortTestRegions(t)
+		SortTestRegionsDesc(t)
 		UpdateTestRegions(t)
 		UpdateTestRegionsWithHeaders(t, header)
 		GetTestRegions(t)
 		GetTestRegionsIMSAfterChange(t, header)
 		DeleteTestRegionsByName(t)
+		VerifyPaginationSupportRegion(t)
 		header = make(map[string][]string)
 		etag := rfc.ETag(currentTime)
 		header.Set(rfc.IfMatch, etag)
 		UpdateTestRegionsWithHeaders(t, header)
+		DeleteTestRegionsByInvalidId(t)
+		DeleteTestRegionsByInvalidName(t)
+		GetTestRegionByInvalidId(t)
+		GetTestRegionByInvalidName(t)
+		GetTestRegionByDivision(t)
+		GetTestRegionByInvalidDivision(t)
+		CreateTestRegionsInvalidDivision(t)
 	})
 }
 
@@ -112,6 +123,15 @@ func GetTestRegionsIMSAfterChange(t *testing.T, header http.Header) {
 	}
 }
 
+func GetTestRegions(t *testing.T) {
+	for _, region := range testData.Regions {
+		resp, _, err := TOSession.GetRegionByName(region.Name, nil)
+		if err != nil {
+			t.Errorf("cannot GET Region by region: %v - %v", err, resp)
+		}
+	}
+}
+
 func CreateTestRegions(t *testing.T) {
 
 	for _, region := range testData.Regions {
@@ -124,9 +144,8 @@ func CreateTestRegions(t *testing.T) {
 }
 
 func SortTestRegions(t *testing.T) {
-	var header http.Header
 	var sortedList []string
-	resp, _, err := TOSession.GetRegions(header)
+	resp, _, err := TOSession.GetRegions(nil, nil)
 	if err != nil {
 		t.Fatalf("Expected no error, but got %v", err.Error())
 	}
@@ -142,6 +161,38 @@ func SortTestRegions(t *testing.T) {
 	}
 }
 
+func SortTestRegionsDesc(t *testing.T) {
+
+	respAsc, _, err1 := TOSession.GetRegions(nil, nil)
+	params := url.Values{}
+	params.Set("sortOrder", "desc")
+	respDesc, _, err2 := TOSession.GetRegions(params, nil)
+
+	if err1 != nil {
+		t.Errorf("Expected no error, but got error in Regions Ascending %v", err1)
+	}
+	if err2 != nil {
+		t.Errorf("Expected no error, but got error in Regions Descending %v", err2)
+	}
+	if len(respAsc) == len(respDesc) {
+		if len(respAsc) > 0 && len(respDesc) > 0 {
+			// reverse the descending-sorted response and compare it to the ascending-sorted one
+			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].Name != "" && respAsc[0].Name != "" {
+				if !reflect.DeepEqual(respDesc[0].Name, respAsc[0].Name) {
+					t.Errorf("Regions responses are not equal after reversal: Asc: %s - Desc: %s", respDesc[0].Name, respAsc[0].Name)
+				}
+			}
+		} else {
+			t.Errorf("No Response returned from GET Regions using SortOrder")
+		}
+	} else {
+		t.Fatalf("Region response length are not equal Asc: %d Desc: %d", len(respAsc), len(respDesc))
+	}
+}
+
 func UpdateTestRegions(t *testing.T) {
 
 	firstRegion := testData.Regions[0]
@@ -175,15 +226,90 @@ func UpdateTestRegions(t *testing.T) {
 	if err != nil {
 		t.Errorf("cannot UPDATE Region by id: %v - %v", err, alert)
 	}
-
 }
 
-func GetTestRegions(t *testing.T) {
-	for _, region := range testData.Regions {
-		resp, _, err := TOSession.GetRegionByName(region.Name, nil)
-		if err != nil {
-			t.Errorf("cannot GET Region by region: %v - %v", err, resp)
+func VerifyPaginationSupportRegion(t *testing.T) {
+
+	qparams := url.Values{}
+	qparams.Set("orderby", "id")
+	regions, _, err := TOSession.GetRegions(qparams, nil)
+	if err != nil {
+		t.Fatalf("cannot GET Regions: %v", err)
+	}
+
+	if len(regions) > 0 {
+		qparams = url.Values{}
+		qparams.Set("orderby", "id")
+		qparams.Set("limit", "1")
+		regionsWithLimit, _, err := TOSession.GetRegions(qparams, nil)
+		if err == nil {
+			if !reflect.DeepEqual(regions[:1], regionsWithLimit) {
+				t.Error("expected GET Regions with limit = 1 to return first result")
+			}
+		} else {
+			t.Error("Error in getting regions by limit")
 		}
+
+		if len(regions) > 1 {
+			qparams = url.Values{}
+			qparams.Set("orderby", "id")
+			qparams.Set("limit", "1")
+			qparams.Set("offset", "1")
+			regionsWithOffset, _, err := TOSession.GetRegions(qparams, nil)
+			if err == nil {
+				if !reflect.DeepEqual(regions[1:2], regionsWithOffset) {
+					t.Error("expected GET Regions with limit = 1, offset = 1 to return second result")
+				}
+			} else {
+				t.Error("Error in getting regions by limit and offset")
+			}
+
+			qparams = url.Values{}
+			qparams.Set("orderby", "id")
+			qparams.Set("limit", "1")
+			qparams.Set("page", "2")
+			regionsWithPage, _, err := TOSession.GetRegions(qparams, nil)
+			if err == nil {
+				if !reflect.DeepEqual(regions[1:2], regionsWithPage) {
+					t.Error("expected GET Regions with limit = 1, page = 2 to return second result")
+				}
+			} else {
+				t.Error("Error in getting regions by limit and page")
+			}
+		} else {
+			t.Errorf("only one region found, so offset functionality can't test")
+		}
+	} else {
+		t.Errorf("No region found to check pagination")
+	}
+
+	qparams = url.Values{}
+	qparams.Set("limit", "-2")
+	_, _, err = TOSession.GetRegions(qparams, nil)
+	if err == nil {
+		t.Error("expected GET Regions to return an error when limit is not bigger than -1")
+	} else if !strings.Contains(err.Error(), "must be bigger than -1") {
+		t.Errorf("expected GET Regions to return an error for limit is not bigger than -1, actual error: " + err.Error())
+	}
+
+	qparams = url.Values{}
+	qparams.Set("limit", "1")
+	qparams.Set("offset", "0")
+	_, _, err = TOSession.GetRegions(qparams, nil)
+	if err == nil {
+		t.Error("expected GET Regions to return an error when offset is not a positive integer")
+	} else if !strings.Contains(err.Error(), "must be a positive integer") {
+		t.Errorf("expected GET Regions to return an error for offset is not a positive integer, actual error: " + err.Error())
+	}
+
+	qparams = url.Values{}
+	qparams.Set("limit", "1")
+	qparams.Set("page", "0")
+	_, _, err = TOSession.GetRegions(qparams, nil)
+	if err == nil {
+		t.Error("expected GET Regions to return an error when page is not a positive integer")
+	} else if !strings.Contains(err.Error(), "must be a positive integer") {
+		t.Errorf("expected GET Regions to return an error for page is not a positive integer, actual error: " + err.Error())
 	}
 }
 
@@ -214,7 +340,6 @@ func DeleteTestRegionsByName(t *testing.T) {
 			t.Errorf("expected Region : %s to be deleted", region.Name)
 		}
 	}
-
 	CreateTestRegions(t)
 }
 
@@ -243,3 +368,79 @@ func DeleteTestRegions(t *testing.T) {
 		}
 	}
 }
+
+func DeleteTestRegionsByInvalidId(t *testing.T) {
+	i := 10000
+	delResp, _, err := TOSession.DeleteRegion(&i, nil)
+	if err == nil {
+		t.Errorf("cannot DELETE Regions by Invalid ID: %v - %v", err, delResp)
+	}
+}
+
+func DeleteTestRegionsByInvalidName(t *testing.T) {
+	i := "invalid"
+	delResp, _, err := TOSession.DeleteRegion(nil, &i)
+	if err == nil {
+		t.Errorf("cannot DELETE Regions by Invalid ID: %v - %v", err, delResp)
+	}
+}
+
+func GetTestRegionByInvalidId(t *testing.T) {
+	regionResp, _, err := TOSession.GetRegionByID(10000, nil)
+	if err != nil {
+		t.Errorf("Error!! Getting Region by Invalid ID %v", err)
+	}
+	if len(regionResp) >= 1 {
+		t.Errorf("Error!! Invalid ID shouldn't have any response %v Error %v", regionResp, err)
+	}
+}
+
+func GetTestRegionByInvalidName(t *testing.T) {
+	regionResp, _, err := TOSession.GetRegionByName("abcd", nil)
+	if err != nil {
+		t.Errorf("Error!! Getting Region by Invalid Name %v", err)
+	}
+	if len(regionResp) >= 1 {
+		t.Errorf("Error!! Invalid Name shouldn't have any response %v Error %v", regionResp, err)
+	}
+}
+
+func GetTestRegionByDivision(t *testing.T) {
+	for _, region := range testData.Regions {
+
+		resp, _, err := TOSession.GetDivisionByName(region.DivisionName, nil)
+		if err != nil {
+			t.Errorf("cannot GET Division by name: %v - %v", region.DivisionName, err)
+		}
+		respDivision := resp[0]
+
+		_, reqInf, err := TOSession.GetRegionByDivision(respDivision.ID, nil)
+		if err != nil {
+			t.Fatalf("Expected no error, but got %v", err.Error())
+		}
+		if reqInf.StatusCode != http.StatusOK {
+			t.Fatalf("Expected 200 status code, got %v", reqInf.StatusCode)
+		}
+	}
+}
+
+func GetTestRegionByInvalidDivision(t *testing.T) {
+	regionResp, _, err := TOSession.GetRegionByDivision(100000, nil)
+	if err != nil {
+		t.Errorf("Getting Region by Invalid Divisions %v", err)
+	}
+	if len(regionResp) >= 1 {
+		t.Errorf("Invalid Division shouldn't have any response %v Error %v", regionResp, err)
+	}
+}
+
+func CreateTestRegionsInvalidDivision(t *testing.T) {
+
+	firstRegion := testData.Regions[0]
+	firstRegion.Division = 100
+	firstRegion.Name = "abcd"
+	_, _, err := TOSession.CreateRegion(firstRegion)
+	if err == nil {
+		t.Errorf("Expected division not found Error %v", err)
+	}
+}

traffic_ops/v4-client/region.go

@@ -57,9 +57,13 @@ func (to *Session) UpdateRegion(id int, region tc.Region, header http.Header) (t
 }
 
 // GetRegions returns all Regions in Traffic Ops.
-func (to *Session) GetRegions(header http.Header) ([]tc.Region, toclientlib.ReqInf, error) {
+func (to *Session) GetRegions(params url.Values, header http.Header) ([]tc.Region, toclientlib.ReqInf, error) {
+	uri := APIRegions
+	if params != nil {
+		uri += "?" + params.Encode()
+	}
 	var data tc.RegionsResponse
-	reqInf, err := to.get(APIRegions, header, &data)
+	reqInf, err := to.get(uri, header, &data)
 	return data.Response, reqInf, err
 }
 
@@ -79,6 +83,14 @@ func (to *Session) GetRegionByName(name string, header http.Header) ([]tc.Region
 	return data.Response, reqInf, err
 }
 
+// GetRegionByDivision retrieves the Region with the given Name.
+func (to *Session) GetRegionByDivision(id int, header http.Header) ([]tc.Region, toclientlib.ReqInf, error) {
+	route := fmt.Sprintf("%s?division=%d", APIRegions, id)
+	var data tc.RegionsResponse
+	reqInf, err := to.get(route, header, &data)
+	return data.Response, reqInf, err
+}
+
 // DeleteRegion lets you DELETE a Region. Only 1 parameter is required, not both.
 func (to *Session) DeleteRegion(id *int, name *string) (tc.Alerts, toclientlib.ReqInf, error) {
 	v := url.Values{}