Cfrtjryk

I have task assigment to implement HTTP server on Go and there are guidelines:

• Server should listen for WebSocket connections on /ws path.


• Server should accept only text type messages.


• Incoming messages should be transformed and sent back to the sender.


• End connection on client command or when non text message is received.

Task must be tested as much as possible. I thought only one test case. What kind of tests I should prepare to assure reliability?

server.go

package main



import (

    "bytes"

    "flag"

    "fmt"

    "log"

    "net/http"



    "github.com/gorilla/websocket"

)



var upgrader = websocket.Upgrader{}



func serveWs(w http.ResponseWriter, r *http.Request) {

    // Upgrade HTTP connection to WebSocket connection

    conn, err := upgrader.Upgrade(w, r, nil)

    if err != nil {

        log.Println(err)

        return

    }

    defer conn.Close()



    for {

        mt, message, err := conn.ReadMessage()

        if err != nil {

            log.Println(err)

            break

        }



        // End connection if client message type is not acceptable

        if mt != websocket.TextMessage {

            break

        }



        log.Printf("Received: %s", message)



        // Transform message and send back to client

        message = bytes.ToUpper(message)

        err = conn.WriteMessage(websocket.TextMessage, message)

        if err != nil {

            log.Println(err)

            break

        }



        log.Printf("Sent: %s", message)

    }

}



func main() {

    flag.Parse()



    if len(flag.Args()) < 1 {

        log.Fatal("Must specify port")

    }



    var port = flag.Args()[0]



    http.HandleFunc("/ws", serveWs)



    err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil)

    if err != nil {

        log.Fatal(err)

    }

}

client.go

package main



import (

    "bufio"

    "bytes"

    "flag"

    "fmt"

    "log"

    "os"



    "github.com/gorilla/websocket"

)



func main() {

    flag.Parse()



    // Check if server URL is specified

    if len(flag.Args()) < 1 {

        log.Fatal("Must specify url")

    }



    var url = flag.Args()[0]



    // Connect to the server

    conn, _, err := websocket.DefaultDialer.Dial(url, nil)

    if err != nil {

        log.Fatal(err)

    }

    defer conn.Close()



    // Create input reader

    reader := bufio.NewReader(os.Stdin)



    // Wait for first user input and send it to the server

    fmt.Print("Message: ")

    input, _ := reader.ReadBytes('n')

    conn.WriteMessage(websocket.TextMessage, bytes.TrimRight(input, "n"))



    // Websocket read loop

    for {

        _, msg, err := conn.ReadMessage()

        if err != nil {

            log.Println(err)

            return

        }



        fmt.Printf("Received: %sn", msg)



        fmt.Print("Message: ")

        input, _ := reader.ReadBytes('n')

        conn.WriteMessage(websocket.TextMessage, bytes.TrimRight(input, "n"))

    }

}

server_test.go

package main



import (

    "net/http"

    "net/http/httptest"

    "strings"

    "testing"



    "github.com/gorilla/websocket"

)



func TestExample(t *testing.T) {

    // Create test server

    s := httptest.NewServer(http.HandlerFunc(serveWs))

    defer s.Close()



    // Convert http URL to ws

    url := "ws" + strings.TrimPrefix(s.URL, "http")



    // Connect to the server

    conn, _, err := websocket.DefaultDialer.Dial(url, nil)

    if err != nil {

        t.Fatalf("%v", err)

    }

    defer conn.Close()



    // Send message to server and check response

    testResponse("hello", "HELLO", conn, t)

    testResponse("heLLo", "HELLO", conn, t)

    testResponse("HeLLo", "HELLO", conn, t)

}



func testResponse(send string, expect string, conn *websocket.Conn, t *testing.T) {

    err := conn.WriteMessage(websocket.TextMessage, byte(send))

    if err != nil {

        t.Errorf("Read: %v", err)

    }



    _, msg, err := conn.ReadMessage()

    if err != nil {

        t.Errorf("Read: %v", err)

    }



    if string(msg) != expect {

        t.Errorf("message transformation failed: got %v want %v", send, expect)

    }

}