Come si effettua una prova net.Conn in unit test in Golang?

Question

Attualmente sto cercando di creare alcuni test unitari per l'interfaccia net.Conn in Go, così come altre funzioni che si basano su quella funzionalità, e mi chiedo quale sia il modo migliore per testare le unità in Google Partire? Il mio codice è simile:

conn, _:=net.Dial("tcp", "127.0.0.1:8080") 
... 
fmt.Fprintf(conn, "test") 
... 
buffer:=make([]byte, 100) 
conn.Read(buffer) 

è il modo più efficace di testare questo codice e il codice che utilizza queste funzioni per girare un goroutine separata di agire come server, utilizzare net.http.httptest package, o qualcos'altro?

Answer 1

Anche se dipenderà dai dettagli di implementazione del caso specifico, l'approccio generale sarà quello di avviare un server (in una goroutine separata, come già accennato) e ascoltare le connessioni in entrata.

Ad esempio, supponiamo di girare un server e verificare che il contenuto che stiamo leggendo dal collegamento corrisponda effettivamente a quello che inviamo corso da parte del cliente:

func TestConn(t *testing.T) { 
    message := "Hi there!\n" 

    go func() { 
     conn, err := net.Dial("tcp", ":3000") 
     if err != nil { 
      t.Fatal(err) 
     } 
     defer conn.Close() 

     if _, err := fmt.Fprintf(conn, message); err != nil { 
      t.Fatal(err) 
     } 
    }() 

    l, err := net.Listen("tcp", ":3000") 
    if err != nil { 
     t.Fatal(err) 
    } 
    defer l.Close() 
    for { 
     conn, err := l.Accept() 
     if err != nil { 
      return 
     } 
     defer conn.Close() 

     buf, err := ioutil.ReadAll(conn) 
     if err != nil { 
      t.Fatal(err) 
     } 

     fmt.Println(string(buf[:])) 
     if msg := string(buf[:]); msg != message { 
      t.Fatalf("Unexpected message:\nGot:\t\t%s\nExpected:\t%s\n", msg, message) 
     } 
     return // Done 
    } 

} 

Si noti che qui non sto iniziando il server nella goroutine, altrimenti il ​​caso di test sarà probabilmente terminato prima che l'ascoltatore abbia eseguito il test.

Answer 2

Potreste essere in grado di fare quello che ti serve con net.Pipe che fondamentalmente ti dà entrambe le estremità di una connessione (si pensi, dopo Accetti())

server, client := net.Pipe() 
go func() { 
    // Do some stuff 
    server.Close() 
}() 

// Do some stuff 
client.Close()