Updated tests to new room name with type api.

src/app/spreed-webrtc-server/channelling_api_test.go

@@ -23,6 +23,7 @@ package main
 
 import (
 	"errors"
+	"fmt"
 	"testing"
 )
 
@@ -48,9 +49,9 @@ func (fake *fakeRoomManager) RoomUsers(session *Session) []*DataSession {
 	return fake.roomUsers
 }
 
-func (fake *fakeRoomManager) JoinRoom(id string, _ *DataRoomCredentials, session *Session, sessionAuthenticated bool, _ Sender) (*DataRoom, error) {
+func (fake *fakeRoomManager) JoinRoom(id, roomName, roomType string, _ *DataRoomCredentials, session *Session, sessionAuthenticated bool, _ Sender) (*DataRoom, error) {
 	fake.joinedID = id
-	return &DataRoom{Name: id}, fake.joinError
+	return &DataRoom{Name: roomName, Type: roomType}, fake.joinError
 }
 
 func (fake *fakeRoomManager) LeaveRoom(roomID, sessionID string) {
@@ -65,6 +66,13 @@ func (fake *fakeRoomManager) UpdateRoom(_ *Session, _ *DataRoom) (*DataRoom, err
 	return fake.updatedRoom, fake.updateError
 }
 
+func (fake *fakeRoomManager) MakeRoomID(roomName, roomType string) string {
+	if roomType == "" {
+		roomType = "Room"
+	}
+	return fmt.Sprintf("%s:%s", roomType, roomName)
+}
+
 func NewTestChannellingAPI() (ChannellingAPI, *fakeClient, *Session, *fakeRoomManager) {
 	client, roomManager := &fakeClient{}, &fakeRoomManager{}
 	session := &Session{
@@ -77,10 +85,10 @@ func NewTestChannellingAPI() (ChannellingAPI, *fakeClient, *Session, *fakeRoomMa
 }
 
 func Test_ChannellingAPI_OnIncoming_HelloMessage_JoinsTheSelectedRoom(t *testing.T) {
-	roomID, ua := "foobar", "unit tests"
+	roomID, roomName, ua := "Room:foobar", "foobar", "unit tests"
 	api, client, session, roomManager := NewTestChannellingAPI()
 
-	api.OnIncoming(client, session, &DataIncoming{Type: "Hello", Hello: &DataHello{Id: roomID, Ua: ua}})
+	api.OnIncoming(client, session, &DataIncoming{Type: "Hello", Hello: &DataHello{Id: roomName, Ua: ua}})
 
 	if roomManager.joinedID != roomID {
 		t.Errorf("Expected to have joined room %v, but got %v", roomID, roomManager.joinedID)
@@ -101,10 +109,10 @@ func Test_ChannellingAPI_OnIncoming_HelloMessage_JoinsTheSelectedRoom(t *testing
 }
 
 func Test_ChannellingAPI_OnIncoming_HelloMessage_LeavesAnyPreviouslyJoinedRooms(t *testing.T) {
-	roomID := "foobar"
+	roomID, roomName := "Room:foobar", "foobar"
 	api, client, session, roomManager := NewTestChannellingAPI()
 
-	api.OnIncoming(client, session, &DataIncoming{Type: "Hello", Hello: &DataHello{Id: roomID}})
+	api.OnIncoming(client, session, &DataIncoming{Type: "Hello", Hello: &DataHello{Id: roomName}})
 	api.OnIncoming(client, session, &DataIncoming{Type: "Hello", Hello: &DataHello{Id: "baz"}})
 
 	if roomManager.leftID != roomID {

src/app/spreed-webrtc-server/room_manager.go

@@ -102,12 +102,18 @@ func (rooms *roomManager) LeaveRoom(roomID, sessionID string) {
 }
 
 func (rooms *roomManager) UpdateRoom(session *Session, room *DataRoom) (*DataRoom, error) {
-	roomID := rooms.MakeRoomID(room.Name, room.Type)
+	var roomID string
+	if room != nil {
+		roomID = rooms.MakeRoomID(room.Name, room.Type)
+	}
 	if !session.Hello || session.Roomid != roomID {
 		return nil, NewDataError("not_in_room", "Cannot update other rooms")
 	}
 	if roomWorker, ok := rooms.Get(session.Roomid); ok {
 		return room, roomWorker.Update(room)
+	} else {
+		// Set default room type if not found.
+		room.Type = rooms.roomTypeDefault
 	}
 	// TODO(lcooper): We should almost certainly return an error in this case.
 	return room, nil

src/app/spreed-webrtc-server/room_manager_test.go

@@ -36,16 +36,16 @@ func Test_RoomManager_JoinRoom_ReturnsAnErrorForUnauthenticatedSessionsWhenCreat
 	config.AuthorizeRoomCreation = true
 
 	unauthenticatedSession := &Session{}
-	_, err := roomManager.JoinRoom("foo", nil, unauthenticatedSession, false, nil)
+	_, err := roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 
 	authenticatedSession := &Session{userid: "9870457"}
-	_, err = roomManager.JoinRoom("foo", nil, authenticatedSession, true, nil)
+	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, authenticatedSession, true, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while authenticated", err)
 	}
 
-	_, err = roomManager.JoinRoom("foo", nil, unauthenticatedSession, false, nil)
+	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while unauthenticated", err)
 	}
@@ -57,16 +57,16 @@ func Test_RoomManager_JoinRoom_ReturnsAnErrorForUnauthenticatedSessionsWhenJoinR
 	config.AuthorizeRoomJoin = true
 
 	unauthenticatedSession := &Session{}
-	_, err := roomManager.JoinRoom("foo", nil, unauthenticatedSession, false, nil)
+	_, err := roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 
 	authenticatedSession := &Session{userid: "9870457"}
-	_, err = roomManager.JoinRoom("foo", nil, authenticatedSession, true, nil)
+	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, authenticatedSession, true, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while authenticated", err)
 	}
 
-	_, err = roomManager.JoinRoom("foo", nil, unauthenticatedSession, false, nil)
+	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 }
 
@@ -79,15 +79,15 @@ func Test_RoomManager_UpdateRoom_ReturnsAnErrorIfNoRoomHasBeenJoined(t *testing.
 
 func Test_RoomManager_UpdateRoom_ReturnsAnErrorIfUpdatingAnUnjoinedRoom(t *testing.T) {
 	roomManager, _ := NewTestRoomManager()
-	session := &Session{Hello: true, Roomid: "foo"}
+	session := &Session{Hello: true, Roomid: "Room:foo"}
 	_, err := roomManager.UpdateRoom(session, &DataRoom{Name: "bar"})
 	assertDataError(t, err, "not_in_room")
 }
 
 func Test_RoomManager_UpdateRoom_ReturnsACorrectlyTypedDocument(t *testing.T) {
 	roomManager, _ := NewTestRoomManager()
-	session := &Session{Hello: true, Roomid: "foo"}
+	session := &Session{Hello: true, Roomid: "Room:foo"}
-	room, err := roomManager.UpdateRoom(session, &DataRoom{Name: session.Roomid})
+	room, err := roomManager.UpdateRoom(session, &DataRoom{Name: "foo"})
 	if err != nil {
 		t.Fatalf("Unexpected error %v updating room", err)
 	}

src/app/spreed-webrtc-server/roomworker_test.go

@@ -26,18 +26,20 @@ import (
 )
 
 const (
+	testRoomID   string = "Room:a-room-name"
 	testRoomName string = "a-room-name"
+	testRoomType string = "Room"
 )
 
 func NewTestRoomWorker() RoomWorker {
-	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomName, nil)
+	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomID, testRoomName, testRoomType, nil)
 	go worker.Start()
 	return worker
 }
 
 func NewTestRoomWorkerWithPIN(t *testing.T) (RoomWorker, string) {
 	pin := "asdf"
-	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomName, &DataRoomCredentials{PIN: pin})
+	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomID, testRoomName, testRoomType, &DataRoomCredentials{PIN: pin})
 	go worker.Start()
 	return worker, pin
 }