public void Should_require_a_room_name_to_be_provided()
        {
            var cmd = new CreateChatRoom {
                CreatorId = Guid.NewGuid().ToString()
            };

            Assert.That(() => Repository.Execute(cmd),
                        Throws.TypeOf <DomainException>().With.Message.EqualTo("No room name was provided"));
        }
        public void Should_require_a_creator_id()
        {
            var cmd = new CreateChatRoom {
                RoomName = "Test_Room"
            };

            Assert.That(() => Repository.Execute(cmd),
                        Throws.TypeOf <DomainException>().With.Message.EqualTo("No room creator was provided"));
        }
        public void Should_not_be_able_to_create_room_if_creator_does_not_exist()
        {
            var cmd = new CreateChatRoom {
                RoomName = "Test_Room", CreatorId = Guid.NewGuid().ToString()
            };

            Assert.That(() => Repository.Execute(cmd),
                        Throws.TypeOf <DomainException>().With.Message.EqualTo("Room creator does not exist"));
        }
Beispiel #4
0
        private async void btnCreateRoom_Click(object sender, RoutedEventArgs e)
        {
            CreateChatRoom createRoomWnd = new CreateChatRoom();

            if (createRoomWnd.ShowDialog() == true)
            {
                await hub.CreateRoom(createRoomWnd.RoomName);
            }
        }
Beispiel #5
0
        private async void btnCreateChatRoom_Click(object sender, RoutedEventArgs e)
        {
            var createRoomWnd = new CreateChatRoom();

            if (createRoomWnd.ShowDialog() == true)
            {
                await connection.SendAsync("CreateRoom", createRoomWnd.RoomName);
            }
        }
        public void Should_not_allow_special_characters_in_room_name(string roomName)
        {
            var cmd = new CreateChatRoom {
                RoomName = roomName, CreatorId = Guid.NewGuid().ToString()
            };

            Assert.That(() => Repository.Execute(cmd),
                        Throws.TypeOf <DomainException>().With.Message.EqualTo(
                            $"Chat room '{roomName}' contains unsupported characters, only alphanumeric names with _ or - are allowed"));
        }
        public void Should_not_allow_rooms_of_the_same_name_to_exist()
        {
            var existingName = "Test_Room";

            new ChatRoomBuilder().With(cr => cr.Name, existingName).BuildAndSave();

            var cmd = new CreateChatRoom {
                RoomName = existingName, CreatorId = Guid.NewGuid().ToString()
            };

            Assert.That(() => Repository.Execute(cmd),
                        Throws.TypeOf <DomainException>().With.Message.EqualTo($"Chat room '{existingName}' already exists"));
        }
        public void Should_create_new_chat_room()
        {
            var creator = new UserBuilder().BuildAndSave();

            var cmd = new CreateChatRoom {
                RoomName = "Test_Room", CreatorId = creator.Id
            };

            var room = Repository.Execute(cmd);

            Assert.That(DataContext.AsQueryable <ChatRoom>().Where(cr =>
                                                                   cr.Id == room.Id && cr.Name == "Test_Room" && cr.Creator.Id == creator.Id &&
                                                                   cr.CreatedAt.Value.Date == DateTime.UtcNow.Date), Has.Exactly(1).Items);
        }
        public IHttpActionResult Put(CreateChatRoom cmd)
        {
            var userId = GetUserId();

            cmd.CreatorId = userId;

            try
            {
                var chatRoom = DomainRegistry.Repository.Execute(cmd);
                return(CreatedAtRoute("DefaultApi", new { id = chatRoom.Name }, chatRoom));
            }
            catch (DomainException ex)
            {
                return(BadRequest(ex.Message));
            }
        }