public async Task UnblockUserByIdAsync_WithValidDAta_ShouldReturnTrue()
{
//Arrange
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser
{
Id = "UserId",
UserName = "******",
IsDeleted = true,
EmailConfirmed = true,
CreatedOn = DateTime.UtcNow.AddDays(-25),
Ads = new List <Ad> {
new Ad(), new Ad()
}
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.UnblockUserByIdAsync("UserId");
//Assert
Assert.True(actual);
Assert.False(testingUser.IsDeleted);
}
public async Task GetMessageDetailsViewModelsAsync_WithCurrentUserNotParticipantInConversation_ShouldThrowAnInvalidOperationException()
{
//Arrange
var expectedErrorMessage = "You are not participant in this conversation!";
var moqAdsService = new Mock <IAdsService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserId())
.Returns("FakeUserId");
var moqIMapper = new Mock <IMapper>();
var context = InitializeContext.CreateContextForInMemory();
var testingAd = CreateTestingAd();
await context.AddAsync(testingAd);
await context.SaveChangesAsync();
messagesService = new MessagesService(context, moqAdsService.Object, moqUsersService.Object, moqIMapper.Object);
//Act and assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() =>
messagesService.GetMessageDetailsViewModelsAsync(1, "SenderId", "RecipientId"));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task GetUserByIdAsync_WithValidDAta_ShouldReturnCorrectUser()
{
//Arrange
var expectedUserId = "UserId";
var expectedUsername = "******";
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(x => x.FindByIdAsync("UserId"))
.ReturnsAsync(new SellMeUser {
Id = "UserId", UserName = "******"
});
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser {
Id = "UserId", UserName = "******"
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.GetUserByIdAsync("UserId");
//Assert
Assert.Equal(expectedUserId, actual.Id);
Assert.Equal(expectedUsername, actual.UserName);
}
public async Task GetAdministrationIndexStatisticViewModel_WithValidData_ShouldReturnCorrectResult()
{
//Assert
var expectedActiveAdsCount = 10;
var expectedAllUsersCount = 5;
var moqAdsService = new Mock <IAdsService>();
moqAdsService.Setup(x => x.GetAllActiveAdsCountAsync())
.ReturnsAsync(10);
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCountOfAllUsersAsync())
.ReturnsAsync(5);
var moqPromotionsService = new Mock <IPromotionsService>();
var context = InitializeContext.CreateContextForInMemory();
statisticsService = new StatisticsService(context, moqAdsService.Object, moqUsersService.Object, moqPromotionsService.Object);
//Act
var actual = await statisticsService.GetAdministrationIndexStatisticViewModel();
//Assert
Assert.Equal(expectedActiveAdsCount, actual.AllAdsCount);
Assert.Equal(expectedAllUsersCount, actual.AllUsersCount);
}
public async Task CreateInspect_WithValidInput_ShouldBeCorrect()
{
MapperInitializer.InitializeMapper();
var context = InitializeContext.CreateContextForInMemory();
var repository = new EfDeletableEntityRepository <Inspect>(context);
var inspectsService = new InspectsService(repository);
var userId = "U1";
var inspectTypeId = "I1";
var liftId = "L1";
var notes = "test";
var prescriptions = "presTest";
var supportCompanyId = "S1";
await inspectsService.CreateAsync(userId, inspectTypeId, liftId, notes, prescriptions, supportCompanyId);
var inspect = context.Inspects.FirstOrDefaultAsync().Result;
Assert.Equal(userId, inspect.ApplicationUserId);
Assert.Equal(inspectTypeId, inspect.InspectTypeId);
Assert.Equal(liftId, inspect.LiftId);
Assert.Equal(notes, inspect.Notes);
Assert.Equal(prescriptions, inspect.Prescriptions);
Assert.Equal(supportCompanyId, inspect.SupportCompanyId);
}
public async Task GetAddressByIdAsync_WithValidId_ShouldReturnCorrectAddress()
{
//Arrange
var context = InitializeContext.CreateContextForInMemory();
addressesService = new AddressesService(context);
var addressId = 1;
var testAddress = new Address
{
Id = 1,
City = "Sofia",
Country = "Bulgaria",
CreatedOn = DateTime.UtcNow,
EmailAddress = "*****@*****.**",
District = "Student City",
ZipCode = 1000,
PhoneNumber = "08552332",
Street = "Ivan Vazov"
};
await context.Addresses.AddAsync(testAddress);
await context.SaveChangesAsync();
//Act
var result = await addressesService.GetAddressByIdAsync(addressId);
//Assert
Assert.Equal(result, testAddress);
}
public async Task GetAddressByIdAsync_WithInvalidId_ShouldThrowArgumentException(int addressId)
{
//Arrange
var context = InitializeContext.CreateContextForInMemory();
addressesService = new AddressesService(context);
var testAddress = new Address
{
Id = 1,
City = "Sofia",
Country = "Bulgaria",
CreatedOn = DateTime.UtcNow,
EmailAddress = "*****@*****.**",
District = "Student City",
ZipCode = 1000,
PhoneNumber = "08552332",
Street = "Ivan Vazov"
};
await context.Addresses.AddAsync(testAddress);
await context.SaveChangesAsync();
var expectErrorMessage = "Address with the given ID doesn't exist!";
//Act
var ex = await Assert.ThrowsAsync <ArgumentException>(() => addressesService.GetAddressByIdAsync(addressId));
Assert.Equal(expectErrorMessage, ex.Message);
}
public async Task GetTheCountOfPromotionsForTheLastTenDaysAsync_WithValidData_ShouldReturnCorrectResult()
{
//Arrange
var expected = new List <int> {
1, 0, 1, 0, 2, 0, 0, 0, 1, 1
};
var moqAdsService = new Mock <IAdsService>();
var context = InitializeContext.CreateContextForInMemory();
promotionsService = new PromotionsService(context, moqAdsService.Object);
var testingPromotions = new List <PromotionOrder>
{
new PromotionOrder {
Id = 1, CreatedOn = DateTime.UtcNow.AddDays(-5)
},
new PromotionOrder {
Id = 2, CreatedOn = DateTime.UtcNow.AddDays(-5)
},
new PromotionOrder {
Id = 3, CreatedOn = DateTime.UtcNow.AddDays(-7)
},
new PromotionOrder {
Id = 4, CreatedOn = DateTime.UtcNow.AddDays(-9)
},
new PromotionOrder {
Id = 5, CreatedOn = DateTime.UtcNow.AddDays(-1)
},
new PromotionOrder {
Id = 6, CreatedOn = DateTime.UtcNow.AddDays(-10)
},
new PromotionOrder {
Id = 7, CreatedOn = DateTime.UtcNow.AddDays(-30)
},
new PromotionOrder {
Id = 8, CreatedOn = DateTime.UtcNow
}
};
await context.PromotionOrders.AddRangeAsync(testingPromotions);
await context.SaveChangesAsync();
//Act
var actual = await promotionsService.GetTheCountOfPromotionsForTheLastTenDaysAsync();
//Assert
Assert.Equal(expected[0], actual[0]);
Assert.Equal(expected[1], actual[1]);
Assert.Equal(expected[2], actual[2]);
Assert.Equal(expected[3], actual[3]);
Assert.Equal(expected[4], actual[4]);
Assert.Equal(expected[5], actual[5]);
Assert.Equal(expected[6], actual[6]);
Assert.Equal(expected[7], actual[7]);
Assert.Equal(expected[8], actual[8]);
Assert.Equal(expected[9], actual[9]);
}
public async Task GetUnreadMessagesCountAsync_WithValidData_ShouldReturnCorrectResult()
{
//Arrange
var expected = 2;
var moqAdsService = new Mock <IAdsService>();
var moqUsersService = new Mock <IUsersService>();
var moqIMapper = new Mock <IMapper>();
var context = InitializeContext.CreateContextForInMemory();
messagesService = new MessagesService(context, moqAdsService.Object, moqUsersService.Object, moqIMapper.Object);
var messages = new List <Message>
{
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content1",
IsRead = false
},
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content2",
IsRead = false
},
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "FakeRecipientId",
Content = "Content3",
IsRead = false
},
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content3",
IsRead = true
}
};
await context.Messages.AddRangeAsync(messages);
await context.SaveChangesAsync();
//Act
var actual = await messagesService.GetUnreadMessagesCountAsync("RecipientId");
//Assert
Assert.Equal(expected, actual);
}
private static SupportCompaniesService InitializeCategoriesService()
{
MapperInitializer.InitializeMapper();
var context = InitializeContext.CreateContextForInMemory();
var repository = new EfDeletableEntityRepository <SupportCompany>(context);
var service = new SupportCompaniesService(repository);
return(service);
}
private static InspectTypesService InitializeCategoriesService()
{
MapperInitializer.InitializeMapper();
var context = InitializeContext.CreateContextForInMemory();
var repository = new EfDeletableEntityRepository <InspectType>(context);
var service = new InspectTypesService(repository);
return(service);
}
public async Task AddToFavoritesAsync_WithAdAlreadyInFavorites_ShouldThrowAnInvalidOperationException()
{
//Arrange
var expectedErrorMessage = "The given ad is already added to favorites!";
var context = InitializeContext.CreateContextForInMemory();
var moqUserService = new Mock <IUsersService>();
moqUserService.Setup(x => x.GetCurrentUserAsync())
.ReturnsAsync(new SellMeUser
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
SellMeUserFavoriteProducts = new List <SellMeUserFavoriteProduct>
{
new SellMeUserFavoriteProduct
{
AdId = 1
}
}
});
favoritesService = new FavoritesService(context, moqUserService.Object);
var testingAd = new Ad
{
Id = 1,
Title = "Iphone 6s",
Description = "PerfectCondition",
ActiveFrom = DateTime.UtcNow,
ActiveTo = DateTime.UtcNow.AddDays(30),
AvailabilityCount = 1,
Price = 120,
Condition = new Condition {
Name = "Brand New"
},
Address = new Address
{
Country = "Bulgaria",
City = "Sofia",
Street = "Ivan Vazov",
District = "Student city",
ZipCode = 1000,
PhoneNumber = "0895335532",
EmailAddress = "*****@*****.**"
}
};
await context.Ads.AddAsync(testingAd);
await context.SaveChangesAsync();
//Act and assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => favoritesService.AddToFavoritesAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
private LiftsService InitializeCategoriesService()
{
MapperInitializer.InitializeMapper();
var context = InitializeContext.CreateContextForInMemory();
this.repository = new EfDeletableEntityRepository <Lift>(context);
var service = new LiftsService(this.repository);
return(service);
}
public async Task CreateCity_WithNotValidInput_ShouldBeReturnFalse(string input)
{
this.context = InitializeContext.CreateContextForInMemory();
this.citiesService = InitializeCategoriesService(this.context);
string cityName = input;
var isCreate = await this.citiesService.CreateAsync(cityName);
Assert.False(isCreate);
}
public async Task CreateCity_WithValidInput_ShouldBeReturnCorrectBool()
{
this.context = InitializeContext.CreateContextForInMemory();
this.citiesService = InitializeCategoriesService(this.context);
string cityName = "Бургас";
var isCreate = await this.citiesService.CreateAsync(cityName);
Assert.True(isCreate);
}
public async Task GetRatingByUserAsync_WithValidData_ShouldReturnCorrectResult()
{
//Arrange
var expected = 2;
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(x => x.FindByIdAsync("UserId"))
.ReturnsAsync(new SellMeUser
{
Id = "UserId",
UserName = "******",
OwnedReviews = new List <Review>
{
new Review {
Comment = "Comment1", Rating = 5
},
new Review {
Comment = "Comment2", Rating = 2
},
new Review {
Comment = "Comment3", Rating = 1
},
new Review {
Comment = "Comment4", Rating = 1
},
new Review {
Comment = "Comment5", Rating = 1
},
}
});
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser {
Id = "UserId", UserName = "******"
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.GetRatingByUserAsync("UserId");
//Assert
Assert.Equal(expected, actual);
}
public async Task GetAllCities_WithValidInput_ShouldBeReturnCorrectAllCitiesForViewModel()
{
this.context = InitializeContext.CreateContextForInMemory();
this.citiesService = InitializeCategoriesService(this.context);
string cityName = "София";
await this.citiesService.CreateAsync(cityName);
var cities = await this.citiesService.GetAllCityForViewModel();
Assert.Equal(1, cities.Count);
Assert.Equal(cityName, cities.FirstOrDefault().Name);
}
public async Task CreateMessageAsync_WithValidData_ShouldCreateAMessage()
{
//Arrange
var expected = new MessageDetailsViewModel
{
AdTitle = "Iphone 6s",
Content = "Content for the message",
Sender = "Ivan",
SentOn = "31/01/2019"
};
var moqAdsService = new Mock <IAdsService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetUserByIdAsync("SenderId"))
.ReturnsAsync(new SellMeUser
{
Id = "SenderId",
UserName = "******"
});
var moqMapper = new Mock <IMapper>();
moqMapper.Setup(x => x.Map <MessageDetailsViewModel>(It.IsAny <Message>()))
.Returns(new MessageDetailsViewModel
{
AdTitle = "Iphone 6s",
Content = "Content for the message",
Sender = "Ivan",
SentOn = "31/01/2019"
});
var context = InitializeContext.CreateContextForInMemory();
messagesService = new MessagesService(context, moqAdsService.Object, moqUsersService.Object, moqMapper.Object);
var testingAd = CreateTestingAd();
await context.Ads.AddAsync(testingAd);
await context.SaveChangesAsync();
//Act and assert
var actual = await messagesService.CreateMessageAsync("SenderId", "RecipientId",
1, "Content for the message");
Assert.Equal(expected.AdTitle, actual.AdTitle);
Assert.Equal(expected.Content, actual.Content);
Assert.Equal(expected.Sender, actual.Sender);
Assert.Equal(expected.SentOn, actual.SentOn);
}
public void CheckOwnerIdAndSellerId_WithOwnerDifferentFromCreator_ShouldReturnFalse()
{
//Arrange
var moqUsersService = new Mock <IUsersService>();
var context = InitializeContext.CreateContextForInMemory();
reviewsService = new ReviewsService(context, moqUsersService.Object);
//Act
var actual = reviewsService.CheckOwnerIdAndSellerId("CreatorId", "AnotherUserId");
//Assert
Assert.False(actual);
}
public async Task CreateUpdateAdAsync_WithInvalidAdId_ShouldThrowAndInvalidArgumentException()
{
//Arrange
var expectedErrorMessage = "Ad with the given id doesn't exist!";
var context = InitializeContext.CreateContextForInMemory();
updatesService = new UpdatesService(context);
//Act and assert
var ex = await Assert.ThrowsAsync <ArgumentException>(() => updatesService.CreateUpdateAdAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public void GetAllCountries_ShouldReturnTheCorrectCount()
{
//Arrange
var context = InitializeContext.CreateContextForInMemory();
addressesService = new AddressesService(context);
var expectedCount = 142;
//Act
var countriesCount = addressesService.GetAllCountries().Count;
//Assert
Assert.Equal(expectedCount, countriesCount);
}
public void GetConditionViewModels_WithoutData_ShouldReturnAnEmptyCollection()
{
//Arrange
var expected = 0;
var context = InitializeContext.CreateContextForInMemory();
conditionsService = InitializeConditionsService(context);
var actual = conditionsService.GetConditionViewModels();
//Act and assert
Assert.Equal(expected, actual.Count);
}
public async Task GetAllCategoryViewModelsAsync_WithoutData_ShouldReturnAnEmptyCollection()
{
//Arrange
var expected = 0;
var context = InitializeContext.CreateContextForInMemory();
categoriesService = InitializeCategoriesService(context);
var actual = await categoriesService.GetAllCategoryViewModelsAsync();
//Act and assert
Assert.Equal(expected, actual.Count);
}
public async Task AddToFavoritesAsync_WithValidData_ShouldReturnTrue()
{
//Arrange
var context = InitializeContext.CreateContextForInMemory();
var moqUserService = new Mock <IUsersService>();
moqUserService.Setup(x => x.GetCurrentUserAsync())
.ReturnsAsync(new SellMeUser
{
Id = Guid.NewGuid().ToString(),
UserName = "******"
});
favoritesService = new FavoritesService(context, moqUserService.Object);
var testingAd = new Ad
{
Id = 1,
Title = "Iphone 6s",
Description = "PerfectCondition",
ActiveFrom = DateTime.UtcNow,
ActiveTo = DateTime.UtcNow.AddDays(30),
AvailabilityCount = 1,
Price = 120,
Condition = new Condition {
Name = "Brand New"
},
Address = new Address
{
Country = "Bulgaria",
City = "Sofia",
Street = "Ivan Vazov",
District = "Student city",
ZipCode = 1000,
PhoneNumber = "0895335532",
EmailAddress = "*****@*****.**"
}
};
await context.Ads.AddAsync(testingAd);
await context.SaveChangesAsync();
//Act
var actual = await favoritesService.AddToFavoritesAsync(1);
//Assert
Assert.True(actual);
}
public async Task GetSubcategoriesByCategoryIdAsync_WithInvalidCategoryId_ShouldThrowAndInvalidArgumentException()
{
//Arrange
var expectedErrorMessage = "Category with the given id doesn't exist!";
var context = InitializeContext.CreateContextForInMemory();
subcategoriesService = new SubCategoriesService(context);
//Act and assert
var ex = await Assert.ThrowsAsync <ArgumentException>(() =>
subcategoriesService.GetSubcategoriesByCategoryIdAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task AddToFavoritesAsync_WithCurrentUserEqualsToNull_ShouldThrowAndInvalidOperationException()
{
//Arrange
var expectedErrorMessage = "Current user can't be null";
var context = InitializeContext.CreateContextForInMemory();
var moqUserService = new Mock <IUsersService>();
favoritesService = new FavoritesService(context, moqUserService.Object);
//Act and assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => favoritesService.AddToFavoritesAsync(1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task GetInspect_WithValidInput_ShouldBeREturnCorrectInspectWithViewModel()
{
MapperInitializer.InitializeMapper();
var context = InitializeContext.CreateContextForInMemory();
var repository = new EfDeletableEntityRepository <Inspect>(context);
var inspectsService = new InspectsService(repository);
var ins = new Inspect
{
Id = "1",
ApplicationUserId = "U1",
InspectTypeId = "I1",
LiftId = "L1",
Notes = "test",
Prescriptions = "presTest",
SupportCompanyId = "S1",
};
await context.Inspects.AddAsync(ins);
await context.SaveChangesAsync();
// var repositoryTest = new EfDeletableEntityRepository<Inspect>(context);
// var userId = "U1";
// var inspectTypeId = "I1";
// var liftId = "L1";
// var notes = "test";
// var prescriptions = "presTest";
// var supportCompanyId = "S1";
// await inspectsServiceTest.CreateAsync(userId, inspectTypeId, liftId, notes, prescriptions, supportCompanyId);
var test = await context.Inspects.FirstOrDefaultAsync();
// Assert.Equal(inspectTypeId, test.InspectTypeId);
// var inspectViewModel = inspectsServiceTest.GetCurrentInspect(test.Id);
Assert.Equal(1, context.Inspects.Count());
Assert.NotNull(inspectsService);
Assert.NotNull(test);
// Assert.Null(inspectViewModel);
// Assert.Equal(inspectTypeId, inspect.InspectTypeId);
// Assert.Equal(test, inspectViewModel);
// Assert.Equal(inspectTypeId, inspectViewModel.InspectTypeId);
// Assert.Equal(liftId, inspectViewModel.LiftId);
// Assert.Equal(notes, inspectViewModel.Notes);
// Assert.Equal(prescriptions, inspectViewModel.Prescriptions);
// Assert.Equal(supportCompanyId, inspectViewModel.SupportCompanyId);
}
public async Task GetTheCountOfPromotionsForTheLastTenDaysAsync_WithValidData_ShouldReturnCorrectCollectionLength()
{
//Arrange
var expectedLength = 10;
var moqAdsService = new Mock <IAdsService>();
var context = InitializeContext.CreateContextForInMemory();
promotionsService = new PromotionsService(context, moqAdsService.Object);
//Act
var actual = await promotionsService.GetTheCountOfPromotionsForTheLastTenDaysAsync();
//Assert
Assert.Equal(expectedLength, actual.Count);
}
public async Task CreateReview_WithNullOrEmptyArguments_ShouldThrowAnArgumentException(string ownerId, string creatorId, string content)
{
//Arrange
var expectedErrorMessage = "Some of the arguments are null or empty!";
var moqUsersService = new Mock <IUsersService>();
var context = InitializeContext.CreateContextForInMemory();
reviewsService = new ReviewsService(context, moqUsersService.Object);
//Assert and act
var ex = await Assert.ThrowsAsync <ArgumentException>(() =>
reviewsService.CreateReview(ownerId, creatorId, content, 1));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task CreateReview_WithValidData_ShouldCreateAReview()
{
//Arrange
var expectedReviewsCount = 1;
var moqUsersService = new Mock <IUsersService>();
var context = InitializeContext.CreateContextForInMemory();
reviewsService = new ReviewsService(context, moqUsersService.Object);
//Act
await reviewsService.CreateReview("OwnerId", "CreatorId", "Content", 3);
//Assert
Assert.Equal(expectedReviewsCount, context.Reviews.Count());
}