func (b *fanOutTestBuffer) Select(user string, from, to, expectedFromIndex, expectedToIndex uint64, expected ...string) {
signals, fromIndex, toIndex, err := b.buffer.SelectForwards(types.Id(types.NewUserId(user, "test")), from, to)
if err != nil {
debug.PrintStack()
b.t.Fatal("failed to get signal range: ", err)
}
if len(signals) != len(expected) {
debug.PrintStack()
b.t.Fatalf("invalid signal count, expected %d but got %d", len(expected), len(signals))
}
if expectedFromIndex != fromIndex {
debug.PrintStack()
b.t.Fatalf("invalid from index, expected %d but got %d", expectedFromIndex, fromIndex)
}
if expectedToIndex != toIndex {
debug.PrintStack()
b.t.Fatalf("invalid to index, expected %d but got %d", expectedToIndex, toIndex)
}
for i, signal := range signals {
if signal.EventId.Id != expected[i] {
debug.PrintStack()
b.t.Fatalf("invalid event id: expected %s, got %s", expected[i], signal.EventId.Id)
}
}
}
func (e authEndpoint) loginWithPassword(hostname string, body *authRequest) interface{} {
if body.Username == "" {
return types.BadJsonError("Missing or invalid user")
}
if body.Password == "" {
return types.BadJsonError("Missing or invalid password")
}
user := ct.NewUserId(body.Username, hostname)
exists, err := e.userService.UserExists(user, user)
if err != nil {
return err
}
if !exists {
return types.NotFoundError("user '" + user.String() + "' doesn't exist")
}
verified, err := e.userService.VerifyPassword(user, body.Password)
if err != nil {
return err
}
if !verified {
return types.ForbiddenError("invalid credentials")
}
accessToken, err := e.tokenService.NewAccessToken(user)
if err != nil {
return err
}
return authResponse{
UserId: user,
AccessToken: accessToken.String(),
}
}
func (b *fanInTestBuffer) Send(id string, user string, expectedIndex uint64) {
index, err := b.buffer.Send(types.EventInfo{
EventId: types.Id(types.NewEventId(id, "test")),
Sender: types.Id(types.NewUserId("tester", "test")),
ContextId: types.Id(types.NewRoomId("room1", "test")),
EventType: "m.test",
}, types.Id(types.NewUserId(user, "test")))
if err != nil {
debug.PrintStack()
b.t.Fatal("error pushing signal: ", err)
}
if index != expectedIndex {
debug.PrintStack()
b.t.Fatal("invalid index, expected %d but got %d", expectedIndex, index)
}
}
func message(eventId, userId string) *matrixTypes.Message {
event := matrixTypes.Message{}
event.EventType = "m.room.create"
event.Content = matrixTypes.CreateEventContent{types.NewUserId(userId, "test")}
event.RoomId = types.NewRoomId("room", "test")
event.Timestamp = types.Timestamp{time.Now()}
event.EventId = types.NewEventId(eventId, "test")
return &event
}
func (es StreamMuxTest) send(event types.Event, index uint64, ids ...string) {
userIds := make([]types.UserId, len(ids))
for i := range ids {
userIds[i] = types.NewUserId(ids[i], "test")
}
err := es.Send(userIds, &indexedEvent{event, index})
if err != nil {
es.t.Fatal(err)
}
}
func (b *fanOutTestBuffer) Push(id string, expectedIndex uint64, users ...string) {
userIds := make([]types.Id, len(users))
for i, user := range users {
userIds[i] = types.Id(types.NewUserId(user, "test"))
}
index, err := b.buffer.Send(types.EventInfo{
EventId: types.Id(types.NewEventId(id, "test")),
Sender: types.Id(types.NewUserId("tester", "test")),
ContextId: types.Id(types.NewRoomId("room1", "test")),
EventType: "m.test",
}, userIds)
if err != nil {
b.t.Fatal("error pushing signal: ", err)
}
if index != expectedIndex {
debug.PrintStack()
b.t.Fatal("invalid index, expected %d but got %d", expectedIndex, index)
}
}
func typing(id string, ids ...string) *matrixTypes.TypingEvent {
event := &matrixTypes.TypingEvent{}
event.EventType = "m.typing"
event.RoomId = types.NewRoomId(id, "test")
userIds := make([]types.UserId, len(ids))
for i := range ids {
userIds[i] = types.NewUserId(ids[i], "test")
}
event.Content.UserIds = userIds
return event
}
func TestEventStreamMux(t *testing.T) {
_es, err := NewStreamMux()
if err != nil {
t.Fatal(err)
}
es := StreamMuxTest{_es, t}
cancel := make(chan struct{}, 1)
streamA, err := es.Listen(types.NewUserId("userA", "test"), cancel)
streamB, err := es.Listen(types.NewUserId("userB", "test"), cancel)
streamC, err := es.Listen(types.NewUserId("userC", "test"), cancel)
streamD, err := es.Listen(types.NewUserId("userD", "test"), cancel)
streamE1, err := es.Listen(types.NewUserId("userE", "test"), cancel)
streamE2, err := es.Listen(types.NewUserId("userE", "test"), cancel)
streamE3, err := es.Listen(types.NewUserId("userE", "test"), cancel)
es.send(typing("room1", "user1"), 1, "userA")
es.send(typing("room2", "user2"), 1, "userB", "userC")
es.send(typing("room3", "user3"), 1, "userA")
close(cancel)
resA := <-streamA
resB := <-streamB
resC := <-streamC
resD := <-streamD
resE1 := <-streamE1
resE2 := <-streamE2
resE3 := <-streamE3
if resA == nil {
t.Error("resA (", resA, ") expected to be not nil")
} else if resA.Event().GetRoomId().Id != "room1" {
t.Error("resA roomId (", resA.Event().GetRoomId(), ") expected to be room1")
}
if resB == nil {
t.Error("resB (", resB, ") expected to be not nil")
} else if resB.Event().GetRoomId().Id != "room2" {
t.Error("resB roomId (", resB.Event().GetRoomId(), ") expected to be room2")
}
if resC == nil {
t.Error("resC (", resC, ") expected to be not nil")
} else if resC.Event().GetRoomId().Id != "room2" {
t.Error("resC roomId (", resC.Event().GetRoomId(), ") expected to be room3")
}
if resD != nil {
t.Error("resD (", resD, ") expected to be nil")
}
if resE1 != nil {
t.Error("resE1( ", resE1, ") expected to be nil")
}
if resE2 != nil {
t.Error("resE2( ", resE2, ") expected to be nil")
}
if resE3 != nil {
t.Error("resE3( ", resE3, ") expected to be nil")
}
}
func (es MessageStreamTest) check(from, to uint64, limit uint, expect ...string) {
user := types.NewUserId("test", "test")
roomSet := map[types.RoomId]struct{}{
types.NewRoomId("room", "test"): struct{}{},
}
result, err := es.Range(&user, nil, roomSet, from, to, limit)
if err != nil {
es.t.Fatal(err)
}
str := fmt.Sprintf("{from=%v, to=%v, limit=%v, expect=%v}", from, to, limit, expect)
if len(result) != len(expect) {
es.t.Fatal(str+": result length should be", len(expect), "was", len(result))
}
for i := range result {
id := result[i].Event().GetContent().(matrixTypes.CreateEventContent).Creator.Id
if id != expect[i] {
es.t.Fatal(str+": result", i, "should be", expect[i], "was", id)
}
}
}
func TestUserCreation(t *testing.T) {
s := setup()
userId := ct.NewUserId("test", "matrix.org")
if err := s.user.CreateUser(userId); err != nil {
t.Fatal(err)
}
s.user.UserExists(userId, userId)
err := s.user.CreateUser(userId)
if err == nil {
t.Fatal("expected M_USER_IN_USE error")
} else if err.Code() != "M_USER_IN_USE" {
t.Error("expected M_USER_IN_USE error code but got ", err.Code())
}
status, err := s.presence.Status(userId, userId)
if err != nil {
t.Fatal(err)
}
if status.Presence != types.PresenceOffline {
t.Error("expected offline presence")
}
if status.StatusMessage != "" {
t.Error("expected empty status message")
}
}
func (e authEndpoint) registerWithPassword(hostname string, body *authRequest) interface{} {
if body.Username == "" {
body.Username = utils.RandomString(24)
}
if body.Password == "" {
return types.BadJsonError("Missing or invalid password")
}
userId := ct.NewUserId(body.Username, hostname)
err := e.userService.CreateUser(userId)
if err != nil {
return err
}
if err := e.userService.SetPassword(userId, userId, body.Password); err != nil {
return err
}
accessToken, err := e.tokenService.NewAccessToken(userId)
if err != nil {
return err
}
return authResponse{
UserId: userId,
AccessToken: accessToken.String(),
}
}
