Merge pull request #1831 from dedis/work-be1-arnauds5-fix-popcha-auth…

…enticate-random-fails

Fixes a test that randomly fails in be1-go

be1-go/channel/authentication/authentication_test.go

@@ -14,6 +14,7 @@ import (
  "golang.org/x/sync/semaphore"
  "golang.org/x/xerrors"
  "io"
+ "net"
  "net/http"
  "os"
  "path/filepath"
@@ -108,25 +109,22 @@ func Test_Authenticate_User(t *testing.T) {
  _, found := fakeHub.channelByID[name]
  require.True(t, found)
 
- time.Sleep(time.Millisecond)
-
  // Create the message
  file := filepath.Join(relativeMsgDataExamplePath, "popcha_authenticate",
  "popcha_authenticate.json")
  buf, err := os.ReadFile(file)
  require.NoError(t, err)
 
- // struct checking that the ws server received a message from the pop backend
- rb := &receivedBuffer{
- received: false,
- once: sync.Once{},
- mutex: sync.Mutex{},
- }
+ // channel where the ws server signals when it has started listening
+ msgCh := make(chan []byte, 1)
+ // channel where the ws server put message it received from the pop backend
+ startCh := make(chan struct{}, 1)
 
  // creating dummy websocket server
- newWSServer(t, "localhost:19006", rb)
+ newWSServer(t, "localhost:19006", msgCh, startCh)
 
- time.Sleep(time.Millisecond)
+ // wait that the ws server has started listening
+ <-startCh
 
  buf64 := base64.URLEncoding.EncodeToString(buf)
 
@@ -158,7 +156,12 @@ func Test_Authenticate_User(t *testing.T) {
  err = authCha.Publish(msg, socket.ClientSocket{})
  require.NoError(t, err)
 
- require.True(t, rb.get())
+ select {
+ case m := <-msgCh:
+ require.NotNil(t, m)
+ case <-time.After(time.Second):
+ t.Errorf("No message received after 1 sec")
+ }
 }
 
 // -----------------------------------------------------------------------------
@@ -305,58 +308,32 @@ var upgrader = websocket.Upgrader{
  WriteBufferSize: 1024,
 }
 
-func websocketHandler(rb *receivedBuffer) func(http.ResponseWriter, *http.Request) {
+func websocketHandler(t *testing.T, msgCh chan []byte) func(http.ResponseWriter, *http.Request) {
  return func(w http.ResponseWriter, r *http.Request) {
  upgrader.CheckOrigin = func(r *http.Request) bool { return true }
 
  conn, err := upgrader.Upgrade(w, r, nil)
- if err != nil {
- log.Error().Msgf("error while upgrading: %v", err)
- return
- }
+ require.NoError(t, err)
+
+ // receive the message and send it to the message channel
+ _, msg, err := conn.ReadMessage()
+ require.NoError(t, err)
 
- // mark the boolean received as true
- rb.recv()
+ msgCh <- msg
  conn.Close()
  }
 }
 
-func newWSServer(t *testing.T, addr string, rb *receivedBuffer) {
- http.HandleFunc("/", websocketHandler(rb))
+func newWSServer(t *testing.T, addr string, msgCh chan []byte, startCh chan struct{}) {
+ http.HandleFunc("/", websocketHandler(t, msgCh))
  go func() {
- err := http.ListenAndServe(addr, nil)
- if err != nil {
- require.NoError(t, err)
- }
- }()
-}
-
-/*
- Atomic Read/Write boolean, to check that the dummy WS server correctly received the request
+ listener, err := net.Listen("tcp", addr)
+ require.NoError(t, err)
 
-*/
+ // signal that the ws server has started listening
+ startCh <- struct{}{}
 
-// receivedBuffer contains a Mutex, a "once" object allowing to perform one flip only, and the boolean
-type receivedBuffer struct {
- received bool
- once sync.Once
- mutex sync.Mutex
-}
-
-// recv flips the boolean. It can only be done once
-func (rb *receivedBuffer) recv() {
- rb.once.Do(func() {
- rb.mutex.Lock()
- defer rb.mutex.Unlock()
- if !rb.received {
- rb.received = true
- }
- })
-}
-
-// get performs an atomic read on the boolean
-func (rb *receivedBuffer) get() bool {
- rb.mutex.Lock()
- defer rb.mutex.Unlock()
- return rb.received
+ err = http.Serve(listener, nil)
+ require.NoError(t, err)
+ }()
 }