This is an automated email from the ASF dual-hosted git repository.
ocket8888 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 3a9517ccbb Refactor Origins Tests (#7013)
3a9517ccbb is described below
commit 3a9517ccbb0cdeee4c0ad03350dcca070fa47e5d
Author: Eric Holguin <[email protected]>
AuthorDate: Mon Aug 29 20:15:38 2022 -0600
Refactor Origins Tests (#7013)
* Initial Origins test refactor
* Refactor Origins tests
---
traffic_ops/testing/api/v3/origins_test.go | 534 +++++-----
traffic_ops/testing/api/v4/origins_test.go | 1450 ++++++++++++----------------
2 files changed, 932 insertions(+), 1052 deletions(-)
diff --git a/traffic_ops/testing/api/v3/origins_test.go
b/traffic_ops/testing/api/v3/origins_test.go
index 4e990230a3..5c08d3b3aa 100644
--- a/traffic_ops/testing/api/v3/origins_test.go
+++ b/traffic_ops/testing/api/v3/origins_test.go
@@ -16,257 +16,355 @@ package v3
*/
import (
+ "encoding/json"
"net/http"
- "reflect"
- "strings"
+ "net/url"
"testing"
"time"
"github.com/apache/trafficcontrol/lib/go-rfc"
"github.com/apache/trafficcontrol/lib/go-tc"
- "github.com/apache/trafficcontrol/lib/go-util"
- toclient "github.com/apache/trafficcontrol/traffic_ops/v3-client"
+ "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 TestOrigins(t *testing.T) {
- WithObjs(t, []TCObj{CDNs, Coordinates, Types, Tenants, Parameters,
Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers,
Users, Topologies, DeliveryServices, Origins}, 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.IfUnmodifiedSince, time)
- UpdateTestOrigins(t)
- UpdateTestOriginsWithHeaders(t, header)
- GetTestOrigins(t)
- NotFoundDeleteTest(t)
- OriginTenancyTest(t)
- VerifyPaginationSupport(t)
- header = make(map[string][]string)
- etag := rfc.ETag(currentTime)
- header.Set(rfc.IfMatch, etag)
- UpdateTestOriginsWithHeaders(t, header)
- })
-}
-
-func UpdateTestOriginsWithHeaders(t *testing.T, header http.Header) {
- if len(testData.Origins) > 0 {
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatalf("couldn't get the name of test origin server")
- }
- // Retrieve the origin by name so we can get the id for the
Update
- resp, _, err := TOSession.GetOriginByName(*firstOrigin.Name)
- if err != nil {
- t.Errorf("cannot GET origin by name: %v - %v",
*firstOrigin.Name, err)
+ WithObjs(t, []TCObj{CDNs, Coordinates, Types, Tenants, Parameters,
Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers,
Users, Topologies, ServiceCategories, DeliveryServices, Origins}, func() {
+
+ currentTime := time.Now().UTC().Add(-15 * time.Second)
+ currentTimeRFC := currentTime.Format(time.RFC1123)
+
+ tenant4UserSession := utils.CreateV3Session(t,
Config.TrafficOps.URL, "tenant4user", "pa$$word",
Config.Default.Session.TimeoutInSecs)
+
+ methodTests := utils.V3TestCase{
+ "GET": {
+ "OK when VALID request": {
+ ClientSession: TOSession,
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1)),
+ },
+ "OK when VALID NAME parameter": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"name":
{"origin1"}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(1),
+
validateOriginsFields(map[string]interface{}{"Name": "origin1"})),
+ },
+ "EMPTY RESPONSE when CHILD TENANT reads PARENT
TENANT ORIGIN": {
+ ClientSession: tenant4UserSession,
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ },
+ "GET QUERY PARAMS": {
+ "FIRST RESULT when LIMIT=1": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"orderby":
{"id"}, "limit": {"1"}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
validateOriginsPagination("limit")),
+ },
+ "SECOND RESULT when LIMIT=1 OFFSET=1": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"orderby":
{"id"}, "limit": {"1"}, "offset": {"1"}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
validateOriginsPagination("offset")),
+ },
+ "SECOND RESULT when LIMIT=1 PAGE=2": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"orderby":
{"id"}, "limit": {"1"}, "page": {"2"}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
validateOriginsPagination("page")),
+ },
+ "BAD REQUEST when INVALID LIMIT parameter": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"limit":
{"-2"}},
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID OFFSET parameter": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"limit":
{"1"}, "offset": {"0"}},
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID PAGE parameter": {
+ ClientSession: TOSession,
+ RequestParams: url.Values{"limit":
{"1"}, "page": {"0"}},
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ },
+ "PUT": {
+ "OK when VALID request": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"multiOriginCachegroup",
+ "Coordinate":
"coordinate2",
+ "deliveryService": "ds3",
+ "fqdn":
"originupdated.example.com",
+ "ipAddress": "1.2.3.4",
+ "ip6Address": "0000::1111",
+ "port": 1234,
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant2")(),
+ },
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+
validateOriginsUpdateCreateFields("origin2",
map[string]interface{}{"Cachegroup": "multiOriginCachegroup", "Coordinate":
"coordinate2", "DeliveryService": "ds3",
+ "FQDN":
"originupdated.example.com", "IPAddress": "1.2.3.4", "IP6Address":
"0000::1111", "Port": 1234, "Protocol": "http", "Tenant": "tenant2"})),
+ },
+ "FORBIDDEN when CHILD TENANT updates PARENT
TENANT ORIGIN": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: tenant4UserSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testtenancy",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"testtenancy.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ "NOT FOUND when ORIGIN DOESNT EXIST": {
+ EndpointId: func() int { return
1111111 },
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "testid",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"testid.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "PRECONDITION FAILED when updating with IMS &
IUS Headers": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestHeaders:
http.Header{rfc.IfUnmodifiedSince: {currentTimeRFC}},
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryService": "ds2",
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(),
utils.HasStatus(http.StatusPreconditionFailed)),
+ },
+ "PRECONDITION FAILED when updating with IFMATCH
ETAG Header": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryService": "ds2",
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ RequestHeaders:
http.Header{rfc.IfMatch: {rfc.ETag(currentTime)}},
+ Expectations:
utils.CkRequest(utils.HasError(),
utils.HasStatus(http.StatusPreconditionFailed)),
+ },
+ },
+ "DELETE": {
+ "NOT FOUND when DOESNT EXIST": {
+ EndpointId: func() int { return
11111111 },
+ ClientSession: TOSession,
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "FORBIDDEN when CHILD TENANT deletes PARENT
TENANT ORIGIN": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: tenant4UserSession,
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ },
}
- if len(resp) > 0 {
- remoteOrigin := resp[0]
- if remoteOrigin.ID == nil {
- t.Fatalf("couldn't get the ID of the response
origin server")
- }
- updatedPort := 4321
- updatedFQDN := "updated.example.com"
- // update port and FQDN values on origin
- remoteOrigin.Port = &updatedPort
- remoteOrigin.FQDN = &updatedFQDN
- _, reqInf, err :=
TOSession.UpdateOriginByIDWithHdr(*remoteOrigin.ID, remoteOrigin, header)
- if err == nil {
- t.Errorf("Expected error about precondition
failed, but got none")
- }
- if reqInf.StatusCode != http.StatusPreconditionFailed {
- t.Errorf("Expected status code 412, got %v",
reqInf.StatusCode)
- }
+ for method, testCases := range methodTests {
+ t.Run(method, func(t *testing.T) {
+ for name, testCase := range testCases {
+ origin := tc.Origin{}
+
+ 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,
&origin)
+ assert.NoError(t, err, "Error
occurred when unmarshalling request body: %v", err)
+ }
+
+ switch method {
+ case "GET":
+ t.Run(name, func(t *testing.T) {
+ if name == "OK when
VALID NAME parameter" {
+ resp, reqInf,
err := testCase.ClientSession.GetOriginByName(testCase.RequestParams["name"][0])
+ for _, check :=
range testCase.Expectations {
+
check(t, reqInf, resp, tc.Alerts{}, err)
+ }
+ } else {
+ resp, reqInf,
err := testCase.ClientSession.GetOrigins()
+ for _, check :=
range testCase.Expectations {
+
check(t, reqInf, resp, tc.Alerts{}, err)
+ }
+ }
+ })
+ case "GET QUERY PARAMS":
+ t.Run(name, func(t *testing.T) {
+ queryParams := "?" +
testCase.RequestParams.Encode()
+ resp, reqInf, err :=
testCase.ClientSession.GetOriginsByQueryParams(queryParams)
+ for _, check := range
testCase.Expectations {
+ check(t,
reqInf, resp, tc.Alerts{}, err)
+ }
+ })
+ case "POST":
+ t.Run(name, func(t *testing.T) {
+ resp, reqInf, err :=
testCase.ClientSession.CreateOrigin(origin)
+ 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.UpdateOriginByIDWithHdr(testCase.EndpointId(), origin,
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.DeleteOriginByID(testCase.EndpointId())
+ for _, check := range
testCase.Expectations {
+ check(t,
reqInf, nil, alerts, err)
+ }
+ })
+ }
+ }
+ })
}
- }
+ })
}
-func CreateTestOrigins(t *testing.T) {
- // loop through origins, assign FKs and create
- for _, origin := range testData.Origins {
- _, _, err := TOSession.CreateOrigin(origin)
- if err != nil {
- t.Errorf("could not CREATE origins: %v", err)
+func validateOriginsFields(expectedResp map[string]interface{})
utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ assert.RequireNotNil(t, resp, "Expected Origin response to not
be nil.")
+ originResp := resp.([]tc.Origin)
+ for field, expected := range expectedResp {
+ for _, origin := range originResp {
+ switch field {
+ case "Cachegroup":
+ assert.RequireNotNil(t,
origin.Cachegroup, "Expected Cachegroup to not be nil.")
+ assert.Equal(t, expected,
*origin.Cachegroup, "Expected Cachegroup to be %v, but got %s", expected,
*origin.Cachegroup)
+ case "CachegroupID":
+ assert.RequireNotNil(t,
origin.CachegroupID, "Expected CachegroupID to not be nil.")
+ assert.Equal(t, expected,
*origin.CachegroupID, "Expected CachegroupID to be %v, but got %d", expected,
*origin.Cachegroup)
+ case "Coordinate":
+ assert.RequireNotNil(t,
origin.Coordinate, "Expected Coordinate to not be nil.")
+ assert.Equal(t, expected,
*origin.Coordinate, "Expected Coordinate to be %v, but got %s", expected,
*origin.Coordinate)
+ case "CoordinateID":
+ assert.RequireNotNil(t,
origin.CoordinateID, "Expected CoordinateID to not be nil.")
+ assert.Equal(t, expected,
*origin.CoordinateID, "Expected CoordinateID to be %v, but got %d", expected,
*origin.CoordinateID)
+ case "DeliveryService":
+ assert.RequireNotNil(t,
origin.DeliveryService, "Expected DeliveryService to not be nil.")
+ assert.Equal(t, expected,
*origin.DeliveryService, "Expected DeliveryService to be %v, but got %s",
expected, *origin.DeliveryService)
+ case "DeliveryServiceID":
+ assert.RequireNotNil(t,
origin.DeliveryServiceID, "Expected DeliveryServiceID to not be nil.")
+ assert.Equal(t, expected,
*origin.DeliveryServiceID, "Expected DeliveryServiceID to be %v, but got %d",
expected, *origin.DeliveryServiceID)
+ case "FQDN":
+ assert.RequireNotNil(t, origin.FQDN,
"Expected FQDN to not be nil.")
+ assert.Equal(t, expected, *origin.FQDN,
"Expected FQDN to be %v, but got %s", expected, *origin.FQDN)
+ case "ID":
+ assert.RequireNotNil(t, origin.ID,
"Expected ID to not be nil.")
+ assert.Equal(t, expected, *origin.ID,
"Expected ID to be %v, but got %d", expected, *origin.ID)
+ case "IPAddress":
+ assert.RequireNotNil(t,
origin.IPAddress, "Expected IPAddress to not be nil.")
+ assert.Equal(t, expected,
*origin.IPAddress, "Expected IPAddress to be %v, but got %s", expected,
*origin.IPAddress)
+ case "IP6Address":
+ assert.RequireNotNil(t,
origin.IP6Address, "Expected IP6Address to not be nil.")
+ assert.Equal(t, expected,
*origin.IP6Address, "Expected IP6Address to be %v, but got %s", expected,
*origin.IP6Address)
+ case "IsPrimary":
+ assert.RequireNotNil(t,
origin.IsPrimary, "Expected IsPrimary to not be nil.")
+ assert.Equal(t, expected,
*origin.IsPrimary, "Expected IsPrimary to be %v, but got %v", expected,
*origin.IsPrimary)
+ case "Name":
+ assert.RequireNotNil(t, origin.Name,
"Expected Name to not be nil.")
+ assert.Equal(t, expected, *origin.Name,
"Expected Name to be %v, but got %s", expected, *origin.Name)
+ case "Port":
+ assert.RequireNotNil(t, origin.Port,
"Expected Port to not be nil.")
+ assert.Equal(t, expected, *origin.Port,
"Expected Port to be %v, but got %d", expected, *origin.Port)
+ case "Profile":
+ assert.RequireNotNil(t, origin.Profile,
"Expected Profile to not be nil.")
+ assert.Equal(t, expected,
*origin.Profile, "Expected Profile to be %v, but got %s", expected,
*origin.Profile)
+ case "ProfileID":
+ assert.RequireNotNil(t,
origin.ProfileID, "Expected ProfileID to not be nil.")
+ assert.Equal(t, expected,
*origin.ProfileID, "Expected ProfileID to be %v, but got %d", expected,
*origin.ProfileID)
+ case "Protocol":
+ assert.RequireNotNil(t,
origin.Protocol, "Expected Protocol to not be nil.")
+ assert.Equal(t, expected,
*origin.Protocol, "Expected Tenant to be %v, but got %s", expected,
*origin.Protocol)
+ case "Tenant":
+ assert.RequireNotNil(t, origin.Tenant,
"Expected Tenant to not be nil.")
+ assert.Equal(t, expected,
*origin.Tenant, "Expected Tenant to be %v, but got %s", expected,
*origin.Tenant)
+ case "TenantID":
+ assert.RequireNotNil(t,
origin.TenantID, "Expected TenantID to not be nil.")
+ assert.Equal(t, expected,
*origin.TenantID, "Expected TenantID to be %v, but got %d", expected,
*origin.TenantID)
+ default:
+ t.Errorf("Expected field: %v, does not
exist in response", field)
+ }
+ }
}
}
}
-func NotFoundDeleteTest(t *testing.T) {
- _, _, err := TOSession.DeleteOriginByID(2020)
- if err == nil {
- t.Error("deleting origin with what should be a non-existent id
- expected: error, actual: nil error")
- } else if !strings.Contains(err.Error(), "not found") {
- t.Errorf("deleted origin with what should be a non-existent id
- expected: 'not found' error, actual: %s", err.Error())
- }
-}
-
-func GetTestOrigins(t *testing.T) {
- _, _, err := TOSession.GetOrigins()
- if err != nil {
- t.Errorf("cannot GET origins: %v", err)
- }
-
- for _, origin := range testData.Origins {
- resp, _, err := TOSession.GetOriginByName(*origin.Name)
- if err != nil {
- t.Errorf("cannot GET Origin by name: %v - %v", err,
resp)
- }
+func validateOriginsUpdateCreateFields(name string, expectedResp
map[string]interface{}) utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ origin, _, err := TOSession.GetOriginByName(name)
+ assert.RequireNoError(t, err, "Error getting Origin: %v", err)
+ assert.RequireEqual(t, 1, len(origin), "Expected one Origin
returned Got: %d", len(origin))
+ validateOriginsFields(expectedResp)(t, toclientlib.ReqInf{},
origin, tc.Alerts{}, nil)
}
}
-func UpdateTestOrigins(t *testing.T) {
- firstOrigin := testData.Origins[0]
- // Retrieve the origin by name so we can get the id for the Update
- resp, _, err := TOSession.GetOriginByName(*firstOrigin.Name)
- if err != nil {
- t.Errorf("cannot GET origin by name: %v - %v",
*firstOrigin.Name, err)
- }
- if len(resp) > 0 {
- remoteOrigin := resp[0]
- updatedPort := 4321
- updatedFQDN := "updated.example.com"
-
- // update port and FQDN values on origin
- remoteOrigin.Port = &updatedPort
- remoteOrigin.FQDN = &updatedFQDN
- updResp, _, err := TOSession.UpdateOriginByID(*remoteOrigin.ID,
remoteOrigin)
- if err != nil && updResp != nil {
- t.Errorf("cannot UPDATE Origin by name: %v - %v", err,
updResp.Alerts)
- }
-
- // Retrieve the origin to check port and FQDN values were
updated
- resp, _, err = TOSession.GetOriginByID(*remoteOrigin.ID)
- if err != nil {
- t.Errorf("cannot GET Origin by ID: %v - %v",
*remoteOrigin.Name, err)
- }
-
- if len(resp) > 0 {
- respOrigin := resp[0]
- if *respOrigin.Port != updatedPort {
- t.Errorf("results do not match actual: %d,
expected: %d", *respOrigin.Port, updatedPort)
- }
- if *respOrigin.FQDN != updatedFQDN {
- t.Errorf("results do not match actual: %s,
expected: %s", *respOrigin.FQDN, updatedFQDN)
- }
+func validateOriginsPagination(paginationParam string) utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ paginationResp := resp.([]tc.Origin)
+ respBase, _, err :=
TOSession.GetOriginsByQueryParams("?orderby=id")
+ assert.RequireNoError(t, err, "Cannot get Origins: %v", err)
+
+ origin := respBase
+ assert.RequireGreaterOrEqual(t, len(origin), 3, "Need at least
3 Origins in Traffic Ops to test pagination support, found: %d", len(origin))
+ switch paginationParam {
+ case "limit:":
+ assert.Exactly(t, origin[:1], paginationResp, "expected
GET Origins with limit = 1 to return first result")
+ case "offset":
+ assert.Exactly(t, origin[1:2], paginationResp,
"expected GET Origins with limit = 1, offset = 1 to return second result")
+ case "page":
+ assert.Exactly(t, origin[1:2], paginationResp,
"expected GET Origins with limit = 1, page = 2 to return second result")
}
}
}
-func OriginTenancyTest(t *testing.T) {
- origins, _, err := TOSession.GetOrigins()
- if err != nil {
- t.Errorf("cannot GET origins: %v", err)
- }
- tenant3Origin := tc.Origin{}
- foundTenant3Origin := false
- for _, o := range origins {
- if *o.FQDN == "origin.ds3.example.net" {
- tenant3Origin = o
- foundTenant3Origin = true
- }
- }
- if !foundTenant3Origin {
- t.Error("expected to find origin with tenant 'tenant3' and fqdn
'origin.ds3.example.net'")
- }
-
- toReqTimeout := time.Second *
time.Duration(Config.Default.Session.TimeoutInSecs)
- tenant4TOClient, _, err := toclient.LoginWithAgent(TOSession.URL,
"tenant4user", "pa$$word", true, "to-api-v3-client-tests/tenant4user", true,
toReqTimeout)
- if err != nil {
- t.Fatalf("failed to log in with tenant4user: %v", err.Error())
- }
-
- originsReadableByTenant4, _, err := tenant4TOClient.GetOrigins()
- if err != nil {
- t.Error("tenant4user cannot GET origins")
- }
-
- // assert that tenant4user cannot read origins outside of its tenant
- for _, origin := range originsReadableByTenant4 {
- if *origin.FQDN == "origin.ds3.example.net" {
- t.Error("expected tenant4 to be unable to read origins
from tenant 3")
- }
- }
-
- // assert that tenant4user cannot update tenant3user's origin
- if _, _, err = tenant4TOClient.UpdateOriginByID(*tenant3Origin.ID,
tenant3Origin); err == nil {
- t.Error("expected tenant4user to be unable to update tenant3's
origin")
- }
-
- // assert that tenant4user cannot delete an origin outside of its tenant
- if _, _, err = tenant4TOClient.DeleteOriginByID(*origins[0].ID); err ==
nil {
- t.Errorf("expected tenant4user to be unable to delete an origin
outside of its tenant (origin %s)", *origins[0].Name)
- }
-
- // assert that tenant4user cannot create origins outside of its tenant
- tenant3Origin.FQDN = util.StrPtr("origin.tenancy.test.example.com")
- if _, _, err = tenant4TOClient.CreateOrigin(tenant3Origin); err == nil {
- t.Error("expected tenant4user to be unable to create an origin
outside of its tenant")
+func GetOriginID(t *testing.T, name string) func() int {
+ return func() int {
+ origins, _, err := TOSession.GetOriginByName(name)
+ assert.RequireNoError(t, err, "Get Origins Request failed with
error:", err)
+ assert.RequireEqual(t, 1, len(origins), "Expected response
object length 1, but got %d", len(origins))
+ assert.RequireNotNil(t, origins[0].ID, "Expected ID to not be
nil.")
+ return *origins[0].ID
}
}
-func VerifyPaginationSupport(t *testing.T) {
- origins, _, err := TOSession.GetOriginsByQueryParams("?orderby=id")
- if err != nil {
- t.Fatalf("cannot GET origins: %v", err)
- }
-
- originsWithLimit, _, err :=
TOSession.GetOriginsByQueryParams("?orderby=id&limit=1")
- if !reflect.DeepEqual(origins[:1], originsWithLimit) {
- t.Error("expected GET origins with limit = 1 to return first
result")
- }
-
- originsWithOffset, _, err :=
TOSession.GetOriginsByQueryParams("?orderby=id&limit=1&offset=1")
- if !reflect.DeepEqual(origins[1:2], originsWithOffset) {
- t.Error("expected GET origins with limit = 1, offset = 1 to
return second result")
- }
-
- originsWithPage, _, err :=
TOSession.GetOriginsByQueryParams("?orderby=id&limit=1&page=2")
- if !reflect.DeepEqual(origins[1:2], originsWithPage) {
- t.Error("expected GET origins with limit = 1, page = 2 to
return second result")
- }
-
- _, _, err = TOSession.GetOriginsByQueryParams("?limit=-2")
- if err == nil {
- t.Error("expected GET origins 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 origins to return an error for limit is
not bigger than -1, actual error: " + err.Error())
- }
- _, _, err = TOSession.GetOriginsByQueryParams("?limit=1&offset=0")
- if err == nil {
- t.Error("expected GET origins 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 origins to return an error for offset is
not a positive integer, actual error: " + err.Error())
- }
- _, _, err = TOSession.GetOriginsByQueryParams("?limit=1&page=0")
- if err == nil {
- t.Error("expected GET origins 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 origins to return an error for page is
not a positive integer, actual error: " + err.Error())
+func CreateTestOrigins(t *testing.T) {
+ for _, origin := range testData.Origins {
+ resp, _, err := TOSession.CreateOrigin(origin)
+ assert.RequireNoError(t, err, "Could not create Origins: %v -
alerts: %+v", err, resp.Alerts)
}
}
func DeleteTestOrigins(t *testing.T) {
- for _, origin := range testData.Origins {
- resp, _, err := TOSession.GetOriginByName(*origin.Name)
- if err != nil {
- t.Errorf("cannot GET Origin by name: %v - %v",
*origin.Name, err)
- }
- if len(resp) > 0 {
- respOrigin := resp[0]
-
- delResp, _, err :=
TOSession.DeleteOriginByID(*respOrigin.ID)
- if err != nil {
- t.Errorf("cannot DELETE Origin by ID: %v - %v",
err, delResp)
- }
-
+ origins, _, err := TOSession.GetOrigins()
+ assert.NoError(t, err, "Cannot get Origins : %v", err)
+
+ for _, origin := range origins {
+ assert.RequireNotNil(t, origin.ID, "Expected origin ID to not
be nil.")
+ assert.RequireNotNil(t, origin.Name, "Expected origin ID to not
be nil.")
+ assert.RequireNotNil(t, origin.IsPrimary, "Expected origin ID
to not be nil.")
+ if !*origin.IsPrimary {
+ alerts, _, err := TOSession.DeleteOriginByID(*origin.ID)
+ assert.NoError(t, err, "Unexpected error deleting
Origin '%s' (#%d): %v - alerts: %+v", *origin.Name, *origin.ID, err,
alerts.Alerts)
// Retrieve the Origin to see if it got deleted
- org, _, err := TOSession.GetOriginByName(*origin.Name)
- if err != nil {
- t.Errorf("error deleting Origin name: %s",
err.Error())
- }
- if len(org) > 0 {
- t.Errorf("expected Origin name: %s to be
deleted", *origin.Name)
- }
+ getOrigin, _, err := TOSession.GetOriginByID(*origin.ID)
+ assert.NoError(t, err, "Error getting Origin '%s' after
deletion: %v", *origin.Name, err)
+ assert.Equal(t, 0, len(getOrigin), "Expected Origin
'%s' to be deleted, but it was found in Traffic Ops", *origin.Name)
}
}
}
diff --git a/traffic_ops/testing/api/v4/origins_test.go
b/traffic_ops/testing/api/v4/origins_test.go
index 7cac422d62..fadf6038d6 100644
--- a/traffic_ops/testing/api/v4/origins_test.go
+++ b/traffic_ops/testing/api/v4/origins_test.go
@@ -16,8 +16,9 @@ package v4
*/
import (
+ "encoding/json"
"net/http"
- "reflect"
+ "net/url"
"strconv"
"strings"
"testing"
@@ -25,339 +26,649 @@ import (
"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 TestOrigins(t *testing.T) {
WithObjs(t, []TCObj{CDNs, Coordinates, Types, Tenants, Parameters,
Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers,
Users, Topologies, ServiceCategories, DeliveryServices, Origins}, 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.IfUnmodifiedSince, time)
- CreateTestOriginDuplicateData(t)
- GetTestOriginsByParams(t)
- GetTestOriginsByInvalidParams(t)
- UpdateTestOrigins(t)
- UpdateTestOriginsWithHeaders(t, header)
- GetTestOrigins(t)
- NotFoundDeleteTest(t)
- OriginTenancyTest(t)
- GetTestPaginationSupportOrigins(t)
- header = make(map[string][]string)
- etag := rfc.ETag(currentTime)
- header.Set(rfc.IfMatch, etag)
- UpdateTestOriginsWithHeaders(t, header)
- CreateTestOriginInvalidData(t)
- updateTestOriginsWithInvalidData(t)
- })
-}
-
-func UpdateTestOriginsWithHeaders(t *testing.T, header http.Header) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test updating Origins with
an HTTP header")
- }
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatalf("couldn't get the name of test origin server")
- }
-
- // Retrieve the origin by name so we can get the id for the Update
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("name", *firstOrigin.Name)
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin '%s'': %v - alerts: %+v",
*firstOrigin.Name, err, resp.Alerts)
- }
- if len(resp.Response) != 1 {
- t.Fatalf("Expected exactly one Origin to exist with name '%s',
found: %d", *firstOrigin.Name, len(resp.Response))
- }
- remoteOrigin := resp.Response[0]
- if remoteOrigin.ID == nil {
- t.Fatal("couldn't get the ID of the response origin server")
- }
- updatedPort := 4321
- updatedFQDN := "updated.example.com"
+ currentTime := time.Now().UTC().Add(-15 * time.Second)
+ currentTimeRFC := currentTime.Format(time.RFC1123)
+
+ tenant4UserSession := utils.CreateV4Session(t,
Config.TrafficOps.URL, "tenant4user", "pa$$word",
Config.Default.Session.TimeoutInSecs)
+
+ methodTests := utils.V4TestCase{
+ "GET": {
+ "OK when VALID request": {
+ ClientSession: TOSession,
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1)),
+ },
+ "OK when VALID NAME parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"name": {"origin1"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(1),
+
validateOriginsFields(map[string]interface{}{"Name": "origin1"})),
+ },
+ "OK when VALID DELIVERYSERVICE parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"deliveryservice":
{strconv.Itoa(GetDeliveryServiceId(t, "ds1")())}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"DeliveryServiceID":
GetDeliveryServiceId(t, "ds1")()})),
+ },
+ "OK when VALID CACHEGROUP parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"cachegroup":
{strconv.Itoa(GetCacheGroupId(t, "originCachegroup")())}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"CachegroupID": GetCacheGroupId(t,
"originCachegroup")()})),
+ },
+ "OK when VALID COORDINATE parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"coordinate":
{strconv.Itoa(GetCoordinateID(t, "coordinate1")())}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"Coordinate": "coordinate1"})),
+ },
+ "OK when VALID PROFILEID parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"profileId":
{strconv.Itoa(GetProfileId(t, "ATS_EDGE_TIER_CACHE"))}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"ProfileID": GetProfileId(t,
"ATS_EDGE_TIER_CACHE")})),
+ },
+ "OK when VALID PRIMARY parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"primary": {"true"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"IsPrimary": true})),
+ },
+ "OK when VALID TENANT parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"tenant":
{strconv.Itoa(GetTenantID(t, "tenant1")())}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseLengthGreaterOrEqual(1),
+
validateOriginsFields(map[string]interface{}{"TenantID": GetTenantID(t,
"tenant1")()})),
+ },
+ "EMPTY RESPONSE when CHILD TENANT reads PARENT
TENANT ORIGIN": {
+ ClientSession: tenant4UserSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"tenant":
{strconv.Itoa(GetTenantID(t, "tenant3")())}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "EMPTY RESPONSE when NAME parameter that DOESNT
EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"name": {"doesntexist"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "EMPTY RESPONSE when DELIVERYSERVICE parameter
that DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"deliveryservice":
{"1000000"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "EMPTY RESPONSE when CACHEGROUP parameter that
DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"cachegroup": {"1000000"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "EMPTY RESPONSE when COORDINATE parameter that
DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"coordinate": {"1000000"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "EMPTY RESPONSE when PROFILEID parameter that
DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"profileId": {"1000000"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "BAD REQUEST when INVALID PRIMARY parameter": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"primary": {"1000000"}}},
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "EMPTY RESPONSE when TENANT parameter that
DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{QueryParameters: url.Values{"tenant": {"1000000"}}},
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
utils.ResponseHasLength(0)),
+ },
+ "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),
validateOriginsPagination("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),
validateOriginsPagination("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),
validateOriginsPagination("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)),
+ },
+ },
+ "POST": {
+ "BAD REQUEST when ALREADY EXISTS": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin1",
+ "cachegroup":
"originCachegroup",
+ "Coordinate":
"coordinate1",
+ "deliveryService": "ds1",
+ "fqdn":
"origin1.example.com",
+ "ipAddress": "1.2.3.4",
+ "ip6Address":
"dead:beef:cafe::42",
+ "port": 1234,
+ "Profile":
"ATS_EDGE_TIER_CACHE",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ "isPrimary": true,
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "FORBIDDEN when CHILD TENANT CREATES ORIGIN
OUTSIDE TENANCY": {
+ ClientSession: tenant4UserSession,
+ RequestBody: map[string]interface{}{
+ "name":
"originTenancyTest",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origintenancy.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant3")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ "NOT FOUND when CACHEGROUP DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "testcg",
+ "cachegroupId": 10000000,
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.cachegroupId.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "NOT FOUND when PROFILEID DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testprofile",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.profileId.com",
+ "profileId": 1000000,
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "NOT FOUND when COORDINATE DOESNT EXIST": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testcoordinate",
+ "coordinateId": 10000000,
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.coordinate.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "FORBIDDEN when INVALID TENANT": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testtenant",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.tenant.com",
+ "protocol": "http",
+ "tenantId": 11111111,
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ "BAD REQUEST when INVALID PROTOCOL": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testprotocol",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.protocol.com",
+ "protocol":
"httttpppss",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID IPV4 ADDRESS": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "testip",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"test.ip.com",
+ "ipAddress":
"311.255.323.412",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID IPV6 ADDRESS": {
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "testipv6",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin1.example.com",
+ "ip6Address":
"badipv6::addresss",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ },
+ "PUT": {
+ "OK when VALID request": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"multiOriginCachegroup",
+ "Coordinate":
"coordinate2",
+ "deliveryService": "ds3",
+ "fqdn":
"originupdated.example.com",
+ "ipAddress": "1.2.3.4",
+ "ip6Address": "0000::1111",
+ "port": 1234,
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant2")(),
+ },
+ Expectations:
utils.CkRequest(utils.NoError(), utils.HasStatus(http.StatusOK),
+
validateOriginsUpdateCreateFields("origin2",
map[string]interface{}{"Cachegroup": "multiOriginCachegroup", "Coordinate":
"coordinate2", "DeliveryService": "ds3",
+ "FQDN":
"originupdated.example.com", "IPAddress": "1.2.3.4", "IP6Address":
"0000::1111", "Port": 1234, "Protocol": "http", "Tenant": "tenant2"})),
+ },
+ "FORBIDDEN when CHILD TENANT updates PARENT
TENANT ORIGIN": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: tenant4UserSession,
+ RequestBody: map[string]interface{}{
+ "name":
"testtenancy",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"testtenancy.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ "NOT FOUND when ORIGIN DOESNT EXIST": {
+ EndpointId: func() int { return
1111111 },
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "testid",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"testid.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "BAD REQUEST when DELIVERY SERVICE DOESNT
EXIST": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "deliveryServiceId": 11111111,
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "NOT FOUND when CACHEGROUP DOESNT EXIST": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroupId": 1111111,
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "NOT FOUND when PROFILEID DOESNT EXIST": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin2.example.com",
+ "profileId": 11111111,
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "NOT FOUND when COORDINATE DOESNT EXIST": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "coordinateId": 1111111,
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "FORBIDDEN when INVALID TENANT": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin1",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin1.example.com",
+ "protocol": "http",
+ "tenantId": 1111111,
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ "BAD REQUEST when INVALID PROTOCOL": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds1")(),
+ "fqdn":
"origin2.example.com",
+ "protocol":
"htttttpssss",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID IPV4 ADDRESS": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds2")(),
+ "fqdn":
"origin2.example.com",
+ "ipAddress":
"300.254.123.1",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID IPV6 ADDRESS": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds2")(),
+ "fqdn":
"origin2.example.com",
+ "ip6Address": "test::42",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "BAD REQUEST when INVALID PORT": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryServiceId":
GetDeliveryServiceId(t, "ds2")(),
+ "fqdn":
"origin2.example.com",
+ "port": 80000,
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusBadRequest)),
+ },
+ "PRECONDITION FAILED when updating with IMS &
IUS Headers": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestOpts:
client.RequestOptions{Header: http.Header{rfc.IfUnmodifiedSince:
{currentTimeRFC}}},
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryService": "ds2",
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ Expectations:
utils.CkRequest(utils.HasError(),
utils.HasStatus(http.StatusPreconditionFailed)),
+ },
+ "PRECONDITION FAILED when updating with IFMATCH
ETAG Header": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: TOSession,
+ RequestBody: map[string]interface{}{
+ "name": "origin2",
+ "cachegroup":
"originCachegroup",
+ "deliveryService": "ds2",
+ "fqdn":
"origin2.example.com",
+ "protocol": "http",
+ "tenantId":
GetTenantID(t, "tenant1")(),
+ },
+ RequestOpts:
client.RequestOptions{Header: http.Header{rfc.IfMatch:
{rfc.ETag(currentTime)}}},
+ Expectations:
utils.CkRequest(utils.HasError(),
utils.HasStatus(http.StatusPreconditionFailed)),
+ },
+ },
+ "DELETE": {
+ "NOT FOUND when DOESNT EXIST": {
+ EndpointId: func() int { return
11111111 },
+ ClientSession: TOSession,
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusNotFound)),
+ },
+ "FORBIDDEN when CHILD TENANT deletes PARENT
TENANT ORIGIN": {
+ EndpointId: GetOriginID(t,
"origin2"),
+ ClientSession: tenant4UserSession,
+ Expectations:
utils.CkRequest(utils.HasError(), utils.HasStatus(http.StatusForbidden)),
+ },
+ },
+ }
- // update port and FQDN values on origin
- remoteOrigin.Port = &updatedPort
- remoteOrigin.FQDN = &updatedFQDN
- opts.QueryParameters.Del("name")
- opts.Header = header
- _, reqInf, err := TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, opts)
- if err == nil {
- t.Errorf("Expected error about precondition failed, but got
none")
- }
- if reqInf.StatusCode != http.StatusPreconditionFailed {
- t.Errorf("Expected status code 412, got %v", reqInf.StatusCode)
- }
+ for method, testCases := range methodTests {
+ t.Run(method, func(t *testing.T) {
+ for name, testCase := range testCases {
+ origin := tc.Origin{}
+
+ 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,
&origin)
+ 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.GetOrigins(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.CreateOrigin(origin, 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.UpdateOrigin(testCase.EndpointId(), origin,
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.DeleteOrigin(testCase.EndpointId(), testCase.RequestOpts)
+ for _, check := range
testCase.Expectations {
+ check(t,
reqInf, nil, alerts, err)
+ }
+ })
+ }
+ }
+ })
+ }
+ })
}
-func CreateTestOrigins(t *testing.T) {
- // loop through origins, assign FKs and create
- for _, origin := range testData.Origins {
- resp, _, err := TOSession.CreateOrigin(origin,
client.RequestOptions{})
- if err != nil {
- t.Errorf("could not create Origins: %v - alerts: %+v",
err, resp.Alerts)
+func validateOriginsFields(expectedResp map[string]interface{})
utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ assert.RequireNotNil(t, resp, "Expected Origin response to not
be nil.")
+ originResp := resp.([]tc.Origin)
+ for field, expected := range expectedResp {
+ for _, origin := range originResp {
+ switch field {
+ case "Cachegroup":
+ assert.RequireNotNil(t,
origin.Cachegroup, "Expected Cachegroup to not be nil.")
+ assert.Equal(t, expected,
*origin.Cachegroup, "Expected Cachegroup to be %v, but got %s", expected,
*origin.Cachegroup)
+ case "CachegroupID":
+ assert.RequireNotNil(t,
origin.CachegroupID, "Expected CachegroupID to not be nil.")
+ assert.Equal(t, expected,
*origin.CachegroupID, "Expected CachegroupID to be %v, but got %d", expected,
*origin.Cachegroup)
+ case "Coordinate":
+ assert.RequireNotNil(t,
origin.Coordinate, "Expected Coordinate to not be nil.")
+ assert.Equal(t, expected,
*origin.Coordinate, "Expected Coordinate to be %v, but got %s", expected,
*origin.Coordinate)
+ case "CoordinateID":
+ assert.RequireNotNil(t,
origin.CoordinateID, "Expected CoordinateID to not be nil.")
+ assert.Equal(t, expected,
*origin.CoordinateID, "Expected CoordinateID to be %v, but got %d", expected,
*origin.CoordinateID)
+ case "DeliveryService":
+ assert.RequireNotNil(t,
origin.DeliveryService, "Expected DeliveryService to not be nil.")
+ assert.Equal(t, expected,
*origin.DeliveryService, "Expected DeliveryService to be %v, but got %s",
expected, *origin.DeliveryService)
+ case "DeliveryServiceID":
+ assert.RequireNotNil(t,
origin.DeliveryServiceID, "Expected DeliveryServiceID to not be nil.")
+ assert.Equal(t, expected,
*origin.DeliveryServiceID, "Expected DeliveryServiceID to be %v, but got %d",
expected, *origin.DeliveryServiceID)
+ case "FQDN":
+ assert.RequireNotNil(t, origin.FQDN,
"Expected FQDN to not be nil.")
+ assert.Equal(t, expected, *origin.FQDN,
"Expected FQDN to be %v, but got %s", expected, *origin.FQDN)
+ case "ID":
+ assert.RequireNotNil(t, origin.ID,
"Expected ID to not be nil.")
+ assert.Equal(t, expected, *origin.ID,
"Expected ID to be %v, but got %d", expected, *origin.ID)
+ case "IPAddress":
+ assert.RequireNotNil(t,
origin.IPAddress, "Expected IPAddress to not be nil.")
+ assert.Equal(t, expected,
*origin.IPAddress, "Expected IPAddress to be %v, but got %s", expected,
*origin.IPAddress)
+ case "IP6Address":
+ assert.RequireNotNil(t,
origin.IP6Address, "Expected IP6Address to not be nil.")
+ assert.Equal(t, expected,
*origin.IP6Address, "Expected IP6Address to be %v, but got %s", expected,
*origin.IP6Address)
+ case "IsPrimary":
+ assert.RequireNotNil(t,
origin.IsPrimary, "Expected IsPrimary to not be nil.")
+ assert.Equal(t, expected,
*origin.IsPrimary, "Expected IsPrimary to be %v, but got %v", expected,
*origin.IsPrimary)
+ case "Name":
+ assert.RequireNotNil(t, origin.Name,
"Expected Name to not be nil.")
+ assert.Equal(t, expected, *origin.Name,
"Expected Name to be %v, but got %s", expected, *origin.Name)
+ case "Port":
+ assert.RequireNotNil(t, origin.Port,
"Expected Port to not be nil.")
+ assert.Equal(t, expected, *origin.Port,
"Expected Port to be %v, but got %d", expected, *origin.Port)
+ case "Profile":
+ assert.RequireNotNil(t, origin.Profile,
"Expected Profile to not be nil.")
+ assert.Equal(t, expected,
*origin.Profile, "Expected Profile to be %v, but got %s", expected,
*origin.Profile)
+ case "ProfileID":
+ assert.RequireNotNil(t,
origin.ProfileID, "Expected ProfileID to not be nil.")
+ assert.Equal(t, expected,
*origin.ProfileID, "Expected ProfileID to be %v, but got %d", expected,
*origin.ProfileID)
+ case "Protocol":
+ assert.RequireNotNil(t,
origin.Protocol, "Expected Protocol to not be nil.")
+ assert.Equal(t, expected,
*origin.Protocol, "Expected Tenant to be %v, but got %s", expected,
*origin.Protocol)
+ case "Tenant":
+ assert.RequireNotNil(t, origin.Tenant,
"Expected Tenant to not be nil.")
+ assert.Equal(t, expected,
*origin.Tenant, "Expected Tenant to be %v, but got %s", expected,
*origin.Tenant)
+ case "TenantID":
+ assert.RequireNotNil(t,
origin.TenantID, "Expected TenantID to not be nil.")
+ assert.Equal(t, expected,
*origin.TenantID, "Expected TenantID to be %v, but got %d", expected,
*origin.TenantID)
+ default:
+ t.Errorf("Expected field: %v, does not
exist in response", field)
+ }
+ }
}
}
}
-func CreateTestOriginDuplicateData(t *testing.T) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test duplicate scenario")
- }
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatalf("couldn't get the name of test origin server")
- }
- resp, reqInf, err := TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected, origin name %s already exists, but no error
found - Alerts %v", *firstOrigin.Name, resp.Alerts)
+func validateOriginsUpdateCreateFields(name string, expectedResp
map[string]interface{}) utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ opts := client.NewRequestOptions()
+ opts.QueryParameters.Set("name", name)
+ origin, _, err := TOSession.GetOrigins(opts)
+ assert.RequireNoError(t, err, "Error getting Origin: %v -
alerts: %+v", err, origin.Alerts)
+ assert.RequireEqual(t, 1, len(origin.Response), "Expected one
Origin returned Got: %d", len(origin.Response))
+ validateOriginsFields(expectedResp)(t, toclientlib.ReqInf{},
origin.Response, tc.Alerts{}, nil)
}
}
-func NotFoundDeleteTest(t *testing.T) {
- resp, _, err := TOSession.DeleteOrigin(2020, client.RequestOptions{})
- if err == nil {
- t.Fatal("deleting origin with what should be a non-existent id
- expected: error, actual: nil error")
- }
-
- found := false
- for _, alert := range resp.Alerts {
- if alert.Level == tc.ErrorLevel.String() &&
strings.Contains(alert.Text, "not found") {
- found = true
- break
+func validateOriginsPagination(paginationParam string) utils.CkReqFunc {
+ return func(t *testing.T, _ toclientlib.ReqInf, resp interface{}, _
tc.Alerts, _ error) {
+ paginationResp := resp.([]tc.Origin)
+
+ opts := client.NewRequestOptions()
+ opts.QueryParameters.Set("orderby", "id")
+ respBase, _, err := TOSession.GetOrigins(opts)
+ assert.RequireNoError(t, err, "Cannot get Origins: %v - alerts:
%+v", err, respBase.Alerts)
+
+ origin := respBase.Response
+ assert.RequireGreaterOrEqual(t, len(origin), 3, "Need at least
3 Origins in Traffic Ops to test pagination support, found: %d", len(origin))
+ switch paginationParam {
+ case "limit:":
+ assert.Exactly(t, origin[:1], paginationResp, "expected
GET Origins with limit = 1 to return first result")
+ case "offset":
+ assert.Exactly(t, origin[1:2], paginationResp,
"expected GET Origins with limit = 1, offset = 1 to return second result")
+ case "page":
+ assert.Exactly(t, origin[1:2], paginationResp,
"expected GET Origins with limit = 1, page = 2 to return second result")
}
}
- if !found {
- t.Errorf("deleted origin with what should be a non-existent id
- expected: 'not found' error-level alert, actual: %v - alerts: %+v", err,
resp.Alerts)
- }
}
-func GetTestOrigins(t *testing.T) {
- resp, _, err := TOSession.GetOrigins(client.RequestOptions{})
- if err != nil {
- t.Errorf("cannot get Origins: %v - alerts: %+v", err,
resp.Alerts)
- }
-
- opts := client.NewRequestOptions()
- for _, origin := range testData.Origins {
- opts.QueryParameters.Set("name", *origin.Name)
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by name: %v - alerts: %+v",
err, resp.Alerts)
- }
+func GetOriginID(t *testing.T, name string) func() int {
+ return func() int {
+ opts := client.NewRequestOptions()
+ opts.QueryParameters.Set("name", name)
+ origins, _, err := TOSession.GetOrigins(opts)
+ assert.RequireNoError(t, err, "Get Origins Request failed with
error:", err)
+ assert.RequireEqual(t, 1, len(origins.Response), "Expected
response object length 1, but got %d", len(origins.Response))
+ assert.RequireNotNil(t, origins.Response[0].ID, "Expected ID to
not be nil.")
+ return *origins.Response[0].ID
}
}
-func UpdateTestOrigins(t *testing.T) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test updating Origins")
- }
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatal("Found an Origin in the testing data with null or
undefined name")
- }
- foName := *firstOrigin.Name
-
- // Retrieve the origin by name so we can get the id for the Update
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("name", foName)
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin '%s': %v - alerts: %+v", foName,
err, resp.Alerts)
- }
- if len(resp.Response) != 1 {
- t.Fatalf("Expected exactly one Origin to exist with name '%s',
found: %d", foName, len(resp.Response))
- }
-
- remoteOrigin := resp.Response[0]
- if remoteOrigin.ID == nil {
- t.Fatalf("Traffic Ops responded with a representation of Origin
'%s' that had null or undefined ID", foName)
- }
- updatedPort := 4321
- updatedFQDN := "updated.example.com"
- updatedIpAddress := "5.6.7.8"
- updatedIpv6Address := "dead:beef:cafe::455"
- updatedIsPrimary := false
- updatedProfile := "EDGEInCDN2"
- updateDeliveryService := "ds3"
- updateCachegroup := "multiOriginCachegroup"
- updateCoordinate := "coordinate2"
- updateProtocol := "https"
- updateTenant := "tenant2"
-
- // update Cachegroup/Coordinate/Name/Delivery
Service/Port/FQDN/IPAddress/IPV6Address/Profile/IsPrimary/Protocol/Tenant
values on origin
- originRequest := tc.Origin{
- Cachegroup: &updateCachegroup,
- Coordinate: &updateCoordinate,
- Name: remoteOrigin.Name,
- DeliveryService: &updateDeliveryService,
- FQDN: &updatedFQDN,
- IP6Address: &updatedIpv6Address,
- IPAddress: &updatedIpAddress,
- IsPrimary: &updatedIsPrimary,
- Port: &updatedPort,
- Profile: &updatedProfile,
- Protocol: &updateProtocol,
- Tenant: &updateTenant,
- }
-
- updResp, reqInf, err := TOSession.UpdateOrigin(*remoteOrigin.ID,
originRequest, client.RequestOptions{})
- if err != nil {
- t.Errorf("cannot update Origin '%s' (#%d): %v - %v", foName,
*remoteOrigin.ID, err, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusOK {
- t.Errorf("Expected 200 Status Code, but found %d",
reqInf.StatusCode)
- }
- // Retrieve the origin to check cachegroup, coordinate,
deliveryservice, port, FQDN, IPAddress, IPV6Address, Profile, IsPrimary,
Protocol, Tenant values were updated
- opts.QueryParameters.Del("name")
- opts.QueryParameters.Set("id", strconv.Itoa(*remoteOrigin.ID))
- resp, _, err = TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin #%d ('%s'): %v - alerts: %+v",
*remoteOrigin.ID, foName, err, resp.Alerts)
- }
- if len(resp.Response) != 1 {
- t.Fatalf("Expected exactly one Origin to exist with ID %d,
found: %d", *remoteOrigin.ID, len(resp.Response))
- }
- respOrigin := resp.Response[0]
-
- if respOrigin.Cachegroup == nil {
- t.Errorf("results do not match, actual: null or undefined -
expected: %s", updateCachegroup)
- } else if *respOrigin.Cachegroup != updateCachegroup {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.Cachegroup, updateCachegroup)
- }
-
- if respOrigin.Coordinate == nil {
- t.Errorf("results do not match, actual: null or undefined -
expected: %s", updateCoordinate)
- } else if *respOrigin.Coordinate != updateCoordinate {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.Coordinate, updateCoordinate)
- }
-
- if respOrigin.DeliveryService == nil {
- t.Errorf("results do not match, actual: null or undefined -
expected: %s", updateDeliveryService)
- } else if *respOrigin.DeliveryService != updateDeliveryService {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.DeliveryService, updateDeliveryService)
- }
-
- if respOrigin.Port == nil {
- t.Errorf("results do not match, actual: null or undefined -
expected: %d", updatedPort)
- } else if *respOrigin.Port != updatedPort {
- t.Errorf("results do not match actual: %d, expected: %d",
*respOrigin.Port, updatedPort)
- }
- if respOrigin.FQDN == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updatedFQDN)
- } else if *respOrigin.FQDN != updatedFQDN {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.FQDN, updatedFQDN)
- }
- if respOrigin.IPAddress == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updatedIpAddress)
- } else if *respOrigin.IPAddress != updatedIpAddress {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.IPAddress, updatedIpAddress)
- }
-
- if respOrigin.IP6Address == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updatedIpv6Address)
- } else if *respOrigin.IP6Address != updatedIpv6Address {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.IP6Address, updatedIpv6Address)
- }
-
- if respOrigin.IsPrimary == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%t'", updatedIsPrimary)
- } else if *respOrigin.IsPrimary != updatedIsPrimary {
- t.Errorf("results do not match actual: %t, expected: %t",
*respOrigin.IsPrimary, updatedIsPrimary)
- }
-
- if respOrigin.Profile == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updatedProfile)
- } else if *respOrigin.Profile != updatedProfile {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.Profile, updatedProfile)
- }
-
- if respOrigin.Protocol == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updateProtocol)
- } else if *respOrigin.Protocol != updateProtocol {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.Protocol, updateProtocol)
- }
-
- if respOrigin.Tenant == nil {
- t.Errorf("results do not match, actual: null or undefined,
expected: '%s'", updateTenant)
- } else if *respOrigin.Tenant != updateTenant {
- t.Errorf("results do not match actual: %s, expected: %s",
*respOrigin.Tenant, updateTenant)
+func CreateTestOrigins(t *testing.T) {
+ for _, origin := range testData.Origins {
+ resp, _, err := TOSession.CreateOrigin(origin,
client.RequestOptions{})
+ assert.RequireNoError(t, err, "Could not create Origins: %v -
alerts: %+v", err, resp.Alerts)
}
}
-func OriginTenancyTest(t *testing.T) {
+func DeleteTestOrigins(t *testing.T) {
origins, _, err := TOSession.GetOrigins(client.RequestOptions{})
- if err != nil {
- t.Errorf("cannot get Origins: %v - alerts: %+v", err,
origins.Alerts)
- }
- if len(origins.Response) < 1 {
- t.Fatal("Need at least one Origin to exist in Traffic Ops to
test Tenancy for Origins")
- }
- // This ID check specifically needs to be a fatal condition, despite
also being an error below,
- // because we explicitly dereference the ID of the 0th Origin in this
slice later on.
- if origins.Response[0].ID == nil || origins.Response[0].Name == nil {
- t.Fatal("Traffic Ops returned a representation for an Origin
with null or undefined ID and/or Name")
- }
-
- var tenant3Origin tc.Origin
- foundTenant3Origin := false
- for _, o := range origins.Response {
- if o.FQDN == nil || o.ID == nil {
- t.Error("Traffic Ops responded with a representation of
an Origin with null or undefined FQDN and/or ID")
- continue
- }
- if *o.FQDN == "origin.ds3.example.net" {
- tenant3Origin = o
- foundTenant3Origin = true
- }
- }
- if !foundTenant3Origin {
- t.Error("expected to find origin with tenant 'tenant3' and fqdn
'origin.ds3.example.net'")
- }
-
- toReqTimeout := time.Second *
time.Duration(Config.Default.Session.TimeoutInSecs)
- tenant4TOClient, _, err := client.LoginWithAgent(TOSession.URL,
"tenant4user", "pa$$word", true, "to-api-v3-client-tests/tenant4user", true,
toReqTimeout)
- if err != nil {
- t.Fatalf("failed to log in with tenant4user: %v", err)
- }
-
- originsReadableByTenant4, _, err :=
tenant4TOClient.GetOrigins(client.RequestOptions{})
- if err != nil {
- t.Errorf("tenant4user cannot get Origins: %v - alerts: %+v",
err, originsReadableByTenant4.Alerts)
- }
-
- // assert that tenant4user cannot read origins outside of its tenant
- for _, origin := range originsReadableByTenant4.Response {
- if origin.FQDN == nil {
- t.Error("Traffic Ops returned a representation of an
Origin with null or undefined FQDN")
- } else if *origin.FQDN == "origin.ds3.example.net" {
- t.Error("expected tenant4 to be unable to read origins
from tenant 3")
+ assert.NoError(t, err, "Cannot get Origins : %v - alerts: %+v", err,
origins.Alerts)
+
+ for _, origin := range origins.Response {
+ assert.RequireNotNil(t, origin.ID, "Expected origin ID to not
be nil.")
+ assert.RequireNotNil(t, origin.Name, "Expected origin ID to not
be nil.")
+ assert.RequireNotNil(t, origin.IsPrimary, "Expected origin ID
to not be nil.")
+ if !*origin.IsPrimary {
+ alerts, _, err := TOSession.DeleteOrigin(*origin.ID,
client.RequestOptions{})
+ assert.NoError(t, err, "Unexpected error deleting
Origin '%s' (#%d): %v - alerts: %+v", *origin.Name, *origin.ID, err,
alerts.Alerts)
+ // Retrieve the Origin to see if it got deleted
+ opts := client.NewRequestOptions()
+ opts.QueryParameters.Set("id", strconv.Itoa(*origin.ID))
+ getOrigin, _, err := TOSession.GetOrigins(opts)
+ assert.NoError(t, err, "Error getting Origin '%s' after
deletion: %v - alerts: %+v", *origin.Name, err, getOrigin.Alerts)
+ assert.Equal(t, 0, len(getOrigin.Response), "Expected
Origin '%s' to be deleted, but it was found in Traffic Ops", *origin.Name)
}
}
-
- // assert that tenant4user cannot update tenant3user's origin
- if _, _, err = tenant4TOClient.UpdateOrigin(*tenant3Origin.ID,
tenant3Origin, client.RequestOptions{}); err == nil {
- t.Error("expected tenant4user to be unable to update tenant3's
origin")
- }
-
- // assert that tenant4user cannot delete an origin outside of its tenant
- if _, _, err = tenant4TOClient.DeleteOrigin(*origins.Response[0].ID,
client.RequestOptions{}); err == nil {
- t.Errorf("expected tenant4user to be unable to delete an origin
outside of its tenant (origin %s)", *origins.Response[0].Name)
- }
-
- // assert that tenant4user cannot create origins outside of its tenant
- tenant3Origin.FQDN = util.StrPtr("origin.tenancy.test.example.com")
- if _, _, err = tenant4TOClient.CreateOrigin(tenant3Origin,
client.RequestOptions{}); err == nil {
- t.Error("expected tenant4user to be unable to create an origin
outside of its tenant")
- }
}
func alertsHaveError(alerts []tc.Alert, err string) bool {
@@ -368,532 +679,3 @@ func alertsHaveError(alerts []tc.Alert, err string) bool {
}
return false
}
-
-func GetTestPaginationSupportOrigins(t *testing.T) {
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("orderby", "id")
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Fatalf("cannot get Origins: %v - alerts: %+v", err,
resp.Alerts)
- }
- origins := resp.Response
- if len(origins) < 3 {
- t.Fatalf("Need at least 3 Origins in Traffic Ops to test
pagination, found: %d", len(resp.Response))
- }
-
- opts.QueryParameters.Set("limit", "1")
- originsWithLimit, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Fatalf("cannot get Origins with limit: %v - alerts: %+v",
err, originsWithLimit.Alerts)
- }
- if !reflect.DeepEqual(origins[:1], originsWithLimit.Response) {
- t.Error("expected GET origins with limit = 1 to return first
result")
- }
-
- opts.QueryParameters.Set("offset", "1")
- originsWithOffset, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Fatalf("cannot get Origins with offset: %v - alerts: %+v",
err, originsWithOffset.Alerts)
- }
- if !reflect.DeepEqual(origins[1:2], originsWithOffset.Response) {
- t.Error("expected GET origins with limit = 1, offset = 1 to
return second result")
- }
-
- opts.QueryParameters.Del("offset")
- opts.QueryParameters.Set("page", "2")
- originsWithPage, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Fatalf("cannot get Origins with page: %v - alerts: %+v", err,
originsWithPage.Alerts)
- }
- if !reflect.DeepEqual(origins[1:2], originsWithPage.Response) {
- t.Error("expected GET origins with limit = 1, page = 2 to
return second result")
- }
-
- opts.QueryParameters.Del("page")
- opts.QueryParameters.Del("orderby")
- opts.QueryParameters.Set("limit", "-2")
- resp, _, err = TOSession.GetOrigins(opts)
- if err == nil {
- t.Error("expected GET origins to return an error when limit is
not bigger than -1")
- } else if !alertsHaveError(resp.Alerts.Alerts, "must be bigger than
-1") {
- t.Errorf("expected GET origins to return an error for limit is
not bigger than -1, actual error: " + err.Error())
- }
-
- opts.QueryParameters.Set("limit", "1")
- opts.QueryParameters.Set("offset", "0")
- resp, _, err = TOSession.GetOrigins(opts)
- if err == nil {
- t.Error("expected GET origins to return an error when offset is
not a positive integer")
- } else if !alertsHaveError(resp.Alerts.Alerts, "must be a positive
integer") {
- t.Errorf("expected GET origins to return an error for offset is
not a positive integer, actual error: " + err.Error())
- }
-
- opts.QueryParameters.Del("offset")
- opts.QueryParameters.Set("page", "0")
- resp, _, err = TOSession.GetOrigins(opts)
- if err == nil {
- t.Error("expected GET origins to return an error when page is
not a positive integer")
- } else if !alertsHaveError(resp.Alerts.Alerts, "must be a positive
integer") {
- t.Errorf("expected GET origins to return an error for page is
not a positive integer, actual error: " + err.Error())
- }
-}
-
-func DeleteTestOrigins(t *testing.T) {
- opts := client.NewRequestOptions()
- for _, origin := range testData.Origins {
- if origin.Name == nil {
- t.Error("Found an Origin in the testing data with null
or undefined name")
- continue
- }
-
- opts.QueryParameters.Set("name", *origin.Name)
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin '%s': %v - alerts: %+v",
*origin.Name, err, resp.Alerts)
- }
- if len(resp.Response) > 0 {
- respOrigin := resp.Response[0]
- if respOrigin.ID == nil {
- t.Error("Traffic Ops returned a representation
for an Origin that has null or undefined ID")
- continue
- }
- delResp, _, err :=
TOSession.DeleteOrigin(*respOrigin.ID, client.RequestOptions{})
- if err != nil {
- t.Errorf("cannot DELETE Origin by ID: %v - %v",
err, delResp)
- }
-
- // Retrieve the Origin to see if it got deleted
- org, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("error fetching Origin '%s' after
deletion: %v - alerts: %+v", *origin.Name, err, org.Alerts)
- }
- if len(org.Response) > 0 {
- t.Errorf("expected Origin '%s' to be deleted,
but it was found in Traffic Ops", *origin.Name)
- }
- }
- }
-}
-
-func GetTestOriginsByParams(t *testing.T) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test Get Origins by
params")
- }
- origins := testData.Origins[0]
- if origins.Name == nil || len(*origins.Name) == 0 {
- t.Fatal("Found nil value in Origin name")
- }
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("name", *origins.Name)
- originByName, _, _ := TOSession.GetOrigins(opts)
- if len(originByName.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Delivery Service, but found %d", len(originByName.Response))
- }
- if originByName.Response[0].DeliveryServiceID == nil {
- t.Fatal("Found nil value in delivery service")
- }
- if originByName.Response[0].CachegroupID == nil {
- t.Fatal("Found nil value in Cachegroup")
- }
- if originByName.Response[0].CoordinateID == nil {
- t.Fatal("Found nil value in Coordinate")
- }
- if originByName.Response[0].ProfileID == nil {
- t.Fatal("Found nil value in Profile")
- }
- if originByName.Response[0].IsPrimary == nil {
- t.Fatal("Found nil value in IsPrimary field")
- }
-
- //Get Origins by DSID
- dsId := *originByName.Response[0].DeliveryServiceID
- opts.QueryParameters.Del("name")
- opts.QueryParameters.Set("deliveryservice", strconv.Itoa(dsId))
- originByDs, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by DeliveryService ID: %v - alerts:
%+v", err, originByDs.Alerts)
- }
- if len(originByDs.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Delivery Service, but found %d", len(originByDs.Response))
- }
-
- //Get Origins by Cachegroup
- cachegroupID := *originByName.Response[0].CachegroupID
- opts.QueryParameters.Del("deliveryservice")
- opts.QueryParameters.Set("cachegroup", strconv.Itoa(cachegroupID))
- originByCg, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by Cachegroup ID: %v - alerts:
%+v", err, originByCg.Alerts)
- }
- if len(originByCg.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Cachegroups, but found %d", len(originByCg.Response))
- }
-
- //Get Origins by Coordinate
- CoordinateID := *originByName.Response[0].CoordinateID
- opts.QueryParameters.Del("cachegroup")
- opts.QueryParameters.Set("coordinate", strconv.Itoa(CoordinateID))
- originByCoordinate, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by Coordinate ID: %v - alerts:
%+v", err, originByCoordinate.Alerts)
- }
- if len(originByCoordinate.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Coordinate, but found %d", len(originByCoordinate.Response))
- }
-
- //Get Origins by Profile
- profileId := *originByName.Response[0].ProfileID
- opts.QueryParameters.Del("coordinate")
- opts.QueryParameters.Set("profileId", strconv.Itoa(profileId))
- originByProfile, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by Profile ID: %v - alerts: %+v",
err, originByProfile.Alerts)
- }
- if len(originByProfile.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Profile, but found %d", len(originByProfile.Response))
- }
-
- //Get Origins by Primary
- isPrimary := *originByName.Response[0].IsPrimary
- opts.QueryParameters.Del("profileId")
- opts.QueryParameters.Set("isPrimary", strconv.FormatBool(isPrimary))
- originByPrimary, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by Primary ID: %v - alerts: %+v",
err, originByPrimary.Alerts)
- }
- if len(originByPrimary.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by
Primary, but found %d", len(originByPrimary.Response))
- }
-
- //Get Origins by Tenant
- tenant := *originByName.Response[0].TenantID
- opts.QueryParameters.Del("isPrimary")
- opts.QueryParameters.Set("tenant", strconv.Itoa(tenant))
- originByTenant, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin by Tenant ID: %v - alerts: %+v",
err, originByTenant.Alerts)
- }
- if len(originByTenant.Response) < 1 {
- t.Fatalf("Expected atleast one Origin for GET Origin by Tenant,
but found %d", len(originByTenant.Response))
- }
-}
-
-func GetTestOriginsByInvalidParams(t *testing.T) {
-
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("deliveryservice", "12345")
- originByDs, _, _ := TOSession.GetOrigins(opts)
- if len(originByDs.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Delivery Service, but found %d", len(originByDs.Response))
- }
-
- //Get Origins by Cachegroup
- opts.QueryParameters.Del("deliveryservice")
- opts.QueryParameters.Set("cachegroup", "12345")
- originByCg, _, _ := TOSession.GetOrigins(opts)
- if len(originByCg.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Cachegroups, but found %d", len(originByCg.Response))
- }
-
- //Get Origins by Coordinate
- opts.QueryParameters.Del("cachegroup")
- opts.QueryParameters.Set("coordinate", "12345")
- originByCoordinate, _, _ := TOSession.GetOrigins(opts)
- if len(originByCoordinate.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Coordinate, but found %d", len(originByCoordinate.Response))
- }
-
- //Get Origins by Profile
- opts.QueryParameters.Del("coordinate")
- opts.QueryParameters.Set("profileId", "12345")
- originByProfile, _, _ := TOSession.GetOrigins(opts)
- if len(originByProfile.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Profile, but found %d", len(originByProfile.Response))
- }
-
- //Get Origins by Tenant
- opts.QueryParameters.Del("profileId")
- opts.QueryParameters.Set("tenant", "12345")
- originByTenant, _, _ := TOSession.GetOrigins(opts)
- if len(originByTenant.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Tenant, but found %d", len(originByTenant.Response))
- }
-
- //Get Origins by Name
- opts.QueryParameters.Del("tenant")
- opts.QueryParameters.Set("name", "abcdef")
- originByName, _, _ := TOSession.GetOrigins(opts)
- if len(originByName.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
name, but found %d", len(originByName.Response))
- }
-
- //Get Origins by Primary
- opts.QueryParameters.Del("name")
- opts.QueryParameters.Set("primary", "12345")
- originByPrimary, _, _ := TOSession.GetOrigins(opts)
- if len(originByPrimary.Response) > 0 {
- t.Fatalf("Expected empty response for GET Origin by invalid
Primary, but found %d", len(originByPrimary.Response))
- }
-}
-
-func CreateTestOriginInvalidData(t *testing.T) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test duplicate Origins")
- }
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatalf("couldn't get the name of test origin server")
- }
- oldCachegroupId := firstOrigin.CachegroupID
- oldProfileId := firstOrigin.ProfileID
- oldTenantId := firstOrigin.TenantID
- oldProtocol := firstOrigin.Protocol
- oldCoordinateId := firstOrigin.CoordinateID
- oldIpv4 := firstOrigin.IPAddress
-
- //invalid cg id
- cachegroupID := new(int)
- *cachegroupID = 12345
- name := new(string)
- *name = "invalid"
- firstOrigin.CachegroupID = cachegroupID
- firstOrigin.Name = name
- resp, reqInf, err := TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected cachegroup not found - Alerts %v",
resp.Alerts)
- }
-
- //invalid profile id
- firstOrigin.CachegroupID = oldCachegroupId
- profileId := new(int)
- *profileId = 12345
- firstOrigin.ProfileID = profileId
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected profile not found - Alerts %v", resp.Alerts)
- }
-
- //invalid tenant id
- firstOrigin.ProfileID = oldProfileId
- tenantId := new(int)
- *tenantId = 12345
- firstOrigin.TenantID = tenantId
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusForbidden {
- t.Errorf("Expected 403 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected user not authorized for requested tenant -
Alerts %v", resp.Alerts)
- }
-
- //invalid protocol id
- firstOrigin.TenantID = oldTenantId
- protocol := new(string)
- *protocol = "abcd"
- firstOrigin.Protocol = protocol
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected 'protocol' must be http or https - Alerts
%v", resp.Alerts)
- }
-
- //invalid coordinate id
- firstOrigin.Protocol = oldProtocol
- coordinateId := new(int)
- *coordinateId = 12345
- firstOrigin.CoordinateID = coordinateId
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected coordinate not found - Alerts %v",
resp.Alerts)
- }
-
- //invalid IPV4
- firstOrigin.CoordinateID = oldCoordinateId
- ipv4 := new(string)
- *ipv4 = "1.11"
- firstOrigin.IPAddress = ipv4
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected 'ipAddress' must be a valid IPv4 address -
Alerts %v", resp.Alerts)
- }
-
- //invalid IPV6
- firstOrigin.IPAddress = oldIpv4
- ipv6 := new(string)
- *ipv6 = "1:1:1:1:1"
- firstOrigin.IP6Address = ipv6
- resp, reqInf, err = TOSession.CreateOrigin(firstOrigin,
client.RequestOptions{})
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status code, but found %d",
reqInf.StatusCode)
- }
- if err == nil {
- t.Errorf("Expected 'ip6Address' must be a valid IPv6 address -
Alerts %v", resp.Alerts)
- }
-}
-
-func updateTestOriginsWithInvalidData(t *testing.T) {
- if len(testData.Origins) < 1 {
- t.Fatal("Need at least one Origin to test updating Origins")
- }
- firstOrigin := testData.Origins[0]
- if firstOrigin.Name == nil {
- t.Fatal("Found an Origin in the testing data with null or
undefined name")
- }
- foName := *firstOrigin.Name
- // Retrieve the origin by name so we can get the id for the Update
- opts := client.NewRequestOptions()
- opts.QueryParameters.Set("name", foName)
- resp, _, err := TOSession.GetOrigins(opts)
- if err != nil {
- t.Errorf("cannot get Origin '%s': %v - alerts: %+v", foName,
err, resp.Alerts)
- }
- if len(resp.Response) != 1 {
- t.Fatalf("Expected exactly one Origin to exist with name '%s',
found: %d", foName, len(resp.Response))
- }
- remoteOrigin := resp.Response[0]
- if remoteOrigin.ID == nil {
- t.Fatalf("Traffic Ops responded with a representation of Origin
'%s' that had null or undefined ID", foName)
- }
-
- oldCachegroupId := remoteOrigin.CachegroupID
- oldProfileId := remoteOrigin.ProfileID
- oldTenantId := remoteOrigin.TenantID
- oldProtocol := remoteOrigin.Protocol
- oldCoordinateId := remoteOrigin.CoordinateID
- oldIpv4 := remoteOrigin.IPAddress
- oldIpv6 := remoteOrigin.IP6Address
- oldPort := remoteOrigin.Port
- oldDeliveryServiceId := remoteOrigin.DeliveryServiceID
-
- //update invalid port
- updatedPort := 123456
- remoteOrigin.Port = &updatedPort
- updResp, reqInf, err := TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Port must be a valid integer between 1 and
65535. Port - %d, Alerts %v", updatedPort, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update cachegroup id
- remoteOrigin.Port = oldPort
- updatedCachegroupId := 123456
- remoteOrigin.CachegroupID = &updatedCachegroupId
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Cachegroup not found. Cachegroup - %d,
Alerts %v", updatedCachegroupId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update coordinate id
- remoteOrigin.CachegroupID = oldCachegroupId
- updatedCoordinateId := 123456
- remoteOrigin.CoordinateID = &updatedCoordinateId
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Coordinate not found, Coordinate - %d,
Alerts %v", updatedCoordinateId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid ds id
- remoteOrigin.CoordinateID = oldCoordinateId
- updatedDeliveryServiceId := 123456
- remoteOrigin.DeliveryServiceID = &updatedDeliveryServiceId
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - checking tenancy: requested delivery
service does not exist, Delivery Service - %d, Alerts %v",
updatedDeliveryServiceId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid protocol
- remoteOrigin.DeliveryServiceID = oldDeliveryServiceId
- updatedProtocol := "httpsss"
- remoteOrigin.Protocol = &updatedProtocol
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Protocol must be http or https. Protocol -
%s, Alerts %v", updatedProtocol, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid ipv6
- remoteOrigin.Protocol = oldProtocol
- updatedIpv6 := "1.1"
- remoteOrigin.IP6Address = &updatedIpv6
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Ip6Address must be a valid IPv6 address.
IPV6 Address - %s, Alerts %v", updatedIpv6, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid ipv4
- remoteOrigin.IP6Address = oldIpv6
- updatedIpv4 := "1.1"
- remoteOrigin.IPAddress = &updatedIpv4
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - IpAddress must be a valid IPv4 address.
IPV4 - %s, Alerts %v", updatedIpv4, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusBadRequest {
- t.Errorf("Expected 400 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid tenant
- remoteOrigin.IPAddress = oldIpv4
- updatedTenantId := 11111
- remoteOrigin.TenantID = &updatedTenantId
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - user not authorized for requested tenant.
Tenant - %d, Alerts %v", updatedTenantId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusForbidden {
- t.Errorf("Expected 403 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid profile
- remoteOrigin.TenantID = oldTenantId
- updatedProfileId := 12345
- remoteOrigin.ProfileID = &updatedProfileId
- updResp, reqInf, err = TOSession.UpdateOrigin(*remoteOrigin.ID,
remoteOrigin, client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - profile not found %d - Alerts %v",
updatedProfileId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status Code, but found %d",
reqInf.StatusCode)
- }
-
- //update invalid id
- remoteOrigin.ProfileID = oldProfileId
- invalidId := new(int)
- *invalidId = 12345
- updResp, reqInf, err = TOSession.UpdateOrigin(*invalidId, remoteOrigin,
client.RequestOptions{})
- if err == nil {
- t.Errorf("Expected - Origin not found. Origin ID - %d, Alerts
%v", *invalidId, updResp.Alerts)
- }
- if reqInf.StatusCode != http.StatusNotFound {
- t.Errorf("Expected 404 Status Code, but found %d",
reqInf.StatusCode)
- }
-}
