public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Gigs = new GigRepository(_context);
Genres = new GenreRepository(_context);
Attendances = new AttendanceRepository(_context);
}
public MainWindow()
{
InitializeComponent();
IList <Genre> genreList = GenreRepository.GetGenres();
Genre_Combobox.ItemsSource = genreList;
}
// Initalize Method used for all tests
public GenreRepositoryTests(DatabaseFixture fixture)
{
this.fixture = fixture;
_bookRepository = new BookRepository(fixture.dbContext);
_genreRepository = new GenreRepository(fixture.dbContext);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request.QueryString["ID"] != null && !IsPostBack)
{
DropDownListDirectorName.DataSource = DirectorRepository.GetAllDirectors();
DropDownListDirectorName.DataBind();
DropDownListGenre.DataSource = GenreRepository.GetAllGenres();
DropDownListGenre.DataBind();
int id = int.Parse(Request.QueryString["ID"]);
var movie = MovieRepository.GetViewMovie(id);
MovieName.Value = movie.MovieName;
DropDownListDirectorName.ClearSelection();
DropDownListDirectorName.Items.FindByValue(movie.DirectorName).Selected = true;
DropDownListGenre.ClearSelection();
DropDownListGenre.Items.FindByValue(movie.GenreName).Selected = true;
Description.Value = movie.Description;
ReleaseDate.Value = movie.ReleaseDate.ToString();
Score.Value = movie.Score.ToString();
Title = movie.MovieName + " (" + movie.ReleaseDate + ")";
}
}
public EFUnitOfWork(AEXTestDBContext context)
{
this.context = context;
MovieRepository = new MovieRepository(this.context);
ActorRepository = new ActorRepository(this.context);
GenreRepository = new GenreRepository(this.context);
}
public MovieController()
{
string cnn = ConfigurationManager.ConnectionStrings["CinemaCnn"].ToString();
var dbContext = new DatabaseContext(cnn);
var movieRepository = new MovieRepository(dbContext);
var theaterRepository = new TheaterRepository(dbContext);
var genreRepository = new GenreRepository(dbContext);
var timeIntervalRepository = new TimeIntervalRepository(dbContext);
var userRepository = new UserRepository(dbContext);
var movieUserRepository = new MovieUserRepository(dbContext);
_db = dbContext;
_movieRepository = movieRepository;
_genreRepository = genreRepository;
_theaterRepository = theaterRepository;
_timeIntervalRepository = timeIntervalRepository;
_userRepository = userRepository;
_movieUserRepository = movieUserRepository;
_movieService = new MovieService(movieRepository, theaterRepository,
_genreRepository, timeIntervalRepository);
_genreService = new GenreService(genreRepository);
_theaterService = new TheaterService(theaterRepository);
_movieUserService = new MovieUserService(movieUserRepository, movieRepository, userRepository);
}
private GenreService SetUpService()
{
var list = GetTestCollection().AsQueryable();
var mockSet = new Mock <DbSet <Genre> >();
mockSet.As <IQueryable <Genre> >().Setup(p => p.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Genre> >().Setup(p => p.Expression).Returns(list.Expression);
mockSet.As <IQueryable <Genre> >().Setup(p => p.ElementType).Returns(list.ElementType);
mockSet.As <IQueryable <Genre> >().Setup(p => p.GetEnumerator()).Returns(list.GetEnumerator);
var mockCtx = new Mock <ApplicationDbContext>();
mockCtx.Setup(p => p.Genres).Returns(mockSet.Object);
var repository = new GenreRepository(mockCtx.Object);
var mapperConfig = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Genre, GenreDTO>();
});
var mapper = mapperConfig.CreateMapper();
var svc = new GenreService(repository, mapper);
return(svc);
}
public UnitOfWorkMem()
{
context = new VideoAppContext();
VideoRepository = new VideoRepositoryEFMemory(context);
GenreRepository = new GenreRepository(context);
RentalRepository = new RentalRepository(context);
}
public GenreController()
{
string cnn = ConfigurationManager.ConnectionStrings["CinemaCnn"].ToString();
var dbContext = new DatabaseContext(cnn);
var genreRepo = new GenreRepository(dbContext);
_genreRepository = genreRepo;
}
public Film GetById(int id)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
GenreRepository genreRepository = new GenreRepository(new MssqlGenreContext());
conn.Open();
string query = "SELECT * FROM dbo.film WHERE ID = @ID";
SqlCommand cmd = new SqlCommand(query, conn);
cmd.Parameters.AddWithValue("ID", id);
SqlDataReader reader = cmd.ExecuteReader();
Film f = new Film();
while (reader.Read())
{
string naam = reader.GetString(reader.GetOrdinal("naam"));
string beschrijving = reader.GetString(reader.GetOrdinal("beschrijving"));
int lengte = reader.GetInt32(reader.GetOrdinal("lengte"));
int prijs = reader.GetInt32(reader.GetOrdinal("prijs"));
double rating = (double)reader.GetDecimal(reader.GetOrdinal("rating"));
byte[] image;
Stream s = reader.GetStream(reader.GetOrdinal("Image"));
using (BinaryReader br = new BinaryReader(s))
{
image = br.ReadBytes((int)s.Length);
}
int jaar = reader.GetInt32(reader.GetOrdinal("jaar"));
List <Genre> filmgenres = genreRepository.GetFilmGenres(id);
f = new Film(id, naam, beschrijving, filmgenres, lengte, prijs, rating, image, jaar);
}
conn.Close();
return(f);
}
}
public RepositoryManager(ShuflContext context)
{
AlbumRepository = new AlbumRepository(context);
AlbumArtistRepository = new AlbumArtistRepository(context);
AlbumImageRepository = new AlbumImageRepository(context);
ArtistRepository = new ArtistRepository(context);
ArtistImageRepository = new ArtistImageRepository(context);
ArtistGenreRepository = new ArtistGenreRepository(context);
GenreRepository = new GenreRepository(context);
GroupRepository = new GroupRepository(context);
GroupAlbumRepository = new GroupAlbumRepository(context);
GroupAlbumRatingRepository = new GroupAlbumRatingRepository(context);
GroupInviteRepository = new GroupInviteRepository(context);
GroupMemberRepository = new GroupMemberRepository(context);
GroupPlaylistRepository = new GroupPlaylistRepository(context);
GroupPlaylistRatingRepository = new GroupPlaylistRatingRepository(context);
PasswordResetRepository = new PasswordResetRepository(context);
PlaylistRepository = new PlaylistRepository(context);
PlaylistImageRepository = new PlaylistImageRepository(context);
TrackRepository = new TrackRepository(context);
TrackArtistRepository = new TrackArtistRepository(context);
UserRepository = new UserRepository(context);
UserImageRepository = new UserImageRepository(context);
UserVerificationRepository = new UserVerificationRepository(context);
}
public GenreController()
{
string cnnString = ConfigurationManager.ConnectionStrings["defaultCnn"].ToString();
var dbContext = new CinemaDbContext(cnnString);
var genreRepo = new GenreRepository(dbContext);
_genreService = new GenreService(genreRepo);
}
async void GetGenresAsync()
{
if (!IsBusy)
{
Exception Error = null;
try
{
IsBusy = true;
var reposiroty = new GenreRepository();
var genres = await reposiroty.GenreMovieListAsync();
foreach (var genre in genres)
{
Genres.Add(genre);
}
}
catch (Exception ex)
{
Error = ex;
}
finally
{
IsBusy = false;
}
if (Error != null)
{
await Application.Current.MainPage.DisplayAlert("Falha ao conectar com o Servidor.", Error.Message, "OK");
}
}
return;
}
public async Task Should_returns_null_with_id_not_present()
{
var sut = new GenreRepository(_factory.ContextInstance);
var result = await sut.GetAsync(Guid.NewGuid());
result.ShouldBeNull();
}
public UpdateAlbumPage()
{
InitializeComponent();
genreComboBox.ItemsSource = GenreRepository.GetAllGenres();
artistComboBox.ItemsSource = ArtistRepository.GetAllArtists();
}
// GET: Movies/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GenreRepository genreRepository = new GenreRepository(db);
var genres = genreRepository.GetAll().ToList();
MovieRepository movieRepository = new MovieRepository(db);
Movie movie = movieRepository.GetById(id);
if (movie == null)
{
return(HttpNotFound());
}
AddUpdateMovieModel addUpdateMovieModel = new AddUpdateMovieModel(movie); // Create the model from details
// supplied into the controller
addUpdateMovieModel.genres = genres;
addUpdateMovieModel.PageTitle = "Edit Movie";
return(View(addUpdateMovieModel));
}
public void GetGenresAsync()
{
var repository = new GenreRepository();
var items = repository.GenreMovieListAsync().Result;
Assert.AreEqual(19, items.Count);
}
/// <summary>
/// Adds an order to the database and returns it.
/// </summary>
/// <param name="ord">the order to be added</param>
public Order Add(Order ord)
{
using (var ctx = new MovieShopContext())
{
foreach (Orderline item in ord.Orderlines)
{
bool isDetached = ctx.Entry(item.Movie).State == EntityState.Detached;
if (isDetached)
ctx.Movies.Attach(item.Movie);
ctx.Entry(item.Movie.Genre).State = EntityState.Detached;
}
GenreRepository genreRep = new GenreRepository();
foreach (var item in genreRep.GetAll())
{
ctx.Genres.Attach(item);
}
foreach (var item in ctx.Status.ToList())
{
if (item.Name.Equals("Processing"))
ord.Status = item;
}
Order newOrd = ctx.Orders.Add(ord);
ctx.SaveChanges();
return newOrd;
}
}
public BookService(IConfiguration configuration)
{
_bookRepository = new BookRepository(configuration.GetConnectionString("DefaultConnection"));
_goodRepository = new GoodRepository(configuration.GetConnectionString("DefaultConnection"));
_authorRepository = new AuthorRepository(configuration.GetConnectionString("DefaultConnection"));
_genreRepository = new GenreRepository(configuration.GetConnectionString("DefaultConnection"));
}
public void GetGenreList()
{
var repo = new GenreRepository();
var list = repo.GetList();
Assert.NotNull(list);
}
public UnitOfWork(ApplicationDbContext context, ISeatRepostory seats, IRepository <MovieImage> movieImages)
{
_context = context;
Seats = seats;
MovieImages = movieImages;
Genres = new GenreRepository(_context);
}
// Anropen mot Ratings och Users kan bli tunga med flera tusen
// ratings och användare, därför har jag valt att jobba asynkront.
// Databasen är till för att användas med ett ASP.NET MVC projekt och
// EF Core är inte threadsafe ännu vilket var till fördel
// för asynkront.
public void GetBookInfoRatingAndUsersAsync(Book inputBook)
{
BookRepository bookRepo = new BookRepository();
AuthorRepository authorRepo = new AuthorRepository();
GenreRepository genreRepository = new GenreRepository();
CollectionRepository collectionRepo = new CollectionRepository();
var book = bookRepo.GetById(1);
var bookRatingsAsync = bookRepo.GetAllUserRatingsByBookAsync(book);
var usersAsync = bookRepo.GetAllBookOwnersAsync(book);
var genreAsync = bookRepo.GetBookGenresAsync(book);
var authorAsync = authorRepo.GetByIdAsync(book.Id);
var author = authorAsync.Result;
var genres = genreAsync.Result;
var users = usersAsync.Result;
var bookRatings = bookRatingsAsync.Result;
Console.WriteLine("Title: " + book.Title + "\nAuthor: " + author.FirstName + " " + author.LastName);
Console.Write("Genres: ");
foreach (var genre in genres)
{
Console.Write(" / " + genre.Category);
}
Console.WriteLine("\nAverage Score: " + bookRatings.Values.Average() + " / 10");
Console.WriteLine("In users collection: ");
foreach (var user in users)
{
Console.WriteLine("- " + user.Username);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
lanrepo = new LanguageRepository();
qualrepo = new QualityRepository();
genrepo = new GenreRepository();
List <LanguageTable> lan = lanrepo.GetAllLanguages();
List <GenreTable> gen = genrepo.GetAllGenres();
List <QualityTable> qual = qualrepo.GetAllQualities();
DropDownList6.DataSource = lan;
DropDownList6.DataTextField = "LanguageName";
DropDownList6.DataValueField = "LanguageID";
DropDownList6.DataBind();
DropDownList7.DataSource = qual;
DropDownList7.DataTextField = "QualityName";
DropDownList7.DataValueField = "QualityID";
DropDownList7.DataBind();
DropDownList8.DataSource = gen;
DropDownList8.DataTextField = "GenreName";
DropDownList8.DataValueField = "GenreID";
DropDownList8.DataBind();
}
}
public void Genre_DeleteById_ValidId_ValidatesRemoval(int id)
{
GenreRepository repository = new GenreRepository(_context, _mapper);
Assert.DoesNotThrow(() => repository.DeleteById(id));
Assert.Null(repository.GetById(id));
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Customers = new CustomerRepository(_context);
Books = new BookRepository(_context);
Genres = new GenreRepository(_context);
MembershipTypes = new MembershipTypeRepository(_context);
}
public GigsController()
{
_context = new ApplicationDbContext();
_attendanceRepository = new AttendanceRepository(_context);
_gigRepository = new GigRepository(_context);
_genreRepository = new GenreRepository(_context);
_unitOfWork = new UnitOfWork(_context);
}
public UnitOfWork(ApplicationDbContext dbContext)
{
_dbContext = dbContext;
Gigs = new GigsRepository(dbContext);
Followings = new FollowingsRepository(dbContext);
Genres = new GenreRepository(dbContext);
Attendances = new AttendanceRepository(dbContext);
}
public GenreRepository GetGenryRepository()
{
if (genreRepo == null)
{
genreRepo = new GenreRepository();
}
return genreRepo;
}
public void GetGenre()
{
var genre = new Genre();
var repo = new GenreRepository();
genre = repo.GetGenre(2);
Assert.NotNull(genre);
}
public GenreController()
{
string cnnString = ConfigurationManager.ConnectionStrings["defaultCnn"].ToString();
var dbContext = new eMovieDbContext(cnnString);
var genreRepo = new GenreRepository(dbContext);
_genreService = new GenreService(genreRepo);
}
public GigsController()
{
db = new ApplicationDbContext();
attendanceRepository = new AttendanceRepository(db);
gigRepository = new GigRepository(db);
genreRepository = new GenreRepository(db);
followingRepository = new FollowingRepository(db);
}
public void getgenre_should_thrown_exception_with_null_id()
{
var repository = new GenreRepository(_catalogDataContextFactory.ContextInstance);
var sut = new GetGenreHandler(repository);
sut.Handle(null, CancellationToken.None).ShouldThrow <ArgumentNullException>();
}
public async Task should_return_record_by_id(Genre request)
{
var sut = new GenreRepository(_testDataContextFactory.ContextInstance);
var result = await sut.GetAsync(request.GenreId);
result.GenreId.ShouldBe(request.GenreId);
result.GenreDescription.ShouldBe(request.GenreDescription);
}
public void ConnectionSucceded()
{
var genre = new Genre();
var repo = new GenreRepository();
var conn = repo.Connection;
Assert.NotNull(conn);
}
public Oefening1()
{
InitializeComponent();
IList <Genre> listGenres = new List <Genre>();
listGenres = GenreRepository.GetGenres();
genreSelector.ItemsSource = listGenres;
}
public void GenreRepository_FetchNull_ReturnsAll()
{
// Arrange
var repo = new GenreRepository();
var list = repo.Fetch();
Assert.IsNotNull(list);
Assert.IsTrue(list.Any());
}
public void Test_Update_And_Get()
{
GenreRepository repository = new GenreRepository();
Genre genre = repository.Get(1);
Assert.NotNull(genre);
genre.Name = "Krimi";
Genre result = repository.Update(genre);
Assert.AreEqual(result.Name, "Krimi");
}
public BaseController()
{
string cnnString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
var dbContext = new CinemaDbContext(cnnString);
var actorsRepo = new ActorRepository(dbContext);
_actorService = new ActorService(actorsRepo);
var genreRepo = new GenreRepository(dbContext);
_genreService = new GenreService(genreRepo);
var hallRepo = new HallRepository(dbContext);
_hallService = new HallService(hallRepo);
var movieRepo = new MovieRepository(dbContext);
_movieService = new MovieService(movieRepo, actorsRepo);
}
public void GenreRepository_FetchAll_ReturnsData()
{
// Arrange
var repo = new GenreRepository();
// Act
var results = repo.Fetch();
// Assert
Assert.IsTrue(results != null);
Assert.IsTrue(results.Any());
Assert.IsTrue(results.Count() == 7);
Assert.IsTrue(results.ToList()[6].Name == "Suspense");
}
public void GenreRepository_FetchOne_ReturnsData()
{
// Arrange
var repo = new GenreRepository();
// Act
var results = repo.Fetch(3);
// Assert
Assert.IsTrue(results != null);
Assert.IsTrue(results.Any());
Assert.IsTrue(results.Count() == 1);
Assert.IsTrue(results.Single().GenreId == 3);
}
public void GenreRepository_InsertUpdateDelete_Works()
{
// Arrange
var repo = new GenreRepository();
var testItem = new Genre
{
Name = "TestItem",
Code = "TestItemCode",
IsInactive = true,
DisplayOrder = 99
};
// Act - Insert
var insertedItem = repo.Persist(testItem);
var newId = insertedItem.GenreId;
// Assert for Insert
Assert.IsTrue(newId > 0);
var existingItem = repo.Fetch(newId).Single();
Assert.IsTrue(existingItem.Name == "TestItem");
Assert.IsTrue(existingItem.Code == "TestItemCode");
Assert.IsTrue(existingItem.IsInactive == true);
Assert.IsTrue(existingItem.DisplayOrder == 99);
// Act - Update
existingItem.Name = "TestItem1";
existingItem.Code = "TestItemCode1";
existingItem.IsInactive = false;
existingItem.DisplayOrder = 10;
repo.Persist(existingItem);
// Assert for Update
var updatedItem = repo.Fetch(newId).Single();
Assert.IsTrue(updatedItem.Name == "TestItem1");
Assert.IsTrue(updatedItem.Code == "TestItemCode1");
Assert.IsTrue(updatedItem.IsInactive == false);
Assert.IsTrue(updatedItem.DisplayOrder == 10);
// Act - Delete
updatedItem.IsMarkedForDeletion = true;
var deletedItem = repo.Persist(updatedItem);
// Assert for Delete
Assert.IsNull(deletedItem);
var emptyResult = repo.Fetch(newId);
Assert.IsFalse(emptyResult.Any());
}
public void GenreRepository_Delete_Deletes()
{
// Arrange
var repo = new GenreRepository();
var existingItem = repo.Fetch(3).Single();
// Act
existingItem.IsMarkedForDeletion = true;
var deletedItem = repo.Persist(existingItem);
// Assert for Delete
Assert.IsNull(deletedItem);
var emptyResult = repo.Fetch(3);
Assert.IsFalse(emptyResult.Any());
}
public void GenreRepository_FetchOne_ReturnsOne()
{
// Arrange
var repo = new GenreRepository();
var all = repo.Fetch(null).ToList();
var genreId = all[0].GenreId;
var name = all[0].Name;
var item = repo.Fetch(genreId).Single();
Assert.IsNotNull(item);
Assert.IsTrue(item.GenreId == genreId);
Assert.IsTrue(item.Name == name);
Assert.IsFalse(item.IsMarkedForDeletion);
Assert.IsFalse(item.IsDirty);
}
public void Test_Add_ListAll()
{
Genre genre = new Genre()
{
Id = 1,
Name = "Anime",
};
GenreRepository repository = new GenreRepository();
int numberOfGenres = repository.GetAll().Count();
Genre result = repository.Add(genre);
Assert.NotNull(result);
int finalNumberOfGenres = repository.GetAll().Count();
Assert.AreEqual(numberOfGenres + 1, finalNumberOfGenres);
}
public void GenreRepository_InsertDelete()
{
// Arrange
var repo = new GenreRepository();
var newItem = new Genre
{
Code = "TestCode",
Name = "TestName",
IsInactive = false,
DisplayOrder = 99
};
// Act for Insert
var item = repo.Persist(newItem);
var newId = item.GenreId;
// Assert for Insert - Make sure local object is updated
Assert.IsTrue(item.GenreId > 0);
Assert.IsFalse(item.IsMarkedForDeletion);
Assert.IsFalse(item.IsDirty);
// Assert for Insert - Make sure refetched object is correct
var refetch = repo.Fetch(newId).First();
Assert.IsTrue(refetch.GenreId == newId);
Assert.IsFalse(refetch.IsMarkedForDeletion);
Assert.IsFalse(refetch.IsDirty);
Assert.IsTrue(refetch.Code == "TestCode");
Assert.IsTrue(refetch.Name == "TestName");
Assert.IsTrue(refetch.IsInactive == false);
Assert.IsTrue(refetch.DisplayOrder == 99);
// Clean-up (Act for Delete)
item.IsMarkedForDeletion = true;
repo.Persist(item);
// Assert for Delete
var result = repo.Fetch(newId);
Assert.IsFalse(result.Any());
}
public void Test_Update()
{
MovieRepository repository = new MovieRepository();
GenreRepository gr = new GenreRepository();
Movie mov = repository.Get(1);
Assert.NotNull(mov);
mov.Title = "Red";
mov.Genre = gr.Get(3);
mov.Price = 20;
mov.ImgUrl = "http://scaled.ysimag.es/movie/it-follows";
mov.TrailerUrl = "https://www.youtube.com/watch?v=w0qQkSuWOS8";
mov.Year = DateTime.Today.Date;
Movie result = repository.Update(mov);
Assert.AreEqual(result.Title,"Red");
Assert.AreEqual(result.Genre.Id, 3);
Assert.AreEqual(result.Price, 20);
Assert.AreEqual(result.ImgUrl, "http://scaled.ysimag.es/movie/it-follows");
Assert.AreEqual(result.TrailerUrl, "https://www.youtube.com/watch?v=w0qQkSuWOS8");
Assert.AreEqual(result.Year, DateTime.Today.Date);
}
public void GenreRepository_Insert_Insertss()
{
// Arrange
var repo = new GenreRepository();
var testItem = new Genre
{
Name = "TestItem",
Code = "TestItemCode",
IsInactive = true,
DisplayOrder = 99
};
// Act
var insertedItem = repo.Persist(testItem);
var newId = insertedItem.GenreId;
// Assert
Assert.IsTrue(newId > 0);
var existingItem = repo.Fetch(newId).Single();
Assert.IsTrue(existingItem.Name == "TestItem");
Assert.IsTrue(existingItem.Code == "TestItemCode");
Assert.IsTrue(existingItem.IsInactive == true);
Assert.IsTrue(existingItem.DisplayOrder == 99);
}
public void GenreRepository_Update_Updates()
{
// Arrange
var repo = new GenreRepository();
var existingItem = repo.Fetch(2).Single();
// Act - Update
existingItem.Name = "TestItem1";
existingItem.Code = "TestItemCode1";
existingItem.IsInactive = false;
existingItem.DisplayOrder = 10;
repo.Persist(existingItem);
// Assert for Update
var updatedItem = repo.Fetch(2).Single();
Assert.IsTrue(updatedItem.Name == "TestItem1");
Assert.IsTrue(updatedItem.Code == "TestItemCode1");
Assert.IsTrue(updatedItem.IsInactive == false);
Assert.IsTrue(updatedItem.DisplayOrder == 10);
}
public GenreController()
{
this.context = new GenreRepository(new MusicSystemDbContext());
}
public void GenreRepository_InsertUpdateDelete()
{
// Arrange
var repo = new GenreRepository();
var newItem = new Genre
{
Code = "TestCode",
Name = "TestName",
IsInactive = false,
DisplayOrder = 99
};
var item = repo.Persist(newItem);
var newId = item.GenreId;
// Act for Update
item.Name = "XYZ";
item.Code = "ABC";
item.IsInactive = true;
item.DisplayOrder = 999;
item.IsDirty = true;
var updatedItem = repo.Persist(item);
Assert.IsTrue(updatedItem.IsDirty == false);
Assert.IsTrue(updatedItem.Name == "XYZ");
Assert.IsTrue(updatedItem.Code == "ABC");
Assert.IsTrue(updatedItem.IsInactive);
Assert.IsTrue(updatedItem.DisplayOrder == 999);
// Assert for Update
var refetch = repo.Fetch(newId).First();
Assert.IsTrue(refetch.Name == "XYZ");
// Clean-up (Act for Delete)
item.IsMarkedForDeletion = true;
repo.Persist(item);
// Assert for Delete
var result = repo.Fetch(newId);
Assert.IsFalse(result.Any());
}
public RepositoryRegistry()
{
For<ICredentialRepository>()
.Use(factory =>
{
return new CredentialRepository(factory.GetInstance<Entities>());
});
For<IProfileRepository>()
.Use(factory =>
{
var repository = new ProfileRepository(factory.GetInstance<Entities>());
return repository;
});
For<IProfileActivityRepository>()
.Use(factory =>
{
var repository = new ProfileActivityRepository(factory.GetInstance<Entities>());
return repository;
});
For<IGrunkerRepository>()
.Use(factory =>
{
var repository = new GrunkerRepository(factory.GetInstance<Entities>());
return repository;
});
For<IActivityTypeRepository>()
.Use(factory =>
{
var repository = new ActivityTypeRepository(factory.GetInstance<Entities>());
return repository;
});
For<IPictureRepository>()
.Use(factory =>
{
var repository = new PictureRepository(factory.GetInstance<Entities>());
return repository;
});
For<IGenreRepository>()
.Use(factory =>
{
var repository = new GenreRepository(factory.GetInstance<Entities>());
return repository;
});
For<IArtistRepository>()
.Use(factory =>
{
var repository = new ArtistRepository(factory.GetInstance<Entities>());
return repository;
});
For<IAlbumRepository>()
.Use(factory =>
{
var repository = new AlbumRepository(factory.GetInstance<Entities>());
return repository;
});
For<IPurchaseRepository>()
.Use(factory =>
{
var repository = new PurchaseRepository(factory.GetInstance<Entities>());
return repository;
});
For<IReviewRepository>()
.Use(factory =>
{
var repository = new ReviewRepository(factory.GetInstance<Entities>());
return repository;
});
For<IReviewLinkRepository>()
.Use(factory =>
{
var repository = new ReviewLinkRepository(factory.GetInstance<Entities>());
return repository;
});
For<IStoreDetailsRepository>()
.Use(factory =>
{
var repository = new StoreDetailsRepository(HttpContext.Current.Server.MapPath("~/App_Data/storedetails.xml"));
return repository;
});
For<IStaticTextRepository>()
.Use(factory =>
{
var repository = new StaticTextRepository(factory.GetInstance<Entities>());
return repository;
});
}
