| package v14 |
| |
| /* |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "net/http" |
| "reflect" |
| "strconv" |
| "testing" |
| "time" |
| |
| "github.com/apache/trafficcontrol/lib/go-tc" |
| "github.com/apache/trafficcontrol/lib/go-util" |
| toclient "github.com/apache/trafficcontrol/traffic_ops/client" |
| ) |
| |
| func TestDeliveryServices(t *testing.T) { |
| WithObjs(t, []TCObj{CDNs, Types, Tenants, Users, Parameters, Profiles, Statuses, Divisions, Regions, PhysLocations, CacheGroups, Servers, DeliveryServices}, func() { |
| UpdateTestDeliveryServices(t) |
| UpdateNullableTestDeliveryServices(t) |
| UpdateDeliveryServiceWithInvalidRemapText(t) |
| GetTestDeliveryServices(t) |
| DeliveryServiceMinorVersionsTest(t) |
| DeliveryServiceTenancyTest(t) |
| }) |
| } |
| |
| func CreateTestDeliveryServices(t *testing.T) { |
| pl := tc.Parameter{ |
| ConfigFile: "remap.config", |
| Name: "location", |
| Value: "/remap/config/location/parameter/", |
| } |
| _, _, err := TOSession.CreateParameter(pl) |
| if err != nil { |
| t.Errorf("cannot create parameter: %v", err) |
| } |
| for _, ds := range testData.DeliveryServices { |
| _, err = TOSession.CreateDeliveryService(&ds) |
| if err != nil { |
| t.Errorf("could not CREATE delivery service '%s': %v", ds.XMLID, err) |
| } |
| } |
| } |
| |
| func GetTestDeliveryServices(t *testing.T) { |
| actualDSes, _, err := TOSession.GetDeliveryServices() |
| if err != nil { |
| t.Errorf("cannot GET DeliveryServices: %v - %v", err, actualDSes) |
| } |
| actualDSMap := map[string]tc.DeliveryService{} |
| for _, ds := range actualDSes { |
| actualDSMap[ds.XMLID] = ds |
| } |
| cnt := 0 |
| for _, ds := range testData.DeliveryServices { |
| if _, ok := actualDSMap[ds.XMLID]; !ok { |
| t.Errorf("GET DeliveryService missing: %v", ds.XMLID) |
| } |
| // exactly one ds should have exactly 3 query params. the rest should have none |
| if c := len(ds.ConsistentHashQueryParams); c > 0 { |
| if c != 3 { |
| t.Errorf("deliveryservice %s has %d query params; expected %d or %d", ds.XMLID, c, 3, 0) |
| } |
| cnt++ |
| } |
| } |
| if cnt > 2 { |
| t.Errorf("exactly 2 deliveryservices should have more than one query param; found %d", cnt) |
| } |
| } |
| |
| func UpdateTestDeliveryServices(t *testing.T) { |
| firstDS := testData.DeliveryServices[0] |
| |
| dses, _, err := TOSession.GetDeliveryServices() |
| if err != nil { |
| t.Errorf("cannot GET Delivery Services: %v", err) |
| } |
| |
| remoteDS := tc.DeliveryService{} |
| found := false |
| for _, ds := range dses { |
| if ds.XMLID == firstDS.XMLID { |
| found = true |
| remoteDS = ds |
| break |
| } |
| } |
| if !found { |
| t.Errorf("GET Delivery Services missing: %v", firstDS.XMLID) |
| } |
| |
| updatedLongDesc := "something different" |
| updatedMaxDNSAnswers := 164598 |
| updatedMaxOriginConnections := 100 |
| remoteDS.LongDesc = updatedLongDesc |
| remoteDS.MaxDNSAnswers = updatedMaxDNSAnswers |
| remoteDS.MaxOriginConnections = updatedMaxOriginConnections |
| remoteDS.MatchList = nil // verify that this field is optional in a PUT request, doesn't cause nil dereference panic |
| |
| if updateResp, err := TOSession.UpdateDeliveryService(strconv.Itoa(remoteDS.ID), &remoteDS); err != nil { |
| t.Errorf("cannot UPDATE DeliveryService by ID: %v - %v", err, updateResp) |
| } |
| |
| // Retrieve the server to check rack and interfaceName values were updated |
| resp, _, err := TOSession.GetDeliveryService(strconv.Itoa(remoteDS.ID)) |
| if err != nil { |
| t.Errorf("cannot GET Delivery Service by ID: %v - %v", remoteDS.XMLID, err) |
| } |
| if resp == nil { |
| t.Errorf("cannot GET Delivery Service by ID: %v - nil", remoteDS.XMLID) |
| } |
| |
| if resp.LongDesc != updatedLongDesc || resp.MaxDNSAnswers != updatedMaxDNSAnswers || resp.MaxOriginConnections != updatedMaxOriginConnections { |
| t.Errorf("results do not match actual: %s, expected: %s", resp.LongDesc, updatedLongDesc) |
| t.Errorf("results do not match actual: %v, expected: %v", resp.MaxDNSAnswers, updatedMaxDNSAnswers) |
| t.Errorf("results do not match actual: %v, expected: %v", resp.MaxOriginConnections, updatedMaxOriginConnections) |
| } |
| } |
| |
| func UpdateNullableTestDeliveryServices(t *testing.T) { |
| firstDS := testData.DeliveryServices[0] |
| |
| dses, _, err := TOSession.GetDeliveryServicesNullable() |
| if err != nil { |
| t.Fatalf("cannot GET Delivery Services: %v", err) |
| } |
| |
| remoteDS := tc.DeliveryServiceNullable{} |
| found := false |
| for _, ds := range dses { |
| if ds.XMLID == nil || ds.ID == nil { |
| continue |
| } |
| if *ds.XMLID == firstDS.XMLID { |
| found = true |
| remoteDS = ds |
| break |
| } |
| } |
| if !found { |
| t.Fatalf("GET Delivery Services missing: %v", firstDS.XMLID) |
| } |
| |
| updatedLongDesc := "something else different" |
| updatedMaxDNSAnswers := 164599 |
| remoteDS.LongDesc = &updatedLongDesc |
| remoteDS.MaxDNSAnswers = &updatedMaxDNSAnswers |
| |
| if updateResp, err := TOSession.UpdateDeliveryServiceNullable(strconv.Itoa(*remoteDS.ID), &remoteDS); err != nil { |
| t.Fatalf("cannot UPDATE DeliveryService by ID: %v - %v", err, updateResp) |
| } |
| |
| // Retrieve the server to check rack and interfaceName values were updated |
| resp, _, err := TOSession.GetDeliveryServiceNullable(strconv.Itoa(*remoteDS.ID)) |
| if err != nil { |
| t.Fatalf("cannot GET Delivery Service by ID: %v - %v", remoteDS.XMLID, err) |
| } |
| if resp == nil { |
| t.Fatalf("cannot GET Delivery Service by ID: %v - nil", remoteDS.XMLID) |
| } |
| |
| if resp.LongDesc == nil || resp.MaxDNSAnswers == nil { |
| t.Errorf("results do not match actual: %v, expected: %s", resp.LongDesc, updatedLongDesc) |
| t.Fatalf("results do not match actual: %v, expected: %d", resp.MaxDNSAnswers, updatedMaxDNSAnswers) |
| } |
| |
| if *resp.LongDesc != updatedLongDesc || *resp.MaxDNSAnswers != updatedMaxDNSAnswers { |
| t.Errorf("results do not match actual: %s, expected: %s", *resp.LongDesc, updatedLongDesc) |
| t.Fatalf("results do not match actual: %d, expected: %d", *resp.MaxDNSAnswers, updatedMaxDNSAnswers) |
| } |
| } |
| |
| // UpdateDeliveryServiceWithInvalidRemapText ensures that a delivery service can't be updated with a remap text value with a line break in it. |
| func UpdateDeliveryServiceWithInvalidRemapText(t *testing.T) { |
| firstDS := testData.DeliveryServices[0] |
| |
| dses, _, err := TOSession.GetDeliveryServicesNullable() |
| if err != nil { |
| t.Fatalf("cannot GET Delivery Services: %v", err) |
| } |
| |
| remoteDS := tc.DeliveryServiceNullable{} |
| found := false |
| for _, ds := range dses { |
| if ds.XMLID == nil || ds.ID == nil { |
| continue |
| } |
| if *ds.XMLID == firstDS.XMLID { |
| found = true |
| remoteDS = ds |
| break |
| } |
| } |
| if !found { |
| t.Fatalf("GET Delivery Services missing: %v", firstDS.XMLID) |
| } |
| |
| updatedRemapText := "@plugin=tslua.so @pparam=/opt/trafficserver/etc/trafficserver/remapPlugin1.lua\nline2" |
| remoteDS.RemapText = &updatedRemapText |
| |
| if _, err := TOSession.UpdateDeliveryServiceNullable(strconv.Itoa(*remoteDS.ID), &remoteDS); err == nil { |
| t.Errorf("Delivery service updated with invalid remap text: %v", updatedRemapText) |
| } |
| } |
| |
| func DeleteTestDeliveryServices(t *testing.T) { |
| dses, _, err := TOSession.GetDeliveryServices() |
| if err != nil { |
| t.Errorf("cannot GET deliveryservices: %v", err) |
| } |
| for _, testDS := range testData.DeliveryServices { |
| ds := tc.DeliveryService{} |
| found := false |
| for _, realDS := range dses { |
| if realDS.XMLID == testDS.XMLID { |
| ds = realDS |
| found = true |
| break |
| } |
| } |
| if !found { |
| t.Errorf("DeliveryService not found in Traffic Ops: %v", ds.XMLID) |
| } |
| |
| delResp, err := TOSession.DeleteDeliveryService(strconv.Itoa(ds.ID)) |
| if err != nil { |
| t.Errorf("cannot DELETE DeliveryService by ID: %v - %v", err, delResp) |
| } |
| |
| // Retrieve the Server to see if it got deleted |
| foundDS, err := TOSession.DeliveryService(strconv.Itoa(ds.ID)) |
| if err == nil && foundDS != nil { |
| t.Errorf("expected Delivery Service: %s to be deleted", ds.XMLID) |
| } |
| } |
| |
| // clean up parameter created in CreateTestDeliveryServices() |
| params, _, err := TOSession.GetParameterByNameAndConfigFile("location", "remap.config") |
| for _, param := range params { |
| deleted, _, err := TOSession.DeleteParameterByID(param.ID) |
| if err != nil { |
| t.Errorf("cannot DELETE parameter by ID (%d): %v - %v", param.ID, err, deleted) |
| } |
| } |
| } |
| |
| func DeliveryServiceMinorVersionsTest(t *testing.T) { |
| testDS := testData.DeliveryServices[4] |
| if testDS.XMLID != "ds-test-minor-versions" { |
| t.Errorf("expected XMLID: ds-test-minor-versions, actual: %s", testDS.XMLID) |
| } |
| |
| dses, _, err := TOSession.GetDeliveryServicesNullable() |
| if err != nil { |
| t.Errorf("cannot GET DeliveryServices: %v - %v", err, dses) |
| } |
| ds := tc.DeliveryServiceNullable{} |
| for _, d := range dses { |
| if *d.XMLID == testDS.XMLID { |
| ds = d |
| break |
| } |
| } |
| // GET latest, verify expected values for 1.3 and 1.4 fields |
| if ds.DeepCachingType == nil { |
| t.Errorf("expected DeepCachingType: %s, actual: nil", testDS.DeepCachingType.String()) |
| } else if *ds.DeepCachingType != testDS.DeepCachingType { |
| t.Errorf("expected DeepCachingType: %s, actual: %s", testDS.DeepCachingType.String(), ds.DeepCachingType.String()) |
| } |
| if ds.FQPacingRate == nil { |
| t.Errorf("expected FQPacingRate: %d, actual: nil", testDS.FQPacingRate) |
| } else if *ds.FQPacingRate != testDS.FQPacingRate { |
| t.Errorf("expected FQPacingRate: %d, actual: %d", testDS.FQPacingRate, *ds.FQPacingRate) |
| } |
| if ds.SigningAlgorithm == nil { |
| t.Errorf("expected SigningAlgorithm: %s, actual: nil", testDS.SigningAlgorithm) |
| } else if *ds.SigningAlgorithm != testDS.SigningAlgorithm { |
| t.Errorf("expected SigningAlgorithm: %s, actual: %s", testDS.SigningAlgorithm, *ds.SigningAlgorithm) |
| } |
| if ds.Tenant == nil { |
| t.Errorf("expected Tenant: %s, actual: nil", testDS.Tenant) |
| } else if *ds.Tenant != testDS.Tenant { |
| t.Errorf("expected Tenant: %s, actual: %s", testDS.Tenant, *ds.Tenant) |
| } |
| if ds.TRRequestHeaders == nil { |
| t.Errorf("expected TRRequestHeaders: %s, actual: nil", testDS.TRRequestHeaders) |
| } else if *ds.TRRequestHeaders != testDS.TRRequestHeaders { |
| t.Errorf("expected TRRequestHeaders: %s, actual: %s", testDS.TRRequestHeaders, *ds.TRRequestHeaders) |
| } |
| if ds.TRResponseHeaders == nil { |
| t.Errorf("expected TRResponseHeaders: %s, actual: nil", testDS.TRResponseHeaders) |
| } else if *ds.TRResponseHeaders != testDS.TRResponseHeaders { |
| t.Errorf("expected TRResponseHeaders: %s, actual: %s", testDS.TRResponseHeaders, *ds.TRResponseHeaders) |
| } |
| if ds.ConsistentHashRegex == nil { |
| t.Errorf("expected ConsistentHashRegex: %s, actual: nil", testDS.ConsistentHashRegex) |
| } else if *ds.ConsistentHashRegex != testDS.ConsistentHashRegex { |
| t.Errorf("expected ConsistentHashRegex: %s, actual: %s", testDS.ConsistentHashRegex, *ds.ConsistentHashRegex) |
| } |
| if ds.ConsistentHashQueryParams == nil { |
| t.Errorf("expected ConsistentHashQueryParams: %v, actual: nil", testDS.ConsistentHashQueryParams) |
| } else if !reflect.DeepEqual(ds.ConsistentHashQueryParams, testDS.ConsistentHashQueryParams) { |
| t.Errorf("expected ConsistentHashQueryParams: %v, actual: %v", testDS.ConsistentHashQueryParams, ds.ConsistentHashQueryParams) |
| } |
| if ds.MaxOriginConnections == nil { |
| t.Errorf("expected MaxOriginConnections: %d, actual: nil", testDS.MaxOriginConnections) |
| } else if *ds.MaxOriginConnections != testDS.MaxOriginConnections { |
| t.Errorf("expected MaxOriginConnections: %d, actual: %d", testDS.MaxOriginConnections, *ds.MaxOriginConnections) |
| } |
| |
| // GET 1.1, verify 1.3 and 1.4 fields are nil |
| data := tc.DeliveryServicesNullableResponse{} |
| if err = makeV11Request(http.MethodGet, "deliveryservices/"+strconv.Itoa(*ds.ID), nil, &data); err != nil { |
| t.Errorf("cannot GET 1.1 deliveryservice: %s", err.Error()) |
| } |
| respDS := data.Response[0] |
| if !dsV13FieldsAreNil(respDS) || !dsV14FieldsAreNil(respDS) { |
| t.Error("expected 1.3 and 1.4 values to be nil, actual: non-nil") |
| } |
| |
| // GET 1.3, verify 1.3 fields are non-nil and 1.4 fields are nil |
| data = tc.DeliveryServicesNullableResponse{} |
| if err = makeV13Request(http.MethodGet, "deliveryservices/"+strconv.Itoa(*ds.ID), nil, &data); err != nil { |
| t.Errorf("cannot GET 1.3 deliveryservice: %s", err.Error()) |
| } |
| respDS = data.Response[0] |
| if dsV13FieldsAreNil(respDS) { |
| t.Error("expected 1.3 values to be non-nil, actual: nil") |
| } |
| if !dsV14FieldsAreNil(respDS) { |
| t.Error("expected 1.4 values to be nil, actual: non-nil") |
| } |
| if _, err = TOSession.DeleteDeliveryService(strconv.Itoa(*ds.ID)); err != nil { |
| t.Errorf("cannot DELETE deliveryservice: %s", err.Error()) |
| } |
| |
| ds.ID = nil |
| dsBody, err := json.Marshal(ds) |
| if err != nil { |
| t.Errorf("cannot POST deliveryservice, failed to marshal JSON: %s", err.Error()) |
| } |
| dsV11Body, err := json.Marshal(ds.DeliveryServiceNullableV11) |
| if err != nil { |
| t.Errorf("cannot POST deliveryservice, failed to marshal JSON: %s", err.Error()) |
| } |
| |
| // POST 1.3 w/ 1.4 data, verify 1.4 fields were ignored |
| postDSResp := tc.CreateDeliveryServiceNullableResponse{} |
| if err = makeV13Request(http.MethodPost, "deliveryservices", bytes.NewBuffer(dsBody), &postDSResp); err != nil { |
| t.Errorf("cannot POST 1.3 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV14FieldsAreNil(postDSResp.Response[0]) { |
| t.Error("POST 1.3 expected 1.4 values to be nil, actual: non-nil") |
| } |
| respID := postDSResp.Response[0].ID |
| getDS, _, err := TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if !dsV14FieldsAreNilOrDefault(*getDS) { |
| t.Error("POST 1.3 expected 1.4 values to be nil/default, actual: non-nil/default") |
| } |
| if _, err = TOSession.DeleteDeliveryService(strconv.Itoa(*respID)); err != nil { |
| t.Errorf("cannot DELETE deliveryservice: %s", err.Error()) |
| } |
| |
| // POST 1.1 w/ 1.4 data, verify 1.3 and 1.4 fields were ignored |
| postDSResp = tc.CreateDeliveryServiceNullableResponse{} |
| if err = makeV11Request(http.MethodPost, "deliveryservices", bytes.NewBuffer(dsBody), &postDSResp); err != nil { |
| t.Errorf("cannot POST 1.1 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV13FieldsAreNil(postDSResp.Response[0]) || !dsV14FieldsAreNil(postDSResp.Response[0]) { |
| t.Errorf("POST 1.1 expected 1.3 and 1.4 values to be nil, actual: non-nil %+v", postDSResp.Response[0]) |
| } |
| respID = postDSResp.Response[0].ID |
| getDS, _, err = TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if !dsV13FieldsAreNilOrDefault(*getDS) || !dsV14FieldsAreNilOrDefault(*getDS) { |
| t.Errorf("POST 1.1 expected 1.3 and 1.4 values to be nil/default, actual: non-nil/default %+v", *getDS) |
| } |
| |
| // PUT 1.4 w/ 1.4 data, then verify that a PUT 1.1 with 1.1 data preserves the existing 1.3 and 1.4 data |
| if _, err = TOSession.UpdateDeliveryServiceNullable(strconv.Itoa(*respID), &ds); err != nil { |
| t.Errorf("cannot PUT deliveryservice: %s", err.Error()) |
| } |
| putDSResp := tc.UpdateDeliveryServiceNullableResponse{} |
| if err = makeV11Request(http.MethodPut, "deliveryservices/"+strconv.Itoa(*respID), bytes.NewBuffer(dsV11Body), &putDSResp); err != nil { |
| t.Errorf("cannot PUT 1.1 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV13FieldsAreNil(putDSResp.Response[0]) || !dsV14FieldsAreNil(putDSResp.Response[0]) { |
| t.Errorf("PUT 1.1 expected 1.3 and 1.4 values to be nil, actual: non-nil %+v", putDSResp.Response[0]) |
| } |
| getDS, _, err = TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if getDS.FQPacingRate == nil { |
| t.Errorf("expected FQPacingRate: %d, actual: nil", testDS.FQPacingRate) |
| } else if *getDS.FQPacingRate != testDS.FQPacingRate { |
| t.Errorf("expected FQPacingRate: %d, actual: %d", testDS.FQPacingRate, *getDS.FQPacingRate) |
| } |
| if getDS.MaxOriginConnections == nil { |
| t.Errorf("expected MaxOriginConnections: %d, actual: nil", testDS.MaxOriginConnections) |
| } else if *getDS.MaxOriginConnections != testDS.MaxOriginConnections { |
| t.Errorf("expected MaxOriginConnections: %d, actual: %d", testDS.MaxOriginConnections, *getDS.MaxOriginConnections) |
| } |
| |
| // PUT 1.3 w/ 1.1 data, verify that 1.4 fields were preserved |
| putDSResp = tc.UpdateDeliveryServiceNullableResponse{} |
| if err = makeV13Request(http.MethodPut, "deliveryservices/"+strconv.Itoa(*respID), bytes.NewBuffer(dsV11Body), &putDSResp); err != nil { |
| t.Errorf("cannot PUT 1.3 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV14FieldsAreNil(putDSResp.Response[0]) { |
| t.Errorf("PUT 1.3 expected 1.4 values to be nil, actual: non-nil %+v", putDSResp.Response[0]) |
| } |
| getDS, _, err = TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if getDS.MaxOriginConnections == nil { |
| t.Errorf("expected MaxOriginConnections: %d, actual: nil", testDS.MaxOriginConnections) |
| } else if *getDS.MaxOriginConnections != testDS.MaxOriginConnections { |
| t.Errorf("expected MaxOriginConnections: %d, actual: %d", testDS.MaxOriginConnections, *getDS.MaxOriginConnections) |
| } |
| |
| // DELETE+POST 1.1 again, so that 1.3 and 1.4 fields are back to nil/default |
| if _, err = TOSession.DeleteDeliveryService(strconv.Itoa(*respID)); err != nil { |
| t.Errorf("cannot DELETE deliveryservice: %s", err.Error()) |
| } |
| postDSResp = tc.CreateDeliveryServiceNullableResponse{} |
| if err = makeV11Request(http.MethodPost, "deliveryservices", bytes.NewBuffer(dsV11Body), &postDSResp); err != nil { |
| t.Errorf("cannot POST 1.1 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| respID = postDSResp.Response[0].ID |
| |
| // PUT 1.1 w/ 1.4 data - make sure 1.3 and 1.4 fields were ignored |
| putDSResp = tc.UpdateDeliveryServiceNullableResponse{} |
| if err = makeV11Request(http.MethodPut, "deliveryservices/"+strconv.Itoa(*respID), bytes.NewBuffer(dsBody), &putDSResp); err != nil { |
| t.Errorf("cannot PUT 1.1 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV13FieldsAreNil(putDSResp.Response[0]) || !dsV14FieldsAreNil(putDSResp.Response[0]) { |
| t.Errorf("PUT 1.1 expected 1.3 and 1.4 values to be nil, actual: non-nil %+v", putDSResp.Response[0]) |
| } |
| respID = putDSResp.Response[0].ID |
| getDS, _, err = TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if !dsV13FieldsAreNilOrDefault(*getDS) || !dsV14FieldsAreNilOrDefault(*getDS) { |
| t.Errorf("PUT 1.1 expected 1.3 and 1.4 values to be nil/default, actual: non-nil/default %+v", *getDS) |
| } |
| |
| // PUT 1.3 w/ 1.4 data, make sure 1.4 fields were ignored |
| putDSResp = tc.UpdateDeliveryServiceNullableResponse{} |
| if err = makeV13Request(http.MethodPut, "deliveryservices/"+strconv.Itoa(*respID), bytes.NewBuffer(dsBody), &putDSResp); err != nil { |
| t.Errorf("cannot PUT 1.1 deliveryservice, failed to make request: %s", err.Error()) |
| } |
| if !dsV14FieldsAreNil(putDSResp.Response[0]) { |
| t.Error("PUT 1.3 expected 1.4 values to be nil, actual: non-nil") |
| } |
| respID = putDSResp.Response[0].ID |
| getDS, _, err = TOSession.GetDeliveryServiceNullable(strconv.Itoa(*respID)) |
| if err != nil { |
| t.Errorf("cannot GET deliveryservice: %s", err.Error()) |
| } |
| if !dsV14FieldsAreNilOrDefault(*getDS) { |
| t.Error("PUT 1.3 expected 1.4 values to be nil/default, actual: non-nil/default") |
| } |
| } |
| |
| func dsV13FieldsAreNilOrDefault(ds tc.DeliveryServiceNullable) bool { |
| return (ds.DeepCachingType == nil || *ds.DeepCachingType == tc.DeepCachingTypeNever) && |
| (ds.FQPacingRate == nil || *ds.FQPacingRate == 0) && |
| (ds.TRRequestHeaders == nil || *ds.TRRequestHeaders == "") && |
| (ds.TRResponseHeaders == nil || *ds.TRResponseHeaders == "") |
| } |
| |
| func dsV14FieldsAreNilOrDefault(ds tc.DeliveryServiceNullable) bool { |
| return (ds.ConsistentHashRegex == nil || *ds.ConsistentHashRegex == "") && |
| (ds.ConsistentHashQueryParams == nil || len(ds.ConsistentHashQueryParams) == 0) && |
| (ds.MaxOriginConnections == nil || *ds.MaxOriginConnections == 0) |
| } |
| |
| func dsV13FieldsAreNil(ds tc.DeliveryServiceNullable) bool { |
| return ds.DeepCachingType == nil && |
| ds.FQPacingRate == nil && |
| ds.SigningAlgorithm == nil && |
| ds.Tenant == nil && |
| ds.TRRequestHeaders == nil && |
| ds.TRResponseHeaders == nil |
| } |
| |
| func dsV14FieldsAreNil(ds tc.DeliveryServiceNullable) bool { |
| return ds.ConsistentHashRegex == nil && |
| (ds.ConsistentHashQueryParams == nil || len(ds.ConsistentHashQueryParams) == 0) && |
| ds.MaxOriginConnections == nil |
| } |
| |
| func makeV11Request(method string, path string, body io.Reader, respStruct interface{}) error { |
| return makeRequest("1.1", method, path, body, respStruct) |
| } |
| |
| func makeV13Request(method string, path string, body io.Reader, respStruct interface{}) error { |
| return makeRequest("1.3", method, path, body, respStruct) |
| } |
| |
| // TODO: move this helper function into a better location |
| func makeRequest(version string, method string, path string, body io.Reader, respStruct interface{}) error { |
| req, err := http.NewRequest(method, TOSession.URL+"/api/"+version+"/"+path, body) |
| if err != nil { |
| return fmt.Errorf("failed to create request: %s", err.Error()) |
| } |
| resp, err := TOSession.Client.Do(req) |
| if err != nil { |
| return fmt.Errorf("running request: %s", err.Error()) |
| } |
| defer resp.Body.Close() |
| bts, err := ioutil.ReadAll(resp.Body) |
| if err != nil { |
| return fmt.Errorf("reading body: " + err.Error()) |
| } |
| if err = json.Unmarshal(bts, respStruct); err != nil { |
| return fmt.Errorf("unmarshalling body '" + string(bts) + "': " + err.Error()) |
| } |
| return nil |
| } |
| |
| func DeliveryServiceTenancyTest(t *testing.T) { |
| dses, _, err := TOSession.GetDeliveryServicesNullable() |
| if err != nil { |
| t.Errorf("cannot GET deliveryservices: %v", err) |
| } |
| tenant3DS := tc.DeliveryServiceNullable{} |
| foundTenant3DS := false |
| for _, d := range dses { |
| if *d.XMLID == "ds3" { |
| tenant3DS = d |
| foundTenant3DS = true |
| } |
| } |
| if !foundTenant3DS || *tenant3DS.Tenant != "tenant3" { |
| t.Error("expected to find deliveryservice 'ds3' with tenant 'tenant3'") |
| } |
| |
| toReqTimeout := time.Second * time.Duration(Config.Default.Session.TimeoutInSecs) |
| tenant4TOClient, _, err := toclient.LoginWithAgent(TOSession.URL, "tenant4user", "pa$$word", true, "to-api-v14-client-tests/tenant4user", true, toReqTimeout) |
| if err != nil { |
| t.Fatalf("failed to log in with tenant4user: %v", err.Error()) |
| } |
| |
| dsesReadableByTenant4, _, err := tenant4TOClient.GetDeliveryServicesNullable() |
| if err != nil { |
| t.Error("tenant4user cannot GET deliveryservices") |
| } |
| |
| // assert that tenant4user cannot read deliveryservices outside of its tenant |
| for _, ds := range dsesReadableByTenant4 { |
| if *ds.XMLID == "ds3" { |
| t.Error("expected tenant4 to be unable to read delivery services from tenant 3") |
| } |
| } |
| |
| // assert that tenant4user cannot update tenant3user's deliveryservice |
| if _, err = tenant4TOClient.UpdateDeliveryServiceNullable(string(*tenant3DS.ID), &tenant3DS); err == nil { |
| t.Errorf("expected tenant4user to be unable to update tenant3's deliveryservice (%s)", *tenant3DS.XMLID) |
| } |
| |
| // assert that tenant4user cannot delete tenant3user's deliveryservice |
| if _, err = tenant4TOClient.DeleteDeliveryService(string(*tenant3DS.ID)); err == nil { |
| t.Errorf("expected tenant4user to be unable to delete tenant3's deliveryservice (%s)", *tenant3DS.XMLID) |
| } |
| |
| // assert that tenant4user cannot create a deliveryservice outside of its tenant |
| tenant3DS.XMLID = util.StrPtr("deliveryservicetenancytest") |
| tenant3DS.DisplayName = util.StrPtr("deliveryservicetenancytest") |
| if _, err = tenant4TOClient.CreateDeliveryServiceNullable(&tenant3DS); err == nil { |
| t.Error("expected tenant4user to be unable to create a deliveryservice outside of its tenant") |
| } |
| |
| } |
