Golang Rejectの例

コード例 #1

ファイル: request_test.go プロジェクト: tomas-fp/gentleman

func TestRequestAlreadyDispatched(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, world")
	}))
	defer ts.Close()

	req := NewRequest()
	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		h.Next(ctx)
	})

	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		u, _ := url.Parse(ts.URL)
		ctx.Request.URL = u
		h.Next(ctx)
	})

	res, err := req.Send()
	st.Expect(t, err, nil)
	st.Reject(t, res.RawRequest.URL, nil)
	st.Expect(t, res.StatusCode, 200)

	res, err = req.Send()
	st.Reject(t, err, nil)
}

コード例 #2

ファイル: conn_test.go プロジェクト: wbond/epp

func TestConnClose(t *testing.T) {
	c, err := NewConn(testDial(t))
	st.Expect(t, err, nil)
	st.Reject(t, c, nil)
	st.Reject(t, c.Greeting.ServerName, "")
	err = c.Close()
	st.Expect(t, err, nil)
}

コード例 #3

ファイル: readme_test.go プロジェクト: ryanfaerman/st

// Allows comparing non-comparable types to prevent panics when comparing slices
// or maps.
func TestDeeperEquality(t *testing.T) {
	type testStr string
	slice1 := []interface{}{"A", 1, []byte("steak sauce")}
	slice2 := []interface{}{"R", 2, 'd', int64(2)}
	map1 := map[string]string{"clever": "crafty", "modest": "prim"}
	map2 := map[string]string{"silk": "scarf", "wool": "sweater"}
	str1 := "same"
	str2 := testStr("same")

	st.Expect(t, slice1, slice2)
	st.Reject(t, slice1, slice1)
	st.Expect(t, map1, map2)
	st.Reject(t, map1, map1)
	st.Expect(t, str1, str2)
	st.Reject(t, str1, str1)
}

コード例 #4

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseSaveToFileError(t *testing.T) {
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	res, _ := buildResponse(ctx)
	err := res.SaveToFile("body.tmp")
	st.Reject(t, err, nil)
}

コード例 #5

ファイル: readme_test.go プロジェクト: paulhammond/st

func TestExample(t *testing.T) {
	st.Expect(t, "a", "a")
	st.Reject(t, 42, int64(42))

	st.Assert(t, "t", "t")
	st.Refute(t, 99, int64(99))
}

コード例 #6

ファイル: request_test.go プロジェクト: tomas-fp/gentleman

func TestMiddlewareErrorInjectionAndInterception(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, world")
	}))
	defer ts.Close()

	req := NewRequest()
	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		h.Next(ctx)
	})

	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		u, _ := url.Parse(ts.URL)
		ctx.Request.URL = u
		h.Error(ctx, errors.New("Error"))
	})

	req.UseError(func(ctx *context.Context, h context.Handler) {
		ctx.Error = nil
		h.Next(ctx)
	})

	res, err := req.Send()
	st.Expect(t, err, nil)
	st.Reject(t, res.RawRequest.URL, nil)
	st.Expect(t, res.StatusCode, 200)
}

コード例 #7

ファイル: readme_test.go プロジェクト: ryanfaerman/st

// Prints failure output, including the correct line number.
func TestFailedExpectationMessages(t *testing.T) {
	t.Log("Tests purposely fail to demonstrate output")
	st.Expect(t, 1, 2)
	st.Reject(t, "same", "same")
	var typedNil *string
	st.Expect(t, typedNil, nil) // in Go, a typed nil != nil
}

コード例 #8

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseCloseError(t *testing.T) {
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	res, _ := buildResponse(ctx)
	err := res.Close()
	st.Reject(t, err, nil)
	st.Expect(t, err.Error(), "foo error")
}

コード例 #9

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseBytesError(t *testing.T) {
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	utils.WriteBodyString(ctx.Response, "foo bar")
	res, err := buildResponse(ctx)
	body := res.Bytes()
	st.Reject(t, err, nil)
	st.Expect(t, string(body), "")
}

コード例 #10

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseReadError(t *testing.T) {
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	res, _ := buildResponse(ctx)
	num, err := res.Read([]byte{})
	st.Reject(t, err, nil)
	st.Expect(t, err.Error(), "foo error")
	st.Expect(t, num, -1)
}

コード例 #11

ファイル: dispatcher_test.go プロジェクト: tomas-fp/gentleman

func TestDispatcherError(t *testing.T) {
	req := NewRequest()
	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		u, _ := url.Parse("http://127.0.0.1:9123")
		ctx.Request.URL = u
		h.Next(ctx)
	})

	var err error
	req.UseError(func(ctx *context.Context, h context.Handler) {
		err = ctx.Error
		h.Next(ctx)
	})

	ctx := NewDispatcher(req).Dispatch()
	st.Reject(t, err, nil)
	st.Reject(t, ctx.Error, nil)
}

コード例 #12

ファイル: response_test.go プロジェクト: moomerman/whois

func TestReadMIME(t *testing.T) {
	fns, err := whoistest.ResponseFiles()
	st.Assert(t, err, nil)
	for _, fn := range fns {
		// fmt.Printf("%s\n", fn)
		res, err := ReadMIMEFile(fn)
		st.Reject(t, res, nil)
		st.Expect(t, err, nil)
		// fmt.Printf("%#v\n\n", res)
	}
}

コード例 #13

ファイル: dispatcher_test.go プロジェクト: tomas-fp/gentleman

func TestDispatcherResponseError(t *testing.T) {
	req := NewRequest().URL("http://127.0.0.1:9123")
	req.UseError(func(ctx *context.Context, h context.Handler) {
		ctx.Response.StatusCode = 503
		h.Next(ctx)
	})

	ctx := NewDispatcher(req).Dispatch()
	st.Reject(t, ctx.Error, nil)
	st.Expect(t, ctx.Response.StatusCode, 503)
}

コード例 #14

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseReaderBufferError(t *testing.T) {
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	res, err := buildResponse(ctx)
	body := res.Bytes()
	st.Reject(t, err, nil)
	st.Expect(t, string(body), "")
	st.Expect(t, res.buffer.Len(), 0)
	res.ClearInternalBuffer()
	st.Expect(t, res.buffer.Len(), 0)
}

コード例 #15

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseJSONError(t *testing.T) {
	type jsonData struct {
		Foo string `json:foo`
	}
	json := &jsonData{}
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	res, _ := buildResponse(ctx)
	err := res.JSON(json)
	st.Reject(t, err, nil)
	st.Expect(t, json.Foo, "")
}

コード例 #16

ファイル: check_test.go プロジェクト: wrouesnel/epp

func TestConnCheck(t *testing.T) {
	c := testLogin(t)

	dcr, err := c.CheckDomain("google.com")
	st.Expect(t, err, nil)
	st.Reject(t, dcr, nil)
	st.Expect(t, len(dcr.Checks), 1)
	st.Expect(t, dcr.Checks[0].Domain, "google.com")
	st.Expect(t, dcr.Checks[0].Available, false)

	dcr, err = c.CheckDomain("dmnr-test-x759824vim-i2.com")
	st.Expect(t, err, nil)
	st.Reject(t, dcr, nil)
	st.Expect(t, len(dcr.Checks), 1)
	st.Expect(t, dcr.Checks[0].Domain, "dmnr-test-x759824vim-i2.com")
	st.Expect(t, dcr.Checks[0].Available, true)

	dcr, err = c.CheckDomain("--dmnr-test--.com")
	st.Reject(t, err, nil)
	st.Expect(t, dcr, (*DomainCheckResponse)(nil))
}

コード例 #17

ファイル: response_test.go プロジェクト: tomas-fp/gentleman

func TestResponseXMLError(t *testing.T) {
	type xml struct {
		Foo string `xml:"foo"`
	}
	xmlData := &xml{}
	ctx := NewContext()
	ctx.Error = errors.New("foo error")
	utils.WriteBodyString(ctx.Response, `<xml><foo>bar</foo></xml>`)
	res, _ := buildResponse(ctx)
	err := res.XML(xmlData, nil)
	st.Reject(t, err, nil)
	st.Expect(t, xmlData.Foo, "")
}

コード例 #18

ファイル: dispatcher_test.go プロジェクト: tomas-fp/gentleman

func TestDispatcherStoppedMiddleware(t *testing.T) {
	req := NewRequest().URL("http://127.0.0.1:9123")

	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		ctx.Set("foo", "bar")
		h.Stop(ctx)
	})
	req.UseHandler("stop", func(ctx *context.Context, h context.Handler) {
		h.Error(ctx, errors.New("stop"))
	})

	ctx := NewDispatcher(req).Dispatch()
	st.Expect(t, ctx.Stopped, true)
	st.Reject(t, ctx.Error, nil)
	st.Expect(t, ctx.Error.Error(), "stop")
	st.Expect(t, ctx.GetString("foo"), "bar")
}

コード例 #19

ファイル: readme_test.go プロジェクト: paulhammond/st

func TestTableExample(t *testing.T) {
	examples := []struct{ a, t string }{
		{"first", "first"},
		{"second", "second"},
	}

	// Pass example index to improve the error message for table-based tests.
	for i, ex := range examples {
		st.Expect(t, ex, ex, i)
		st.Reject(t, ex, &ex, i)
	}

	// Cannot pass index into Assert or Refute, they fail fast.
	for _, ex := range examples {
		st.Assert(t, ex, ex)
		st.Refute(t, ex, &ex)
	}
}

コード例 #20

ファイル: request_test.go プロジェクト: tomas-fp/gentleman

func TestRequestTimeout(t *testing.T) {
	if runtime.Version() != "go1.6" {
		return
	}

	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(1000 * time.Millisecond)
		fmt.Fprintln(w, "Hello, world")
	}))
	defer ts.Close()

	req := NewRequest().URL(ts.URL)

	req.UseRequest(func(ctx *context.Context, h context.Handler) {
		ctx.Client.Timeout = 50 * time.Millisecond
		h.Next(ctx)
	})

	res, err := req.Send()
	st.Reject(t, err, nil)
	st.Expect(t, strings.Contains(err.Error(), "net/http: request canceled"), true)
	st.Expect(t, res.StatusCode, 0)
}

コード例 #21

ファイル: readme_test.go プロジェクト: paulhammond/st

// Prints failure output, including the correct line number.
func TestFailedExpectationMessages(t *testing.T) {
	st.Expect(t, 1, 2)
	st.Reject(t, "same", "same")
	var typedNil *string
	st.Expect(t, typedNil, nil) // in Go, a typed nil != nil
}

コード例 #22

ファイル: readme_test.go プロジェクト: paulhammond/st

// Prints failure output, including the correct line number.
func TestFailedRefuteMessage(t *testing.T) {
	st.Reject(t, 42, 7*6)
}

コード例 #23

ファイル: request_test.go プロジェクト: tomas-fp/gentleman

func TestRequestCookieJar(t *testing.T) {
	req := NewRequest()
	req.CookieJar()
	req.Middleware.Run("request", req.Context)
	st.Reject(t, req.Context.Client.Jar, nil)
}