public void DeleteChannel_WithMessages_ShouldReturn409Conflict()
        {
            // Arrange -> create a channel with a message posted in it
            TestingEngine.CleanDatabase();

            // Create a channel
            var channelName = "channel" + DateTime.Now.Ticks;
            var httpResponseCreateChanel = TestingEngine.CreateChannelHttpPost(channelName);

            Assert.AreEqual(HttpStatusCode.Created, httpResponseCreateChanel.StatusCode);
            var channel = httpResponseCreateChanel.Content.ReadAsAsync <ChannelModel>().Result;

            Assert.AreEqual(1, TestingEngine.GetChannelsCountFromDb());

            // Post an anonymous message in the channel
            var httpResponsePostMsg = TestingEngine.SendChannelMessageHttpPost(channelName, "message");

            Assert.AreEqual(HttpStatusCode.OK, httpResponsePostMsg.StatusCode);

            // Act -> try to delete the channel with the message
            var httpDeleteResponse = TestingEngine.HttpClient.DeleteAsync(
                "/api/channels/" + channel.Id).Result;

            // Assert -> HTTP status code is 409 (Conflict), channel is not empty
            Assert.AreEqual(HttpStatusCode.Conflict, httpDeleteResponse.StatusCode);
            Assert.AreEqual(1, TestingEngine.GetChannelsCountFromDb());
        }
        public void CreateNewChannel_EmptyBody_ShouldReturn400BadRequest()
        {
            // Arrange
            TestingEngine.CleanDatabase();

            // Act
            var httpResponse = TestingEngine.HttpClient.PostAsync("/api/channels", null).Result;

            // Assert
            Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
            var channelsCountInDb = TestingEngine.GetChannelsCountFromDb();

            Assert.AreEqual(0, channelsCountInDb);
        }
        public void DeleteChannel_DeleteExistingChannel_ShouldReturn200OK()
        {
            // Arrange -> prepare a few channels
            TestingEngine.CleanDatabase();
            var channelName = "deleteme";

            // Act -> create a few channels
            this.CreateChannelHttpPost(channelName);
            var deleteResponseMessage = this.DeleteChannelHttpDelete(channelName);

            Assert.AreEqual(HttpStatusCode.OK, deleteResponseMessage.StatusCode);
            Assert.AreEqual("", deleteResponseMessage.Content);
            Assert.AreEqual(0, TestingEngine.GetChannelsCountFromDb());
        }
        public void CreateNewChannel_NameTooLong_ShouldReturn400BadRequest()
        {
            // Arrange
            TestingEngine.CleanDatabase();
            var tooLongChannelName = new string('a', 101);

            // Act
            var httpResponse = TestingEngine.CreateChannelHttpPost(tooLongChannelName);

            // Assert
            Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
            var channelsCountInDb = TestingEngine.GetChannelsCountFromDb();

            Assert.AreEqual(0, channelsCountInDb);
        }
        public void CreateNewChannel_InvalidData_ShouldReturn400BadRequest()
        {
            // Arrange
            TestingEngine.CleanDatabase();
            var invalidChannelName = string.Empty;

            // Act
            var httpResponse = TestingEngine.CreateChannelHttpPost(invalidChannelName);

            // Assert
            Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
            var channelsCountInDb = TestingEngine.GetChannelsCountFromDb();

            Assert.AreEqual(0, channelsCountInDb);
        }
        public void DeleteExistingChannel_ShouldReturn200OK()
        {
            // Arrange -> create a channel
            TestingEngine.CleanDatabase();

            var channelName      = "channel" + DateTime.Now.Ticks;
            var httpPostResponse = TestingEngine.CreateChannelHttpPost(channelName);

            Assert.AreEqual(HttpStatusCode.Created, httpPostResponse.StatusCode);
            var channel = httpPostResponse.Content.ReadAsAsync <ChannelModel>().Result;

            Assert.AreEqual(1, TestingEngine.GetChannelsCountFromDb());

            // Act -> delete the channel
            var httpDeleteResponse = TestingEngine.HttpClient.DeleteAsync(
                "/api/channels/" + channel.Id).Result;

            // Assert -> HTTP status code is 200 (OK)
            Assert.AreEqual(HttpStatusCode.OK, httpDeleteResponse.StatusCode);
            Assert.AreEqual(0, TestingEngine.GetChannelsCountFromDb());
        }
        public void CreateNewChannel_ShouldCreateChannel_Return201Created()
        {
            // Arrange
            TestingEngine.CleanDatabase();
            var channelName = "channel" + DateTime.Now.Ticks;

            // Act
            var httpResponse = TestingEngine.CreateChannelHttpPost(channelName);

            // Assert
            Assert.AreEqual(HttpStatusCode.Created, httpResponse.StatusCode);
            Assert.IsNotNull(httpResponse.Headers.Location);
            var newChannel = httpResponse.Content.ReadAsAsync <ChannelModel>().Result;

            Assert.IsTrue(newChannel.Id != 0);
            Assert.AreEqual(newChannel.Name, channelName);

            var channelsCountInDb = TestingEngine.GetChannelsCountFromDb();

            Assert.AreEqual(1, channelsCountInDb);
        }