Counter support (#129)

* TDD add counter config

* add counter config

* counter config implemntation

* add docs for counter config and improve docs

* cr fixes

* cr fix

Author: Andrea Spacca

docs/fields-configuration.md

@@ -10,11 +10,12 @@ The config file is a yaml file consisting of root level `fields` object that's a
 
 For each config entry the following fields are available:
 - `name` *mandatory*: dotted path field, matching an entry in [Fields definition](./glossary.md#fields-definition)
-- `fuzziness` *optional (`long` and `double` type only)*: when generating data you could want generated values to change in a known interval. Fuzziness allow to specify the maximum delta a generated value can have from the previous value (for the same field), as a delta percentage; value must be between 0.0 and 1.0, where 0 is 0% and 1 is 100%. When not specified there is no constraint on the generated values, boundaries will be defined by the underlying field type
-- `range` *optional (`long` and `double` type only)*: value will be generated between `min` and `max`
+- `fuzziness` *optional (`long` and `double` type only)*: when generating data you could want generated values to change in a known interval. Fuzziness allow to specify the maximum delta a generated value can have from the previous value (for the same field), as a delta percentage that will be applied below and above the previous value; value must be between 0.0 and 1.0, where 0 is 0% and 1 is 100%. When not specified there is no constraint on the generated values, boundaries will be defined by the underlying field type. For example, `fuzziness: 0.1`, assuming a `double` field type and with first value generated `10.`, will generate the second value in the range between `9.` and `11.`. Assuming the second value generated will be `10.5`, the third one will be generated in the range between `9.45` and `11.55`, and so on.
+- `range` *optional (`long` and `double` type only)*: value will be generated between `min` and `max`. If `fuzziness` is defined, the value will be generated within a delta defined by `fuzziness` from the previous value. In any case (`fuzziness` or not) the value would not escape the `min`/`max` bounds.
 - `range` *optional (`date` type only)*: value will be generated between `from` and `to`. Only one between `from` and `to` can be set, in this case the dates will be generated between `from`/`to` and `time.Now()`. Progressive order of the generated dates is always assured regardless the interval involving `from`, `to` and `time.Now()` is positive or negative. If both at least one of `from` or `to` and `period` settings are defined an error will be returned and the generator will stop. The format of the date must be parsable by the following golang date format: `2006-01-02T15:04:05.999999999-07:00`. 
-- `cardinality` *optional*: number of different values for the field; note that this value may not be respected if not enough events are generated. Es `cardinality: 1000` with `100` generated events would produce `100` different values, not `1000`.
-- `period` *optional (`date` type only)*: values will be evenly generated between `time.Now()` and `time.Now().Add(period)`, where period is expressed as `time.Duration`. It accepts also a negative duration: in this case  values will be evenly generated between `time.Now().Add(period)` and `time.Now()`. If both `period` and at least one of `from` or `to` settings are defined an error will be returned and the generator will stop.
+- `cardinality` *optional*: exact number of different values to generate for the field; note that this setting may not be respected if not enough events are generated. For example, `cardinality: 1000` with `100` generated events would produce `100` different values, not `1000`. Similarly, the setting may not be respected if other settings prevents it. For example, `cardinality: 10` with an `enum` list of only 5 strings would produce `5` different values, not `10`. Or `cardinality: 10` for a `long` with `range.min: 1` and `range.max: 5` would produce `5` different values, not `10`. 
+- `counter` *optional (`long` and  `double` type only)*: if set to `true` values will be generated only ever-increasing. If `fuzziness` is not defined, the positive delta from the previous value will be totally random and unbounded. For example, assuming `counter: true`, assuming a `int` field type and with first value generated `10.`, will generate the second value with any random value greater than `10`, like `11` or `987615243`. If `fuzziness` is defined, the value will be generated within a positive delta defined by `fuzziness` from the previous value. For example, `fuzziness: 0.1`, assuming `counter: true` , assuming a `double` field type and with first value generated `10.`, will generate the second value in the range between `10.` and `11.`. Assuming the second value generated will be `10.5`, the third one will be generated in the range between `10.5` and `11.55`, and so on. If both `counter: true` and at least one of `range.min` or `range.max` settings are defined an error will be returned and the generator will stop.
+- `period` *optional (`date` type only)*: values will be evenly generated between `time.Now()` and `time.Now().Add(period)`, where period is expressed as `time.Duration`. It accepts also a negative duration: in this case  values will be evenly generated between `time.Now().Add(period)` and `time.Now()`. If both `period` and at least one of `range.from` or `range.to` settings are defined an error will be returned and the generator will stop.
 - `object_keys` *optional (`object` type only)*: list of field names to generate in a object field type; if not specified a random number of field names will be generated in the object filed type
 - `value` *optional*: hardcoded value to set for the field (any `cardinality` will be ignored)
 - `enum` *optional (`keyword` type only)*: list of strings to randomly chose from a value to set for the field (any `cardinality` will be applied limited to the size of the `enum` values)

pkg/genlib/config/config.go

@@ -14,6 +14,7 @@ import (
 var rangeBoundNotSet = errors.New("range bound not set")
 var rangeTimeNotSet = errors.New("range time not set")
 var rangeInvalidConfig = errors.New("range defining both `period` and `from`/`to`")
+var counterInvalidConfig = errors.New("both `range` and `counter` defined")
 
 type TimeRange struct {
 	time.Time
@@ -46,6 +47,7 @@ type ConfigField struct {
 	Enum        []string      `config:"enum"`
 	ObjectKeys  []string      `config:"object_keys"`
 	Value       any           `config:"value"`
+	Counter     bool          `config:"counter"`
 }
 
 func (cf ConfigField) ValidForDateField() error {
@@ -56,6 +58,14 @@ func (cf ConfigField) ValidForDateField() error {
 	return nil
 }
 
+func (cf ConfigField) ValidCounter() error {
+	if cf.Counter && (cf.Range.Min != nil || cf.Range.Max != nil) {
+		return counterInvalidConfig
+	}
+
+	return nil
+}
+
 func (r Range) FromAsTime() (time.Time, error) {
 	if r.From == nil {
 		return time.Time{}, rangeTimeNotSet

pkg/genlib/config/config_test.go

@@ -160,6 +160,93 @@ func TestIsValidForDateField(t *testing.T) {
 	}
 }
 
+func TestIsValidCounter(t *testing.T) {
+	testCases := []struct {
+		scenario string
+		config   string
+		hasError bool
+	}{
+		{
+			scenario: "no range, no counter",
+			config:   "name: field",
+			hasError: false,
+		},
+		{
+			scenario: "range with both min and max, no counter",
+			config:   "name: field\nrange:\n  min: 1\n  max: 10",
+			hasError: false,
+		},
+		{
+			scenario: "range with min and no max, no counter",
+			config:   "name: field\nrange:\n  min: 1",
+			hasError: false,
+		},
+		{
+			scenario: "range with max and no min, no counter",
+			config:   "name: field\nrange:\n  max: 10",
+			hasError: false,
+		},
+		{
+			scenario: "with counter, no range",
+			config:   "name: field\ncounter: true",
+			hasError: false,
+		},
+		{
+			scenario: "range with both min and max, with counter",
+			config:   "name: field\nrange:\n  min: 1\n  max: 10\ncounter: true",
+			hasError: true,
+		},
+		{
+			scenario: "range with min and no max, with counter",
+			config:   "name: field\nrange:\n  min: 1\ncounter: true",
+			hasError: true,
+		},
+		{
+			scenario: "range with max and no min, with counter",
+			config:   "name: field\nrange:\n  max: 10\ncounter: true",
+			hasError: true,
+		},
+		{
+			scenario: "range with both min and max, with counter:false",
+			config:   "name: field\nrange:\n  min: 1\n  max: 10\ncounter: false",
+			hasError: false,
+		},
+		{
+			scenario: "range with min and no max, with counter:false",
+			config:   "name: field\nrange:\n  min: 1\ncounter: false",
+			hasError: false,
+		},
+		{
+			scenario: "range with max and no min, with counter:false",
+			config:   "name: field\nrange:\n  max: 10\ncounter: false",
+			hasError: false,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.scenario, func(t *testing.T) {
+			cfg, err := yaml.NewConfig([]byte(testCase.config))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var config ConfigField
+			err = cfg.Unpack(&config)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = config.ValidCounter()
+			if testCase.hasError && err == nil {
+
+			}
+
+			if !testCase.hasError && err != nil {
+
+			}
+		})
+	}
+}
+
 func TestRange_MaxAsFloat64(t *testing.T) {
 	testCases := []struct {
 		scenario  string

pkg/genlib/generator_interface.go

@@ -567,7 +567,48 @@ func fuzzyInt(previous int64, fuzziness, min, max float64) int64 {
 	return customRand.Int63n(int64(math.Ceil(higherBound-lowerBound))) + int64(lowerBound)
 }
 
+func fuzzyIntCounter(previous int64, fuzziness float64) int64 {
+	lowerBound := float64(previous)
+	higherBound := float64(previous) * (1 + fuzziness)
+	return customRand.Int63n(int64(math.Ceil(higherBound-lowerBound))) + int64(lowerBound)
+}
+
 func bindLong(fieldCfg ConfigField, field Field, fieldMap map[string]any) error {
+	if err := fieldCfg.ValidCounter(); err != nil {
+		return err
+	}
+
+	if fieldCfg.Counter {
+		var emitFNotReturn emitFNotReturn
+		emitFNotReturn = func(state *genState, buf *bytes.Buffer) error {
+			previous := int64(1)
+			var dummyInt int64
+			var dummyFunc func() int64
+
+			if previousDummyInt, ok := state.prevCache[field.Name].(int64); ok {
+				previous = previousDummyInt
+			}
+
+			if fieldCfg.Fuzziness <= 0 {
+				dummyFunc = makeIntCounterFunc(previous, field)
+
+				dummyInt = dummyFunc()
+			} else {
+				dummyInt = fuzzyIntCounter(previous, fieldCfg.Fuzziness)
+			}
+
+			state.prevCache[field.Name] = dummyInt
+			v := make([]byte, 0, 32)
+			v = strconv.AppendInt(v, dummyInt, 10)
+			buf.Write(v)
+			return nil
+		}
+
+		fieldMap[field.Name] = emitFNotReturn
+
+		return nil
+	}
+
 	dummyFunc := makeIntFunc(fieldCfg, field)
 
 	if fieldCfg.Fuzziness <= 0 {
@@ -617,7 +658,46 @@ func fuzzyFloat(previous, fuzziness, min, max float64) float64 {
 	return lowerBound + customRand.Float64()*(higherBound-lowerBound)
 }
 
+func fuzzyFloatCounter(previous, fuzziness float64) float64 {
+	lowerBound := previous
+	higherBound := previous * (1 + fuzziness)
+	return lowerBound + customRand.Float64()*(higherBound-lowerBound)
+}
+
 func bindDouble(fieldCfg ConfigField, field Field, fieldMap map[string]any) error {
+	if err := fieldCfg.ValidCounter(); err != nil {
+		return err
+	}
+
+	if fieldCfg.Counter {
+		var emitFNotReturn emitFNotReturn
+		emitFNotReturn = func(state *genState, buf *bytes.Buffer) error {
+			previous := float64(1)
+			var dummyFloat float64
+			var dummyFunc func() float64
+
+			if previousDummyFloat, ok := state.prevCache[field.Name].(float64); ok {
+				previous = previousDummyFloat
+			}
+
+			if fieldCfg.Fuzziness <= 0 {
+				dummyFunc = makeFloatCounterFunc(previous, field)
+
+				dummyFloat = dummyFunc()
+			} else {
+				dummyFloat = fuzzyFloatCounter(previous, fieldCfg.Fuzziness)
+			}
+
+			state.prevCache[field.Name] = dummyFloat
+			_, err := fmt.Fprintf(buf, "%f", dummyFloat)
+			return err
+		}
+
+		fieldMap[field.Name] = emitFNotReturn
+
+		return nil
+	}
+
 	dummyFunc := makeFloatFunc(fieldCfg, field)
 
 	if fieldCfg.Fuzziness <= 0 {
@@ -886,6 +966,39 @@ func randIP() (int, int, int, int) {
 	return i0, i1, i2, i3
 }
 func bindLongWithReturn(fieldCfg ConfigField, field Field, fieldMap map[string]any) error {
+	if err := fieldCfg.ValidCounter(); err != nil {
+		return err
+	}
+
+	if fieldCfg.Counter {
+		var emitF emitF
+
+		emitF = func(state *genState) any {
+			previous := int64(1)
+			var dummyInt int64
+			var dummyFunc func() int64
+
+			if previousDummyInt, ok := state.prevCache[field.Name].(int64); ok {
+				previous = previousDummyInt
+			}
+
+			if fieldCfg.Fuzziness <= 0 {
+				dummyFunc = makeIntCounterFunc(previous, field)
+
+				dummyInt = dummyFunc()
+			} else {
+				dummyInt = fuzzyIntCounter(previous, fieldCfg.Fuzziness)
+			}
+
+			state.prevCache[field.Name] = dummyInt
+			return dummyInt
+		}
+
+		fieldMap[field.Name] = emitF
+
+		return nil
+	}
+
 	dummyFunc := makeIntFunc(fieldCfg, field)
 
 	if fieldCfg.Fuzziness <= 0 {
@@ -920,7 +1033,74 @@ func bindLongWithReturn(fieldCfg ConfigField, field Field, fieldMap map[string]a
 	return nil
 }
 
+func makeIntCounterFunc(previousDummyInt int64, field Field) func() int64 {
+	var dummyFunc func() int64
+
+	switch {
+	case len(field.Example) == 0:
+		dummyFunc = func() int64 { return previousDummyInt + customRand.Int63n(10) }
+	default:
+		totDigit := len(field.Example)
+		max := int64(math.Pow10(totDigit))
+		dummyFunc = func() int64 {
+			return previousDummyInt + customRand.Int63n(max)
+		}
+	}
+
+	return dummyFunc
+}
+
+func makeFloatCounterFunc(previousDummyFloat float64, field Field) func() float64 {
+	var dummyFunc func() float64
+
+	switch {
+	case len(field.Example) == 0:
+		dummyFunc = func() float64 { return previousDummyFloat + customRand.Float64()*10 }
+	default:
+		totDigit := len(field.Example)
+		max := math.Pow10(totDigit)
+		dummyFunc = func() float64 {
+			return previousDummyFloat + customRand.Float64()*max
+		}
+	}
+
+	return dummyFunc
+}
+
 func bindDoubleWithReturn(fieldCfg ConfigField, field Field, fieldMap map[string]any) error {
+	if err := fieldCfg.ValidCounter(); err != nil {
+		return err
+	}
+
+	if fieldCfg.Counter {
+		var emitF emitF
+
+		emitF = func(state *genState) any {
+			previous := float64(1)
+			var dummyFloat float64
+			var dummyFunc func() float64
+
+			if previousDummyFloat, ok := state.prevCache[field.Name].(float64); ok {
+				previous = previousDummyFloat
+			}
+
+			if fieldCfg.Fuzziness <= 0 {
+				dummyFunc = makeFloatCounterFunc(previous, field)
+
+				dummyFloat = dummyFunc()
+			} else {
+				dummyFloat = fuzzyFloatCounter(previous, fieldCfg.Fuzziness)
+			}
+
+			state.prevCache[field.Name] = dummyFloat
+			return dummyFloat
+		}
+
+		fieldMap[field.Name] = emitF
+
+		return nil
+	}
+
 	dummyFunc := makeFloatFunc(fieldCfg, field)
 
 	if fieldCfg.Fuzziness <= 0 {