mirror of https://github.com/knative/client.git
482 lines
18 KiB
Go
482 lines
18 KiB
Go
// Copyright 2019 The Knative Authors
|
|
|
|
// 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 im
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// +build e2e
|
|
// +build !eventing
|
|
|
|
package e2e
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gotest.tools/assert"
|
|
|
|
"knative.dev/client/lib/test"
|
|
)
|
|
|
|
var targetsSeparator = "|"
|
|
var targetFieldsSeparator = ","
|
|
var targetFieldsLength = 4
|
|
|
|
// returns deployed service targets separated by '|' and each target fields seprated by comma
|
|
var targetsJsonPath = "jsonpath={range .status.traffic[*]}{.tag}{','}{.revisionName}{','}{.percent}{','}{.latestRevision}{'|'}{end}"
|
|
|
|
// TargetFields are used in e2e to store expected fields per traffic target
|
|
// and actual traffic targets fields of deployed service are converted into struct before comparing
|
|
type TargetFields struct {
|
|
Tag string
|
|
Revision string
|
|
Percent int
|
|
Latest bool
|
|
}
|
|
|
|
func newTargetFields(tag, revision string, percent int, latest bool) TargetFields {
|
|
return TargetFields{tag, revision, percent, latest}
|
|
}
|
|
|
|
func splitTargets(s, separator string, partsCount int) ([]string, error) {
|
|
s = strings.TrimSuffix(s, targetsSeparator)
|
|
parts := strings.Split(s, separator)
|
|
if len(parts) != partsCount {
|
|
return nil, fmt.Errorf("expecting %d targets, got %d targets "+
|
|
"targets: %s separator: %s", partsCount, len(parts), s, separator)
|
|
}
|
|
return parts, nil
|
|
}
|
|
|
|
// formatActualTargets takes the traffic targets string received after jsonpath operation and converts
|
|
// them into []TargetFields for comparison
|
|
func formatActualTargets(t *testing.T, it *test.KnTest, actualTargets []string) (formattedTargets []TargetFields) {
|
|
for _, each := range actualTargets {
|
|
each := strings.TrimSuffix(each, targetFieldsSeparator)
|
|
fields, err := splitTargets(each, targetFieldsSeparator, targetFieldsLength)
|
|
assert.NilError(t, err)
|
|
percentInt, err := strconv.Atoi(fields[2])
|
|
assert.NilError(t, err)
|
|
latestBool, err := strconv.ParseBool(fields[3])
|
|
assert.NilError(t, err)
|
|
formattedTargets = append(formattedTargets, newTargetFields(fields[0], fields[1], percentInt, latestBool))
|
|
}
|
|
return
|
|
}
|
|
|
|
// TestTrafficSplitSuite runs different e2e tests for service traffic splitting and verifies the traffic targets from service status
|
|
func TestTrafficSplit(t *testing.T) {
|
|
t.Parallel()
|
|
it, err := test.NewKnTest()
|
|
assert.NilError(t, err)
|
|
defer func() {
|
|
assert.NilError(t, it.Teardown())
|
|
}()
|
|
|
|
serviceBase := "echo"
|
|
t.Run("50:50",
|
|
func(t *testing.T) {
|
|
t.Log("tag two revisions as v1 and v2 and give 50-50% share")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
test.ServiceCreate(r, serviceName)
|
|
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
tflags := []string{"--tag", fmt.Sprintf("%s=v1,%s=v2", rev1, rev2),
|
|
"--traffic", "v1=50,v2=50"}
|
|
test.ServiceUpdate(r, serviceName, tflags...)
|
|
|
|
// make ordered fields per tflags (tag, revision, percent, latest)
|
|
expectedTargets := []TargetFields{newTargetFields("v1", rev1, 50, false), newTargetFields("v2", rev2, 50, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("20:80",
|
|
func(t *testing.T) {
|
|
t.Log("ramp/up down a revision to 20% adjusting other traffic to accommodate")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
test.ServiceCreate(r, serviceName)
|
|
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
test.ServiceUpdate(r, serviceName, "--traffic", fmt.Sprintf("%s=20,%s=80", rev1, rev2))
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev1, 20, false), newTargetFields("", rev2, 80, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagCandidate",
|
|
func(t *testing.T) {
|
|
t.Log("tag a revision as candidate, without otherwise changing any traffic split")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
|
|
|
|
// no traffic, append new target with tag in traffic block
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=%s", rev1, "candidate"))
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true), newTargetFields("candidate", rev1, 0, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagCandidate:2:98",
|
|
func(t *testing.T) {
|
|
t.Log("tag a revision as candidate, set 2% traffic adjusting other traffic to accommodate")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
|
|
|
|
// traffic by tag name and use % at the end
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--tag", fmt.Sprintf("%s=%s", rev1, "candidate"),
|
|
"--traffic", "candidate=2%,@latest=98%")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 98, true), newTargetFields("candidate", rev1, 2, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagCurrent",
|
|
func(t *testing.T) {
|
|
t.Log("update tag for a revision from candidate to current, tag current is present on another revision")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
// make available 3 revisions for service first
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
rev3 := fmt.Sprintf("%s-rev-3", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v3", "--revision-name", rev3) //note that this gives 100% traffic to latest revision (rev3)
|
|
|
|
// make existing state: tag current and candidate exist in traffic block
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=current,%s=candidate", rev1, rev2))
|
|
|
|
// desired state of tags: update tag of revision (rev2) from candidate to current (which is present on rev1)
|
|
//untag first to update
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--untag", "current,candidate",
|
|
"--tag", fmt.Sprintf("%s=current", rev2))
|
|
|
|
// there will be 2 targets in existing block 1. @latest, 2.for revision $rev2
|
|
// target for rev1 is removed as it had no traffic and we untagged it's tag current
|
|
expectedTargets := []TargetFields{newTargetFields("", rev3, 100, true), newTargetFields("current", rev2, 0, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagStagingLatest",
|
|
func(t *testing.T) {
|
|
t.Log("update tag from testing to staging for @latest revision")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
// make existing state: tag @latest as testing
|
|
test.ServiceUpdate(r, serviceName, "--tag", "@latest=testing")
|
|
|
|
// desired state: change tag from testing to staging
|
|
test.ServiceUpdate(r, serviceName, "--untag", "testing", "--tag", "@latest=staging")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("staging", rev1, 100, true)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagStagingNonLatest",
|
|
func(t *testing.T) {
|
|
t.Log("update tag from testing to staging for a revision (non @latest)")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
// make existing state: tag a revision as testing
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=testing", rev1))
|
|
|
|
// desired state: change tag from testing to staging
|
|
test.ServiceUpdate(r, serviceName, "--untag", "testing", "--tag", fmt.Sprintf("%s=staging", rev1))
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true),
|
|
newTargetFields("staging", rev1, 0, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
// test reducing number of targets from traffic blockdd
|
|
t.Run("RemoveTag",
|
|
func(t *testing.T) {
|
|
t.Log("remove a revision with tag old from traffic block entirely")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
// existing state: traffic block having a revision with tag old and some traffic
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--tag", fmt.Sprintf("%s=old", rev1),
|
|
"--traffic", "old=2,@latest=98")
|
|
|
|
// desired state: remove revision with tag old
|
|
test.ServiceUpdate(r, serviceName, "--untag", "old", "--traffic", "@latest=100")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagStable:50:50",
|
|
func(t *testing.T) {
|
|
t.Log("tag a revision as stable and current with 50-50% traffic")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
// existing state: traffic block having two targets
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2")
|
|
|
|
// desired state: tag non-@latest revision with two tags and 50-50% traffic each
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--tag", fmt.Sprintf("%s=stable,%s=current", rev1, rev1),
|
|
"--traffic", "stable=50%,current=50%")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("stable", rev1, 50, false), newTargetFields("current", rev1, 50, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("RevertToLatest",
|
|
func(t *testing.T) {
|
|
t.Log("revert all traffic to latest ready revision of service")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
// existing state: latest ready revision not getting any traffic
|
|
test.ServiceUpdate(r, serviceName, "--traffic", fmt.Sprintf("%s=100", rev1))
|
|
|
|
// desired state: revert traffic to latest ready revision
|
|
test.ServiceUpdate(r, serviceName, "--traffic", "@latest=100")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagLatestAsCurrent",
|
|
func(t *testing.T) {
|
|
t.Log("tag latest ready revision of service as current")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
// existing state: latest revision has no tag
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
// desired state: tag latest ready revision as 'current'
|
|
test.ServiceUpdate(r, serviceName, "--tag", "@latest=current")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("current", rev1, 100, true)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("UpdateTag:100:0",
|
|
func(t *testing.T) {
|
|
t.Log("update tag for a revision as testing and assign all the traffic to it")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
// existing state: two revision exists with traffic share and
|
|
// each revision has tag and traffic portions
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--tag", fmt.Sprintf("@latest=current,%s=candidate", rev1),
|
|
"--traffic", "current=90,candidate=10")
|
|
|
|
// desired state: update tag for rev1 as testing (from candidate) with 100% traffic
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--untag", "candidate", "--tag", fmt.Sprintf("%s=testing", rev1),
|
|
"--traffic", "testing=100")
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("current", rev2, 0, true),
|
|
newTargetFields("testing", rev1, 100, false)}
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("TagReplace",
|
|
func(t *testing.T) {
|
|
t.Log("replace latest tag of a revision with old and give latest to another revision")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
rev2 := fmt.Sprintf("%s-rev-2", serviceName)
|
|
test.ServiceUpdate(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
|
|
|
|
// existing state: a revision exist with latest tag
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=latest", rev1))
|
|
|
|
// desired state of revision tags: rev1=old rev2=latest
|
|
test.ServiceUpdate(r, serviceName,
|
|
"--untag", "latest",
|
|
"--tag", fmt.Sprintf("%s=old,%s=latest", rev1, rev2))
|
|
|
|
expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true),
|
|
newTargetFields("old", rev1, 0, false),
|
|
// Tagging by revision name adds a new target even though latestReadyRevision==rev2,
|
|
// because we didn't refer @latest reference, but explcit name of revision.
|
|
// In spec of traffic block (not status) either latestReadyRevision:true or revisionName can be given per target
|
|
newTargetFields("latest", rev2, 0, false)}
|
|
|
|
verifyTargets(r, serviceName, expectedTargets, false)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("UntagNonExistentTag",
|
|
func(t *testing.T) {
|
|
t.Log("use --untag on a tag that does not exist")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
// existing state: a revision exist with latest tag
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=latest", rev1))
|
|
|
|
// desired state of revision tags: rev1=latest
|
|
// attempt to untag a tag that does not exist for the service's revisions
|
|
test.ServiceUpdateWithError(r, serviceName, "--untag", "foo")
|
|
|
|
// state should remain the same as error from --untag will stop service update
|
|
expectedTargets := []TargetFields{
|
|
newTargetFields("", rev1, 100, true),
|
|
newTargetFields("latest", rev1, 0, false),
|
|
}
|
|
|
|
verifyTargets(r, serviceName, expectedTargets, true)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
t.Run("UntagNonExistentTagAndValidTag",
|
|
func(t *testing.T) {
|
|
t.Log("use --untag on a tag that does not exist in addition to a tag that exists")
|
|
r := test.NewKnRunResultCollector(t, it)
|
|
defer r.DumpIfFailed()
|
|
|
|
serviceName := test.GetNextServiceName(serviceBase)
|
|
rev1 := fmt.Sprintf("%s-rev-1", serviceName)
|
|
serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
|
|
|
|
// existing state: a revision exist with latest tag
|
|
test.ServiceUpdate(r, serviceName, "--tag", fmt.Sprintf("%s=latest", rev1))
|
|
|
|
// desired state of revision tags: rev1=latest
|
|
// attempt to untag a tag that does not exist for the service's revisions (foo)
|
|
// and also untag a tag that exists (latest)
|
|
test.ServiceUpdateWithError(r, serviceName, "--untag", "latest", "--untag", "foo")
|
|
|
|
// state should remain the same as error from --untag will stop service update
|
|
expectedTargets := []TargetFields{
|
|
newTargetFields("", rev1, 100, true),
|
|
newTargetFields("latest", rev1, 0, false),
|
|
}
|
|
|
|
verifyTargets(r, serviceName, expectedTargets, true)
|
|
test.ServiceDelete(r, serviceName)
|
|
},
|
|
)
|
|
}
|
|
|
|
func verifyTargets(r *test.KnRunResultCollector, serviceName string, expectedTargets []TargetFields, expectErr bool) {
|
|
out := test.ServiceDescribeWithJSONPath(r, serviceName, targetsJsonPath)
|
|
assert.Check(r.T(), out != "")
|
|
actualTargets, err := splitTargets(out, targetsSeparator, len(expectedTargets))
|
|
if !expectErr {
|
|
assert.NilError(r.T(), err)
|
|
}
|
|
formattedActualTargets := formatActualTargets(r.T(), r.KnTest(), actualTargets)
|
|
assert.DeepEqual(r.T(), expectedTargets, formattedActualTargets)
|
|
if r.T().Failed() {
|
|
r.AddDump("service", serviceName, r.KnTest().Kn().Namespace())
|
|
}
|
|
}
|