Beispiel #1
0
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
}
Beispiel #2
0
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
}
Beispiel #3
0
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)
	}
}
Beispiel #4
0
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)
	}
}
Beispiel #5
0
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)
		}
	}
}
Beispiel #6
0
func (s roomService) CreateRoom(
	domain string,
	creator ct.UserId,
	desc *types.RoomDescription,
) (ct.RoomId, *ct.Alias, types.Error) {
	var alias *ct.Alias
	id := ct.NewRoomId(utils.RandomString(16), domain)
	if desc.Alias != nil {
		a := ct.NewAlias(*desc.Alias, domain)
		err := s.aliases.AddAlias(a, id)
		if err != nil {
			return ct.RoomId{}, nil, err
		}
		alias = &a
	}
	exists, err := s.rooms.CreateRoom(id)
	if exists {
		return ct.RoomId{}, nil, types.RoomInUseError("room '" + id.String() + "' already exists")
	}
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	s.members.AddMember(id, creator)

	_, err = s.sendMessage(id, creator, &types.CreateEventContent{creator})
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	_, err = s.setState(id, creator, &types.CreateEventContent{creator}, "")
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	profile, err := s.profileProvider.Profile(creator)
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	membership := &types.MembershipEventContent{&profile, types.MembershipMember}
	_, err = s.setState(id, creator, membership, creator.String())
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	_, err = s.setState(id, creator, types.DefaultPowerLevels(creator), "")
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	joinRuleContent := types.JoinRulesEventContent{desc.Visibility.ToJoinRule()}
	_, err = s.setState(id, creator, &joinRuleContent, "")
	if err != nil {
		return ct.RoomId{}, nil, err
	}
	if alias != nil {
		_, err = s.setState(id, creator, &types.AliasesEventContent{[]ct.Alias{*alias}}, "")
		if err != nil {
			return ct.RoomId{}, nil, err
		}
	}
	if desc.Name != nil {
		_, err = s.setState(id, creator, &types.NameEventContent{*desc.Name}, "")
		if err != nil {
			return ct.RoomId{}, nil, err
		}
	}
	if desc.Topic != nil {
		_, err = s.setState(id, creator, &types.TopicEventContent{*desc.Topic}, "")
		if err != nil {
			return ct.RoomId{}, nil, err
		}
	}
	for _, invited := range desc.Invited {
		membership := types.MembershipEventContent{nil, types.MembershipInvited}
		_, err = s.setState(id, creator, &membership, invited.String())
		if err != nil {
			return ct.RoomId{}, nil, err
		}
	}
	return id, alias, nil
}