basic integration test

test/integration_helpers.go

@@ -3,22 +3,32 @@ package test
 import (
 	"context"
 	"fmt"
+	"net/http"
+	"testing"
 	"time"
 
 	"github.com/livekit/livekit-server/cmd/cli/client"
 	"github.com/livekit/livekit-server/pkg/auth"
 	"github.com/livekit/livekit-server/pkg/config"
+	"github.com/livekit/livekit-server/pkg/logger"
 	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/livekit-server/proto/livekit"
 )
 
 const (
 	testApiKey    = "apikey"
 	testApiSecret = "apiSecret"
+	testRoom      = "mytestroom"
+)
+
+var (
+	serverConfig *config.Config
+	roomClient   livekit.RoomService
 )
 
 func waitForServerToStart(s *service.LivekitServer) {
 	// wait till ready
-	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
+	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
 	for {
 		select {
 		case <-ctx.Done():
@@ -31,20 +41,51 @@ func waitForServerToStart(s *service.LivekitServer) {
 	}
 }
 
+func withTimeout(t *testing.T, f func() bool) {
+	ctx, _ := context.WithTimeout(context.Background(), time.Second)
+	for {
+		select {
+		case <-ctx.Done():
+			t.Fatal("timed out")
+		case <-time.After(10 * time.Millisecond):
+			if f() {
+				return
+			}
+		}
+	}
+}
+
 func createServer() *service.LivekitServer {
-	conf, err := config.NewConfig("")
+	var err error
+	serverConfig, err = config.NewConfig("")
 	if err != nil {
 		panic(fmt.Sprintf("could not create config: %v", err))
 	}
-	s, err := service.InitializeServer(conf, &StaticKeyProvider{})
+	s, err := service.InitializeServer(serverConfig, &StaticKeyProvider{})
 	if err != nil {
 		panic(fmt.Sprintf("could not create server: %v", err))
 	}
+
+	roomClient = livekit.NewRoomServiceJSONClient(fmt.Sprintf("http://localhost:%d", serverConfig.APIPort), &http.Client{})
 	return s
 }
 
-func createClient(room, name string) *client.RTCClient {
-	return nil
+// creates a client and runs against server
+func createClient(name string) *client.RTCClient {
+	token := joinToken(testRoom, name)
+	ws, err := client.NewWebSocketConn(fmt.Sprintf("ws://localhost:%d", serverConfig.RTCPort), token)
+	if err != nil {
+		panic(err)
+	}
+
+	c, err := client.NewRTCClient(ws)
+	if err != nil {
+		panic(err)
+	}
+
+	go c.Run()
+
+	return c
 }
 
 func joinToken(room, name string) string {
@@ -78,6 +119,7 @@ func (p *StaticKeyProvider) NumKeys() int {
 
 func (p *StaticKeyProvider) GetSecret(key string) string {
 	if key == testApiKey {
+		logger.GetLogger().Debugf("returning secret: %s", testApiSecret)
 		return testApiSecret
 	}
 	return ""

test/integration_test.go

@@ -1,26 +1,58 @@
 package test
 
 import (
+	"context"
+	"net/http"
 	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/twitchtv/twirp"
+
+	"github.com/livekit/livekit-server/pkg/logger"
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/livekit-server/proto/livekit"
 )
 
-func TestScenarioDefault(t *testing.T) {
-	assert.True(t, true)
+func TestClientCouldConnect(t *testing.T) {
+	c1 := createClient("c1")
+	assert.NoError(t, c1.WaitUntilConnected())
+	c2 := createClient("c2")
+	assert.NoError(t, c2.WaitUntilConnected())
+
+	// ensure they both see each other
+	withTimeout(t, func() bool {
+		return len(c1.RemoteParticipants()) == 1 && len(c2.RemoteParticipants()) == 1
+	})
 }
 
 func TestMain(m *testing.M) {
+	logger.InitDevelopment()
 	s := createServer()
+	service.AuthRequired = true
 	go func() {
 		s.Start()
 	}()
 
 	waitForServerToStart(s)
 
+	// create test room
+	token := createRoomToken()
+	header := make(http.Header)
+	logger.GetLogger().Debugw("auth token", "token", token)
+	header.Set("Authorization", "Bearer "+token)
+	tctx, err := twirp.WithHTTPRequestHeaders(context.Background(), header)
+	if err != nil {
+		panic(err)
+	}
+	_, err = roomClient.CreateRoom(tctx, &livekit.CreateRoomRequest{Name: testRoom})
+	if err != nil {
+		panic(err)
+	}
+
 	code := m.Run()
 
+	roomClient.DeleteRoom(tctx, &livekit.DeleteRoomRequest{Room: testRoom})
 	s.Stop()
 	os.Exit(code)
 }