public void GetAllTest()
{
//Arrange
using (var context = new AppDbContext(options))
{
var reviews = new List <GoodReview> {
new GoodReview {
Id = 1, GoodId = 1
},
new GoodReview {
Id = 2, GoodId = 1
}, new GoodReview {
Id = 3, GoodId = 1
}
};
var repo = new ReviewRepository(context);
//Act
foreach (var review in reviews)
{
context.Reviews.Add(review);
}
var actualResult = repo.GetAll();
var expectedResult = context.Reviews;
//Assert
Assert.AreEqual(expectedResult, actualResult);
}
}
public ReviewsIndexVM(ReviewRepository newReviewRepository, RestaurantRepository newRestaurantRepository)
{
reviewRepository = newReviewRepository;
restaurantRepository = newRestaurantRepository;
MyReviews = reviewRepository.GetAll().Reverse(); // Most recently created first
MyRestaurants = restaurantRepository.GetAll();
}
public void GetReviewsandRatings()
{
var options = new DbContextOptionsBuilder <RestaurantManagementContext>()
.UseInMemoryDatabase(databaseName: "ReviewManagement")
.Options;
RestaurantManagementContext context = new RestaurantManagementContext(options);
TblRatingandReviews ratingandReviews = new TblRatingandReviews
{
Id = 1,
Rating = 5,
Reviews = "Amazing",
TblRestaurantId = 3
};
context.TblRatingandReviews.Add(ratingandReviews);
TblRestaurant tblRestaurant = new TblRestaurant
{
Id = 3,
Name = "Frotinar"
};
context.TblRestaurant.Add(tblRestaurant);
ReviewRepository reviewRepository = new ReviewRepository(context);
var restaurantratings = reviewRepository.GetRestaurantRating("Frotinar");
Assert.NotNull(restaurantratings);
}
public void TestGetReviewById()
{
var sql = new ReviewSqlContext();
var repo = new ReviewRepository(sql);
Assert.AreEqual(1, repo.GetReviewById(2).AuteurId);
}
public void Get_Id_Returns_Review_Title_from_Index()
{
var underTest = new ReviewRepository();
var result = underTest.FindOneReviewById(1);
Assert.Equal("War And Peace", result.Title);
}
public RestaurantsController(RestaurantRepository newRestaurantRepository,
ReviewRepository newReviewRepository)
{
log = LogManager.GetLogger("file");
restaurantRepository = newRestaurantRepository;
reviewRepository = newReviewRepository;
}
public ReviewRepositoryTests()
{
db = new MlpContext();
db.Database.BeginTransaction();
underTest = new ReviewRepository(db);
}
public ActionResult Delete(int id)
{
reviewRepository = new ReviewRepository();
var review = reviewRepository.GetById(id);
return(View(review));
}
public ActionResult DeleteTestCase(IList <TestCase> rows)
{
var testCaseRepo = new TestCaseRepository();
foreach (var row in rows)
{
var testCase = testCaseRepo.GetById(row.Id);
if (testCase.Evidences != null && testCase.Evidences.Count > 0)
{
var evidenceRepo = new EvidenceRepository();
foreach (var evidence in testCase.Evidences)
{
System.IO.File.Delete(Server.MapPath("~/Uploads/" + evidence.Name + evidence.Extension));
evidenceRepo.Delete(evidence);
}
}
if (testCase.Reviews != null && testCase.Reviews.Count > 0)
{
var reviewsRepo = new ReviewRepository();
foreach (var review in testCase.Reviews)
{
reviewsRepo.Delete(review);
}
}
testCaseRepo.Delete(testCase);
}
TempData["success"] = "Test case/s was deleted!";
return(View("CompanyTests"));
}
public ActionResult EditModify(int id)
{
var reviewRepository = new ReviewRepository();
var reviewToModify = reviewRepository.GetById(id);
return(View(reviewToModify));
}
public ActionResult View(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
BenchRepository benchRepo = new BenchRepository(context);
Bench bench = benchRepo.GetBenchById(id.Value);
if (bench == null)
{
return(RedirectToAction("Index"));
}
ReviewRepository reviewRepo = new ReviewRepository(context);
List <Review> reviews = reviewRepo.GetReviewsByBench(id.Value);
UserRepository userRepo = new UserRepository(context);
List <User> users = userRepo.GetUsers();
var viewModel = new BenchViewModel();
viewModel.Id = bench.Id;
viewModel.Name = bench.Name;
viewModel.Seats = bench.Seats;
viewModel.Description = bench.Description;
viewModel.DateDiscovered = bench.DateDiscovered;
viewModel.Latitude = bench.Latitude;
viewModel.Longitude = bench.Longitude;
viewModel.Reviews = reviews;
viewModel.Users = users;
return(View("View", viewModel));
}
public void GetReviewByReserveIdTest()
{
ContextObl context = ContextFactory.GetMemoryContext(Guid.NewGuid().ToString());
IReviewRepository reviewRepo = new ReviewRepository(context);
ITouristSpotRepository touristSpotRepo = new TouristSpotRepository(context);
ILodgingRepository lodgingRepo = new LodgingRepository(context);
IRepository <Reserve> reserveRepo = new BaseRepository <Reserve>(context);
touristSpotRepo.Add(touristSpot);
lodgingRepo.Add(lodging);
reserveRepo.Add(reserve);
Review reviewToAdd = new Review()
{
Id = Guid.NewGuid(),
Description = "Me gusto mucho la estadia",
IdOfReserve = reserve.Id,
LastNameOfWhoComments = reserve.LastName,
NameOfWhoComments = reserve.Name,
LodgingOfReview = lodging,
Score = 4
};
reviewRepo.Add(reviewToAdd);
Review reviewResult = reviewRepo.GetReviewByReserveId(reserve.Id);
Assert.IsTrue(reviewResult.Equals(reviewToAdd));
}
public void Update_Test_submit_review()
{
TblRating reviewdetails = new TblRating()
{
TblCustomerId = 1,
Rating = 5,
TblRestaurantId = 1,
Comments = "Good"
};
var options = new DbContextOptionsBuilder <ReviewManagementContext>()
.UseInMemoryDatabase(databaseName: "Reviewmanagement")
.Options;
ReviewRepository addreview = new ReviewRepository(new ReviewManagementContext(options));
int reviewid = addreview.RestaurantRating(reviewdetails);
TblRating updatedreviewdetails = new TblRating()
{
TblCustomerId = 1,
Rating = 5,
TblRestaurantId = 1,
Comments = "Excellent"
};
ReviewRepository Updatereview = new ReviewRepository(new ReviewManagementContext(options));
int updatedreviewid = Updatereview.RestaurantRating(updatedreviewdetails);
Assert.AreNotSame(reviewdetails, updatedreviewdetails);
Assert.AreEqual(reviewid, updatedreviewid);
}
public Review OnReview(
Episode episode,
[EventMessage] Review review,
[Service] ReviewRepository repository)
{
return(review);
}
// load remove view
public ActionResult Remove()
{
var reviewRepository = new ReviewRepository();
var ReviewList = reviewRepository.GetAll();
return(View(ReviewList));
}
public async Task GetTest()
{
//Arrange
using (var context = new AppDbContext(options))
{
var review = new GoodReview {
Id = 1, CustomerId = 1
};
var customer = new Customer {
Id = 1, FirstName = "Test"
};
var repo = new ReviewRepository(context);
//Act
context.Customers.Add(customer);
context.Reviews.Add(review);
context.SaveChanges();
var actualResult = await repo.Get(review.Id);
var expectedResult = review;
//Assert
Assert.AreEqual(expectedResult, actualResult);
}
}
public async Task CheckNoDuplicateReviewIsAllowed()
{
_output.WriteLine($"EndPointUrl: {_cosmosDBFixture.CosmosDbConfig.EndPointUrl}");
_output.WriteLine($"CollectionName: {_cosmosDBFixture.CosmosDbConfig.CollectionName}");
_output.WriteLine($"DatabaseName: {_cosmosDBFixture.CosmosDbConfig.DatabaseName}");
_output.WriteLine($"AuthorizationKey: {_cosmosDBFixture.CosmosDbConfig.AuthorizationKey}");
var repository = new ReviewRepository(_cosmosDBFixture.CosmosDbConfig);
var controller = new ReviewsController(repository);
var newReview1 = new ReviewDocument
{
Id = "review2",
Content = "Another review with existing Id"
};
var newReview2 = new ReviewDocument
{
Id = "review3",
Content = "This is boring"
};
await controller.PostAsync(newReview1);
await controller.PostAsync(newReview2);
var reviews = await controller.Get();
// We rely on the fact that we already had review2
// and another review in our test data
Assert.Equal(3, reviews.Count);
}
protected void postBtn_Click(object sender, EventArgs e)
{
int id = Int32.Parse(Request.QueryString["id"].ToString());
if (ratingTxt.Text == "")
{
errorLb.Text = "Rating Must be filled";
}
else if (Int32.Parse(ratingTxt.Text) < 1 || Int32.Parse(ratingTxt.Text) > 5)
{
errorLb.Text = "Rating must be between 1 to 5";
}
else if (reviewDescTxt.Text.Length > 255)
{
errorLb.Text = "Review Description maximal length is 255 characters";
}
else
{
string reviewDesc = reviewDescTxt.Text;
int reviewRating = Int32.Parse(ratingTxt.Text);
Member m = (Member)Session["User"];
Review r = ReviewFactory.createReview(reviewRating, reviewDesc, id, m.MemberEmail);
ReviewRepository.addProductReviewToDatabase(r);
Response.Redirect("ProductDetail.aspx?id=" + id);
}
}
public ReviewsController(/*IReviewRepository reviewRepository/*, ICategoriesRepository categoriesRepository*/)
{
//_reviewRepository = reviewRepository;
// _categoriesRepository = categoriesRepository;
_reviewRepository = new ReviewRepository();
}
public ReviewController(IConfiguration Configuration)
{
IReviewContext Context = new MssqlReviewContext(Configuration.GetConnectionString("DefaultConnection"));
Repo = new ReviewRepository(Context);
Converter = new ReviewViewModelConverter();
}
public void TestInit()
{
TestReviewContext Context = new TestReviewContext();
ReviewDataInitializer.FillData(Context);
Repo = new ReviewRepository(Context);
}
public ActionResult Reviews()
{
reviewRepository = new ReviewRepository();
var reviews = reviewRepository.GetAllReviews();
return(View(reviews));
}
public async void Test_ReviewRepo_GetAsyncById()
{
var dbOptions = await NewDb();
using (var ctx = new LodgingContext(dbOptions))
{
await ctx.Database.EnsureCreatedAsync();
await ctx.SaveChangesAsync();
// Add repo-specific setup here.
await ctx.SaveChangesAsync();
}
using (var ctx = new LodgingContext(dbOptions))
{
var repo = new ReviewRepository(ctx);
// Add repo-specific method calls here.
var actual = await repo.GetAsync(1);
// Add Asserts here.
Assert.Null(actual);
}
}
public void GetAll_Returns_3_Reviews()
{
var underTest = new ReviewRepository();
var result = underTest.GetAll();
Assert.Equal(3, result.Count);
}
public void TestCountReviews()
{
var repository = new ReviewRepository();
var nReviews = repository.GetAllByProjectId(13).Count();
Assert.IsTrue(nReviews == 8);
}
public void Get_Id_Returns_Review_Id_from_Index()
{
var underTest = new ReviewRepository();
var result = underTest.FindOneReviewById(2);
Assert.Equal(456, result.Id);
}
public void TestGetAllReviewsForUploadId()
{
var repository = new ReviewRepository();
var list = repository.GetAllByUploadId(141);
Assert.IsTrue(list.Any());
}
//Get /Details/{id}
public ActionResult Details(int id)
{
if (!AuthRepository.CheckIfUserCanAcces(GebruikerType.All, (Gebruiker)Session["LoggedInUser"]))
{
return(View("~/Views/Error/AuthError.cshtml"));
}
// try {
GebruikerSqlContext gsc = new GebruikerSqlContext();
GebruikerRepository gr = new GebruikerRepository(gsc);
ReviewSqlContext rsc = new ReviewSqlContext();
ReviewRepository rr = new ReviewRepository(rsc);
Gebruiker loggedUser = (Gebruiker)Session["LoggedInUser"];
ViewBag.SelectedUser = gr.GetById(id);
if (loggedUser != null)
{
ViewBag.CanReview = rr.CanReview(loggedUser.Id, id);
}
ViewBag.SelectedUser = gr.GetById(id);
ViewBag.Reviews = rr.GetReviewByVrijwilligerId(id);
return(View("~/Views/Gebruiker/Details.cshtml"));
// }
/*
* catch (Exception e)
* {
* return RedirectToAction("Index", "Error");
* }
*/
}
public void GetReviewsAsync_Test()
{
//fake userinfo provider for resolving userid
var userInfoProvider = new Mock <IUserInfoProvider>();
var reviewDataManager = new Mock <IReviewDataManager>();
var expected = new Review[] {
new Review {
Id = 789,
UserId = 123,
RestaurantId = 22,
Heading = "awesome!!",
Content = "super food",
Rating = 10
}
}.ToList();
var expectedPage = 1;
var expectedPageSize = 20;
var expectedDbFilter = new DbFilter <Review> {
Field = "UserId", Operator = OperatorEnum.Equal, Value = 123
};
reviewDataManager.Setup(x => x.GetReviewsAsync(expectedPage, expectedPageSize, expectedDbFilter)).Returns(Task.FromResult <IEnumerable <Review> >(expected));
var reviewRepo = new ReviewRepository(reviewDataManager.Object, userInfoProvider.Object);
var actual = reviewRepo.GetReviewsAsync(expectedPage, expectedPageSize, expectedDbFilter).Result;
reviewDataManager.VerifyAll();
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count());
Assert.AreEqual(expected[0], actual.First());
}
public void CanReview()
{
var sql = new ReviewSqlContext();
var repo = new ReviewRepository(sql);
bool result = repo.CanReview(1045, 1042);
}
public FCDatabaseContext(SqlConnection connection)
{
_connection = connection;
_products = new ProductRepository(connection);
_restaurants = new RestaurantRepository(connection);
_reviews = new ReviewRepository(connection);
}
public ReviewDboTest()
{
repository = new ReviewRepository(DbContextFactory);
userRepository = new UserRepository(DbContextFactory);
productRepository = new ProductRepository(DbContextFactory);
dataService = new ReviewDataService(repository, UnitOfWork);
}
public OrdersController(CategoryRepository categoryRepository,
UserRepository userRepository, SubcategoryRepository subcategoryRepository,
OrdersRepository ordersRepository, AssetRepository assetRepository, TaskRepository taskRepository,
ReviewRepository reviewRepository, UserService userService,
UserResponseHistoryRepository userResponseHistoryRepository,
ViewCounterService viewCounterService,
BillingService billingService, GigbucketDbContext dbContext)
{
_categoryRepository = categoryRepository;
_userRepository = userRepository;
_subcategoryRepository = subcategoryRepository;
_ordersRepository = ordersRepository;
_assetRepository = assetRepository;
_taskRepository = taskRepository;
_reviewRepository = reviewRepository;
_userService = userService;
_userResponseHistoryRepository = userResponseHistoryRepository;
_viewCounterService = viewCounterService;
_billingService = billingService;
_dbContext = dbContext;
}
public CategoryService(CategoryRepository categoryRepository, ReviewRepository reviewRepository) {
_categoryRepository = categoryRepository;
_reviewRepository = reviewRepository;
}
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;
});
}
public ReviewServices(ReviewRepository reviewRepo) {
_reviewRepo = reviewRepo;
}
