add support for parameter modes

examples/suite_demo/parameters_test.go

@@ -61,6 +61,29 @@ func (s *ParametersDemoSuite) TestAddParameterToNestedStep(t provider.T) {
 	})
 }
 
+func (s *ParametersDemoSuite) TestSetParameterMode(t provider.T) {
+	t.Epic("Demo")
+	t.Feature("Parameters")
+	t.Title("Set Parameters mode")
+	t.Description(`
+		Step A will contain following parameters:
+			Param1 = Val1
+			Param2 = Val2 (hidden)
+			Param3 = Val3 (masked)`)
+
+	t.Tags("Steps", "Mode", "Parameters")
+
+	step := allure.NewSimpleStep("Step A")
+
+	// with step.WithParameters(s) function
+	step.WithParameters(allure.NewParameter("Param1", "Val1"))
+	step.WithParameters(allure.NewParameter("Param2", "Val2").Hidden())
+	step.WithParameters(allure.NewParameter("Param3", "Val3").Masked())
+
+	// don't forget register your step :)
+	t.Step(step)
+}
+
 func TestParameters(t *testing.T) {
 	t.Parallel()
 	suite.RunSuite(t, new(ParametersDemoSuite))

pkg/allure/parameter.go

@@ -15,9 +15,18 @@ import (
 // (for example - request host or server address)
 type Parameter struct {
 	Name  string      `json:"name"`
+	Mode  Mode        `json:"mode,omitempty"`
 	Value interface{} `json:"value"`
 }
 
+// Parameter's Mode constants
+type Mode string
+
+const (
+	Hidden Mode = "hidden"
+	Masked Mode = "masked"
+)
+
 // NewParameter Constructor. Builds and returns a new `Parameter` object,
 // using `name` as the parameter name and `value`, as the value.
 func NewParameter(name string, value ...interface{}) *Parameter {
@@ -59,6 +68,22 @@ func (p *Parameter) GetValue() string {
 	return unquoted
 }
 
+// Hidden marks the parameter as hidden in the Allure report.
+// Use this for internal metadata that should exist in the result file
+// but remain invisible to the reader in the Allure UI.
+func (p *Parameter) Hidden() *Parameter {
+	p.Mode = Hidden
+	return p
+}
+
+// Masked marks the parameter as masked in the Allure report.
+// Use this for sensitive data like passwords, API keys, or PII to ensure
+// the values are obscured in the UI and report exports.
+func (p *Parameter) Masked() *Parameter {
+	p.Mode = Masked
+	return p
+}
+
 // TODO: remove this in v2
 //
 // See explanation in [Parameter.UnmarshalJSON]
@@ -171,6 +196,7 @@ func (p *Parameter) UnmarshalJSON(data []byte) error {
 	var aux struct {
 		Name  string         `json:"name"`
 		Value parameterValue `json:"value"`
+		Mode  Mode           `json:"mode"`
 	}
 
 	if err := json.Unmarshal(data, &aux); err != nil {
@@ -180,6 +206,7 @@ func (p *Parameter) UnmarshalJSON(data []byte) error {
 	*p = Parameter{
 		Name:  aux.Name,
 		Value: aux.Value.Inner(),
+		Mode:  aux.Mode,
 	}
 
 	return nil
@@ -210,9 +237,11 @@ func (p *Parameter) MarshalJSON() ([]byte, error) {
 
 	aux := struct {
 		Name  string          `json:"name"`
+		Mode  Mode            `json:"mode,omitempty"`
 		Value json.RawMessage `json:"value"`
 	}{
 		Name:  p.Name,
+		Mode:  p.Mode,
 		Value: raw,
 	}
 

pkg/allure/parameter_test.go

@@ -136,3 +136,26 @@ func TestParameterUnmarshal(t *testing.T) {
 		require.Equal(t, "map[a:[1 true 3.14]]", param.GetValue())
 	})
 }
+
+func TestParameterMode(t *testing.T) {
+	const paramName = "paramName"
+	paramValue := "paramValue"
+
+	param := NewParameter(paramName, paramValue)
+	require.NotNil(t, param)
+	require.Equal(t, paramName, param.Name)
+	require.Equal(t, string(paramValue), param.GetValue())
+	require.Empty(t, param.Mode)
+
+	param = NewParameter(paramName, paramValue).Hidden()
+	require.NotNil(t, param)
+	require.Equal(t, paramName, param.Name)
+	require.Equal(t, string(paramValue), param.GetValue())
+	require.Equal(t, Hidden, param.Mode)
+
+	param = NewParameter(paramName, paramValue).Masked()
+	require.NotNil(t, param)
+	require.Equal(t, paramName, param.Name)
+	require.Equal(t, string(paramValue), param.GetValue())
+	require.Equal(t, Masked, param.Mode)
+}

pkg/allure/step_test.go

@@ -17,8 +17,8 @@ func TestNewStep(t *testing.T) {
 	stepStart := time.Now().UnixNano() / int64(time.Millisecond)
 	stepStop := time.Now().UnixNano()/int64(time.Millisecond) + 1
 	parameters := []*Parameter{
-		{"Param1", []byte("val1")},
-		{"Param2", []byte("val2")},
+		{"Param1", "", []byte("val1")},
+		{"Param2", "", []byte("val2")},
 	}
 	step := NewStep(stepName, stepStatus, stepStart, stepStop, parameters)
 	assert.Equal(t, stepName, step.Name)