private async Task <string> CreateEvent()
        {
            var newEventDto       = EventTestDataFactory.CreateTestEventDto();
            var newEventDtoString = JsonConvert.SerializeObject(newEventDto);
            var newEventContent   = new StringContent(newEventDtoString, Encoding.UTF8, "application/json");
            var newEventResponse  = await TestClient.PostAsync("EventOrganizer", newEventContent);

            newEventResponse.Headers.TryGetValues("location", out var locations);
            var eventId = locations.ToList()[0].Split('/').Last();

            return(eventId);
        }
        public async Task CreateEvent_WhenUserIsUnauthorized_ShouldReturnUnauthorized()
        {
            // Arrange
            var newEventDto       = EventTestDataFactory.CreateTestEventDto();
            var newEventDtoString = JsonConvert.SerializeObject(newEventDto);
            var content           = new StringContent(newEventDtoString, Encoding.UTF8, "application/json");
            // Act
            var response = await TestClient.PostAsync("EventOrganizer", content);

            // Arrange
            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.Unauthorized);
        }
        public async Task UpdateEvent_WhenEventIdIsNotValid_ShouldReturnBadRequest()
        {
            // Arrange
            await AuthenticateAsync();

            var eventId       = Guid.NewGuid();
            var newEventDto   = EventTestDataFactory.CreateTestEventDto();
            var contentString = JsonConvert.SerializeObject(newEventDto);
            var content       = new StringContent(contentString, Encoding.UTF8, "application/json");
            // Act
            var response = await TestClient.PutAsync($"EventOrganizer/{eventId}", content);

            // Assert
            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.BadRequest);
        }
        public async Task CreateEvent_WhenTitleIsBlank_ShouldReturnBadRequest()
        {
            // Arrange
            await AuthenticateAsync();

            var newEventDto = EventTestDataFactory.CreateTestEventDto();

            newEventDto.Title = string.Empty;
            var newEventDtoString = JsonConvert.SerializeObject(newEventDto);
            var content           = new StringContent(newEventDtoString, Encoding.UTF8, "application/json");
            // Act
            var response = await TestClient.PostAsync("EventOrganizer", content);

            // Arrange
            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.BadRequest);
        }
        public async Task CreateEvent_WhenDatesConfigurationIsNotValid_ShouldReturnBadRequest()
        {
            // Arrange
            await AuthenticateAsync();

            var newEventDto = EventTestDataFactory.CreateTestEventDto();

            newEventDto.StartsAt = DateTime.UtcNow.AddDays(5);
            newEventDto.EndsAt   = DateTime.UtcNow.AddDays(3);
            var newEventDtoString = JsonConvert.SerializeObject(newEventDto);
            var content           = new StringContent(newEventDtoString, Encoding.UTF8, "application/json");
            // Act
            var response = await TestClient.PostAsync("EventOrganizer", content);

            // Arrange
            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.BadRequest);
        }
        public async Task GetEventByTitle_WhenEventNotExist_ShouldReturnNotFound()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto  = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent = JsonConvert.SerializeObject(createEventDto);
            var content         = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            await TestClient.PostAsync("/EventOrganizer", content);

            var parsedTitle = $"INVALID_{createEventDto.Title.Replace(" ","%20")}";
            // Act
            var response = await TestClient.GetAsync($"/Event?eventTitle={parsedTitle}");

            // Assert
            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.NotFound);
        }
        public async Task CreateEvent_WhenEventDtoIsValid_ShouldAddNewEventToList()
        {
            // Arrange
            await AuthenticateAsync();

            var newEventDto       = EventTestDataFactory.CreateTestEventDto();
            var newEventDtoString = JsonConvert.SerializeObject(newEventDto);
            var content           = new StringContent(newEventDtoString, Encoding.UTF8, "application/json");
            // Act
            var response = await TestClient.PostAsync("EventOrganizer", content);

            // Arrange
            response.Headers.TryGetValues("location", out var locations);
            var eventId = locations.ToList()[0].Split('/').Last();

            response = await TestClient.GetAsync($"Event/{eventId}");

            response.StatusCode
            .Should()
            .BeEquivalentTo(HttpStatusCode.OK);
        }
        public async Task GetThumbnail_WhenEventIdIsValidButThumbnailIsNotSet_ShouldReturnNotFound()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto       = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent      = JsonConvert.SerializeObject(createEventDto);
            var content              = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            var createdEventResponse = await TestClient.PostAsync("/EventOrganizer", content);

            createdEventResponse.Headers.TryGetValues("location", out var location);
            string eventLocation = location.ToList()[0];
            var    eventId       = eventLocation.Split('/').Last();
            // Act
            var response = await TestClient.GetAsync($"/Event/{eventId}/thumbnail");

            // Assert
            response.StatusCode
            .Should()
            .Be(HttpStatusCode.NotFound);
        }
        public async Task GetEventByTitle_WhenEventExist_ShouldReturnEventData()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto  = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent = JsonConvert.SerializeObject(createEventDto);
            var content         = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            await TestClient.PostAsync("/EventOrganizer", content);

            var parsedTitle = createEventDto.Title.Replace(" ", "%20");
            // Act
            var response = await TestClient.GetAsync($"/Event?eventTitle={parsedTitle}");

            var responseString = await response.Content.ReadAsStringAsync();

            // Assert
            JsonConvert.DeserializeObject <EventDto>(responseString)
            .Should()
            .NotBeNull();
        }
        public async Task GetAllEvents_WhenEventListNotEmpty_ShouldReturnNotEmptyEventList()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto  = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent = JsonConvert.SerializeObject(createEventDto);
            var content         = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            await TestClient.PostAsync("/EventOrganizer", content);

            // Act
            var response = await TestClient.GetAsync("/Event/all");

            var responseString = await response.Content.ReadAsStringAsync();

            // Assert
            var paginatedEventList = JsonConvert.DeserializeObject <PaginatedResponseDto <EventDto> >(responseString);

            paginatedEventList.Items
            .Should()
            .NotBeEmpty();
        }
        public async Task GetEvent_WhenEventIdIsValid_ShouldReturnEventData()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto       = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent      = JsonConvert.SerializeObject(createEventDto);
            var content              = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            var createdEventResponse = await TestClient.PostAsync("/EventOrganizer", content);

            createdEventResponse.Headers.TryGetValues("location", out var location);
            string eventLocation = location.ToList()[0];
            var    eventId       = eventLocation.Split('/').Last();
            // Act
            var response = await TestClient.GetAsync($"/Event/{eventId}");

            var responseString = await response.Content.ReadAsStringAsync();

            // Assert
            JsonConvert.DeserializeObject <EventDto>(responseString)
            .Should()
            .NotBeNull();
        }
        public async Task UpdateEvent_WhenParamsAreValid_ShouldUpdateEvent()
        {
            // Arrange
            await AuthenticateAsync();

            var eventId = await CreateEvent();

            var updateEventDto = EventTestDataFactory.CreateTestEventDto();
            var contentString  = JsonConvert.SerializeObject(updateEventDto);
            var content        = new StringContent(contentString, Encoding.UTF8, "application/json");
            // Act
            await TestClient.PutAsync($"EventOrganizer/{eventId}", content);

            // Assert
            var response = await TestClient.GetAsync($"Event/{eventId}");

            var responseBodyString = await response.Content.ReadAsStringAsync();

            var @event = JsonConvert.DeserializeObject <EventDto>(responseBodyString);

            @event.Title
            .Should()
            .BeEquivalentTo(updateEventDto.Title);
        }
        public async Task GetThumbnail_WhenEventHasThumbnail_ShouldReturnImageFile()
        {
            // Arrange
            await AuthenticateAsync();

            var createEventDto       = EventTestDataFactory.CreateTestEventDto();
            var serializedEvent      = JsonConvert.SerializeObject(createEventDto);
            var content              = new StringContent(serializedEvent, Encoding.UTF8, "application/json");
            var createdEventResponse = await TestClient.PostAsync("/EventOrganizer", content);

            createdEventResponse.Headers.TryGetValues("location", out var location);
            string eventLocation = location.ToList()[0];
            var    eventId       = eventLocation.Split('/').Last();

            // Set thumbnail
            using var fileStream = File.OpenRead("SampleData/ValidImageFile.jpg");
            var streamContent = new StreamContent(fileStream);

            streamContent.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
            var formData = new MultipartFormDataContent();

            formData.Add(streamContent, "file", "ValidImageFile.jpg");
            await TestClient.PatchAsync($"EventOrganizer/{eventId}/thumbnail", formData);

            // Act
            var response = await TestClient.GetAsync($"/Event/{eventId}/thumbnail");

            // Assert
            var responseContent = await response.Content.ReadAsByteArrayAsync();

            var result = new FileContentResult(responseContent, "image/jpeg");

            result.FileContents
            .Should()
            .NotBeEmpty();
        }