How to use AssertRequire method of td Package

Best Go-testdeep code snippet using td.AssertRequire

response_test.go

Source:response_test.go

...15	. "github.com/jarcoal/httpmock"16	"github.com/jarcoal/httpmock/internal"17)18func TestResponderFromResponse(t *testing.T) {19	assert, require := td.AssertRequire(t)20	responder := ResponderFromResponse(NewStringResponse(200, "hello world"))21	req, err := http.NewRequest(http.MethodGet, testURL, nil)22	require.CmpNoError(err)23	response1, err := responder(req)24	require.CmpNoError(err)25	testURLWithQuery := testURL + "?a=1"26	req, err = http.NewRequest(http.MethodGet, testURLWithQuery, nil)27	require.CmpNoError(err)28	response2, err := responder(req)29	require.CmpNoError(err)30	// Body should be the same for both responses31	assertBody(assert, response1, "hello world")32	assertBody(assert, response2, "hello world")33	// Request should be non-nil and different for each response34	require.NotNil(response1.Request)35	assert.String(response1.Request.URL, testURL)36	require.NotNil(response2.Request)37	assert.String(response2.Request.URL, testURLWithQuery)38}39func TestResponderFromResponses(t *testing.T) {40	assert, require := td.AssertRequire(t)41	jsonResponse, err := NewJsonResponse(200, map[string]string{"test": "toto"})42	require.CmpNoError(err)43	responder := ResponderFromMultipleResponses(44		[]*http.Response{45			jsonResponse,46			NewStringResponse(200, "hello world"),47		},48	)49	req, err := http.NewRequest(http.MethodGet, testURL, nil)50	require.CmpNoError(err)51	response1, err := responder(req)52	require.CmpNoError(err)53	testURLWithQuery := testURL + "?a=1"54	req, err = http.NewRequest(http.MethodGet, testURLWithQuery, nil)55	require.CmpNoError(err)56	response2, err := responder(req)57	require.CmpNoError(err)58	// Body should be the same for both responses59	assertBody(assert, response1, `{"test":"toto"}`)60	assertBody(assert, response2, "hello world")61	// Request should be non-nil and different for each response62	require.NotNil(response1.Request)63	assert.String(response1.Request.URL, testURL)64	require.NotNil(response2.Request)65	assert.String(response2.Request.URL, testURLWithQuery)66	// ensure we can't call the responder more than the number of responses it embeds67	_, err = responder(req)68	assert.String(err, "not enough responses provided: responder called 3 time(s) but 2 response(s) provided")69	// fn usage70	responder = ResponderFromMultipleResponses([]*http.Response{}, func(args ...interface{}) {})71	_, err = responder(req)72	assert.String(err, "not enough responses provided: responder called 1 time(s) but 0 response(s) provided")73	if assert.Isa(err, internal.StackTracer{}) {74		assert.NotNil(err.(internal.StackTracer).CustomFn)75	}76}77func TestNewNotFoundResponder(t *testing.T) {78	assert, require := td.AssertRequire(t)79	responder := NewNotFoundResponder(func(args ...interface{}) {})80	req, err := http.NewRequest("GET", "http://foo.bar/path", nil)81	require.CmpNoError(err)82	const title = "Responder not found for GET http://foo.bar/path"83	resp, err := responder(req)84	assert.Nil(resp)85	assert.String(err, title)86	if assert.Isa(err, internal.StackTracer{}) {87		assert.NotNil(err.(internal.StackTracer).CustomFn)88	}89	// nil fn90	responder = NewNotFoundResponder(nil)91	resp, err = responder(req)92	assert.Nil(resp)93	assert.String(err, title)94	if assert.Isa(err, internal.StackTracer{}) {95		assert.Nil(err.(internal.StackTracer).CustomFn)96	}97}98func TestNewStringResponse(t *testing.T) {99	assert, require := td.AssertRequire(t)100	const (101		body   = "hello world"102		status = 200103	)104	response := NewStringResponse(status, body)105	data, err := ioutil.ReadAll(response.Body)106	require.CmpNoError(err)107	assert.String(data, body)108	assert.Cmp(response.StatusCode, status)109}110func TestNewBytesResponse(t *testing.T) {111	assert, require := td.AssertRequire(t)112	const (113		body   = "hello world"114		status = 200115	)116	response := NewBytesResponse(status, []byte(body))117	data, err := ioutil.ReadAll(response.Body)118	require.CmpNoError(err)119	assert.String(data, body)120	assert.Cmp(response.StatusCode, status)121}122func TestNewJsonResponse(t *testing.T) {123	assert := td.Assert(t)124	type schema struct {125		Hello string `json:"hello"`126	}127	dir, cleanup := tmpDir(assert)128	defer cleanup()129	fileName := filepath.Join(dir, "ok.json")130	writeFile(assert, fileName, []byte(`{ "test": true }`))131	for i, test := range []struct {132		body     interface{}133		expected string134	}{135		{body: &schema{"world"}, expected: `{"hello":"world"}`},136		{body: File(fileName), expected: `{"test":true}`},137	} {138		assert.Run(fmt.Sprintf("#%d", i), func(assert *td.T) {139			response, err := NewJsonResponse(200, test.body)140			if !assert.CmpNoError(err) {141				return142			}143			assert.Cmp(response.StatusCode, 200)144			assert.Cmp(response.Header.Get("Content-Type"), "application/json")145			assertBody(assert, response, test.expected)146		})147	}148	// Error case149	response, err := NewJsonResponse(200, func() {})150	assert.CmpError(err)151	assert.Nil(response)152}153func checkResponder(assert *td.T, r Responder, expectedStatus int, expectedBody string) {154	assert.Helper()155	req, err := http.NewRequest(http.MethodGet, "/foo", nil)156	assert.FailureIsFatal().CmpNoError(err)157	resp, err := r(req)158	if !assert.CmpNoError(err, "Responder returned no error") {159		return160	}161	if !assert.NotNil(resp, "Responder returned a non-nil response") {162		return163	}164	assert.Cmp(resp.StatusCode, expectedStatus, "Status code is OK")165	assertBody(assert, resp, expectedBody)166}167func TestNewJsonResponder(t *testing.T) {168	assert := td.Assert(t)169	assert.Run("OK", func(assert *td.T) {170		r, err := NewJsonResponder(200, map[string]int{"foo": 42})171		if assert.CmpNoError(err) {172			checkResponder(assert, r, 200, `{"foo":42}`)173		}174	})175	assert.Run("OK file", func(assert *td.T) {176		dir, cleanup := tmpDir(assert)177		defer cleanup()178		fileName := filepath.Join(dir, "ok.json")179		writeFile(assert, fileName, []byte(`{  "foo"  :  42  }`))180		r, err := NewJsonResponder(200, File(fileName))181		if assert.CmpNoError(err) {182			checkResponder(assert, r, 200, `{"foo":42}`)183		}184	})185	assert.Run("Error", func(assert *td.T) {186		r, err := NewJsonResponder(200, func() {})187		assert.CmpError(err)188		assert.Nil(r)189	})190	assert.Run("OK don't panic", func(assert *td.T) {191		assert.CmpNotPanic(192			func() {193				r := NewJsonResponderOrPanic(200, map[string]int{"foo": 42})194				checkResponder(assert, r, 200, `{"foo":42}`)195			})196	})197	assert.Run("Panic", func(assert *td.T) {198		assert.CmpPanic(199			func() { NewJsonResponderOrPanic(200, func() {}) },200			td.Ignore())201	})202}203type schemaXML struct {204	Hello string `xml:"hello"`205}206func TestNewXmlResponse(t *testing.T) {207	assert := td.Assert(t)208	body := &schemaXML{"world"}209	b, err := xml.Marshal(body)210	if err != nil {211		t.Fatalf("Cannot xml.Marshal expected body: %s", err)212	}213	expectedBody := string(b)214	dir, cleanup := tmpDir(assert)215	defer cleanup()216	fileName := filepath.Join(dir, "ok.xml")217	writeFile(assert, fileName, b)218	for i, test := range []struct {219		body     interface{}220		expected string221	}{222		{body: body, expected: expectedBody},223		{body: File(fileName), expected: expectedBody},224	} {225		assert.Run(fmt.Sprintf("#%d", i), func(assert *td.T) {226			response, err := NewXmlResponse(200, test.body)227			if !assert.CmpNoError(err) {228				return229			}230			assert.Cmp(response.StatusCode, 200)231			assert.Cmp(response.Header.Get("Content-Type"), "application/xml")232			assertBody(assert, response, test.expected)233		})234	}235	// Error case236	response, err := NewXmlResponse(200, func() {})237	assert.CmpError(err)238	assert.Nil(response)239}240func TestNewXmlResponder(t *testing.T) {241	assert, require := td.AssertRequire(t)242	body := &schemaXML{"world"}243	b, err := xml.Marshal(body)244	require.CmpNoError(err)245	expectedBody := string(b)246	assert.Run("OK", func(assert *td.T) {247		r, err := NewXmlResponder(200, body)248		if assert.CmpNoError(err) {249			checkResponder(assert, r, 200, expectedBody)250		}251	})252	assert.Run("OK file", func(assert *td.T) {253		dir, cleanup := tmpDir(assert)254		defer cleanup()255		fileName := filepath.Join(dir, "ok.xml")256		writeFile(assert, fileName, b)257		r, err := NewXmlResponder(200, File(fileName))258		if assert.CmpNoError(err) {259			checkResponder(assert, r, 200, expectedBody)260		}261	})262	assert.Run("Error", func(assert *td.T) {263		r, err := NewXmlResponder(200, func() {})264		assert.CmpError(err)265		assert.Nil(r)266	})267	assert.Run("OK don't panic", func(assert *td.T) {268		assert.CmpNotPanic(269			func() {270				r := NewXmlResponderOrPanic(200, body)271				checkResponder(assert, r, 200, expectedBody)272			})273	})274	assert.Run("Panic", func(assert *td.T) {275		assert.CmpPanic(276			func() { NewXmlResponderOrPanic(200, func() {}) },277			td.Ignore())278	})279}280func TestNewErrorResponder(t *testing.T) {281	assert, require := td.AssertRequire(t)282	origError := errors.New("oh no")283	responder := NewErrorResponder(origError)284	req, err := http.NewRequest(http.MethodGet, testURL, nil)285	require.CmpNoError(err)286	response, err := responder(req)287	assert.Cmp(err, origError)288	assert.Nil(response)289}290func TestResponseBody(t *testing.T) {291	assert := td.Assert(t)292	const (293		body   = "hello world"294		status = 200295	)296	assert.Run("http.Response", func(assert *td.T) {297		for i, response := range []*http.Response{298			NewBytesResponse(status, []byte(body)),299			NewStringResponse(status, body),300		} {301			assert.Run(fmt.Sprintf("resp #%d", i), func(assert *td.T) {302				assertBody(assert, response, body)303				assert.Cmp(response.StatusCode, status)304				var buf [1]byte305				_, err := response.Body.Read(buf[:])306				assert.Cmp(err, io.EOF)307			})308		}309	})310	assert.Run("Responder", func(assert *td.T) {311		for i, responder := range []Responder{312			NewBytesResponder(200, []byte(body)),313			NewStringResponder(200, body),314		} {315			assert.Run(fmt.Sprintf("resp #%d", i), func(assert *td.T) {316				req, _ := http.NewRequest("GET", "http://foo.bar", nil)317				response, err := responder(req)318				if !assert.CmpNoError(err) {319					return320				}321				assertBody(assert, response, body)322				var buf [1]byte323				_, err = response.Body.Read(buf[:])324				assert.Cmp(err, io.EOF)325			})326		}327	})328}329func TestResponder(t *testing.T) {330	req, err := http.NewRequest(http.MethodGet, "http://foo.bar", nil)331	td.Require(t).CmpNoError(err)332	resp := &http.Response{}333	chk := func(r Responder, expectedResp *http.Response, expectedErr string) {334		t.Helper()335		gotResp, gotErr := r(req)336		td.CmpShallow(t, gotResp, expectedResp)337		var gotErrStr string338		if gotErr != nil {339			gotErrStr = gotErr.Error()340		}341		td.Cmp(t, gotErrStr, expectedErr)342	}343	called := false344	chkNotCalled := func() {345		if called {346			t.Helper()347			t.Errorf("Original responder should not be called")348			called = false349		}350	}351	chkCalled := func() {352		if !called {353			t.Helper()354			t.Errorf("Original responder should be called")355		}356		called = false357	}358	r := Responder(func(*http.Request) (*http.Response, error) {359		called = true360		return resp, nil361	})362	chk(r, resp, "")363	chkCalled()364	//365	// Once366	ro := r.Once()367	chk(ro, resp, "")368	chkCalled()369	chk(ro, nil, "Responder not found for GET http://foo.bar (coz Once and already called 2 times)")370	chkNotCalled()371	chk(ro, nil, "Responder not found for GET http://foo.bar (coz Once and already called 3 times)")372	chkNotCalled()373	ro = r.Once(func(args ...interface{}) {})374	chk(ro, resp, "")375	chkCalled()376	chk(ro, nil, "Responder not found for GET http://foo.bar (coz Once and already called 2 times)")377	chkNotCalled()378	//379	// Times380	rt := r.Times(2)381	chk(rt, resp, "")382	chkCalled()383	chk(rt, resp, "")384	chkCalled()385	chk(rt, nil, "Responder not found for GET http://foo.bar (coz Times and already called 3 times)")386	chkNotCalled()387	chk(rt, nil, "Responder not found for GET http://foo.bar (coz Times and already called 4 times)")388	chkNotCalled()389	rt = r.Times(1, func(args ...interface{}) {})390	chk(rt, resp, "")391	chkCalled()392	chk(rt, nil, "Responder not found for GET http://foo.bar (coz Times and already called 2 times)")393	chkNotCalled()394	//395	// Trace396	rt = r.Trace(func(args ...interface{}) {})397	chk(rt, resp, "")398	chkCalled()399	chk(rt, resp, "")400	chkCalled()401	//402	// Delay403	rt = r.Delay(100 * time.Millisecond)404	before := time.Now()405	chk(rt, resp, "")406	duration := time.Since(before)407	chkCalled()408	td.Cmp(t, duration, td.Gte(100*time.Millisecond), "Responder is delayed")409}410func TestResponder_Then(t *testing.T) {411	assert, require := td.AssertRequire(t)412	req, err := http.NewRequest(http.MethodGet, "http://foo.bar", nil)413	require.CmpNoError(err)414	//415	// Then416	var stack string417	newResponder := func(level string) Responder {418		return func(*http.Request) (*http.Response, error) {419			stack += level420			return NewStringResponse(200, level), nil421		}422	}423	var rt Responder424	chk := func(assert *td.T, expectedLevel, expectedStack string) {425		assert.Helper()...

uploader_test.go

Source:uploader_test.go

...59	}60	return &mock, input, errs61}62func TestMisconfigured(tt *testing.T) {63	assert, _ := td.AssertRequire(tt)64	input := make(chan []byte)65	errs, err := Upload(UploadOptions{66		Client: nil,67		Bucket: "test-bucket",68		GetKey: func(_ time.Time) string {69			return "test-key"70		},71		Input: input,72	})73	assert.Cmp(err, errors.New("no client provided"))74	var c <-chan error = nil75	assert.Cmp(errs, c)76}77func TestUploader(tt *testing.T) {78	assert, require := td.AssertRequire(tt)79	mock, input, errs := config(1024, time.Second*1, 2)80	input <- fixtures[0]81	input <- fixtures[1]82	close(input)83	// Drain.84	for err := range errs {85		assert.Error(err)86	}87	objs := mock.getObjects()88	require.Cmp(len(objs), 1)89	obj := objs[0]90	assert.Cmp(*obj.Bucket, "test-bucket")91	assert.Cmp(*obj.Key, "/test-prefix/0")92	if b, err := ioutil.ReadAll(obj.Body); assert.CmpNoError(err) {93		assert.Cmp(b, []byte{94			31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 172, 208, 191, 106, 28, 65, 12, 6, 240, 222, 143, 161, 250,95			230, 144, 230, 175, 102, 223, 32, 109, 184, 42, 221, 140, 164, 33, 135, 215, 183, 203, 238,96			250, 192, 4, 191, 123, 240, 165, 8, 164, 112, 17, 220, 138, 79, 66, 223, 239, 23, 44, 171,97			109, 237, 184, 46, 55, 152, 64, 77, 182, 183, 245, 128, 19, 188, 238, 182, 125, 83, 152, 32,98			245, 222, 107, 146, 174, 37, 90, 39, 42, 94, 3, 10, 118, 133, 19, 216, 237, 110, 243, 178,99			218, 35, 103, 61, 120, 18, 30, 141, 52, 229, 42, 162, 136, 173, 160, 14, 209, 50, 122, 51,100			173, 53, 103, 47, 173, 177, 105, 26, 230, 153, 53, 75, 231, 212, 48, 138, 81, 234, 12, 39, 56,101			150, 103, 187, 93, 222, 86, 131, 9, 154, 136, 237, 59, 156, 96, 183, 237, 126, 21, 131, 233,102			246, 58, 207, 39, 56, 174, 47, 182, 31, 237, 101, 133, 9, 60, 122, 116, 152, 157, 175, 23,103			239, 39, 207, 19, 210, 185, 4, 252, 241, 113, 170, 237, 207, 223, 109, 110, 199, 245, 110,104			151, 191, 43, 196, 92, 249, 204, 145, 137, 210, 159, 208, 227, 247, 121, 145, 54, 127, 20,105			186, 219, 237, 120, 76, 116, 96, 8, 185, 118, 135, 54, 186, 139, 129, 197, 113, 142, 217, 229,106			220, 52, 139, 145, 161, 68, 120, 127, 250, 50, 189, 56, 178, 146, 145, 138, 199, 22, 71, 172,107			154, 74, 236, 61, 248, 82, 136, 71, 173, 232, 71, 183, 46, 214, 145, 131, 79, 205, 146, 239,108			149, 76, 141, 115, 142, 201, 39, 150, 127, 244, 54, 27, 155, 237, 63, 255, 135, 47, 124, 202,109			87, 145, 206, 24, 2, 113, 248, 148, 175, 214, 136, 35, 21, 118, 100, 152, 92, 172, 13, 93, 45,110			41, 56, 143, 68, 165, 229, 146, 7, 43, 188, 63, 253, 14, 0, 0, 255, 255, 216, 93, 74, 87, 125,111			2, 0, 0,112		})113	}114}115func TestUploaderConcurrent(tt *testing.T) {116	assert, require := td.AssertRequire(tt)117	// The size parameter will force the data into two separate requests.118	mock, input, errs := config(300, time.Second*1, 2)119	input <- fixtures[0]120	input <- fixtures[1]121	close(input)122	// Drain.123	for err := range errs {124		assert.Error(err)125	}126	close(mock.objects)127	objs := make(map[string]*s3.PutObjectInput, 2)128	for obj := range mock.objects {129		objs[*obj.Key] = obj130	}131	require.Cmp(len(objs), 2)132	assert.Cmp(*objs["/test-prefix/0"].Bucket, "test-bucket")133	assert.Cmp(*objs["/test-prefix/1"].Bucket, "test-bucket")134}135func TestUploaderWindow(tt *testing.T) {136	assert, require := td.AssertRequire(tt)137	// The window parameter will force the data into two separate requests.138	mock, input, errs := config(1024, time.Millisecond*100, 2)139	input <- fixtures[0]140	time.Sleep(time.Millisecond * 100)141	for atomic.LoadUint64(&mock.objectCount) < 1 {142		time.Sleep(time.Millisecond * 10)143	}144	input <- fixtures[1]145	close(input)146	// Drain.147	for err := range errs {148		assert.Error(err)149	}150	objs := mock.getObjects()...

order_book_test.go

Source:order_book_test.go

...4	"github.com/maxatome/go-testdeep/td"5	"kraken/internal/orderbook"6)7func TestOrderBook(t *testing.T) {8	assert, require := td.AssertRequire(t)9	// Retrieve all scenarios in 'inout.txt' and their outputs in 'output.txt'10	scenarios, err := orderbook.GetScenarios("testdata")11	require.CmpNoError(err)12	for _, s := range scenarios {13		assert.RunAssertRequire(s.Description,14			func(assert, require *td.T) {15				ob := orderbook.NewOrderBook(s.ShouldTrade)16				output, err := ob.ProcessFromStringInstructions(s.Instructions)17				assert.CmpNoError(err)18				assert.Cmp(output, s.Output)19			})20	}21}...

AssertRequire

Using AI Code Generation

1import (2func TestAssertRequire(t *testing.T) {3	fmt.Println("TestAssertRequire")4	assert := assert.New(t)5	assert.Require(1 == 1, "1 is not equal to 1")6}

AssertRequire

Using AI Code Generation

1import (2func main() {3	td.AssertRequire("2.go", 7, "td.AssertRequire")4	fmt.Println("passed")5}6func init() {7	tests.Register("TestAssertRequire", TestAssertRequire)8}9func TestAssertRequire() {10	gotest.Trace("TestAssertRequire")11	if !(x == 7) {12		panic("assertion failed")13	}14}

AssertRequire

Using AI Code Generation

1import (2func TestAssertRequire(t *testing.T) {3	assert.Equal(t, 3, 3, "Both are equal")4	assert.NotEqual(t, 3, 4, "Both are not equal")5	assert.True(t, 3 == 3, "Both are equal")6	assert.False(t, 3 == 4, "Both are not equal")7	assert.NoError(t, nil, "No error")8	assert.Error(t, fmt.Errorf("error"), "Error")9	assert.Nil(t, nil, "Nil")10	assert.NotNil(t, 3, "Not nil")11	assert.Empty(t, "", "Empty")12	assert.NotEmpty(t, 3, "Not empty")13	assert.Contains(t, "Hello", "He", "Contains")14	assert.NotContains(t, "Hello", "Hi", "Not contains")15	assert.Len(t, "Hello", 5, "Length")16	assert.NotLen(t, "Hello", 6, "Not length")17	assert.Greater(t, 3, 2, "Greater")18	assert.NotGreater(t, 3, 4, "Not greater")19	assert.GreaterOrEqual(t, 3, 3, "Greater or equal")20	assert.NotGreaterOrEqual(t, 3, 4, "Not greater or equal")21	assert.Less(t, 3, 4, "Less")22	assert.NotLess(t, 3, 2, "Not less")23	assert.LessOrEqual(t, 3, 3, "Less or equal")

AssertRequire

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello World!")4}5func TestAssertRequire(t *testing.T) {6	td := new(TestData)7	td.AssertRequire(t, 5)8}

AssertRequire

Using AI Code Generation

1import (2func TestAssertRequire(t *testing.T) {3	fmt.Println("TestAssertRequire")4	var a interface{} = "abc"5	var b interface{} = "abc"6	actual := AssertRequire(a, b)7	fmt.Println(actual)8}9import (10func TestAssertRequire(t *testing.T) {11	fmt.Println("TestAssertRequire")12	var a interface{} = "abc"13	var b interface{} = "abc"14	actual := AssertRequire(a, b)15	fmt.Println(actual)16}17import (18func TestAssertRequire(t *testing.T) {19	fmt.Println("TestAssertRequire")20	var a interface{} = "abc"21	var b interface{} = "abc"22	actual := AssertRequire(a, b)23	fmt.Println(actual)24}25import (26func TestAssertRequire(t *testing.T) {27	fmt.Println("TestAssertRequire")28	var a interface{} = "abc"29	var b interface{} = "abc"30	actual := AssertRequire(a, b)31	fmt.Println(actual)32}33import (34func TestAssertRequire(t *testing.T) {35	fmt.Println("TestAssertRequire")36	var a interface{} = "abc"37	var b interface{} = "abc"38	actual := AssertRequire(a, b)39	fmt.Println(actual)40}41import (42func TestAssertRequire(t *testing.T) {43	fmt.Println("TestAssertRequire")44	var a interface{} = "abc"45	var b interface{} = "abc"46	actual := AssertRequire(a, b)47	fmt.Println(actual)48}49import (50func TestAssertRequire(t *testing.T) {51	fmt.Println("TestAssertRequire")52	var a interface{} = "abc"53	var b interface{} =

AssertRequire

Using AI Code Generation

1import "fmt"2func main() {3	fmt.Println("Hello World")4	fmt.Println("Enter a number")5	fmt.Scanln(&a)6	fmt.Println("Entered number is", a)7}

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.