kind: kindValue
        name: nameValue
        namespace: namespaceValue
        resourceVersion: resourceVersionValue
        uid: uidValue
      csi:
        controllerExpandSecretRef:
          name: nameValue
          namespace: namespaceValue
        controllerPublishSecretRef:
          name: nameValue
          namespace: namespaceValue
        driver: driverValue
        fsType: fsTypeValue

          "controllerPublishSecretRef": {
            "name": "nameValue",
            "namespace": "namespaceValue"
          },
          "nodeStageSecretRef": {
            "name": "nameValue",
            "namespace": "namespaceValue"
          },
          "nodePublishSecretRef": {
            "name": "nameValue",
            "namespace": "namespaceValue"
          },
          "controllerExpandSecretRef": {

        kind: kindValue
        name: nameValue
        namespace: namespaceValue
        resourceVersion: resourceVersionValue
        uid: uidValue
      csi:
        controllerExpandSecretRef:
          name: nameValue
          namespace: namespaceValue
        controllerPublishSecretRef:
          name: nameValue
          namespace: namespaceValue
        driver: driverValue
        fsType: fsTypeValue

	out := *p
	out.Verbose = verbose
	return &out
}

func (p *Params) SetNamespace(namespace string) *Params {
	out := *p
	out.Namespace = namespace
	return &out
}

func (p *Params) SetIstioNamespace(namespace string) *Params {
	out := *p
	out.IstioNamespace = namespace
	return &out
}

func (p *Params) SetPod(pod string) *Params {
	out := *p
	out.Pod = pod
	return &out
}

// Logs returns the logs for the given namespace/pod/container.
func (r *Runner) Logs(namespace, pod, container string, previous, dryRun bool) (string, error) {
	if dryRun {
		return fmt.Sprintf("Dry run: would be running client.PodLogs(%s, %s, %s)", pod, namespace, container), nil
	}
	// ignore cancellation errors since this is subject to global timeout.
	task := fmt.Sprintf("PodLogs %s/%s/%s", namespace, pod, container)
	r.addRunningTask(task)

    allowedRoutes:
      namespaces:
        from: All
---
apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: http
  namespace: default
spec:
  parentRefs:
  - name: gateway
    namespace: istio-system
  hostnames: ["first.domain.example", "another.domain.example"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
      headers:
      - name: my-header

var _ jobControlInterface = &realJobControl{}

func (r realJobControl) GetJob(namespace, name string) (*batchv1.Job, error) {
	return r.KubeClient.BatchV1().Jobs(namespace).Get(context.TODO(), name, metav1.GetOptions{})
}

func (r realJobControl) CreateJob(namespace string, job *batchv1.Job) (*batchv1.Job, error) {
	return r.KubeClient.BatchV1().Jobs(namespace).Create(context.TODO(), job, metav1.CreateOptions{})
}

		ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"},
	}
	eps2 := &discoveryv1.EndpointSlice{
		ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"},
	}

	expectedSvcState := map[types.NamespacedName]*v1.Service{
		{Name: svc1.Name, Namespace: svc1.Namespace}: svc1,
		{Name: svc2.Name, Namespace: svc2.Namespace}: svc2,
	}

# only ask if in interactive mode
if [[ -t 0 && -z ${NAMESPACE} ]];then
  echo -n "namespace ? [default] "
  read -r NAMESPACE
fi

# verify if the namespace exists, otherwise use default namespace
if [[ -n ${NAMESPACE} ]];then
  ns=$(kubectl get namespace "${NAMESPACE}" --no-headers --output=go-template="{{.metadata.name}}" 2>/dev/null)
  if [[ -z ${ns} ]];then
    echo "NAMESPACE ${NAMESPACE} not found."
    NAMESPACE=default
  fi
fi

		{Namespace: "default", Name: "se-3"}: {},
	}
	currSes := map[types.NamespacedName]*config.Config{
		{Namespace: "default", Name: "se-2"}: {},
		{Namespace: "default", Name: "se-4"}: {},
		{Namespace: "default", Name: "se-5"}: {},
	}

	expectedUnselected := map[types.NamespacedName]*config.Config{
		{Namespace: "default", Name: "se-1"}: {},
		{Namespace: "default", Name: "se-3"}: {},
	}