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(), } }