Revision: "default",
	}

	_, err := Generate(context.TODO(), fakeClient, opts, "istio-system")
	assert.NoError(t, err)

	wh, err := fakeClient.Kube().AdmissionregistrationV1().MutatingWebhookConfigurations().
		Get(context.Background(), "istio-sidecar-injector", metav1.GetOptions{})
	assert.NoError(t, err)

	assertFunc(t, wh.Webhooks, defaultWh.Webhooks)
}

func TestGenerateOptions(t *testing.T) {

				t.Errorf("wanted %v configs loaded in got %v", tt.wantConfigs, len(cw.ztunnelDump.Workloads))
			}
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestConfigWriter_PrintSecretSummary(t *testing.T) {
	tests := []struct {
		name               string
		wantOutputSecret   string
		wantOutputWorkload string

			if err := cw.Prime(cd); err != nil {
				t.Errorf("failed to parse config dump: %s", err)
			}
			err := cw.PrintRouteSummary(RouteFilter{Verbose: true})
			assert.NoError(t, err)

			wantOutputFile := path.Join("testdata/routes", tt.name, "output.txt")
			util.CompareContent(t, gotOut.Bytes(), wantOutputFile)
		})
	}

			for key, ss := range tt.input {
				input[key] = ss
			}

			err := sw.PrintAll(input)
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
			want, _ := os.ReadFile(tt.want)
			if err := util.Compare(got.Bytes(), want); err != nil {
				t.Errorf(err.Error())
			}
		})
	}
}

	}
	for _, tt := range tests {
		t.Run(strings.Split(tt.name, ".")[0], func(t *testing.T) {
			gotPodName, gotNamespace, err := InferPodInfoFromTypedResource(tt.name, "test", factory)
			assert.NoError(t, err)
			if gotPodName != tt.wantPodName || gotNamespace != tt.wantNamespace {
				t.Errorf("unexpected podName and namespace: wanted %v %v got %v %v", tt.wantPodName, tt.wantNamespace, gotPodName, gotNamespace)
			}
		})

				return nil, nil
			}
			rootCmd := GetRootCmd(cli.NewFakeContext(&cli.NewFakeContextOption{
				Version: "25",
			}), args)
			err := rootCmd.Execute()
			assert.NoError(t, err)

			readActions := map[string]bool{
				"get":   true,
				"list":  true,
				"watch": true,
			}

			actions := extendedClient.Kube().(*fake.Clientset).Actions()

		Namespace: "default",
	}))
	cmd.SetArgs([]string{
		"all",
		"-f", "testdata/config_dump.json",
	})
	out := bytes.Buffer{}
	cmd.SetOut(&out)
	assert.NoError(t, cmd.Execute())
	expected := util.ReadFile(t, "testdata/config_dump_summary.txt")

	if err := assert.Compare(out.String(), string(expected)); err != nil {

	ctx := cli.NewFakeContext(&cli.NewFakeContextOption{
		Namespace:      c.namespace,
		IstioNamespace: c.istioNamespace,
		Results:        c.configDumps,
	})
	client, err := ctx.CLIClient()
	assert.NoError(t, err)
	// Override the Istio config factory
	for i := range c.istioConfigs {
		switch t := c.istioConfigs[i].(type) {
		case *v1alpha3.DestinationRule:

	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		defer req.Body.Close()
		data, err := io.ReadAll(req.Body)
		assert.NoError(t, err)

		var msg nodeagent.CNIPluginAddEvent
		err = json.Unmarshal(data, &msg)
		assert.NoError(t, err)
		assert.Equal(t, msg.PodName, testPod)
		assert.Equal(t, msg.PodNamespace, testNS)
		assert.Equal(t, msg.Netns, fakeCmdArgs.Netns)

	if err != nil {
		t.Errorf("error reading test data output file: %v", err)
	}

	gotOut := &bytes.Buffer{}
	cw := &ConfigWriter{Stdout: gotOut}
	err = cw.Prime(configDump)
	assert.NoError(t, err)
	err = cw.PrintSecretSummary()
	assert.NoError(t, err)

	assert.Equal(t, string(expectedOut), gotOut.String())