BUG/MEDIUM: healthcheck: keep the type when no parameters are given

SerializeHealthCheckSection removed the "type" line when a healthcheck
of type httpchk, smtpchk, mysql-check or pgsql-check came without its
parameters, so the section was written without a type. The next write
of that section then reached the default branch, which unset a plain
"type" attribute no parser registers and failed with "attribute not
found".

Build the type line before touching the section. httpchk, smtpchk and
mysql-check parameters are optional in HAProxy and the bare
"type <check>" line is written when they are missing. pgsql-check
requires a user and is rejected with a validation error, as is an
unknown type. An empty type only removes the existing type line.
Serializer errors go through HandleError so implicit transactions are
cleaned up.

Add the bare "type httpchk" form to the parser tests.

Author: mjuraga

config-parser/tests/integration/healthcheck_data_test.go

@@ -984,6 +984,7 @@ type OptionHttpchk struct {
 //name:type httpchk
 //no:parse
 //test:ok:type httpchk OPTIONS * HTTP/1.1\\r\\nHost:\\ www
+//test:ok:type httpchk
 //test:ok:type httpchk <uri>
 //test:ok:type httpchk <method> <uri>
 //test:ok:type httpchk <method> <uri> <version>

config-parser/tests/integration/healthcheck_test.go

@@ -21,6 +21,7 @@ import (
 
 	strfmt "github.com/go-openapi/strfmt"
 	parser "github.com/haproxytech/client-native/v6/config-parser"
+	"github.com/haproxytech/client-native/v6/config-parser/common"
 	parsererrors "github.com/haproxytech/client-native/v6/config-parser/errors"
 	"github.com/haproxytech/client-native/v6/config-parser/types"
 	"github.com/haproxytech/client-native/v6/misc"
@@ -256,7 +257,7 @@ func (c *client) CreateHealthcheck(data *models.HealthCheck, transactionID strin
 	}
 
 	if err = SerializeHealthCheckSection(p, data); err != nil {
-		return err
+		return c.HandleError(data.Name, "", "", t, transactionID == "", err)
 	}
 
 	return c.SaveData(p, t, transactionID == "")
@@ -282,7 +283,7 @@ func (c *client) EditHealthcheck(name string, data *models.HealthCheck, transact
 	}
 
 	if err = SerializeHealthCheckSection(p, data); err != nil {
-		return err
+		return c.HandleError(data.Name, "", "", t, transactionID == "", err)
 	}
 
 	return c.SaveData(p, t, transactionID == "")
@@ -329,103 +330,65 @@ func clearAllTypes(p parser.Parser, data *models.HealthCheck) error {
 	return nil
 }
 
-func SerializeHealthCheckSection(p parser.Parser, data *models.HealthCheck) error { //nolint:gocognit
-	if data == nil {
-		return errors.New("empty health check")
-	}
-
-	var err error
-	err = clearAllTypes(p, data)
-	if err != nil {
-		return err
-	}
-
+// serializeHealthCheckType returns the parser attribute and value of the
+// "type" line of a health check, or an empty attribute when no type is set.
+// The parameters of httpchk, smtpchk and mysql-check are optional in HAProxy
+// and the bare "type <check>" line is written when they are not given, while
+// pgsql-check requires a user.
+func serializeHealthCheckType(data *models.HealthCheck) (string, common.ParserData, error) {
 	switch data.Type {
+	case "":
+		return "", nil, nil
 	case "smtpchk":
+		smtpchk := types.TypeSmtpchk{}
 		if data.SmtpchkParams != nil {
-			smtpchck := types.TypeSmtpchk{
-				Domain: data.SmtpchkParams.Domain,
-				Hello:  data.SmtpchkParams.Hello,
-				NoType: false,
-			}
-			if err := p.Set(parser.HealthChecks, data.Name, "type smtpchk", smtpchck); err != nil {
-				return err
-			}
-		} else {
-			if err = p.Set(parser.HealthChecks, data.Name, "type smtpchk", nil); err != nil {
-				return err
-			}
+			smtpchk.Domain = data.SmtpchkParams.Domain
+			smtpchk.Hello = data.SmtpchkParams.Hello
 		}
+		return "type smtpchk", smtpchk, nil
 	case "mysql-check":
+		mysqlchk := types.TypeMysqlCheck{}
 		if data.MysqlCheckParams != nil {
-			mysqlchk := types.TypeMysqlCheck{
-				ClientVersion: data.MysqlCheckParams.ClientVersion,
-				User:          data.MysqlCheckParams.Username,
-				NoType:        false,
-			}
-			if err := p.Set(parser.HealthChecks, data.Name, "type mysql-check", mysqlchk); err != nil {
-				return err
-			}
-		} else {
-			if err = p.Set(parser.HealthChecks, data.Name, "type mysql-check", nil); err != nil {
-				return err
-			}
+			mysqlchk.ClientVersion = data.MysqlCheckParams.ClientVersion
+			mysqlchk.User = data.MysqlCheckParams.Username
 		}
+		return "type mysql-check", mysqlchk, nil
 	case "pgsql-check":
-		if data.PgsqlCheckParams != nil {
-			pgsqlchk := types.TypePgsqlCheck{
-				User:   data.PgsqlCheckParams.Username,
-				NoType: false,
-			}
-			if err := p.Set(parser.HealthChecks, data.Name, "type pgsql-check", pgsqlchk); err != nil {
-				return err
-			}
-		} else {
-			if err = p.Set(parser.HealthChecks, data.Name, "type pgsql-check", nil); err != nil {
-				return err
-			}
+		if data.PgsqlCheckParams == nil || data.PgsqlCheckParams.Username == "" {
+			return "", nil, NewConfError(ErrValidationError, "pgsql_check_params.username is mandatory with type pgsql-check")
 		}
+		return "type pgsql-check", types.TypePgsqlCheck{User: data.PgsqlCheckParams.Username}, nil
 	case "httpchk":
+		httpchk := types.TypeHttpchk{}
 		if data.HttpchkParams != nil {
-			httpchk := types.TypeHttpchk{
-				Method:  data.HttpchkParams.Method,
-				URI:     data.HttpchkParams.URI,
-				Version: data.HttpchkParams.Version,
-				NoType:  false,
-			}
-			if err := p.Set(parser.HealthChecks, data.Name, "type httpchk", httpchk); err != nil {
-				return err
-			}
-		} else {
-			if err = p.Set(parser.HealthChecks, data.Name, "type httpchk", nil); err != nil {
-				return err
-			}
-		}
-	case "ssl-hello-chk":
-		if err = p.Set(parser.HealthChecks, data.Name, "type ssl-hello-chk", &types.SimpleType{}); err != nil {
-			return err
-		}
-	case "redis-check":
-		if err = p.Set(parser.HealthChecks, data.Name, "type redis-check", &types.SimpleType{}); err != nil {
-			return err
-		}
-	case "ldap-check":
-		if err = p.Set(parser.HealthChecks, data.Name, "type ldap-check", &types.SimpleType{}); err != nil {
-			return err
-		}
-	case "spop-check":
-		if err = p.Set(parser.HealthChecks, data.Name, "type spop-check", &types.SimpleType{}); err != nil {
-			return err
-		}
-	case "tcp-check":
-		if err = p.Set(parser.HealthChecks, data.Name, "type tcp-check", &types.SimpleType{}); err != nil {
-			return err
+			httpchk.Method = data.HttpchkParams.Method
+			httpchk.URI = data.HttpchkParams.URI
+			httpchk.Version = data.HttpchkParams.Version
 		}
+		return "type httpchk", httpchk, nil
+	case "ssl-hello-chk", "redis-check", "ldap-check", "spop-check", "tcp-check":
+		return "type " + data.Type, &types.SimpleType{}, nil
 	default:
-		if err = p.Set(parser.HealthChecks, data.Name, "type", nil); err != nil {
-			return err
-		}
+		return "", nil, NewConfError(ErrValidationError, "unknown health check type "+data.Type)
 	}
+}
 
-	return nil
+func SerializeHealthCheckSection(p parser.Parser, data *models.HealthCheck) error {
+	if data == nil {
+		return errors.New("empty health check")
+	}
+
+	// validate before touching the section so that a rejected type leaves
+	// the existing configuration intact
+	attribute, value, err := serializeHealthCheckType(data)
+	if err != nil {
+		return err
+	}
+	if err = clearAllTypes(p, data); err != nil {
+		return err
+	}
+	if attribute == "" {
+		return nil
+	}
+	return p.Set(parser.HealthChecks, data.Name, attribute, value)
 }

config-parser/tests/type-httpchk_generated_test.go

@@ -0,0 +1,86 @@
+// Copyright 2026 HAProxy Technologies
+//
+// 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.
+//
+
+package configuration
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	parser "github.com/haproxytech/client-native/v6/config-parser"
+	"github.com/haproxytech/client-native/v6/config-parser/options"
+	"github.com/haproxytech/client-native/v6/models"
+)
+
+func newHealthCheckParser(t *testing.T, config string) parser.Parser {
+	t.Helper()
+	p, err := parser.New(options.String(config))
+	require.NoError(t, err)
+	return p
+}
+
+// The check types whose parameters are optional in HAProxy must render the
+// bare "type <check>" line when no parameters are given, and that line must
+// be read back with the same type.
+func TestSerializeHealthCheckSectionTypeWithoutParams(t *testing.T) {
+	for _, typ := range []string{"httpchk", "smtpchk", "mysql-check"} {
+		t.Run(typ, func(t *testing.T) {
+			p := newHealthCheckParser(t, "healthcheck hc\n")
+			hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: "hc", Type: typ}}
+			require.NoError(t, SerializeHealthCheckSection(p, hc))
+
+			out := p.String()
+			require.Contains(t, out, "\n  type "+typ+"\n", out)
+
+			got := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: "hc"}}
+			require.NoError(t, ParseHealthcheckSection(newHealthCheckParser(t, out), got))
+			require.Equal(t, typ, got.Type)
+		})
+	}
+}
+
+// An empty type only removes the existing type line, it is not an error.
+func TestSerializeHealthCheckSectionEmptyType(t *testing.T) {
+	p := newHealthCheckParser(t, "healthcheck hc\n  type httpchk GET /\n")
+	hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: "hc"}}
+	require.NoError(t, SerializeHealthCheckSection(p, hc))
+	require.NotContains(t, p.String(), "type")
+}
+
+// pgsql-check has a mandatory user in HAProxy: a bare "type pgsql-check"
+// is rejected instead of being written to the configuration.
+func TestSerializeHealthCheckSectionPgsqlCheckRequiresUser(t *testing.T) {
+	for name, params := range map[string]*models.PgsqlCheckParams{
+		"nil params":     nil,
+		"empty username": {},
+	} {
+		t.Run(name, func(t *testing.T) {
+			p := newHealthCheckParser(t, "healthcheck hc\n")
+			hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{
+				Name: "hc", Type: "pgsql-check", PgsqlCheckParams: params,
+			}}
+			require.ErrorIs(t, SerializeHealthCheckSection(p, hc), ErrValidationError)
+			require.NotContains(t, p.String(), "type")
+		})
+	}
+}
+
+func TestSerializeHealthCheckSectionUnknownType(t *testing.T) {
+	p := newHealthCheckParser(t, "healthcheck hc\n")
+	hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: "hc", Type: "foo-check"}}
+	require.ErrorIs(t, SerializeHealthCheckSection(p, hc), ErrValidationError)
+	require.NotContains(t, p.String(), "type")
+}

config-parser/types/types.go

@@ -187,7 +187,7 @@ func serializeHealthcheckSection(a StructuredToParserArgs, h *models.HealthCheck
 		return err
 	}
 	if err = SerializeHealthCheckSection(p, h); err != nil {
-		return err
+		return a.HandleError(h.Name, "", "", a.TID, a.TID == "", err)
 	}
 
 	for i, httpCheck := range h.HTTPCheckList {

configuration/healthcheck.go

@@ -335,3 +335,44 @@ func TestCreateEditDeleteHealthcheck(t *testing.T) { //nolint:gocognit,gocyclo
 		})
 	}
 }
+
+// A type without parameters must survive a create followed by an edit: the
+// type line used to be dropped on create, leaving a section without a type,
+// and the following edit then failed with "attribute not found".
+func TestCreateEditHealthcheckTypeWithoutParams(t *testing.T) {
+	name := fmt.Sprintf("created_bare_type_%d", version)
+	hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: name, Type: "httpchk"}}
+
+	require.NoError(t, clientTest.CreateHealthcheck(hc, "", version))
+	version++
+
+	_, got, err := clientTest.GetHealthcheck(name, "")
+	require.NoError(t, err)
+	require.Equal(t, "httpchk", got.Type)
+	require.Equal(t, &models.HttpchkParams{}, got.HttpchkParams)
+
+	hc.Type = "smtpchk"
+	require.NoError(t, clientTest.EditHealthcheck(name, hc, "", version))
+	version++
+
+	_, got, err = clientTest.GetHealthcheck(name, "")
+	require.NoError(t, err)
+	require.Equal(t, "smtpchk", got.Type)
+	require.Nil(t, got.HttpchkParams)
+
+	require.NoError(t, clientTest.DeleteHealthcheck(name, "", version))
+	version++
+}
+
+func TestCreateHealthcheckPgsqlCheckWithoutUser(t *testing.T) {
+	name := fmt.Sprintf("created_pgsql_no_user_%d", version)
+	hc := &models.HealthCheck{HealthCheckBase: models.HealthCheckBase{Name: name, Type: "pgsql-check"}}
+
+	require.Error(t, clientTest.CreateHealthcheck(hc, "", version))
+
+	_, _, err := clientTest.GetHealthcheck(name, "")
+	require.Error(t, err)
+	v, err := clientTest.GetVersion("")
+	require.NoError(t, err)
+	require.Equal(t, version, v)
+}