net - Cómo probar las llamadas http en go usando httptest

http servefile

Question

Tengo el siguiente código:

package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"time"
)
type twitterResult struct {
Results []struct {
Text string `json:"text"`
Ids string `json:"id_str"`
Name string `json:"from_user_name"`
Username string `json:"from_user"`
UserId string `json:"from_user_id_str"`
}
}
var (
twitterUrl = "http://search.twitter.com/search.json?q=%23UCL"
pauseDuration = 5 * time.Second
)
func retrieveTweets(c chan<- *twitterResult) {
for {
resp, err := http.Get(twitterUrl)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
r := new(twitterResult) //or &twitterResult{} which returns *twitterResult
err = json.Unmarshal(body, &r)
if err != nil {
log.Fatal(err)
}
c <- r
time.Sleep(pauseDuration)
}
}
func displayTweets(c chan *twitterResult) {
tweets := <-c
for _, v := range tweets.Results {
fmt.Printf("%v:%v/n", v.Username, v.Text)
}
}
func main() {
c := make(chan *twitterResult)
go retrieveTweets(c)
for {
displayTweets(c)
}
}

Me gustaría escribir algunas pruebas para ello, pero no estoy seguro de cómo usar el paquete httptest http://golang.org/pkg/net/http/httptest/ , apreciaría algunos consejos

Se me ocurrió esto (descaradamente copiado de las pruebas para ir a OAuth https://code.google.com/p/goauth2/source/browse/oauth/oauth_test.go ):

var request = struct {
path, query string // request
contenttype, body string // response
}{
path: "/search.json?",
query: "q=%23Kenya",
contenttype: "application/json",
body: twitterResponse,
}
var (
twitterResponse = `{ ''results'': [{''text'':''hello'',''id_str'':''34455w4'',''from_user_name'':''bob'',''from_user_id_str'':''345424''}]}`
)
func TestRetrieveTweets(t *testing.T) {
handler := func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", request.contenttype)
io.WriteString(w, request.body)
}
server := httptest.NewServer(http.HandlerFunc(handler))
defer server.Close()
resp, err := http.Get(server.URL)
if err != nil {
t.Fatalf("Get: %v", err)
}
checkBody(t, resp, twitterResponse)
}
func checkBody(t *testing.T, r *http.Response, body string) {
b, err := ioutil.ReadAll(r.Body)
if err != nil {
t.Error("reading reponse body: %v, want %q", err, body)
}
if g, w := string(b), body; g != w {
t.Errorf("request body mismatch: got %q, want %q", g, w)
}
}

Answer 1

Si desea probar su programa, a menudo es mejor escribirlo teniendo en cuenta las pruebas. Por ejemplo, si extrajo el bucle interno de su función retrieveTweets en algo como esto:

func downloadTweets(tweetsUrl string) (*twitterResult, error)

Puede invocarlo con la URL de un servidor de prueba que ha configurado utilizando el paquete httptest sin tener que preocuparse por las solicitudes repetidas o las solicitudes repetidas.

Answer 2

httptest hace dos tipos de pruebas: respuesta y servidor

Prueba de respuesta:

func TestHeader3D(t *testing.T) {
resp := httptest.NewRecorder()
uri := "/3D/header/?"
path := "/home/test"
unlno := "997225821"
param := make(url.Values)
param["param1"] = []string{path}
param["param2"] = []string{unlno}
req, err := http.NewRequest("GET", uri+param.Encode(), nil)
if err != nil {
t.Fatal(err)
}
http.DefaultServeMux.ServeHTTP(resp, req)
if p, err := ioutil.ReadAll(resp.Body); err != nil {
t.Fail()
} else {
if strings.Contains(string(p), "Error") {
t.Errorf("header response shouldn''t return error: %s", p)
} else if !strings.Contains(string(p), `expected result`) {
t.Errorf("header response doen''t match:/n%s", p)
}
}
}

Prueba de servidor (que es lo que necesita usar):

func TestIt(t *testing.T){
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
fmt.Fprintln(w, `{"fake twitter json string"}`)
}))
defer ts.Close()
twitterUrl = ts.URL
c := make(chan *twitterResult)
go retrieveTweets(c)
tweet := <-c
if tweet != expected1 {
t.Fail()
}
tweet = <-c
if tweet != expected2 {
t.Fail()
}
}

Por cierto, no necesita pasar el puntero de r, porque ya es un puntero.

err = json.Unmarshal(body, r)

EDITAR: para mi prueba de grabador, podría usar mi controlador http de esta manera:

handler(resp, req)

Pero mi código original no usa el mux por defecto (sino de Gorilla / mux), y tengo algo que envolver el mux, por ejemplo, insertar el registro del servidor y agregar contexto de solicitud (Gorila / contexto), así que tuve que empezar desde mux y llamar a ServeHTTP

Answer 3

myserver_test.go

package myserver
import (
"fmt"
"io/ioutil"
"net/http"
"net/http/httptest"
"testing"
)
func TestMyHandler(t *testing.T) {
handler := &MyHandler{}
server := httptest.NewServer(handler)
defer server.Close()
for _, i := range []int{1, 2} {
resp, err := http.Get(server.URL)
if err != nil {
t.Fatal(err)
}
if resp.StatusCode != 200 {
t.Fatalf("Received non-200 response: %d/n", resp.StatusCode)
}
expected := fmt.Sprintf("Visitor count: %d.", i)
actual, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
if expected != string(actual) {
t.Errorf("Expected the message ''%s''/n", expected)
}
}
}

myserver.go

package myserver
import (
"fmt"
"net/http"
"sync"
)
type MyHandler struct {
sync.Mutex
count int
}
func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
var count int
h.Lock()
h.count++
count = h.count
h.Unlock()
fmt.Fprintf(w, "Visitor count: %d.", count)
}