How to use Close method of mocks Package

Best Syzkaller code snippet using mocks.Close

sender_test.go

Source:sender_test.go

...24		na.WithAuthorization())25	r, _ = SendWithSender(client, req,26		WithLogging(logger),27		DoErrorIfStatusCode(http.StatusAccepted),28		DoCloseIfError(),29		DoRetryForAttempts(5, time.Duration(0)))30	Respond(r,31		ByClosing())32	// Output:33	// autorest: Sending GET https://microsoft.com/a/b/c/34	// autorest: GET https://microsoft.com/a/b/c/ received 202 Accepted35	// autorest: Sending GET https://microsoft.com/a/b/c/36	// autorest: GET https://microsoft.com/a/b/c/ received 202 Accepted37	// autorest: Sending GET https://microsoft.com/a/b/c/38	// autorest: GET https://microsoft.com/a/b/c/ received 202 Accepted39	// autorest: Sending GET https://microsoft.com/a/b/c/40	// autorest: GET https://microsoft.com/a/b/c/ received 202 Accepted41	// autorest: Sending GET https://microsoft.com/a/b/c/42	// autorest: GET https://microsoft.com/a/b/c/ received 202 Accepted43}44func ExampleDoRetryForAttempts() {45	client := mocks.NewSender()46	client.SetAndRepeatError(fmt.Errorf("Faux Error"), 10)47	// Retry with backoff -- ensure returned Bodies are closed48	r, _ := SendWithSender(client, mocks.NewRequest(),49		DoCloseIfError(),50		DoRetryForAttempts(5, time.Duration(0)))51	Respond(r,52		ByClosing())53	fmt.Printf("Retry stopped after %d attempts", client.Attempts())54	// Output: Retry stopped after 5 attempts55}56func ExampleDoErrorIfStatusCode() {57	client := mocks.NewSender()58	client.AppendAndRepeatResponse(mocks.NewResponseWithStatus("204 NoContent", http.StatusNoContent), 10)59	// Chain decorators to retry the request, up to five times, if the status code is 20460	r, _ := SendWithSender(client, mocks.NewRequest(),61		DoErrorIfStatusCode(http.StatusNoContent),62		DoCloseIfError(),63		DoRetryForAttempts(5, time.Duration(0)))64	Respond(r,65		ByClosing())66	fmt.Printf("Retry stopped after %d attempts with code %s", client.Attempts(), r.Status)67	// Output: Retry stopped after 5 attempts with code 204 NoContent68}69func TestSendWithSenderRunsDecoratorsInOrder(t *testing.T) {70	client := mocks.NewSender()71	s := ""72	r, err := SendWithSender(client, mocks.NewRequest(),73		withMessage(&s, "a"),74		withMessage(&s, "b"),75		withMessage(&s, "c"))76	if err != nil {77		t.Errorf("autorest: SendWithSender returned an error (%v)", err)78	}79	Respond(r,80		ByClosing())81	if s != "abc" {82		t.Errorf("autorest: SendWithSender invoke decorators out of order; expected 'abc', received '%s'", s)83	}84}85func TestCreateSender(t *testing.T) {86	f := false87	s := CreateSender(88		(func() SendDecorator {89			return func(s Sender) Sender {90				return SenderFunc(func(r *http.Request) (*http.Response, error) {91					f = true92					return nil, nil93				})94			}95		})())96	s.Do(&http.Request{})97	if !f {98		t.Error("autorest: CreateSender failed to apply supplied decorator")99	}100}101func TestSend(t *testing.T) {102	f := false103	Send(&http.Request{},104		(func() SendDecorator {105			return func(s Sender) Sender {106				return SenderFunc(func(r *http.Request) (*http.Response, error) {107					f = true108					return nil, nil109				})110			}111		})())112	if !f {113		t.Error("autorest: Send failed to apply supplied decorator")114	}115}116func TestAfterDelayWaits(t *testing.T) {117	client := mocks.NewSender()118	d := 5 * time.Millisecond119	tt := time.Now()120	r, _ := SendWithSender(client, mocks.NewRequest(),121		AfterDelay(d))122	s := time.Since(tt)123	if s < d {124		t.Error("autorest: AfterDelay failed to wait for at least the specified duration")125	}126	Respond(r,127		ByClosing())128}129func TestAfterDelay_Cancels(t *testing.T) {130	client := mocks.NewSender()131	cancel := make(chan struct{})132	delay := 5 * time.Second133	var wg sync.WaitGroup134	wg.Add(1)135	tt := time.Now()136	go func() {137		req := mocks.NewRequest()138		req.Cancel = cancel139		wg.Done()140		SendWithSender(client, req,141			AfterDelay(delay))142	}()143	wg.Wait()144	close(cancel)145	time.Sleep(5 * time.Millisecond)146	if time.Since(tt) >= delay {147		t.Error("autorest: AfterDelay failed to cancel")148	}149}150func TestAfterDelayDoesNotWaitTooLong(t *testing.T) {151	client := mocks.NewSender()152	d := 5 * time.Millisecond153	start := time.Now()154	r, _ := SendWithSender(client, mocks.NewRequest(),155		AfterDelay(d))156	if time.Since(start) > (5 * d) {157		t.Error("autorest: AfterDelay waited too long (exceeded 5 times specified duration)")158	}159	Respond(r,160		ByClosing())161}162func TestAsIs(t *testing.T) {163	client := mocks.NewSender()164	r1 := mocks.NewResponse()165	client.AppendResponse(r1)166	r2, err := SendWithSender(client, mocks.NewRequest(),167		AsIs())168	if err != nil {169		t.Errorf("autorest: AsIs returned an unexpected error (%v)", err)170	} else if !reflect.DeepEqual(r1, r2) {171		t.Errorf("autorest: AsIs modified the response -- received %v, expected %v", r2, r1)172	}173	Respond(r1,174		ByClosing())175	Respond(r2,176		ByClosing())177}178func TestDoCloseIfError(t *testing.T) {179	client := mocks.NewSender()180	client.AppendResponse(mocks.NewResponseWithStatus("400 BadRequest", http.StatusBadRequest))181	r, _ := SendWithSender(client, mocks.NewRequest(),182		DoErrorIfStatusCode(http.StatusBadRequest),183		DoCloseIfError())184	if r.Body.(*mocks.Body).IsOpen() {185		t.Error("autorest: Expected DoCloseIfError to close response body -- it was left open")186	}187	Respond(r,188		ByClosing())189}190func TestDoCloseIfErrorAcceptsNilResponse(t *testing.T) {191	client := mocks.NewSender()192	SendWithSender(client, mocks.NewRequest(),193		(func() SendDecorator {194			return func(s Sender) Sender {195				return SenderFunc(func(r *http.Request) (*http.Response, error) {196					resp, err := s.Do(r)197					if err != nil {198						resp.Body.Close()199					}200					return nil, fmt.Errorf("Faux Error")201				})202			}203		})(),204		DoCloseIfError())205}206func TestDoCloseIfErrorAcceptsNilBody(t *testing.T) {207	client := mocks.NewSender()208	SendWithSender(client, mocks.NewRequest(),209		(func() SendDecorator {210			return func(s Sender) Sender {211				return SenderFunc(func(r *http.Request) (*http.Response, error) {212					resp, err := s.Do(r)213					if err != nil {214						resp.Body.Close()215					}216					resp.Body = nil217					return resp, fmt.Errorf("Faux Error")218				})219			}220		})(),221		DoCloseIfError())222}223func TestDoErrorIfStatusCode(t *testing.T) {224	client := mocks.NewSender()225	client.AppendResponse(mocks.NewResponseWithStatus("400 BadRequest", http.StatusBadRequest))226	r, err := SendWithSender(client, mocks.NewRequest(),227		DoErrorIfStatusCode(http.StatusBadRequest),228		DoCloseIfError())229	if err == nil {230		t.Error("autorest: DoErrorIfStatusCode failed to emit an error for passed code")231	}232	Respond(r,233		ByClosing())234}235func TestDoErrorIfStatusCodeIgnoresStatusCodes(t *testing.T) {236	client := mocks.NewSender()237	client.AppendResponse(newAcceptedResponse())238	r, err := SendWithSender(client, mocks.NewRequest(),239		DoErrorIfStatusCode(http.StatusBadRequest),240		DoCloseIfError())241	if err != nil {242		t.Error("autorest: DoErrorIfStatusCode failed to ignore a status code")243	}244	Respond(r,245		ByClosing())246}247func TestDoErrorUnlessStatusCode(t *testing.T) {248	client := mocks.NewSender()249	client.AppendResponse(mocks.NewResponseWithStatus("400 BadRequest", http.StatusBadRequest))250	r, err := SendWithSender(client, mocks.NewRequest(),251		DoErrorUnlessStatusCode(http.StatusAccepted),252		DoCloseIfError())253	if err == nil {254		t.Error("autorest: DoErrorUnlessStatusCode failed to emit an error for an unknown status code")255	}256	Respond(r,257		ByClosing())258}259func TestDoErrorUnlessStatusCodeIgnoresStatusCodes(t *testing.T) {260	client := mocks.NewSender()261	client.AppendResponse(newAcceptedResponse())262	r, err := SendWithSender(client, mocks.NewRequest(),263		DoErrorUnlessStatusCode(http.StatusAccepted),264		DoCloseIfError())265	if err != nil {266		t.Error("autorest: DoErrorUnlessStatusCode emitted an error for a knonwn status code")267	}268	Respond(r,269		ByClosing())270}271func TestDoRetryForAttemptsStopsAfterSuccess(t *testing.T) {272	client := mocks.NewSender()273	r, err := SendWithSender(client, mocks.NewRequest(),274		DoRetryForAttempts(5, time.Duration(0)))275	if client.Attempts() != 1 {276		t.Errorf("autorest: DoRetryForAttempts failed to stop after success -- expected attempts %v, actual %v",277			1, client.Attempts())278	}279	if err != nil {280		t.Errorf("autorest: DoRetryForAttempts returned an unexpected error (%v)", err)281	}282	Respond(r,283		ByClosing())284}285func TestDoRetryForAttemptsStopsAfterAttempts(t *testing.T) {286	client := mocks.NewSender()287	client.SetAndRepeatError(fmt.Errorf("Faux Error"), 10)288	r, err := SendWithSender(client, mocks.NewRequest(),289		DoRetryForAttempts(5, time.Duration(0)),290		DoCloseIfError())291	if err == nil {292		t.Error("autorest: Mock client failed to emit errors")293	}294	Respond(r,295		ByClosing())296	if client.Attempts() != 5 {297		t.Error("autorest: DoRetryForAttempts failed to stop after specified number of attempts")298	}299}300func TestDoRetryForAttemptsReturnsResponse(t *testing.T) {301	client := mocks.NewSender()302	client.SetError(fmt.Errorf("Faux Error"))303	r, err := SendWithSender(client, mocks.NewRequest(),304		DoRetryForAttempts(1, time.Duration(0)))305	if err == nil {306		t.Error("autorest: Mock client failed to emit errors")307	}308	if r == nil {309		t.Error("autorest: DoRetryForAttempts failed to return the underlying response")310	}311	Respond(r,312		ByClosing())313}314func TestDoRetryForDurationStopsAfterSuccess(t *testing.T) {315	client := mocks.NewSender()316	r, err := SendWithSender(client, mocks.NewRequest(),317		DoRetryForDuration(10*time.Millisecond, time.Duration(0)))318	if client.Attempts() != 1 {319		t.Errorf("autorest: DoRetryForDuration failed to stop after success -- expected attempts %v, actual %v",320			1, client.Attempts())321	}322	if err != nil {323		t.Errorf("autorest: DoRetryForDuration returned an unexpected error (%v)", err)324	}325	Respond(r,326		ByClosing())327}328func TestDoRetryForDurationStopsAfterDuration(t *testing.T) {329	client := mocks.NewSender()330	client.SetAndRepeatError(fmt.Errorf("Faux Error"), -1)331	d := 5 * time.Millisecond332	start := time.Now()333	r, err := SendWithSender(client, mocks.NewRequest(),334		DoRetryForDuration(d, time.Duration(0)),335		DoCloseIfError())336	if err == nil {337		t.Error("autorest: Mock client failed to emit errors")338	}339	if time.Since(start) < d {340		t.Error("autorest: DoRetryForDuration failed stopped too soon")341	}342	Respond(r,343		ByClosing())344}345func TestDoRetryForDurationStopsWithinReason(t *testing.T) {346	client := mocks.NewSender()347	client.SetAndRepeatError(fmt.Errorf("Faux Error"), -1)348	d := 5 * time.Millisecond349	start := time.Now()350	r, err := SendWithSender(client, mocks.NewRequest(),351		DoRetryForDuration(d, time.Duration(0)),352		DoCloseIfError())353	if err == nil {354		t.Error("autorest: Mock client failed to emit errors")355	}356	if time.Since(start) > (5 * d) {357		t.Error("autorest: DoRetryForDuration failed stopped soon enough (exceeded 5 times specified duration)")358	}359	Respond(r,360		ByClosing())361}362func TestDoRetryForDurationReturnsResponse(t *testing.T) {363	client := mocks.NewSender()364	client.SetAndRepeatError(fmt.Errorf("Faux Error"), -1)365	r, err := SendWithSender(client, mocks.NewRequest(),366		DoRetryForDuration(10*time.Millisecond, time.Duration(0)),367		DoCloseIfError())368	if err == nil {369		t.Error("autorest: Mock client failed to emit errors")370	}371	if r == nil {372		t.Error("autorest: DoRetryForDuration failed to return the underlying response")373	}374	Respond(r,375		ByClosing())376}377func TestDelayForBackoff(t *testing.T) {378	d := 5 * time.Millisecond379	start := time.Now()380	DelayForBackoff(d, 1, nil)381	if time.Since(start) < d {382		t.Error("autorest: DelayForBackoff did not delay as long as expected")383	}384}385func TestDelayForBackoff_Cancels(t *testing.T) {386	cancel := make(chan struct{})387	delay := 5 * time.Second388	var wg sync.WaitGroup389	wg.Add(1)390	start := time.Now()391	go func() {392		wg.Done()393		DelayForBackoff(delay, 1, cancel)394	}()395	wg.Wait()396	close(cancel)397	time.Sleep(5 * time.Millisecond)398	if time.Since(start) >= delay {399		t.Error("autorest: DelayForBackoff failed to cancel")400	}401}402func TestDelayForBackoffWithinReason(t *testing.T) {403	d := 5 * time.Millisecond404	start := time.Now()405	DelayForBackoff(d, 1, nil)406	if time.Since(start) > (5 * d) {407		t.Error("autorest: DelayForBackoff delayed too long (exceeded 5 times the specified duration)")408	}409}410func TestDoPollForStatusCodes_IgnoresUnspecifiedStatusCodes(t *testing.T) {411	client := mocks.NewSender()412	r, _ := SendWithSender(client, mocks.NewRequest(),413		DoPollForStatusCodes(time.Duration(0), time.Duration(0)))414	if client.Attempts() != 1 {415		t.Errorf("autorest: Sender#DoPollForStatusCodes polled for unspecified status code")416	}417	Respond(r,418		ByClosing())419}420func TestDoPollForStatusCodes_PollsForSpecifiedStatusCodes(t *testing.T) {421	client := mocks.NewSender()422	client.AppendResponse(newAcceptedResponse())423	r, _ := SendWithSender(client, mocks.NewRequest(),424		DoPollForStatusCodes(time.Millisecond, time.Millisecond, http.StatusAccepted))425	if client.Attempts() != 2 {426		t.Errorf("autorest: Sender#DoPollForStatusCodes failed to poll for specified status code")427	}428	Respond(r,429		ByClosing())430}431func TestDoPollForStatusCodes_CanBeCanceled(t *testing.T) {432	cancel := make(chan struct{})433	delay := 5 * time.Second434	r := mocks.NewResponse()435	mocks.SetAcceptedHeaders(r)436	client := mocks.NewSender()437	client.AppendAndRepeatResponse(r, 100)438	var wg sync.WaitGroup439	wg.Add(1)440	start := time.Now()441	go func() {442		wg.Done()443		r, _ := SendWithSender(client, mocks.NewRequest(),444			DoPollForStatusCodes(time.Millisecond, time.Millisecond, http.StatusAccepted))445		Respond(r,446			ByClosing())447	}()448	wg.Wait()449	close(cancel)450	time.Sleep(5 * time.Millisecond)451	if time.Since(start) >= delay {452		t.Errorf("autorest: Sender#DoPollForStatusCodes failed to cancel")453	}454}455func TestDoPollForStatusCodes_ClosesAllNonreturnedResponseBodiesWhenPolling(t *testing.T) {456	resp := newAcceptedResponse()457	client := mocks.NewSender()458	client.AppendAndRepeatResponse(resp, 2)459	r, _ := SendWithSender(client, mocks.NewRequest(),460		DoPollForStatusCodes(time.Millisecond, time.Millisecond, http.StatusAccepted))461	if resp.Body.(*mocks.Body).IsOpen() || resp.Body.(*mocks.Body).CloseAttempts() < 2 {462		t.Errorf("autorest: Sender#DoPollForStatusCodes did not close unreturned response bodies")463	}464	Respond(r,465		ByClosing())466}467func TestDoPollForStatusCodes_LeavesLastResponseBodyOpen(t *testing.T) {468	client := mocks.NewSender()469	client.AppendResponse(newAcceptedResponse())470	r, _ := SendWithSender(client, mocks.NewRequest(),471		DoPollForStatusCodes(time.Millisecond, time.Millisecond, http.StatusAccepted))472	if !r.Body.(*mocks.Body).IsOpen() {473		t.Errorf("autorest: Sender#DoPollForStatusCodes did not leave open the body of the last response")474	}475	Respond(r,...

index_integration_test.go

Source:index_integration_test.go

...29func TestIndex(t *testing.T) {30	t.Run("first", func(t *testing.T) {31		t.Parallel()32		reader, writer, db := setupIndex(t)33		defer db.Close()34		assert.NoError(t, writer.First(mocks.GenericHeight))35		// Close the writer to make it commit its transactions.36		require.NoError(t, writer.Close())37		got, err := reader.First()38		require.NoError(t, err)39		assert.Equal(t, mocks.GenericHeight, got)40	})41	t.Run("last", func(t *testing.T) {42		t.Parallel()43		reader, writer, db := setupIndex(t)44		defer db.Close()45		assert.NoError(t, writer.Last(mocks.GenericHeight))46		// Close the writer to make it commit its transactions.47		require.NoError(t, writer.Close())48		got, err := reader.Last()49		require.NoError(t, err)50		assert.Equal(t, mocks.GenericHeight, got)51	})52	t.Run("height", func(t *testing.T) {53		t.Parallel()54		reader, writer, db := setupIndex(t)55		defer db.Close()56		blockID := mocks.GenericHeader.ID()57		assert.NoError(t, writer.Height(blockID, mocks.GenericHeight))58		// Close the writer to make it commit its transactions.59		require.NoError(t, writer.Close())60		got, err := reader.HeightForBlock(blockID)61		require.NoError(t, err)62		assert.Equal(t, mocks.GenericHeight, got)63	})64	t.Run("commit", func(t *testing.T) {65		t.Parallel()66		reader, writer, db := setupIndex(t)67		defer db.Close()68		assert.NoError(t, writer.Commit(mocks.GenericHeight, mocks.GenericCommit(0)))69		// Close the writer to make it commit its transactions.70		require.NoError(t, writer.Close())71		got, err := reader.Commit(mocks.GenericHeight)72		require.NoError(t, err)73		assert.Equal(t, mocks.GenericCommit(0), got)74	})75	t.Run("header", func(t *testing.T) {76		t.Parallel()77		reader, writer, db := setupIndex(t)78		defer db.Close()79		assert.NoError(t, writer.Header(mocks.GenericHeight, mocks.GenericHeader))80		// Close the writer to make it commit its transactions.81		require.NoError(t, writer.Close())82		got, err := reader.Header(mocks.GenericHeight)83		require.NoError(t, err)84		assert.Equal(t, mocks.GenericHeader, got)85	})86	t.Run("payloads", func(t *testing.T) {87		t.Parallel()88		reader, writer, db := setupIndex(t)89		defer db.Close()90		paths := mocks.GenericLedgerPaths(4)91		payloads := mocks.GenericLedgerPayloads(4)92		values := mocks.GenericLedgerValues(4)93		assert.NoError(t, writer.First(mocks.GenericHeight))94		assert.NoError(t, writer.Last(mocks.GenericHeight))95		assert.NoError(t, writer.Payloads(mocks.GenericHeight, paths, payloads))96		// Close the writer to make it commit its transactions.97		require.NoError(t, writer.Close())98		got, err := reader.Values(mocks.GenericHeight, paths)99		require.NoError(t, err)100		assert.ElementsMatch(t, values, got)101	})102	t.Run("collections", func(t *testing.T) {103		t.Parallel()104		collections := mocks.GenericCollections(4)105		reader, writer, db := setupIndex(t)106		defer db.Close()107		assert.NoError(t, writer.Collections(mocks.GenericHeight, collections))108		// Close the writer to make it commit its transactions.109		require.NoError(t, writer.Close())110		// NOTE: The following subtests should NOT be run in parallel, because of the deferral111		// to close the database above.112		t.Run("retrieve collection by ID", func(t *testing.T) {113			got, err := reader.Collection(collections[0].ID())114			require.NoError(t, err)115			assert.Equal(t, collections[0], got)116		})117		t.Run("retrieve collections by height", func(t *testing.T) {118			got, err := reader.CollectionsByHeight(mocks.GenericHeight)119			require.NoError(t, err)120			assert.ElementsMatch(t, mocks.GenericCollectionIDs(4), got)121		})122		t.Run("retrieve transactions from collection", func(t *testing.T) {123			// For now this index is not used.124		})125	})126	t.Run("guarantees", func(t *testing.T) {127		t.Parallel()128		reader, writer, db := setupIndex(t)129		defer db.Close()130		assert.NoError(t, writer.Guarantees(mocks.GenericHeight, mocks.GenericGuarantees(4)))131		// Close the writer to make it commit its transactions.132		require.NoError(t, writer.Close())133		guarantee := mocks.GenericGuarantee(0)134		got, err := reader.Guarantee(guarantee.ID())135		require.NoError(t, err)136		assert.Equal(t, guarantee, got)137	})138	t.Run("transactions", func(t *testing.T) {139		t.Parallel()140		reader, writer, db := setupIndex(t)141		defer db.Close()142		transactions := mocks.GenericTransactions(4)143		txIDs := []flow.Identifier{144			transactions[0].ID(),145			transactions[1].ID(),146			transactions[2].ID(),147			transactions[3].ID(),148		}149		assert.NoError(t, writer.Transactions(mocks.GenericHeight, transactions))150		// Close the writer to make it commit its transactions.151		require.NoError(t, writer.Close())152		// NOTE: The following subtests should NOT be run in parallel, because of the deferral153		// to close the database above.154		t.Run("retrieve transactions by height", func(t *testing.T) {155			gotTxIDs, err := reader.TransactionsByHeight(mocks.GenericHeight)156			require.NoError(t, err)157			assert.ElementsMatch(t, txIDs, gotTxIDs)158		})159		t.Run("retrieve transaction by ID", func(t *testing.T) {160			gotTx, err := reader.Transaction(transactions[0].ID())161			require.NoError(t, err)162			assert.Equal(t, transactions[0], gotTx)163		})164		t.Run("retrieve height for transaction", func(t *testing.T) {165			gotTx, err := reader.HeightForTransaction(transactions[0].ID())166			require.NoError(t, err)167			assert.Equal(t, mocks.GenericHeight, gotTx)168		})169	})170	t.Run("results", func(t *testing.T) {171		t.Parallel()172		reader, writer, db := setupIndex(t)173		defer db.Close()174		results := mocks.GenericResults(4)175		assert.NoError(t, writer.Results(results))176		// Close the writer to make it commit its transactions.177		require.NoError(t, writer.Close())178		got, err := reader.Result(results[0].TransactionID)179		require.NoError(t, err)180		assert.Equal(t, results[0], got)181	})182	t.Run("events", func(t *testing.T) {183		t.Parallel()184		reader, writer, db := setupIndex(t)185		defer db.Close()186		withdrawalType := mocks.GenericEventType(0)187		depositType := mocks.GenericEventType(1)188		withdrawals := mocks.GenericEvents(2, withdrawalType)189		deposits := mocks.GenericEvents(2, depositType)190		events := append(withdrawals, deposits...)191		assert.NoError(t, writer.First(mocks.GenericHeight))192		assert.NoError(t, writer.Last(mocks.GenericHeight))193		assert.NoError(t, writer.Events(mocks.GenericHeight, events))194		// Close the writer to make it commit its transactions.195		require.NoError(t, writer.Close())196		// NOTE: The following subtests should NOT be run in parallel, because of the deferral197		// to close the database above.198		t.Run("no types specified", func(t *testing.T) {199			got, err := reader.Events(mocks.GenericHeight)200			require.NoError(t, err)201			assert.ElementsMatch(t, events, got)202		})203		t.Run("type specified", func(t *testing.T) {204			got1, err := reader.Events(mocks.GenericHeight, withdrawalType)205			require.NoError(t, err)206			assert.Len(t, got1, 2)207			got2, err := reader.Events(mocks.GenericHeight, depositType)208			require.NoError(t, err)209			assert.Len(t, got1, 2)210			assert.NotEqual(t, got1, got2)211		})212	})213	t.Run("seals", func(t *testing.T) {214		t.Parallel()215		reader, writer, db := setupIndex(t)216		defer db.Close()217		seals := mocks.GenericSeals(4)218		assert.NoError(t, writer.Seals(mocks.GenericHeight, seals))219		// Close the writer to make it commit its transactions.220		require.NoError(t, writer.Close())221		// NOTE: The following subtests should NOT be run in parallel, because of the deferral222		// to close the database above.223		t.Run("retrieve seal by ID", func(t *testing.T) {224			got, err := reader.Seal(seals[0].ID())225			require.NoError(t, err)226			assert.Equal(t, seals[0], got)227		})228		t.Run("retrieve seals by height", func(t *testing.T) {229			got, err := reader.SealsByHeight(mocks.GenericHeight)230			require.NoError(t, err)231			assert.ElementsMatch(t, got, mocks.GenericSealIDs(4))232		})233	})234}...

manager_test.go

Source:manager_test.go

...70		mocks.store.EXPECT().MarkFailed(tasks[1]).Return(nil),71	)72	m, err := mocks.new()73	require.NoError(err)74	defer m.Close()75	time.Sleep(50 * time.Millisecond)76}77func TestManagerAddTaskSuccess(t *testing.T) {78	require := require.New(t)79	mocks, cleanup := newManagerMocks(t)80	defer cleanup()81	task := mocks.task()82	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()83	gomock.InOrder(84		mocks.store.EXPECT().GetPending().Return(nil, nil),85		task.EXPECT().Ready().Return(true),86		mocks.store.EXPECT().AddPending(task).Return(nil),87		mocks.executor.EXPECT().Exec(task).Return(nil),88		mocks.store.EXPECT().Remove(task).Return(nil),89	)90	m, err := mocks.new()91	require.NoError(err)92	defer m.Close()93	waitForWorkers()94	require.NoError(m.Add(task))95	time.Sleep(50 * time.Millisecond)96}97func TestManagerAddTaskClosed(t *testing.T) {98	require := require.New(t)99	mocks, cleanup := newManagerMocks(t)100	defer cleanup()101	mocks.store.EXPECT().GetPending().Return(nil, nil)102	m, err := mocks.new()103	require.NoError(err)104	m.Close()105	require.Equal(ErrManagerClosed, m.Add(mocks.task()))106}107func TestManagerAddTaskFail(t *testing.T) {108	require := require.New(t)109	mocks, cleanup := newManagerMocks(t)110	defer cleanup()111	task := mocks.task()112	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()113	gomock.InOrder(114		mocks.store.EXPECT().GetPending().Return(nil, nil),115		task.EXPECT().Ready().Return(true),116		mocks.store.EXPECT().AddPending(task).Return(nil),117		mocks.executor.EXPECT().Exec(task).Return(errors.New("task failed")),118		mocks.store.EXPECT().MarkFailed(task).Return(nil),119		task.EXPECT().GetFailures().Return(1),120		task.EXPECT().Tags().Return(nil),121	)122	m, err := mocks.new()123	require.NoError(err)124	defer m.Close()125	waitForWorkers()126	require.NoError(m.Add(task))127	time.Sleep(50 * time.Millisecond)128}129func TestManagerAddTaskFallbackWhenWorkersBusy(t *testing.T) {130	require := require.New(t)131	mocks, cleanup := newManagerMocks(t)132	defer cleanup()133	task1 := mocks.task()134	task2 := mocks.task()135	task1Done := make(chan bool)136	mocks.store.EXPECT().GetPending().Return(nil, nil)137	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()138	gomock.InOrder(139		task1.EXPECT().Ready().Return(true),140		mocks.store.EXPECT().AddPending(task1).Return(nil),141		mocks.executor.EXPECT().Exec(task1).DoAndReturn(func(Task) error {142			<-task1Done143			return nil144		}),145		mocks.store.EXPECT().Remove(task1).Return(nil),146	)147	gomock.InOrder(148		task2.EXPECT().Ready().Return(true),149		mocks.store.EXPECT().AddPending(task2).Return(nil),150		mocks.store.EXPECT().MarkFailed(task2).Return(nil),151	)152	m, err := mocks.new()153	require.NoError(err)154	defer m.Close()155	waitForWorkers()156	// First task blocks, so the only worker is busy when we add second task, which157	// should then fallback to failed.158	require.NoError(m.Add(task1))159	require.NoError(m.Add(task2))160	task1Done <- true161	time.Sleep(50 * time.Millisecond)162}163func TestManagerRetriesFailedTasks(t *testing.T) {164	require := require.New(t)165	mocks, cleanup := newManagerMocks(t)166	defer cleanup()167	task := mocks.task()168	gomock.InOrder(169		mocks.store.EXPECT().GetPending().Return(nil, nil).MinTimes(1),170		mocks.store.EXPECT().GetFailed().Return([]Task{task}, nil),171		task.EXPECT().Ready().Return(true),172		task.EXPECT().GetLastAttempt().Return(time.Time{}),173		mocks.store.EXPECT().MarkPending(task),174		mocks.executor.EXPECT().Exec(task).Return(nil),175		mocks.store.EXPECT().Remove(task).Return(nil),176	)177	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()178	m, err := mocks.new()179	require.NoError(err)180	defer m.Close()181	time.Sleep(50 * time.Millisecond)182}183func TestManagerRetriesSkipsNotReadyTasks(t *testing.T) {184	require := require.New(t)185	mocks, cleanup := newManagerMocks(t)186	defer cleanup()187	task := mocks.task()188	gomock.InOrder(189		mocks.store.EXPECT().GetPending().Return(nil, nil).MinTimes(1),190		mocks.store.EXPECT().GetFailed().Return([]Task{task}, nil),191		task.EXPECT().Ready().Return(false),192	)193	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()194	m, err := mocks.new()195	require.NoError(err)196	defer m.Close()197	time.Sleep(50 * time.Millisecond)198}199func TestManagerRetriesSkipsRecentlyAttemptedTasks(t *testing.T) {200	require := require.New(t)201	mocks, cleanup := newManagerMocks(t)202	defer cleanup()203	task := mocks.task()204	gomock.InOrder(205		mocks.store.EXPECT().GetPending().Return(nil, nil).MinTimes(1),206		mocks.store.EXPECT().GetFailed().Return([]Task{task}, nil),207		task.EXPECT().Ready().Return(true),208		task.EXPECT().GetLastAttempt().Return(time.Now()),209	)210	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()211	m, err := mocks.new()212	require.NoError(err)213	defer m.Close()214	time.Sleep(50 * time.Millisecond)215}216func TestManagerAddNotReadyTaskMarksAsFailed(t *testing.T) {217	require := require.New(t)218	mocks, cleanup := newManagerMocks(t)219	defer cleanup()220	task := mocks.task()221	mocks.store.EXPECT().GetPending().Return(nil, nil)222	gomock.InOrder(223		task.EXPECT().Ready().Return(false),224		mocks.store.EXPECT().AddFailed(task).Return(nil),225	)226	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()227	m, err := mocks.new()228	require.NoError(err)229	defer m.Close()230	waitForWorkers()231	require.NoError(m.Add(task))232}233func TestManagerNoopsOnFailedTaskConflicts(t *testing.T) {234	require := require.New(t)235	mocks, cleanup := newManagerMocks(t)236	defer cleanup()237	task := mocks.task()238	mocks.store.EXPECT().GetPending().Return(nil, nil)239	gomock.InOrder(240		task.EXPECT().Ready().Return(false),241		mocks.store.EXPECT().AddFailed(task).Return(ErrTaskExists),242	)243	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()244	m, err := mocks.new()245	require.NoError(err)246	defer m.Close()247	waitForWorkers()248	require.NoError(m.Add(task))249}250func TestManagerNoopsOnPendingTaskConflicts(t *testing.T) {251	require := require.New(t)252	mocks, cleanup := newManagerMocks(t)253	defer cleanup()254	task := mocks.task()255	mocks.store.EXPECT().GetPending().Return(nil, nil)256	gomock.InOrder(257		task.EXPECT().Ready().Return(true),258		mocks.store.EXPECT().AddPending(task).Return(ErrTaskExists),259	)260	mocks.store.EXPECT().GetFailed().Return(nil, nil).AnyTimes()261	m, err := mocks.new()262	require.NoError(err)263	defer m.Close()264	waitForWorkers()265	require.NoError(m.Add(task))266}267func TestManagerExec(t *testing.T) {268	require := require.New(t)269	mocks, cleanup := newManagerMocks(t)270	defer cleanup()271	task := mocks.task()272	mocks.store.EXPECT().GetPending().Return(nil, nil)273	m, err := mocks.new()274	require.NoError(err)275	defer m.Close()276	mocks.executor.EXPECT().Exec(task).Return(nil)277	require.NoError(m.SyncExec(task))278}...

Using AI Code Generation

1import (2type MyReader struct {3}4func (m *MyReader) Close() error {5	args := m.Called()6	return args.Error(0)7}8func main() {9	r.On("Close").Return(fmt.Errorf("Close failed"))10	r.Close()11}

Using AI Code Generation

1import (2func main() {3	ctrl := gomock.NewController(nil)4	defer ctrl.Finish()5	mock := mocks.NewMockMyInterface(ctrl)6	mock.EXPECT().Close().Return(nil)7	fmt.Println("hello")8}9import (10func main() {11	ctrl := gomock.NewController(nil)12	defer ctrl.Finish()13	mock := mocks.NewMockMyInterface(ctrl)14	mock.EXPECT().Close().Return(nil)15	fmt.Println("hello")16}17import (18func main() {19	ctrl := gomock.NewController(nil)20	defer ctrl.Finish()21	mock := mocks.NewMockMyInterface(ctrl)22	mock.EXPECT().Close().Return(nil)23	fmt.Println("hello")24}25import (26func main() {27	ctrl := gomock.NewController(nil)28	defer ctrl.Finish()29	mock := mocks.NewMockMyInterface(ctrl)30	mock.EXPECT().Close().Return(nil)31	fmt.Println("hello")32}33import (34func main() {35	ctrl := gomock.NewController(nil)36	defer ctrl.Finish()37	mock := mocks.NewMockMyInterface(ctrl)38	mock.EXPECT().Close().Return(nil)39	fmt.Println("hello")40}41import (42func main() {43	ctrl := gomock.NewController(nil)44	defer ctrl.Finish()45	mock := mocks.NewMockMyInterface(ctrl)46	mock.EXPECT().Close().Return(nil)47	fmt.Println("hello")48}

Using AI Code Generation

1import (2func main() {3	ctrl := gomock.NewController(nil)4	defer ctrl.Finish()5	mock := mocks.NewMockFoo(ctrl)6	mock.EXPECT().Close().Return(nil)7	fmt.Println(mock.Close())8}

Using AI Code Generation

1import (2type mockFile struct {3}4func (m *mockFile) Close() error {5	args := m.Called()6	return args.Error(0)7}8func (m *mockFile) Write(p []byte) (n int, err error) {9	args := m.Called(p)10	return args.Int(0), args.Error(1)11}12type FileTestSuite struct {13}14func (suite *FileTestSuite) SetupTest() {15	suite.mockFile = new(mockFile)16}17func (suite *FileTestSuite) TestWrite() {18	suite.mockFile.On("Write", []byte("Hello World")).Return(11, nil)19	suite.mockFile.Write([]byte("Hello World"))20	suite.mockFile.AssertExpectations(suite.T())21}22func (suite *FileTestSuite) TestClose() {23	suite.mockFile.On("Close").Return(nil)24	suite.mockFile.Close()25	suite.mockFile.AssertExpectations(suite.T())26}27func TestFileTestSuite(t *testing.T) {28	suite.Run(t, new(FileTestSuite))29}30import (31type mockFile struct {32}33func (m *mockFile) Close() error {34	args := m.Called()35	return args.Error(0)36}37func (m *mockFile) Write(p []byte) (n int, err error) {38	args := m.Called(p)39	return args.Int(0), args.Error(1)40}41type FileTestSuite struct {42}43func (suite *FileTestSuite) SetupTest() {44	suite.mockFile = new(mockFile)45}46func (suite *FileTestSuite) TestWrite() {47	suite.mockFile.On("Write", []byte("Hello World")).Return(11, nil)48	suite.mockFile.Write([]byte("Hello World"))49	suite.mockFile.AssertExpectations(suite.T())50}51func (suite *FileTestSuite) TestClose() {52	suite.mockFile.On("Close").Return(nil)53	suite.mockFile.Close()54	suite.mockFile.AssertExpectations(suite.T())55}56func TestFileTestSuite(t *testing.T)

Using AI Code Generation

1import (2type Mocks struct {3    closeFunc func()4}5func (m *Mocks) Close() {6    m.closeFunc()7}8func main() {9    m := &Mocks{}10    m.closeFunc = func() {11        fmt.Println("Close called")12    }13    m.Close()14}15import (16type Mocks struct {17    closeFunc func()18}19func (m *Mocks) Close() {20    m.closeFunc()21}22func main() {23    m := &Mocks{}24    m.closeFunc = func() {25        fmt.Println("Close called")26    }27    m.Close()28}29import (30type Mocks struct {31    closeFunc func()32}33func (m *Mocks) Close() {34    m.closeFunc()35}36func main() {37    m := &Mocks{}38    m.closeFunc = func() {39        fmt.Println("Close called")40    }41    m.Close()42}43import (44type Mocks struct {45    closeFunc func()46}47func (m *Mocks) Close() {48    m.closeFunc()49}50func main() {51    m := &Mocks{}52    m.closeFunc = func() {

Using AI Code Generation

1mockObj.Close()2mockObj.Close()3mockObj.Close()4mockObj.Close()5mockObj.Close()6mockObj.Close()7mockObj.Close()8mockObj.Close()9mockObj.Close()10mockObj.Close()11mockObj.Close()12mockObj.Close()13mockObj.Close()14mockObj.Close()15mockObj.Close()16mockObj.Close()17mockObj.Close()18mockObj.Close()19mockObj.Close()

Using AI Code Generation

1import (2type Mocked struct {3}4func (m *Mocked) Close() {5	fmt.Println("Close method called")6}7func main() {8	mocked := new(Mocked)9	mocked.Close()10}11import (12type Mocked struct {13}14func (m *Mocked) Close() {15	fmt.Println("Close method called")16}17func main() {18	mocked := new(Mocked)19	mocked.On("Close")20	mocked.Close()21}22import (23type Mocked struct {24}25func (m *Mocked) Close() {26	fmt.Println("Close method called")27}28func main() {29	mocked := new(Mocked)30	mocked.On("Close")31	mocked.Close()32	mocked.AssertExpectations(nil)33}34import (35type Mocked struct {36}37func (m *Mocked) Close() {38	fmt.Println("Close method called")39}40func main() {41	mocked := new(Mocked)42	mocked.On("Close")43	mocked.AssertExpectations(nil)44}

Using AI Code Generation

1import (2func main() {3	f, err := os.Create("test.txt")4	if err != nil {5		fmt.Println(err)6	}7	defer f.Close()8	fmt.Fprintln(f, "Hello World")9}10import (11func TestClose(t *testing.T) {12	f, err := os.Create("test.txt")13	if err != nil {14		t.Fatal(err)15	}16	defer f.Close()17	fmt.Fprintln(f, "Hello World")18}19import (20func main() {21	f, err := os.Create("test.txt")22	if err != nil {23		fmt.Println(err)24	}25	defer f.Close()26	fmt.Fprintln(f, "Hello World")27}28import (29func TestClose(t *testing.T) {30	f, err := os.Create("test.txt")31	if err != nil {32		t.Fatal(err)33	}34	defer f.Close()35	fmt.Fprintln(f, "Hello World")36}37import (38func main() {39	f, err := os.Create("test.txt")40	if err != nil {41		fmt.Println(err)42	}43	defer f.Close()44	fmt.Fprintln(f,

Using AI Code Generation

1import (2func main() {3	mock := new(mocks.Mock)4	mock.Close()5	fmt.Println(mock.Closed)6}7import "fmt"8type Mock struct {9}10func (m *Mock) Close() {11	fmt.Println("Close called")12}13func (m *Mock) Close() {14	fmt.Println("Close called")15}16import "fmt"17type Mock struct {18}19func (m *Mock) Close() {20	fmt.Println("Close called")21}22func (m *Mock) Close() {23	fmt.Println("Close called")24}25import "fmt"26type Mock struct {27}28func (m *Mock) Close() {29	fmt.Println("Close called")30}31func (m *Mock) Close() {32	fmt.Println("Close called")33}34import "fmt"35type Mock struct {36}37func (m *Mock) Close() {38	fmt.Println("Close called")

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.