How to use TestNewThreshold method of metrics Package

Best K6 code snippet using metrics.TestNewThreshold

thresholds_test.go

Source:thresholds_test.go

...28	"go.k6.io/k6/errext/exitcodes"29	"go.k6.io/k6/lib/types"30	"gopkg.in/guregu/null.v3"31)32func TestNewThreshold(t *testing.T) {33	t.Parallel()34	src := `rate<0.01`35	abortOnFail := false36	gracePeriod := types.NullDurationFrom(2 * time.Second)37	gotThreshold := newThreshold(src, abortOnFail, gracePeriod)38	assert.Equal(t, src, gotThreshold.Source)39	assert.False(t, gotThreshold.LastFailed)40	assert.Equal(t, abortOnFail, gotThreshold.AbortOnFail)41	assert.Equal(t, gracePeriod, gotThreshold.AbortGracePeriod)42	assert.Nil(t, gotThreshold.parsed)43}44func TestThreshold_runNoTaint(t *testing.T) {45	t.Parallel()46	tests := []struct {47		name             string48		parsed           *thresholdExpression49		abortGracePeriod types.NullDuration50		sinks            map[string]float6451		wantOk           bool52		wantErr          bool53	}{54		{55			name:             "valid expression using the > operator over passing threshold",56			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreater, 0.01},57			abortGracePeriod: types.NullDurationFrom(0 * time.Second),58			sinks:            map[string]float64{"rate": 1},59			wantOk:           true,60			wantErr:          false,61		},62		{63			name:             "valid expression using the > operator over passing threshold and defined abort grace period",64			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreater, 0.01},65			abortGracePeriod: types.NullDurationFrom(2 * time.Second),66			sinks:            map[string]float64{"rate": 1},67			wantOk:           true,68			wantErr:          false,69		},70		{71			name:             "valid expression using the >= operator over passing threshold",72			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreaterEqual, 0.01},73			abortGracePeriod: types.NullDurationFrom(0 * time.Second),74			sinks:            map[string]float64{"rate": 0.01},75			wantOk:           true,76			wantErr:          false,77		},78		{79			name:             "valid expression using the <= operator over passing threshold",80			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenLessEqual, 0.01},81			abortGracePeriod: types.NullDurationFrom(0 * time.Second),82			sinks:            map[string]float64{"rate": 0.01},83			wantOk:           true,84			wantErr:          false,85		},86		{87			name:             "valid expression using the < operator over passing threshold",88			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenLess, 0.01},89			abortGracePeriod: types.NullDurationFrom(0 * time.Second),90			sinks:            map[string]float64{"rate": 0.00001},91			wantOk:           true,92			wantErr:          false,93		},94		{95			name:             "valid expression using the == operator over passing threshold",96			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenLooselyEqual, 0.01},97			abortGracePeriod: types.NullDurationFrom(0 * time.Second),98			sinks:            map[string]float64{"rate": 0.01},99			wantOk:           true,100			wantErr:          false,101		},102		{103			name:             "valid expression using the === operator over passing threshold",104			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenStrictlyEqual, 0.01},105			abortGracePeriod: types.NullDurationFrom(0 * time.Second),106			sinks:            map[string]float64{"rate": 0.01},107			wantOk:           true,108			wantErr:          false,109		},110		{111			name:             "valid expression using != operator over passing threshold",112			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenBangEqual, 0.01},113			abortGracePeriod: types.NullDurationFrom(0 * time.Second),114			sinks:            map[string]float64{"rate": 0.02},115			wantOk:           true,116			wantErr:          false,117		},118		{119			name:             "valid expression over failing threshold",120			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreater, 0.01},121			abortGracePeriod: types.NullDurationFrom(0 * time.Second),122			sinks:            map[string]float64{"rate": 0.00001},123			wantOk:           false,124			wantErr:          false,125		},126		{127			name:             "valid expression over non-existing sink",128			parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreater, 0.01},129			abortGracePeriod: types.NullDurationFrom(0 * time.Second),130			sinks:            map[string]float64{"med": 27.2},131			wantOk:           false,132			wantErr:          true,133		},134		{135			// The ParseThresholdCondition constructor should ensure that no invalid136			// operator gets through, but let's protect our future selves anyhow.137			name:             "invalid expression operator",138			parsed:           &thresholdExpression{tokenRate, null.Float{}, "&", 0.01},139			abortGracePeriod: types.NullDurationFrom(0 * time.Second),140			sinks:            map[string]float64{"rate": 0.00001},141			wantOk:           false,142			wantErr:          true,143		},144	}145	for _, testCase := range tests {146		testCase := testCase147		t.Run(testCase.name, func(t *testing.T) {148			t.Parallel()149			threshold := &Threshold{150				LastFailed:       false,151				AbortOnFail:      false,152				AbortGracePeriod: testCase.abortGracePeriod,153				parsed:           testCase.parsed,154			}155			gotOk, gotErr := threshold.runNoTaint(testCase.sinks)156			assert.Equal(t,157				testCase.wantErr,158				gotErr != nil,159				"Threshold.runNoTaint() error = %v, wantErr %v", gotErr, testCase.wantErr,160			)161			assert.Equal(t,162				testCase.wantOk,163				gotOk,164				"Threshold.runNoTaint() gotOk = %v, want %v", gotOk, testCase.wantOk,165			)166		})167	}168}169func BenchmarkRunNoTaint(b *testing.B) {170	threshold := &Threshold{171		Source:           "rate>0.01",172		LastFailed:       false,173		AbortOnFail:      false,174		AbortGracePeriod: types.NullDurationFrom(2 * time.Second),175		parsed:           &thresholdExpression{tokenRate, null.Float{}, tokenGreater, 0.01},176	}177	sinks := map[string]float64{"rate": 1}178	b.ResetTimer()179	for i := 0; i < b.N; i++ {180		threshold.runNoTaint(sinks) // nolint181	}182}183func TestThresholdRun(t *testing.T) {184	t.Parallel()185	t.Run("true", func(t *testing.T) {186		t.Parallel()187		sinks := map[string]float64{"rate": 0.0001}188		parsed, parseErr := parseThresholdExpression("rate<0.01")189		require.NoError(t, parseErr)190		threshold := newThreshold(`rate<0.01`, false, types.NullDuration{})191		threshold.parsed = parsed192		t.Run("no taint", func(t *testing.T) {193			b, err := threshold.runNoTaint(sinks)194			assert.NoError(t, err)195			assert.True(t, b)196			assert.False(t, threshold.LastFailed)197		})198		t.Run("taint", func(t *testing.T) {199			t.Parallel()200			b, err := threshold.run(sinks)201			assert.NoError(t, err)202			assert.True(t, b)203			assert.False(t, threshold.LastFailed)204		})205	})206	t.Run("false", func(t *testing.T) {207		t.Parallel()208		sinks := map[string]float64{"rate": 1}209		parsed, parseErr := parseThresholdExpression("rate<0.01")210		require.NoError(t, parseErr)211		threshold := newThreshold(`rate<0.01`, false, types.NullDuration{})212		threshold.parsed = parsed213		t.Run("no taint", func(t *testing.T) {214			b, err := threshold.runNoTaint(sinks)215			assert.NoError(t, err)216			assert.False(t, b)217			assert.False(t, threshold.LastFailed)218		})219		t.Run("taint", func(t *testing.T) {220			b, err := threshold.run(sinks)221			assert.NoError(t, err)222			assert.False(t, b)223			assert.True(t, threshold.LastFailed)224		})225	})226}227func TestThresholdsParse(t *testing.T) {228	t.Parallel()229	t.Run("valid threshold expressions", func(t *testing.T) {230		t.Parallel()231		// Prepare a Thresholds collection containing syntaxically232		// correct thresholds233		ts := Thresholds{234			Thresholds: []*Threshold{235				newThreshold("rate<1", false, types.NullDuration{}),236			},237		}238		// Collect the result of the parsing operation239		gotErr := ts.Parse()240		assert.NoError(t, gotErr, "Parse shouldn't fail parsing valid expressions")241		assert.Condition(t, func() bool {242			for _, threshold := range ts.Thresholds {243				if threshold.parsed == nil {244					return false245				}246			}247			return true248		}, "Parse did not fail, but some Thresholds' parsed field is left empty")249	})250	t.Run("invalid threshold expressions", func(t *testing.T) {251		t.Parallel()252		// Prepare a Thresholds collection containing syntaxically253		// correct thresholds254		ts := Thresholds{255			Thresholds: []*Threshold{256				newThreshold("foo&1", false, types.NullDuration{}),257			},258		}259		// Collect the result of the parsing operation260		gotErr := ts.Parse()261		assert.Error(t, gotErr, "Parse should fail parsing invalid expressions")262		assert.Condition(t, func() bool {263			for _, threshold := range ts.Thresholds {264				if threshold.parsed == nil {265					return true266				}267			}268			return false269		}, "Parse failed, but some Thresholds' parsed field was not empty")270	})271	t.Run("mixed valid/invalid threshold expressions", func(t *testing.T) {272		t.Parallel()273		// Prepare a Thresholds collection containing syntaxically274		// correct thresholds275		ts := Thresholds{276			Thresholds: []*Threshold{277				newThreshold("rate<1", false, types.NullDuration{}),278				newThreshold("foo&1", false, types.NullDuration{}),279			},280		}281		// Collect the result of the parsing operation282		gotErr := ts.Parse()283		assert.Error(t, gotErr, "Parse should fail parsing invalid expressions")284		assert.Condition(t, func() bool {285			for _, threshold := range ts.Thresholds {286				if threshold.parsed == nil {287					return true288				}289			}290			return false291		}, "Parse failed, but some Thresholds' parsed field was not empty")292	})293}294func TestThresholdsValidate(t *testing.T) {295	t.Parallel()296	t.Run("validating thresholds applied to a non existing metric fails", func(t *testing.T) {297		t.Parallel()298		testRegistry := NewRegistry()299		// Prepare a Thresholds collection containing syntaxically300		// correct thresholds301		ts := Thresholds{302			Thresholds: []*Threshold{303				newThreshold("rate<1", false, types.NullDuration{}),304			},305		}306		parseErr := ts.Parse()307		require.NoError(t, parseErr)308		var wantErr errext.HasExitCode309		// Collect the result of the parsing operation310		gotErr := ts.Validate("non-existing", testRegistry)311		assert.Error(t, gotErr)312		assert.ErrorIs(t, gotErr, ErrInvalidThreshold)313		assert.ErrorAs(t, gotErr, &wantErr)314		assert.Equal(t, exitcodes.InvalidConfig, wantErr.ExitCode())315	})316	t.Run("validating unparsed thresholds fails", func(t *testing.T) {317		t.Parallel()318		testRegistry := NewRegistry()319		_, err := testRegistry.NewMetric("test_counter", Counter)320		require.NoError(t, err)321		// Prepare a Thresholds collection containing syntaxically322		// correct thresholds323		ts := Thresholds{324			Thresholds: []*Threshold{325				newThreshold("rate<1", false, types.NullDuration{}),326			},327		}328		// Note that we're not parsing the thresholds329		// Collect the result of the parsing operation330		gotErr := ts.Validate("non-existing", testRegistry)331		assert.Error(t, gotErr)332	})333	t.Run("thresholds supported aggregation methods for metrics", func(t *testing.T) {334		t.Parallel()335		testRegistry := NewRegistry()336		testCounter, err := testRegistry.NewMetric("test_counter", Counter)337		require.NoError(t, err)338		_, err = testCounter.AddSubmetric("foo:bar")339		require.NoError(t, err)340		_, err = testCounter.AddSubmetric("abc:123,easyas:doremi")341		require.NoError(t, err)342		_, err = testRegistry.NewMetric("test_rate", Rate)343		require.NoError(t, err)344		_, err = testRegistry.NewMetric("test_gauge", Gauge)345		require.NoError(t, err)346		_, err = testRegistry.NewMetric("test_trend", Trend)347		require.NoError(t, err)348		tests := []struct {349			name       string350			metricName string351			thresholds Thresholds352			wantErr    bool353		}{354			{355				name:       "threshold expression using 'count' is valid against a counter metric",356				metricName: "test_counter",357				thresholds: Thresholds{358					Thresholds: []*Threshold{newThreshold("count==1", false, types.NullDuration{})},359				},360				wantErr: false,361			},362			{363				name:       "threshold expression using 'rate' is valid against a counter metric",364				metricName: "test_counter",365				thresholds: Thresholds{366					Thresholds: []*Threshold{newThreshold("rate==1", false, types.NullDuration{})},367				},368				wantErr: false,369			},370			{371				name:       "threshold expression using 'rate' is valid against a counter single tag submetric",372				metricName: "test_counter{foo:bar}",373				thresholds: Thresholds{374					Thresholds: []*Threshold{newThreshold("rate==1", false, types.NullDuration{})},375				},376				wantErr: false,377			},378			{379				name:       "threshold expression using 'rate' is valid against a counter multi-tag submetric",380				metricName: "test_counter{abc:123,easyas:doremi}",381				thresholds: Thresholds{382					Thresholds: []*Threshold{newThreshold("rate==1", false, types.NullDuration{})},383				},384				wantErr: false,385			},386			{387				name:       "threshold expression using 'value' is valid against a gauge metric",388				metricName: "test_gauge",389				thresholds: Thresholds{390					Thresholds: []*Threshold{newThreshold("value==1", false, types.NullDuration{})},391				},392				wantErr: false,393			},394			{395				name:       "threshold expression using 'rate' is valid against a rate metric",396				metricName: "test_rate",397				thresholds: Thresholds{398					Thresholds: []*Threshold{newThreshold("rate==1", false, types.NullDuration{})},399				},400				wantErr: false,401			},402			{403				name:       "threshold expression using 'avg' is valid against a trend metric",404				metricName: "test_trend",405				thresholds: Thresholds{406					Thresholds: []*Threshold{newThreshold("avg==1", false, types.NullDuration{})},407				},408				wantErr: false,409			},410			{411				name:       "threshold expression using 'min' is valid against a trend metric",412				metricName: "test_trend",413				thresholds: Thresholds{414					Thresholds: []*Threshold{newThreshold("min==1", false, types.NullDuration{})},415				},416				wantErr: false,417			},418			{419				name:       "threshold expression using 'max' is valid against a trend metric",420				metricName: "test_trend",421				thresholds: Thresholds{422					Thresholds: []*Threshold{newThreshold("max==1", false, types.NullDuration{})},423				},424				wantErr: false,425			},426			{427				name:       "threshold expression using 'med' is valid against a trend metric",428				metricName: "test_trend",429				thresholds: Thresholds{430					Thresholds: []*Threshold{newThreshold("med==1", false, types.NullDuration{})},431				},432				wantErr: false,433			},434			{435				name:       "threshold expression using 'p(value)' is valid against a trend metric",436				metricName: "test_trend",437				thresholds: Thresholds{438					Thresholds: []*Threshold{newThreshold("p(99)==1", false, types.NullDuration{})},439				},440				wantErr: false,441			},442		}443		for _, testCase := range tests {444			testCase := testCase445			t.Run(testCase.name, func(t *testing.T) {446				t.Parallel()447				// Ensure thresholds are parsed448				parseErr := testCase.thresholds.Parse()449				require.NoError(t, parseErr)450				gotErr := testCase.thresholds.Validate(testCase.metricName, testRegistry)451				assert.Equal(t,452					testCase.wantErr,453					gotErr != nil,454					"Thresholds.Validate() error = %v, wantErr %v", gotErr, testCase.wantErr,455				)456				if testCase.wantErr {457					var targetErr errext.HasExitCode458					assert.ErrorIs(t,459						gotErr,460						ErrInvalidThreshold,461						"Validate error chain should contain an ErrInvalidThreshold error",462					)463					assert.ErrorAs(t,464						gotErr,465						&targetErr,466						"Validate error chain should contain an errext.HasExitCode error",467					)468					assert.Equal(t,469						exitcodes.InvalidConfig,470						targetErr.ExitCode(),471						"Validate error should have been exitcodes.InvalidConfig",472					)473				}474			})475		}476	})477}478func TestNewThresholds(t *testing.T) {479	t.Parallel()480	t.Run("empty", func(t *testing.T) {481		t.Parallel()482		ts := NewThresholds([]string{})483		assert.Len(t, ts.Thresholds, 0)484	})485	t.Run("two", func(t *testing.T) {486		t.Parallel()487		sources := []string{`rate<0.01`, `p(95)<200`}488		ts := NewThresholds(sources)489		assert.Len(t, ts.Thresholds, 2)490		for i, th := range ts.Thresholds {491			assert.Equal(t, sources[i], th.Source)492			assert.False(t, th.LastFailed)493			assert.False(t, th.AbortOnFail)494		}495	})496}497func TestNewThresholdsWithConfig(t *testing.T) {498	t.Parallel()499	t.Run("empty", func(t *testing.T) {500		t.Parallel()501		ts := NewThresholds([]string{})502		assert.Len(t, ts.Thresholds, 0)503	})504	t.Run("two", func(t *testing.T) {505		t.Parallel()506		configs := []thresholdConfig{507			{`rate<0.01`, false, types.NullDuration{}},508			{`p(95)<200`, true, types.NullDuration{}},509		}510		ts := newThresholdsWithConfig(configs)511		assert.Len(t, ts.Thresholds, 2)...

TestNewThreshold

Using AI Code Generation

1import (2func main() {3	config := cluster.NewConfig()4	brokers := []string{"localhost:9092"}5	topics := []string{"test"}6	consumer, err := cluster.NewConsumer(brokers, "my-group", topics, config)7	if err != nil {8		panic(err)9	}10	defer consumer.Close()11	t := metrics.NewThreshold(1.0)12	metrics.Register("my-metric", t)13	go metrics.Log(metrics.DefaultRegistry, 5*time.Second, log.New(os.Stderr, "metrics: ", log.Lmicroseconds))14	go func() {15		for err := range consumer.Errors() {16			fmt.Println(err)17		}18	}()19	go func() {20		for ntf := range consumer.Notifications() {21			fmt.Println(ntf)22		}23	}()24	for {25		select {26		case msg, ok := <-consumer.Messages():27			if ok {28				fmt.Println(string(msg.Value))29			}30		}31	}32}33import (34func main() {35	config := sarama.NewConfig()36	brokers := []string{"localhost:9092"}37	topics := []string{"test"}38	consumer, err := sarama.NewConsumer(brokers, config)39	if err != nil {40		panic(err)41	}42	defer consumer.Close()43	t := metrics.NewThreshold(1.0)44	metrics.Register("my-metric", t)45	go metrics.Log(metrics.Default

TestNewThreshold

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello, playground")4	thresh := metrics.TestNewThreshold()5	fmt.Println(thresh)6}7import (8func main() {9	fmt.Println("Hello, playground")10	thresh := metrics.TestNewThreshold()11	fmt.Println(thresh)12}

TestNewThreshold

Using AI Code Generation

1import (2func main() {3	stats.NewThreshold("somekey", 1, 5)4}5import (6func main() {7	stats.NewThreshold("somekey", 1, 5)8}9import (10func main() {11	stats.NewThreshold("somekey", 1, 5)12}13import (14func main() {15	stats.NewThreshold("somekey", 1, 5)16}17import (18func main() {19	stats.NewThreshold("somekey", 1, 5)20}21import (22func main() {23	stats.NewThreshold("somekey", 1, 5)24}25import (26func main() {27	stats.NewThreshold("somekey", 1, 5)28}29import (30func main() {31	stats.NewThreshold("somekey", 1, 5)32}33import (34func main() {

TestNewThreshold

Using AI Code Generation

1import (2func main() {3    var t = mdata.NewThreshold(1, 2, 3, 4)4    fmt.Println(t)5}6{1 2 3 4}7import (8func main() {9    var t = mdata.NewThreshold(1, 2, 3, 4)10    fmt.Println(t)11}12{1 2 3 4}13import (14func main() {15    var t = mdata.NewThreshold(1, 2, 3, 4)16    fmt.Println(t)17}18{1 2 3 4}19import (20func main() {21    var t = mdata.NewThreshold(1, 2, 3, 4)22    fmt.Println(t)23}24{1 2 3 4}25import (26func main() {27    var t = mdata.NewThreshold(1, 2, 3, 4)28    fmt.Println(t)29}30{1 2 3 4}31import (

TestNewThreshold

Using AI Code Generation

1import (2func main() {3	th := stats.NewThreshold(10)4	counter := stats.NewCounter32("counter")5	gauge := stats.NewGauge32("gauge")6	gauge64 := stats.NewGauge64("gauge64")7	rate := stats.NewRate32("rate")8	rate64 := stats.NewRate64("rate64")9	timer := stats.NewTimer32("timer")10	timer64 := stats.NewTimer64("timer64")11	timerRate := stats.NewTimerRate32("timerRate")12	timerRate64 := stats.NewTimerRate64("timerRate64")13	timerHist := stats.NewTimerHistogram32("timerHist")14	timerHist64 := stats.NewTimerHistogram64("timerHist64")15	th.Add(counter, gauge, gauge64, rate, rate64, timer, timer64, timerRate, timerRate64, timerHist, timerHist64)16	fmt.Println(th.Crossed())17	gauge.Value(10)18	fmt.Println(th.Crossed())19	gauge64.Value(10)20	fmt.Println(th.Crossed())21	counter.Inc(10)22	fmt.Println(th.Crossed())23	rate.Inc(10)24	fmt.Println(th.Crossed())25	rate64.Inc(10)26	fmt.Println(th.Crossed())

TestNewThreshold

Using AI Code Generation

1import (2func main() {3	m := metrics.New()4	t := m.NewThreshold("test", 100, 10)5	t.Start()6	t.Update(100)7	t.Stop()8	<-t.Done()9	fmt.Println(t.Value())10	fmt.Println(t.Status())11	fmt.Println(t.Time())12	fmt.Println(t.Duration())13	fmt.Println(t.Rate())14	fmt.Println(t.RatePerSecond())15	fmt.Println(t.RatePerMinute())16	fmt.Println(t.RatePerHour())17}18import (19func main() {20	m := metrics.New()21	t := m.NewThreshold("test", 100, 10)22	t.Start()23	t.Update(100)24	<-t.Done()25	fmt.Println(t.Value())26	fmt.Println(t.Status())27	fmt.Println(t.Time())28	fmt.Println(t.Duration())29	fmt.Println(t.Rate())30	fmt.Println(t.RatePerSecond())31	fmt.Println(t.RatePer

TestNewThreshold

Using AI Code Generation

1m := metrics.NewMetrics()2t := m.NewThreshold(10, 20, 30)3fmt.Println(t)4m := metrics.NewMetrics()5t := m.NewThreshold(10, 20, 30)6fmt.Println(t)7{10 20 30}8GoLang Interface | Set 1 (Introduction)9GoLang Interface | Set 2 (Implementing Interface)10GoLang Interface | Set 3 (Interface as a Type)11GoLang Interface | Set 4 (Interface as a Parameter)12GoLang Interface | Set 5 (Interface as a Return Type)13GoLang Interface | Set 6 (Interface as a Field)14GoLang Interface | Set 7 (Nested Interface)15GoLang Interface | Set 8 (Interface with a Pointer Receiver)16GoLang Interface | Set 9 (Interface with a Value Receiver)17GoLang Interface | Set 10 (Interface with a Nil Receiver)18GoLang Interface | Set 11 (Interface with an Empty Receiver)19GoLang Interface | Set 12 (Interface with a Non-Empty Receiver)20GoLang Interface | Set 13 (Interface with a Function Receiver)21GoLang Interface | Set 14 (Interface with a Function Pointer Receiver)22GoLang Interface | Set 15 (Interface with a Function Value Receiver)23GoLang Interface | Set 16 (Interface with a Function Variable Receiver)24GoLang Interface | Set 17 (Interface with a Method Receiver)25GoLang Interface | Set 18 (Interface with a Method Pointer Receiver)26GoLang Interface | Set 19 (Interface with a Method Value Receiver)27GoLang Interface | Set 20 (Interface with a Method Variable Receiver)28GoLang Interface | Set 21 (Interface with a Method Set Receiver)

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.