Example #1
1
func postJSON(jsonMessage []byte, url string) (*http.Response, error) {
	timeout := time.Duration(5 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	return client.Post(url, contentTypeJSON, bytes.NewBuffer(jsonMessage))
}
Example #2
0
func Plusone(httpClient *http.Client, url string) (int, error) {
	resp, err := httpClient.Post(
		"https://clients6.google.com/rpc?key=AIzaSyCKSbrvQasunBoV16zDH9R33D88CeLr9gQ",
		"application/json",
		villa.NewPByteSlice([]byte(`[{"method":"pos.plusones.get","id":"p","params":{"nolog":true,"id": "`+
			url+`","source":"widget","userId":"@viewer","groupId":"@self"},"jsonrpc":"2.0","key":"p","apiVersion":"v1"}]`)))
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()

	dec := json.NewDecoder(resp.Body)
	var v [1]struct {
		Result struct {
			Metadata struct {
				GlobalCounts struct {
					Count float64
				}
			}
		}
	}
	if err := dec.Decode(&v); err != nil {
		return 0, err
	}

	return int(0.5 + v[0].Result.Metadata.GlobalCounts.Count), nil
}
Example #3
0
File: api.go Project: leobcn/health
// Notify will send the error and stack trace to Bugsnag. Note that this doesn't take advantage of all of Bugsnag's capabilities.
func Notify(config *Config, jobName string, eventName string, err error, trace *stack.Trace, kvs map[string]string) error {

	// Make a struct that serializes to the JSON needed for the API request to bugsnag
	p := newPayload(config, jobName, eventName, err, trace, kvs)

	// JSON serialize it
	data, err := json.MarshalIndent(p, "", "\t")
	if err != nil {
		return err
	}

	// Post it to the server:
	client := http.Client{}
	resp, err := client.Post(config.Endpoint, "application/json", bytes.NewBuffer(data))
	if err != nil {
		return err
	}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if string(body) != "OK" {
		return fmt.Errorf("response from bugsnag wasn't 'OK'")
	}

	return nil
}
Example #4
0
func sendMapToPipeviz(m *ingest.Message, r *git.Repository) {
	addr, err := GetTargetAddr(r)
	// Find the target pipeviz instance from the git config
	if err != nil {
		log.Fatalln("Could not find target address in config:", err)
	}

	msg, err := json.Marshal(m)
	if err != nil {
		log.Fatalln("JSON encoding failed with err:", err)
	}
	//dump, _ := json.MarshalIndent(m, "", "    ")
	//fmt.Println(string(dump))

	client := http.Client{Timeout: 3 * time.Second}
	resp, err := client.Post(addr, "application/json", bytes.NewReader(msg))
	if err != nil {
		log.Fatalln("Error on sending to server:", err)
	}

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		bod, err := ioutil.ReadAll(resp.Body)
		resp.Body.Close()
		if err != nil {
			log.Fatalf(err.Error())
		}

		log.Fatalln("Message rejected by pipeviz server: %v", string(bod))
	}
}
Example #5
0
// Upload uploads data to logstore and returns logPath.
// data will be compressed.
func Upload(client *http.Client, prefix string, data []byte) (string, error) {
	hd := sha256.Sum256(data)
	h := base64.URLEncoding.EncodeToString(hd[:])
	logPath := path.Join("upload", fmt.Sprintf("%s.%s.gz", prefix, h))
	var buf bytes.Buffer
	gw := gzip.NewWriter(&buf)
	gw.Write(data)
	err := gw.Close()
	if err != nil {
		return "", err
	}

	// https://cloud.google.com/storage/docs/json_api/v1/how-tos/upload#simple
	requrl := fmt.Sprintf(`https://www.googleapis.com/upload/storage/v1/b/chromium-build-stats.appspot.com/o?uploadType=media&name=%s`, logPath)
	resp, err := client.Post(requrl, "application/octet-data", bytes.NewReader(buf.Bytes()))
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if resp.StatusCode != 200 {
		return "", fmt.Errorf("upload status: %s %d %s: %s: %v", requrl, resp.StatusCode, resp.Status, body, err)
	}
	return logPath, nil
}
Example #6
0
func v1CompatBroadcast(
	ctx *grader.Context,
	client *http.Client,
	message *broadcaster.Message,
) error {
	marshaled, err := json.Marshal(message)
	if err != nil {
		return err
	}

	resp, err := client.Post(
		"https://localhost:32672/broadcast/",
		"text/json",
		bytes.NewReader(marshaled),
	)
	if err != nil {
		return err
	}
	if resp.StatusCode != 200 {
		return fmt.Errorf(
			"Request to broadcast failed with error code %d",
			resp.StatusCode,
		)
	}
	return nil
}
Example #7
0
// Like Verify on a parsed URL
func VerifyValues(values url.Values) (grant bool, identifier string, err error) {
	err = nil

	var postArgs url.Values
	postArgs = url.Values(map[string][]string{})

	// Create the url
	URLEndPoint := values.Get("openid.op_endpoint")
	if URLEndPoint == "" {
		log.Printf("no openid.op_endpoint")
		return false, "", errors.New("no openid.op_endpoint")
	}
	for k, v := range values {
		postArgs[k] = v
	}
	postArgs.Set("openid.mode", "check_authentication")
	postContent := postArgs.Encode()

	// Post the request
	var client = new(http.Client)
	postReader := bytes.NewBuffer([]byte(postContent))
	response, err := client.Post(URLEndPoint, "application/x-www-form-urlencoded", postReader)
	if err != nil {
		log.Printf("VerifyValues failed at post")
		return false, "", err
	}

	// Parse the response
	// Convert the reader
	// We limit the size of the response to 1024 bytes but it should be large enough for most cases
	buffer := make([]byte, 1024)
	_, err = response.Body.Read(buffer)
	if err != nil {
		log.Printf("VerifyValues failed reading response")
		return false, "", err
	}

	// Check for ns
	rematch := REVerifyDirectNs.FindSubmatch(buffer)
	if rematch == nil {
		return false, "", errors.New("VerifyValues: ns value not found on the response of the OP")
	}
	nsValue := string(rematch[1])
	if !bytes.Equal([]byte(nsValue), []byte("http://specs.openid.net/auth/2.0")) {
		return false, "", errors.New("VerifyValues: ns value not correct: " + nsValue)
	}

	// Check for is_valid
	match, err := regexp.Match(REVerifyDirectIsValid, buffer)
	if err != nil {
		return false, "", err
	}

	identifier = values.Get("openid.claimed_id")
	if !match {
		log.Printf("no is_valid:true in \"%s\"", buffer)
	}

	return match, identifier, nil
}
Example #8
0
func sendMatchData(src io.Reader, addr string) (MatchHash, error) {
	cl := http.Client{}

	url := fmt.Sprintf("http://%s/api/matches/new", addr)

	log.Printf("posting to URL: %s", url)

	resp, err := cl.Post(url, "application/vnd.q3-match-stats", src)
	if err != nil {
		return emptyHash, errors.Wrap(err, "posting match data failed")
	}

	log.Printf("response: %d", resp.StatusCode)

	if resp.StatusCode != http.StatusOK {
		return emptyHash, fmt.Errorf("request failed with status: %d",
			resp.StatusCode)
	}

	matchhash, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return emptyHash, errors.Wrap(err, "failed to receive response")
	}

	return MatchHash(matchhash), nil
}
Example #9
0
func submitSerialRequest(t *state.Task, serialRequest string, client *http.Client) (*asserts.Serial, error) {
	st := t.State()
	st.Unlock()
	defer st.Lock()
	resp, err := client.Post(serialRequestURL, asserts.MediaType, bytes.NewBufferString(serialRequest))
	if err != nil {
		return nil, retryErr(t, "cannot deliver device serial request: %v", err)
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200, 201:
	case 202:
		return nil, errPoll
	default:
		return nil, retryErr(t, "cannot deliver device serial request: unexpected status %d", resp.StatusCode)
	}

	// decode body with serial assertion
	dec := asserts.NewDecoder(resp.Body)
	got, err := dec.Decode()
	if err != nil { // assume broken i/o
		return nil, retryErr(t, "cannot read response to request for a serial: %v", err)
	}

	serial, ok := got.(*asserts.Serial)
	if !ok {
		return nil, fmt.Errorf("cannot use device serial assertion of type %q", got.Type().Name)
	}

	return serial, nil
}
Example #10
0
// SendRequest sends a SMS using provided SmsSendRequest structure.
func (self Session) SendRequest(request SmsSendRequest) (result *SmsSendResult, err error) {
	request.Login = self.Login
	request.Password = self.Password

	data, err := xml.Marshal(&request)
	if err != nil {
		return nil, err
	}

	client := http.Client{
		// Self-signed certificate workaround
		Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}},
	}
	response, err := client.Post(ServiceAddress, "application/xml", bytes.NewBuffer(data))
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	data, err = ioutil.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}

	result = &SmsSendResult{}
	err = xml.Unmarshal(data, result)
	if err != nil {
		return nil, err
	}

	if result.Code != 1 {
		return nil, &SendError{result.Code, result.CodeDescription}
	}
	return result, nil
}
Example #11
0
File: fun.go Project: qgweb/new
// 统计数据
func StatisticsData(db, key, val, opt string) error {
	client := http.Client{
		Transport: &http.Transport{
			Dial: func(netw, addr string) (net.Conn, error) {
				deadline := time.Now().Add(10 * time.Second)
				c, err := net.DialTimeout(netw, addr, time.Second*10)
				if err != nil {
					return nil, err
				}
				c.SetDeadline(deadline)
				return c, nil
			},
		},
	}
	surl := GetConfVal("default::stats_url")
	v := url.Values{}
	v.Set("db", db)
	v.Set("key", key)
	v.Set("value", val)
	v.Set("opt", opt)

	res, err := client.Post(surl+"api/create", "application/x-www-form-urlencoded",
		ioutil.NopCloser(strings.NewReader(v.Encode())))
	if err != nil {
		return err
	}

	if res != nil && res.Body != nil {
		res.Body.Close()
	}
	return nil
}
func reportLaunch() {
	json := fmt.Sprintf(`{"os": "%s", "arch": "%s", "app": "gollector"}`, runtime.GOOS, runtime.GOARCH)
	data := bytes.NewBufferString(json)
	client := http.Client{Timeout: time.Duration(5 * time.Second)}
	go client.Post("https://logs-01.loggly.com/inputs/8a0edd84-92ba-46e4-ada8-c529d0f105af/tag/reporting/",
		"application/json", data)
}
Example #13
0
// postPhoto uses the Buzz API to post the image to the user's Buzz stream.
func postPhoto(client *http.Client, photoURL string) error {
	const url = "https://www.googleapis.com/buzz/v1/activities/@me/@self"
	const text = "Moustachio"

	type m map[string]interface{}
	post := m{"data": m{"object": m{
		"type":    "note",
		"content": text,
		"attachments": []m{{
			"type":    "photo",
			"content": text,
			"links": m{
				"enclosure": []m{{
					"href": photoURL,
					"type": "image/jpeg",
				}},
			},
		}},
	}}}

	b, err := json.Marshal(post)
	if err != nil {
		return err
	}
	resp, err := client.Post(url, "application/json", bytes.NewBuffer(b))
	if err != nil {
		return err
	}
	if resp.StatusCode != 200 {
		return errors.New("invalid post " + resp.Status)
	}
	return nil
}
// Retry wrapper for http://golang.org/pkg/net/http/#Client.Post where attempts is the number of http calls made (one plus number of retries).
func (httpRetryClient *Client) ClientPost(c *http.Client, url string, bodyType string, body []byte) (resp *http.Response, attempts int, err error) {
	return httpRetryClient.Retry(func() (*http.Response, error, error) {
		resp, err := c.Post(url, bodyType, bytes.NewBuffer(body))
		// assume all errors should result in a retry
		return resp, err, nil
	})
}
Example #15
0
func sendBadBlockReport(block *types.Block, err error) {
	if !EnableBadBlockReporting {
		return
	}

	var (
		blockRLP, _ = rlp.EncodeToBytes(block)
		params      = map[string]interface{}{
			"block":     common.Bytes2Hex(blockRLP),
			"blockHash": block.Hash().Hex(),
			"errortype": err.Error(),
			"client":    "go",
		}
	)
	if !block.ReceivedAt.IsZero() {
		params["receivedAt"] = block.ReceivedAt.UTC().String()
	}
	if p, ok := block.ReceivedFrom.(*peer); ok {
		params["receivedFrom"] = map[string]interface{}{
			"enode":           fmt.Sprintf("enode://%x@%v", p.ID(), p.RemoteAddr()),
			"name":            p.Name(),
			"protocolVersion": p.version,
		}
	}
	jsonStr, _ := json.Marshal(map[string]interface{}{"method": "eth_badBlock", "id": "1", "jsonrpc": "2.0", "params": []interface{}{params}})
	client := http.Client{Timeout: 8 * time.Second}
	resp, err := client.Post(badBlocksURL, "application/json", bytes.NewReader(jsonStr))
	if err != nil {
		glog.V(logger.Debug).Infoln(err)
		return
	}
	glog.V(logger.Debug).Infof("Bad Block Report posted (%d)", resp.StatusCode)
	resp.Body.Close()
}
Example #16
0
func (e *Endpoint) Think(state *common.RobotState) (*common.RobotCommands, error) {
	timeout := time.Duration(5 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	u, err := url.Parse(e.Root)
	if err != nil {
		return nil, err
	}
	u.Path = "think"

	log.Println("Making request to ", u.String())
	js, _ := json.Marshal(state)
	r, err := client.Post(u.String(), "application/json", bytes.NewBuffer(js))
	if err != nil {
		return nil, err
	}
	if r.StatusCode != http.StatusOK {
		return nil, errors.New(fmt.Sprintf("expected HTTP 200 - OK, got %v", r.StatusCode))
	} else {
		log.Println("OK")
	}

	decoder := json.NewDecoder(r.Body)
	message := &common.RobotCommands{}
	err = decoder.Decode(message)
	if err != nil {
		log.Println(err)
		return nil, err
	}

	return message, nil
}
Example #17
0
func (p *payload) deliver() error {

	if len(p.APIKey) != 32 {
		return fmt.Errorf("bugsnag/payload.deliver: invalid api key")
	}

	buf, err := json.Marshal(p)

	if err != nil {
		return fmt.Errorf("bugsnag/payload.deliver: %v", err)
	}

	client := http.Client{
		Transport: p.Transport,
	}

	resp, err := client.Post(p.Endpoint, "application/json", bytes.NewBuffer(buf))

	if err != nil {
		return fmt.Errorf("bugsnag/payload.deliver: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("bugsnag/payload.deliver: Got HTTP %s\n", resp.Status)
	}

	return nil
}
Example #18
0
func (r *StdAlgTest) DoRequest(client *http.Client, resChan chan PerfResult) {
	var tpReq tpRequest
	tpReq.Points = make([]tpPoint, numPoints)
	for i := uint(0); i < numPoints; i++ {
		tpReq.Points[int(i)] = tpPoint{int32(random(lowerLat, upperLat) * 1.0e+7), int32(random(leftLon, rightLon) * 1.0e+7)}
	}
	tpReq.Constraints = make(map[string]interface{})
	if constrained != "" {
		tpReq.Constraints[constrained] = intConstrained
	}
	b, err := json.Marshal(tpReq)
	if err != nil {
		fmt.Println(err)
		return
	}
	startTime := time.Now()
	response, err := client.Post(r.Server+"/alg"+algSuffix, "application/x-jackson-smile", bytes.NewBuffer(b))
	if err != nil {
		fmt.Println(err)
		return
	}
	contentLength := response.ContentLength
	var length int
	if contentLength < 0 {
		length, err = response.Body.Read(r.buffer[:])
		for err == nil {
			contentLength += int64(length)
			length, err = response.Body.Read(r.buffer[:])
		}
	}

	response.Body.Close()
	resChan <- PerfResult{response.StatusCode, time.Since(startTime), contentLength}
}
Example #19
0
func sendUsageStats() {
	log.Trace("Sending anonymous usage stats to stats.grafana.org")

	version := strings.Replace(setting.BuildVersion, ".", "_", -1)

	metrics := map[string]interface{}{}
	report := map[string]interface{}{
		"version": version,
		"metrics": metrics,
	}

	UsageStats.Each(func(name string, i interface{}) {
		switch metric := i.(type) {
		case Counter:
			if metric.Count() > 0 {
				metrics[name+".count"] = metric.Count()
				metric.Clear()
			}
		}
	})

	statsQuery := m.GetSystemStatsQuery{}
	if err := bus.Dispatch(&statsQuery); err != nil {
		log.Error(3, "Failed to get system stats", err)
		return
	}

	metrics["stats.dashboards.count"] = statsQuery.Result.DashboardCount
	metrics["stats.users.count"] = statsQuery.Result.UserCount
	metrics["stats.orgs.count"] = statsQuery.Result.OrgCount
	metrics["stats.playlist.count"] = statsQuery.Result.PlaylistCount
	metrics["stats.plugins.apps.count"] = len(plugins.Apps)
	metrics["stats.plugins.panels.count"] = len(plugins.Panels)
	metrics["stats.plugins.datasources.count"] = len(plugins.DataSources)

	dsStats := m.GetDataSourceStatsQuery{}
	if err := bus.Dispatch(&dsStats); err != nil {
		log.Error(3, "Failed to get datasource stats", err)
		return
	}

	// send counters for each data source
	// but ignore any custom data sources
	// as sending that name could be sensitive information
	dsOtherCount := 0
	for _, dsStat := range dsStats.Result {
		if m.IsKnownDataSourcePlugin(dsStat.Type) {
			metrics["stats.ds."+dsStat.Type+".count"] = dsStat.Count
		} else {
			dsOtherCount += dsStat.Count
		}
	}
	metrics["stats.ds.other.count"] = dsOtherCount

	out, _ := json.MarshalIndent(report, "", " ")
	data := bytes.NewBuffer(out)

	client := http.Client{Timeout: time.Duration(5 * time.Second)}
	go client.Post("https://stats.grafana.org/grafana-usage-report", "application/json", data)
}
Example #20
0
func (h *harness) postInOut(c *http.Client, s string, t *testing.T) string {
	res, err := c.Post(h.baseUrl+"inout", "text/plain",
		bytes.NewBuffer(([]byte)(s)))
	require.Nil(t, err)
	require.Equal(t, http.StatusOK, res.StatusCode)
	return readAll(res.Body, t)
}
Example #21
0
// POST the given JSON body to Rollbar synchronously.
func post(body map[string]interface{}, httpClient *http.Client) {
	if len(Token) == 0 {
		stderr("empty token")
		return
	}

	jsonBody, err := json.Marshal(body)
	if err != nil {
		stderr("failed to encode payload: %s", err.Error())
		return
	}

	if httpClient == nil {
		httpClient = &http.Client{}
	}

	resp, err := httpClient.Post(Endpoint, "application/json", bytes.NewReader(jsonBody))
	if err != nil {
		stderr("POST failed: %s", err.Error())
		return
	} else if resp.StatusCode != 200 {
		stderr("received response: %s", resp.Status)
	}
	if resp != nil {
		resp.Body.Close()
	}
	defer resp.Body.Close()
}
Example #22
0
// QueryResponse performs a v2 OpenTSDB request to the given host. host should
// be of the form hostname:port. A nil client uses DefaultClient.
func (r *Request) QueryResponse(host string, client *http.Client) (*http.Response, error) {
	u := url.URL{
		Scheme: "http",
		Host:   host,
		Path:   "/api/query",
	}
	b, err := json.Marshal(&r)
	if err != nil {
		return nil, err
	}
	if client == nil {
		client = DefaultClient
	}
	resp, err := client.Post(u.String(), "application/json", bytes.NewReader(b))
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		e := RequestError{Request: string(b)}
		defer resp.Body.Close()
		body, _ := ioutil.ReadAll(resp.Body)
		if err := json.NewDecoder(bytes.NewBuffer(body)).Decode(&e); err == nil {
			return nil, &e
		}
		s := fmt.Sprintf("opentsdb: %s", resp.Status)
		if len(body) > 0 {
			s = fmt.Sprintf("%s: %s", s, body)
		}
		return nil, errors.New(s)
	}
	return resp, nil
}
Example #23
0
func reportLaunch() {
	json := fmt.Sprintf(`{"os": "%s", "arch": "%s", "gomaxprocs": %d, "numcpu": %d, "numshards": %d, "app": "ekanited"}`,
		runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0), runtime.NumCPU(), numShards)
	data := bytes.NewBufferString(json)
	client := http.Client{Timeout: time.Duration(5 * time.Second)}
	go client.Post("https://logs-01.loggly.com/inputs/8a0edd84-92ba-46e4-ada8-c529d0f105af/tag/reporting/",
		"application/json", data)
}
func RunAvailabilityScenario(url string, client *http.Client) error {
	resp, err := client.Post(url, "application/json", nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return nil
}
Example #25
0
func getMonthPhotos(cxt appengine.Context, httpClient *http.Client, apiIndex int) (success bool, photos *Photos) {
	now := time.Now()
	year := now.Year()
	month := int(now.Month())

	response, err := httpClient.Post(fmt.Sprintf("http://nasa-photo-dev%d.appspot.com/month_list", apiIndex), "application/json", bytes.NewBufferString(fmt.Sprintf(`{"reqId":"%s","year":%d, "month" : %d, "timeZone":"CET"}`, NewV4().String(), year, month)))
	return getPhotos(cxt, response, err)
}
Example #26
0
func (suite *RouterTestSuite) TestPostFail() {
	client := http.Client{}
	res, err := client.Post(suite.server.URL, "application/text", nil)
	if err != nil {
		suite.Fail("POST request failed", err)
	}
	res.Body.Close()
	suite.Equal(http.StatusBadRequest, res.StatusCode)
}
Example #27
0
func post_url(client *http.Client, url string, post_data string) (response []byte, header http.Header) {
	resp, err := client.Post(url, "application/x-www-form-urlencoded", strings.NewReader(post_data))
	if err != nil {
		// handle error
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	return body, resp.Header
}
Example #28
0
func (suite *RouterTestSuite) TestPost() {
	client := http.Client{}
	res, err := client.Post(suite.server.URL, "application/text", strings.NewReader(ResponseBody))
	if err != nil {
		suite.Fail("POST request failed", err)
	}
	res.Body.Close()
	suite.Equal(http.StatusOK, res.StatusCode)
}
Example #29
0
// Ensure the server can handle a request.
func TestHTTPServerRequest(t *testing.T) {
	addr := "localhost:64000"
	path := "/test"
	status := 200
	request := "ping"
	response := "pong"
	uri := "http://" + addr + path

	requests := make(chan MockRequest, 1)
	defer close(requests)
	handler := NewMockHandler(t, status, []byte(response), requests)
	server := NewHTTPServer(addr, handler)

	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		if err := server.ListenAndServe(); err != nil {
			t.Error(err)
		}
	}()
	time.Sleep(100 * time.Millisecond)

	client := http.Client{}
	rdr := bytes.NewReader([]byte(request))
	if res, err := client.Post(uri, "text/plain", rdr); err == nil {
		if status != res.StatusCode {
			t.Errorf("response status is invalid: %d != %d", status, res.StatusCode)
		}
		if responseBody, err := ioutil.ReadAll(res.Body); err != nil {
			t.Error(err)
		} else if string(responseBody) != response {
			t.Errorf("response body is invalid: %s != %s", responseBody, response)
		}
		res.Body.Close()
	} else {
		t.Fatal(err)
	}

	req := <-requests
	if req.Method != "POST" {
		t.Errorf("request method invalid: %s != POST", req.Method)
	}
	if req.URL.Path != path {
		t.Errorf("request path invalid: %s != %s", req.URL.Path, path)
	}
	reqBody := string(req.Body)
	if reqBody != request {
		t.Errorf("request body invalid: %s != %s", reqBody, request)
	}

	if err := server.Close(); err != nil {
		t.Fatal(err)
	}
	wg.Wait()
}
func TestOperationsList(t *testing.T) {
	testOver := make(chan struct{})
	defer close(testOver)
	simpleStorage := &SimpleRESTStorage{
		injectedFunction: func(obj runtime.Object) (runtime.Object, error) {
			// Eliminate flakes by ensuring the create operation takes longer than this test.
			<-testOver
			return obj, nil
		},
	}
	handler := Handle(map[string]RESTStorage{
		"foo": simpleStorage,
	}, codec, "/prefix", "version", selfLinker, admissionControl)
	handler.(*defaultAPIServer).group.handler.asyncOpWait = 0
	server := httptest.NewServer(handler)
	defer server.Close()
	client := http.Client{}

	simple := &Simple{
		ObjectMeta: api.ObjectMeta{Name: "foo"},
	}
	data, err := codec.Encode(simple)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	response, err := client.Post(server.URL+"/prefix/version/foo", "application/json", bytes.NewBuffer(data))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if response.StatusCode != http.StatusAccepted {
		t.Fatalf("Unexpected response %#v", response)
	}

	response, err = client.Get(server.URL + "/prefix/version/operations")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if response.StatusCode != http.StatusOK {
		t.Fatalf("unexpected status code %#v", response)
	}
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	obj, err := codec.Decode(body)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	oplist, ok := obj.(*api.OperationList)
	if !ok {
		t.Fatalf("expected ServerOpList, got %#v", obj)
	}
	if len(oplist.Items) != 1 {
		t.Errorf("expected 1 operation, got %#v", obj)
	}
}