github.com/angenalZZZ/gofunc@v0.0.0-20210507121333-48ff1be3917b/http/longpoll/client/client_test.go (about)

     1  package client
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"github.com/angenalZZZ/gofunc/http/longpoll"
     7  	"net"
     8  	"net/http"
     9  	"net/url"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/davecgh/go-spew/spew"
    14  )
    15  
    16  func testEventsManager() *longpoll.LongpollManager {
    17  	var err error
    18  	eventsManager, err := longpoll.StartLongpoll(longpoll.Options{
    19  		LoggingEnabled: true,
    20  	})
    21  	if err != nil {
    22  		fmt.Println("Failed to create manager: %q", err)
    23  	}
    24  
    25  	return eventsManager
    26  }
    27  
    28  func testServer() (*url.URL, *longpoll.LongpollManager) {
    29  	eventsManager := testEventsManager()
    30  
    31  	var hf http.HandlerFunc = eventsManager.SubscriptionHandler
    32  
    33  	listener, err := net.Listen("tcp", "127.0.0.1:0")
    34  	if err != nil {
    35  		panic(err)
    36  	}
    37  	fmt.Println("Tests event server listening on", listener.Addr().String())
    38  
    39  	go func() {
    40  		panic(http.Serve(listener, hf))
    41  	}()
    42  
    43  	u, _ := url.Parse("http://" + listener.Addr().String() + "/events")
    44  
    45  	return u, eventsManager
    46  }
    47  
    48  func testAuthServer(username, password string) (*url.URL, *longpoll.LongpollManager) {
    49  	eventsManager := testEventsManager()
    50  
    51  	var hf http.HandlerFunc = func(w http.ResponseWriter, req *http.Request) {
    52  		reqUsername, reqPassword, _ := req.BasicAuth()
    53  		if reqUsername == username && reqPassword == password {
    54  			eventsManager.SubscriptionHandler(w, req)
    55  		} else {
    56  			w.WriteHeader(401)
    57  		}
    58  	}
    59  
    60  	listener, err := net.Listen("tcp", "127.0.0.1:0")
    61  	if err != nil {
    62  		panic(err)
    63  	}
    64  	fmt.Println("Tests event server listening on", listener.Addr().String())
    65  
    66  	go func() {
    67  		panic(http.Serve(listener, hf))
    68  	}()
    69  
    70  	u, _ := url.Parse("http://" + listener.Addr().String() + "/events")
    71  
    72  	return u, eventsManager
    73  }
    74  
    75  func TestClient(t *testing.T) {
    76  	category := "testing"
    77  
    78  	u, manager := testServer()
    79  
    80  	c := NewClient(u, category)
    81  	// Have a small timeout for tests
    82  	c.Timeout = 1
    83  
    84  	c.Start()
    85  
    86  	manager.Publish(category, "test")
    87  
    88  	select {
    89  	case e := <-c.EventsChan:
    90  		var data string
    91  		err := json.Unmarshal(e.Data, &data)
    92  		if err != nil {
    93  			t.Error("Error while decoding event from channel")
    94  		}
    95  		if data != "test" {
    96  			t.Error("Wrong data coming out of the events channel")
    97  		}
    98  
    99  	case <-time.After(2 * time.Second):
   100  		t.Error("Error selecting from the events channel")
   101  	}
   102  
   103  	// We'll stop the client, and make sure it doesn't handle any events anymore
   104  	c.Stop()
   105  
   106  	manager.Publish(category, "test2")
   107  
   108  	select {
   109  	case <-c.EventsChan:
   110  		t.Error("Got something in the events chan although the client has been stopped")
   111  
   112  	case <-time.After(2 * time.Second):
   113  		// all good, we needed this to happen
   114  	}
   115  
   116  	// Now start it back and send a few events
   117  	expectedResults := []string{"test1", "test2", "test3"}
   118  
   119  	c.Start()
   120  
   121  	for _, result := range expectedResults {
   122  		manager.Publish(category, result)
   123  	}
   124  
   125  	for i := 0; i < len(expectedResults); i++ {
   126  		select {
   127  		case e := <-c.EventsChan:
   128  			var data string
   129  			err := json.Unmarshal(e.Data, &data)
   130  			if err != nil {
   131  				t.Error("Error while decoding event from channel")
   132  			}
   133  			if data != expectedResults[i] {
   134  				t.Error("Wrong data coming out of the events channel")
   135  			}
   136  
   137  		case <-time.After(2 * time.Second):
   138  			t.Error("Error selecting from the events channel")
   139  		}
   140  	}
   141  }
   142  
   143  func TestClientAuthentication(t *testing.T) {
   144  	category := "testing"
   145  	testUser := "bob"
   146  	testPassword := "bob"
   147  
   148  	u, manager := testAuthServer(testUser, testPassword)
   149  
   150  	c := NewClient(u, category)
   151  	// Have a small timeout for tests
   152  	c.Timeout = 1
   153  
   154  	// Setup basic auth
   155  	c.BasicAuthUsername = testUser
   156  	c.BasicAuthPassword = testPassword
   157  
   158  	c.Start()
   159  
   160  	manager.Publish(category, "test")
   161  
   162  	select {
   163  	case e := <-c.EventsChan:
   164  		var data string
   165  		err := json.Unmarshal(e.Data, &data)
   166  		if err != nil {
   167  			t.Error("Error while decoding event from channel")
   168  		}
   169  		if data != "test" {
   170  			t.Error("Wrong data coming out of the events channel")
   171  		}
   172  
   173  	case <-time.After(2 * time.Second):
   174  		t.Error("Error selecting from the events channel")
   175  	}
   176  
   177  	// Now use an invalid password
   178  	c.Stop()
   179  	c.BasicAuthPassword = "password"
   180  	c.Start()
   181  
   182  	manager.Publish(category, "test")
   183  
   184  	select {
   185  	case e := <-c.EventsChan:
   186  		t.Error("Received something in the events channel although the requests are unauthorized")
   187  		spew.Dump(e)
   188  
   189  	case <-time.After(2 * time.Second):
   190  		// worked as expected, the request was invalid
   191  	}
   192  }