public async Task <IEnumerable <Movie> > GetMoviesByGenre(Genre genre)
{
GenreParser.Validate(genre);
var allMovies = await GetAllMovies().ConfigureAwait(false);
return(allMovies.Where(m => m.Genre == genre));
}
private static Task <HttpResponseMessage> WriteMoviesToResponse(HttpRequestMessage request, IEnumerable <global::DomainLayer.Managers.Models.Movie> movies)
{
IEnumerable <ImdbMovie> imdbMovies = null;
var absolutePath = request.RequestUri.AbsolutePath;
if (absolutePath.Contains("withcategories"))
{
imdbMovies = movies.Select(m => new ImdbMovie {
Title = m.Title, Category = GenreParser.ToString(m.Genre)
});
}
else if (absolutePath.Contains("withimageurls"))
{
imdbMovies = movies.Select(m => new ImdbMovie {
Title = m.Title, ImageUrl = m.ImageUrl
});
}
else if (absolutePath.Contains("withyears"))
{
imdbMovies = movies.Select(m => new ImdbMovie {
Title = m.Title, Year = m.Year
});
}
var imdbMoviesJson = JsonConvert.SerializeObject(imdbMovies);
var httpResponseMessage = request.CreateResponse();
httpResponseMessage.Content = new StringContent(imdbMoviesJson, Encoding.UTF8, "application/json");
return(Task.FromResult(httpResponseMessage));
}
public async Task CreateMovie_WhenAnExceptionIsThrownInTheDomainLayer_ShouldThrow()
{
// Arrange
var expectedMessage = "Some Exception Message";
var expectedException = new DuplicateMovieException(expectedMessage);
var moviesController = new MovieControllerForTest(expectedException);
var movieResource = new MovieResource
{
Title = "Some Title",
Genre = GenreParser.ToString(Genre.Action),
ImageUrl = "Some Url",
Year = 1900
};
// Act
try
{
await moviesController.CreateMovie(movieResource);
Assert.Fail("We were expecting an exception of type: DuplicateMovieException to be thrown, but no exception was thrown");
}
catch (DuplicateMovieException e)
{
// Assert
Assert.AreEqual(expectedMessage, e.Message);
}
}
public static void AssertMoviesAreEqual(IEnumerable <Movie> expectedMovies, IEnumerable <Movie> actualMovies)
{
var movieEqualityComparer = new MovieEqualityComparer();
var moviesNotInActual = expectedMovies.Except(actualMovies, movieEqualityComparer);
var moviesNotInExpected = actualMovies.Except(expectedMovies, movieEqualityComparer);
if (!moviesNotInActual.Any() && !moviesNotInExpected.Any())
{
return;
}
var errorMessages = new StringBuilder();
if (moviesNotInActual.Any())
{
errorMessages.AppendLine("The Following movies are in Expected Movies but Not in Actual Movies");
foreach (var movie in moviesNotInActual)
{
errorMessages.AppendLine($"Title: {movie.Title}, Genre: {GenreParser.ToString(movie.Genre)}, Year: {movie.Year}");
}
}
if (moviesNotInExpected.Any())
{
errorMessages.AppendLine("The Following movies are in Actual Movies but Not in Expected Movies");
foreach (var movie in moviesNotInExpected)
{
errorMessages.AppendLine($"Title: {movie.Title}, Genre: {GenreParser.ToString(movie.Genre)}, Year: {movie.Year}");
}
}
throw new AssertFailedException(errorMessages.ToString());
}
public async Task <IEnumerable <MovieResource> > GetMoviesByGenre(string genreAsString)
{
var genre = GenreParser.Parse(genreAsString);
var movies = await GetMoviesByGenre(genre);
return(ModelToResourceMapper.MapToMovieResource(movies));
}
private static IEnumerable <Movie> JoinImdbMoviesMapToMovies(IEnumerable <ImdbMovie> moviesWithCategory, IEnumerable <ImdbMovie> moviesWithImgUrl, IEnumerable <ImdbMovie> moviesWithYear)
{
var allMovies = new List <Movie>();
using (var moviesWithCategoryEnumerator = moviesWithCategory.GetEnumerator())
using (var moviesWithImgUrlEnumerator = moviesWithImgUrl.GetEnumerator())
using (var moviesWithYearEnumerator = moviesWithYear.GetEnumerator())
{
while (moviesWithCategoryEnumerator.MoveNext())
{
var movieWithCategory = moviesWithCategoryEnumerator.Current;
moviesWithImgUrlEnumerator.MoveNext();
var movieWithImgUrl = moviesWithImgUrlEnumerator.Current;
moviesWithYearEnumerator.MoveNext();
var movieWithYear = moviesWithYearEnumerator.Current;
allMovies.Add(new Movie(
title: movieWithCategory.Title,
imageUrl: movieWithImgUrl.ImageUrl,
genre: GenreParser.Parse(movieWithCategory.Category),
year: movieWithYear.Year));
}
}
return(allMovies);
}
public async Task <IEnumerable <MovieResource> > MoviesByGenre(string genreAsString)
{
var genre = GenreParser.Parse(genreAsString);
var movies = await GetMoviesByGenre(genre).ConfigureAwait(false);
return(MapToMovieResource(movies));
}
private static IEnumerable <Movie> MapMovieResourceToMovie(IEnumerable <MovieResource> movieResources)
{
foreach (var movieResource in movieResources)
{
yield return(new Movie(movieResource.Name, GenreParser.Parse(movieResource.Genre), movieResource.Year, movieResource.ImageUrl));
}
}
public IEnumerable <MovieResource> GetMoviesByGenre(string genreAsString)
{
var genre = GenreParser.Parse(genreAsString);
var movies = _domainFacade.GetMoviesByGenre(genre);
return(MapToMovieResource(movies));
}
public static Movie MapToMovie(MovieResource movieResource)
{
return(new Movie(
title: movieResource.Title,
imageUrl: movieResource.ImageUrl,
genre: GenreParser.Parse(movieResource.Genre),
year: movieResource.Year));
}
private static IEnumerable <MovieResource> MapToMovieResource(IEnumerable <Movie> movies)
{
foreach (var movie in movies)
{
yield return(new MovieResource {
Name = movie.Name, Genre = GenreParser.ToString(movie.Genre), ImageUrl = movie.ImageUrl, Year = movie.Year
});
}
}
private IEnumerable <ImdbMovieResource> MapMoviesToImdbMovies(IEnumerable <Movie> movies)
{
foreach (var movie in movies)
{
yield return(new ImdbMovieResource {
Title = movie.Name, Category = GenreParser.ToString(movie.Genre), ImageUrl = movie.ImageUrl, Year = movie.Year
});
}
}
public static MovieResource MapToMovieResource(Movie movie)
{
return(new MovieResource
{
Title = movie.Title,
ImageUrl = movie.ImageUrl,
Genre = GenreParser.ToString(movie.Genre),
Year = movie.Year
});
}
private static string ValidateGenre(Genre genre)
{
var errorMessage = GenreParser.ValidationMessage(genre);
if (errorMessage != null)
{
errorMessage += "\r\n";
}
return(errorMessage);
}
private static async IAsyncEnumerable <Movie> MapToMoviesStreaming(DbDataReader dbDataReader)
{
while (await dbDataReader.ReadAsync().ConfigureAwait(false))
{
yield return(new Movie(
title: (string)dbDataReader[0],
genre: GenreParser.Parse((string)dbDataReader[1]),
year: (int)dbDataReader[2],
imageUrl: (string)dbDataReader[3]));
}
}
private static IEnumerable <Movie> MapMovieResourceToMovie(IEnumerable <ImdbMovieResource> moviesResource)
{
foreach (var movieResource in moviesResource)
{
yield return(new Movie(
movieResource.Title,
GenreParser.Parse(movieResource.Category),
movieResource.Year,
movieResource.ImageUrl));
}
}
public async Task <IEnumerable <Movie> > GetMoviesByGenre(Genre genre)
{
GenreParser.Validate(genre);
var moviesFromImdbTask = ImdbServiceGateway.GetAllMovies();
var moviesFromDbMatchingGenreTask = DataFacade.GetMovieByGenre(genre);
await Task.WhenAll(moviesFromImdbTask, moviesFromDbMatchingGenreTask).ConfigureAwait(false);
var moviesMatchingGenre = moviesFromDbMatchingGenreTask.Result.ToList();
moviesMatchingGenre.AddRange(moviesFromImdbTask.Result.Where(m => m.Genre == genre));
return(moviesMatchingGenre);
}
public static IEnumerable <ImdbMovie> ToImdbMovies(DbDataReader dbDataReader)
{
while (dbDataReader.Read())
{
yield return(new ImdbMovie(
title: (string)dbDataReader[0],
genre: GenreParser.Parse((string)dbDataReader[1]),
year: (int)dbDataReader[2],
imageUrl: (string)dbDataReader[3]
));
}
}
private static IEnumerable <SqlDataRecord> ConvertToSqlDataRecord(IEnumerable <Movie> movies)
{
var sqlDataRecord = new SqlDataRecord(s_sqlMetaDataCreateMovies);
foreach (var movie in movies)
{
sqlDataRecord.SetString(0, movie.Title);
sqlDataRecord.SetString(1, GenreParser.ToString(movie.Genre));
sqlDataRecord.SetInt32(2, movie.Year);
sqlDataRecord.SetString(3, movie.ImageUrl);
yield return(sqlDataRecord);
}
}
private static async Task <Movie> MapToMovie(DbDataReader dbDataReader)
{
if (await dbDataReader.ReadAsync().ConfigureAwait(false))
{
return(new Movie(
title: (string)dbDataReader[0],
genre: GenreParser.Parse((string)dbDataReader[1]),
year: (int)dbDataReader[2],
imageUrl: (string)dbDataReader[3]));
}
return(null);
}
public ActionResult <IEnumerable <MovieResource> > GetMoviesByGenre(string genreAsString)
{
try
{
var genre = GenreParser.Parse(genreAsString);
var movies = _domainFacade.GetMoviesByGenre(genre);
return(new OkObjectResult(MapToMovieResource(movies)));
}
catch (Exception e)
{
return(new ExceptionActionResult(e));
}
}
private static IEnumerable <Movie> MapToMovies(DbDataReader dbDataReader)
{
var movies = new List <Movie>();
while (dbDataReader.Read())
{
movies.Add(new Movie(
title: (string)dbDataReader[0],
genre: GenreParser.Parse((string)dbDataReader[1]),
year: (int)dbDataReader[2],
imageUrl: (string)dbDataReader[3]));
}
return(movies);
}
private static async Task <IEnumerable <Movie> > MapToMovies(DbDataReader dbDataReader)
{
var movies = new List <Movie>();
while (await dbDataReader.ReadAsync().ConfigureAwait(false))
{
movies.Add(new Movie(
title: (string)dbDataReader[0],
genre: GenreParser.Parse((string)dbDataReader[1]),
year: (int)dbDataReader[2],
imageUrl: (string)dbDataReader[3]));
}
return(movies);
}
public async Task GetMoviesByGenre_WhenProvidedWithAValidGenre_ReturnsMoviesByGenre()
{
// Arrange
//// It is not the controller's responsibility to filter by genre
/// or ensure all movies being returned have the genre specified
var expectedMovies = RandomMovieGenerator.GenerateRandomMovies(50);
var moviesController = new MovieControllerForTest(expectedMovies);
var validGenreAsString = GenreParser.ToString(Genre.SciFi);
// Act
var actualMovieResources = await moviesController.GetMoviesByGenre(validGenreAsString);
// Assert
var actualMovies = MapToMvoies(actualMovieResources);
MovieAssertions.AssertMoviesAreEqual(expectedMovies, actualMovies);
}
private static IEnumerable <Movie> MapToMvoies(IEnumerable <MovieResource> movieResources)
{
var movies = new List <Movie>();
foreach (var movieResource in movieResources)
{
movies.Add(
new Movie(
movieResource.Title,
movieResource.ImageUrl,
GenreParser.Parse(movieResource.Genre),
movieResource.Year)
);
}
return(movies);
}
public static async Task <Movie> RetrieveMovie(string dbConnectionString, string title)
{
DbConnection dbConnection = null;
DbCommand dbCommand = null;
try
{
dbConnection = CreateDbConnection(dbConnectionString);
await dbConnection.OpenAsync();
dbCommand = dbConnection.CreateCommand();
dbCommand.CommandType = CommandType.Text;
dbCommand.CommandText = "SELECT Title, Genre, Year, ImageUrl FROM dbo.MovieVw WHERE Title = @Title";
AddDbParameter(dbCommand, "@Title", title, DbType.String, 50);
var dbDataReader = await dbCommand.ExecuteReaderAsync();
if (dbDataReader.Read())
{
const int MovieTitleIndex = 0;
const int MovieGenreIndex = 1;
const int MovieYearIndex = 2;
const int MovieImageUrlIndex = 3;
return(new Movie
(
title: (string)dbDataReader[MovieTitleIndex],
imageUrl: (string)dbDataReader[MovieImageUrlIndex],
genre: GenreParser.Parse((string)dbDataReader[MovieGenreIndex]),
year: (int)dbDataReader[MovieYearIndex]
));
}
return(null);
}
finally
{
dbCommand?.Dispose();
dbConnection.Dispose();
}
}
public async Task CreateMovie_WhenProvidedWithAValidMovieResource_Succeeds()
{
// Arrange
var movieResource = new MovieResource
{
Title = "Some Title",
Genre = GenreParser.ToString(Genre.Action),
ImageUrl = "Some Url",
Year = 1900
};
var moviesController = new MovieControllerForTest(movies: null);
// Act
await moviesController.CreateMovie(movieResource);
// Assert
// Nothing to Assert
Assert.IsTrue(true);
}
public async Task GetMoviesByGenre_WhenProvidedWithAValidAndExistingGenre_ShouldReturnMoviesForGenre()
{
// Act
var validGenre = GenreParser.ToString(Genre.SciFi);
var httpResponseMessage = await _httpClient.GetAsync($"api/movies/genre/{validGenre}");
// Assert
if (httpResponseMessage.StatusCode == HttpStatusCode.OK)
{
var actualMovieResource = await httpResponseMessage.Content.ReadAsAsync <IEnumerable <MovieResource> >();
Assert.IsTrue(actualMovieResource.All(m => m.Genre == validGenre));
}
else
{
var httpContent = await httpResponseMessage.Content.ReadAsStringAsync();
Assert.Fail($"Reason Phrase: {httpResponseMessage.ReasonPhrase} with Content: {httpContent}");
}
}
public static DbCommand CreateCommandForGetMoviesByGenre(DbConnection dbConnection, Genre genre)
{
var dbCommand = dbConnection.CreateCommand();
dbCommand.CommandType = CommandType.StoredProcedure;
dbCommand.CommandText = "dbo.GetMoviesByGenre";
AddReturnValueParameter(dbCommand);
AddCommandParameter(dbCommand, "@Genre", ParameterDirection.Input, DbType.String, GenreParser.ToString(genre), 50);
return(dbCommand);
}
public static DbCommand CreateCommandForCreateMovie(DbConnection dbConnection, DbTransaction dbTransaction, Movie movie)
{
var dbCommand = dbConnection.CreateCommand();
dbCommand.CommandText = "dbo.CreateMovie";
dbCommand.CommandType = CommandType.StoredProcedure;
dbCommand.Transaction = dbTransaction;
AddReturnValueParameter(dbCommand);
AddCommandParameter(dbCommand, "@Title", ParameterDirection.Input, DbType.String, movie.Title, 50);
AddCommandParameter(dbCommand, "@Genre", ParameterDirection.Input, DbType.String, GenreParser.ToString(movie.Genre), 50);
AddCommandParameter(dbCommand, "@Year", ParameterDirection.Input, DbType.Int32, movie.Year, 0);
AddCommandParameter(dbCommand, "@ImageUrl", ParameterDirection.Input, DbType.String, movie.ImageUrl, 200);
return(dbCommand);
}
