writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(apiErrCode), r.URL)
		return
	}

	cfgData := ""
	{
		tgtSuffix := ""
		if cfgTarget != madmin.Default {
			tgtSuffix = config.SubSystemSeparator + cfgTarget
		}
		cfgData = subSys + tgtSuffix + config.KvSpaceSeparator + string(reqBytes)
	}

	cfg, err := readServerConfig(ctx, objectAPI, nil)
	if err != nil {

		// Form empty ILM details with `ExpiryUpdatedAt` field and save
		var cfgData []byte
		if expiryRuleRemoved {
			var lcCfg lifecycle.Lifecycle
			currtime := time.Now()
			lcCfg.ExpiryUpdatedAt = &currtime
			cfgData, err = xml.Marshal(lcCfg)
			if err != nil {
				return updatedAt, err
			}
		}
		return sys.updateAndParse(ctx, bucket, configFile, cfgData, false)
	}

	flags := &diffFlags{
		cfgPath: "",
		out:     io.Discard,
	}

	testCases := []struct {
		name            string
		args            []string
		setManifestPath bool
		manifestPath    string
		cfgPath         string
		expectedError   bool
	}{
		{
			name:            "valid: run diff with empty config path on valid manifest path",
			cfgPath:         "",
			setManifestPath: true,

	tests := []struct {
		name         string
		cfgPath      string
		fileContents string
		want         *kubeadmapi.UpgradeConfiguration
		wantErr      bool
	}{
		{
			name:    "Config file does not exists",
			cfgPath: "tmp",
			want:    nil,
			wantErr: true,
		},
		{
			name:         "Config file format is basic text",
			cfgPath:      filePath,
			want:         nil,

		return "", err
	}
	buf.Write(data)
	buf.WriteString("---\n")
	data, err = yaml.Marshal(&clusterCfg)
	if err != nil {
		return "", err
	}
	buf.Write(data)

	err = os.WriteFile(cfgPath, buf.Bytes(), 0644)
	return cfgPath, err
}

func TestKubeConfigSubCommandsThatWritesToOut(t *testing.T) {

	// Temporary folders for the test case
	tmpdir := testutil.SetupTempDir(t)
	defer os.RemoveAll(tmpdir)

			- %s
		`), kubeadmapiv1old.SchemeGroupVersion),
		RunE: func(cmd *cobra.Command, args []string) error {
			if len(cfgPath) == 0 {
				return errors.Errorf("the --%s flag is mandatory", options.CfgPath)
			}

			cfgBytes, err := os.ReadFile(cfgPath)
			if err != nil {
				return err
			}

			if err := configutil.ValidateConfig(cfgBytes, allowExperimental); err != nil {
				return err

}

// AddConfigFlag adds the --config flag to the given flagset
func AddConfigFlag(fs *pflag.FlagSet, cfgPath *string) {
	fs.StringVar(cfgPath, CfgPath, *cfgPath, "Path to a kubeadm configuration file.")
}

// AddIgnorePreflightErrorsFlag adds the --ignore-preflight-errors flag to the given flagset

	outputFlags.AddFlags(cmd)
	return cmd
}

type expirationFlags struct {
	cfgPath        string
	kubeconfigPath string
	cfg            kubeadmapiv1.ClusterConfiguration
}

func addExpirationFlags(cmd *cobra.Command, flags *expirationFlags) {
	options.AddConfigFlag(cmd.Flags(), &flags.cfgPath)
	options.AddCertificateDirFlag(cmd.Flags(), &flags.cfg.CertificatesDir)

			options.APIServerAdvertiseAddress,
			options.CfgPath,
			options.ControlPlane,
			options.NodeName,
			options.FileDiscovery,
			options.TokenDiscovery,
			options.TokenDiscoveryCAHash,
			options.TokenDiscoverySkipCAHash,
			options.TLSBootstrapToken,
			options.TokenStr,
			options.DryRun,
		}
	case "kubeconfig":
		flags = []string{
			options.CfgPath,
			options.ControlPlane,
			options.FileDiscovery,

func newCmdUserKubeConfig(out io.Writer) *cobra.Command {

	initCfg := &kubeadmapiv1.InitConfiguration{}
	clusterCfg := &kubeadmapiv1.ClusterConfiguration{}

	var (
		token, clientName, cfgPath string
		organizations              []string
		validityPeriod             time.Duration
	)

	// Creates the UX Command
	cmd := &cobra.Command{
		Use:     "user",