public void CreateParcel_Should_Throw_Exception_When_Current_User_Is_Not_Purchaser()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var createdParcel =
new DTO.Parcel
{
RublesPerDollar = 31.5m,
PurchaserSpentOnDelivery = 149m,
TrackingNumber = "US867958674896Z",
SentDate = new DateTime(2013, 5, 31),
Distributor = container.Get <IDtoService>().CreateUser(UserMockFactory.Olesya),
Comments = "Some comments"
};
var parcelService = container.Get <IParcelService>();
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => parcelService.CreateParcel(createdParcel),
"Only purchaser can create parcel.");
}
public void ResetPassword_Should_Reset_Password_For_User()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var changedUser = dtoService.CreateUser(UserMockFactory.Olesya);
container.Remove <IPasswordGeneratorService>();
var passwordGeneratorServiceMock = new Mock <IPasswordGeneratorService>();
passwordGeneratorServiceMock
.Setup(m => m.GenerateTemporaryPassword(changedUser.Login))
.Returns(EncryptServiceMockFactory.NewPasswordData.Password);
container.SetConstant <IPasswordGeneratorService, IPasswordGeneratorService>(passwordGeneratorServiceMock.Object);
// Act
securityService.ResetPassword(changedUser);
// Assert
securityService.LogOut();
securityService.LogIn(changedUser.Login, EncryptServiceMockFactory.NewPasswordData.Password);
}
public void ResetPassword_Should_Throw_Exception_When_User_Is_Inactive()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var changedUser = dtoService.CreateUser(UserMockFactory.Andrey);
container.Remove <IPasswordGeneratorService>();
var passwordGeneratorServiceMock = new Mock <IPasswordGeneratorService>();
passwordGeneratorServiceMock
.Setup(m => m.GenerateTemporaryPassword(changedUser.Login))
.Returns(EncryptServiceMockFactory.NewPasswordData.Password);
container.SetConstant <IPasswordGeneratorService, IPasswordGeneratorService>(passwordGeneratorServiceMock.Object);
// Act
// Assert
ExceptionAssert.Throw <SecurityServiceException>(
() => securityService.ResetPassword(changedUser),
"Пользователь отключен администратором.");
}
public void UpdateUser_Should_Throw_Exception_When_User_Tries_Remove_Administrator_Role()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var updatedUser =
new DTO.User
{
Id = UserMockFactory.Jenya.Id,
Email = "*****@*****.**",
FirstName = "New First Name",
LastName = "New Last Name",
Login = "******",
Active = true,
Roles =
new[]
{
dtoService.CreateRole(RoleMockFactory.Purchaser),
dtoService.CreateRole(RoleMockFactory.Distributor)
}
};
// Act
// Assert
ExceptionAssert.Throw <SecurityServiceException>(
() => securityService.UpdateUser(updatedUser),
"Пользователь не может удалить роль администратора у себя.");
}
public void GetUsers_Should_Return_All_Users_When_Filter_Is_Empty()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
// Act
var users = securityService.GetUsers(null);
// Assert
var expectedUsers =
new[]
{
dtoService.CreateUser(UserMockFactory.Andrey),
dtoService.CreateUser(UserMockFactory.Jenya),
dtoService.CreateUser(UserMockFactory.Olesya),
dtoService.CreateUser(UserMockFactory.Diana)
};
CollectionAssert.AreEqual(expectedUsers, users);
}
public void UpdateSize_Should_Throw_Exception_When_Size_With_The_Same_Name_Brand_SubCategory_Already_Exists()
{
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var updatedSize =
new DTO.Size
{
Id = SizeMockFactory.Carters_Boys_0_2_3M.Id,
Name = SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months.Name,
Brand = container.Get <IDtoService>().CreateBrand(SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months.Brand),
SubCategory = container.Get <IDtoService>().CreateSubCategory(SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months.SubCategory),
Weight = "New Weight",
Height = "New Height",
Active = true
};
var sizeService = container.Get <ISizeService>();
// Act
// Assert
ExceptionAssert.Throw <SizeServiceException>(
() => sizeService.UpdateSize(updatedSize),
"Размер с заданным названием уже существует для данной подкатегории и данного бренда.");
}
public void AvailableRoles_Should_Return_All_Roles()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogInGuest();
var dtoService = container.Get <IDtoService>();
// Act
var roles = securityService.AvailableRoles;
// Assert
var expectedRoles =
new[]
{
dtoService.CreateRole(RoleMockFactory.Administrator),
dtoService.CreateRole(RoleMockFactory.Purchaser),
dtoService.CreateRole(RoleMockFactory.Seller),
dtoService.CreateRole(RoleMockFactory.Distributor)
};
CollectionAssert.AreEqual(expectedRoles, roles);
}
public void UpdateProductSize_Should_Throw_Exception_When_Current_User_Is_Not_Seller()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var size = container.Get <IDtoService>().CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_Newborn);
var product = container.Get <IDtoService>().CreateProduct(ProductMockFactory.TheChildrensPlace_Boys_TShirt);
const decimal NEW_PRODUCT_SIZE_PRICE = 1200;
var updatedProductSize =
new DTO.ProductSize
{
Id = ProductSizeMockFactory.Boys_Sweater_0_3_Months.Id,
Size = size,
Product = product,
Active = false,
Price = NEW_PRODUCT_SIZE_PRICE
};
var productSizeService = container.Get <IProductSizeService>();
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => productSizeService.UpdateProductSize(updatedProductSize),
"Only seller can change product size.");
}
public void UpdateProductSize_Should_Throw_Exception_When_ProductSize_With_The_Same_Product_Size_Already_Exists()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var size = container.Get <IDtoService>().CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months);
var product = container.Get <IDtoService>().CreateProduct(ProductMockFactory.TheChildrensPlace_Boys_Sweater);
const decimal NEW_PRODUCT_SIZE_PRICE = 1200;
var updatedProductSize =
new DTO.ProductSize
{
Id = ProductSizeMockFactory.Girls_Sweater_0_3_Months.Id,
Size = size,
Product = product,
Active = true,
Price = NEW_PRODUCT_SIZE_PRICE
};
var productSizeService = container.Get <IProductSizeService>();
// Act
// Assert
ExceptionAssert.Throw <ProductSizeServiceException>(
() => productSizeService.UpdateProductSize(updatedProductSize),
"Размер товара с заданным размером уже существует для данного товара.");
}
public void GetParcels_Should_Return_Parcels_With_Orders_Created_By_Current_User_When_Current_User_Is_Seller()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.DianaDistributor.Active = false;
UserRoleMockFactory.DianaPurchaser.Active = false;
UserRoleMockFactory.DianaAdministrator.Active = false;
UserRoleMockFactory.DianaSeller.Active = true;
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var parcelService = container.Get <IParcelService>();
// Act
var parcels =
parcelService.GetParcels(
TimeServiceMockFactory.Date1, TimeServiceMockFactory.Date5, null);
// Assert
var expectedParcels =
new[]
{
dtoService.CreateParcel(ParcelMockFactory.Parcel_2),
dtoService.CreateParcel(ParcelMockFactory.Parcel_3)
};
CollectionAssert.AreEqual(expectedParcels, parcels);
}
public void GetBrands_Should_Return_Brands_By_Filter()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var brandService = container.Get <IBrandService>();
// Act
var brands = brandService.GetBrands("a");
// Assert
var expectedBrands =
new[]
{
dtoService.CreateBrand(BrandMockFactory.Carters),
dtoService.CreateBrand(BrandMockFactory.Crazy8),
dtoService.CreateBrand(BrandMockFactory.TheChildrensPlace)
};
CollectionAssert.AreEqual(expectedBrands, brands);
}
public void UpdateParcel_Should_Throw_Exception_When_Current_User_Is_Distributor_And_Parcel_Is_Assigned_To_Another_Distributor()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.OlesyaDistributor.Active = true;
UserRoleMockFactory.OlesyaPurchaser.Active = false;
UserRoleMockFactory.OlesyaAdministrator.Active = false;
UserRoleMockFactory.OlesyaSeller.Active = false;
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var updatedParcel =
new DTO.Parcel
{
Id = ParcelMockFactory.Parcel_2.Id,
RublesPerDollar = 31.5m,
PurchaserSpentOnDelivery = 149m,
TrackingNumber = "US867958674896Z",
SentDate = new DateTime(2013, 5, 31),
Distributor = container.Get <IDtoService>().CreateUser(UserMockFactory.Diana),
Comments = "Some comments",
ReceivedDate = new DateTime(2013, 6, 30)
};
var parcelService = container.Get <IParcelService>();
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => parcelService.UpdateParcel(updatedParcel),
"Only purchaser and distributor can change parcel.");
}
public void UpdateParcel_Should_Update_Parcel_When_Current_User_Is_Purchaser_And_Distributor_And_Parcel_Is_Assigned_To_Another_Distributor()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.JenyaDistributor.Active = true;
UserRoleMockFactory.JenyaPurchaser.Active = true;
UserRoleMockFactory.JenyaAdministrator.Active = false;
UserRoleMockFactory.JenyaSeller.Active = false;
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
const decimal RUBLES_PER_DOLLAR = 31.5m;
const decimal PURCHASER_SPENT_ON_DELIVERY = 149m;
const string TRACK_NUMBER = "US867958674896Z";
var sentDate = new DateTime(2013, 5, 31);
var distributor = container.Get <IDtoService>().CreateUser(UserMockFactory.Diana);
const string COMMENTS = "Some comments";
var receivedDate = ParcelMockFactory.Parcel_1.ReceivedDate;
var createDate = ParcelMockFactory.Parcel_1.CreateDate;
var createdBy = ParcelMockFactory.Parcel_1.CreatedBy;
var updatedParcel =
new DTO.Parcel
{
Id = ParcelMockFactory.Parcel_1.Id,
RublesPerDollar = RUBLES_PER_DOLLAR,
PurchaserSpentOnDelivery = PURCHASER_SPENT_ON_DELIVERY,
TrackingNumber = TRACK_NUMBER,
SentDate = sentDate,
Distributor = distributor,
Comments = COMMENTS,
ReceivedDate = new DateTime(2013, 6, 30)
};
var parcelService = container.Get <IParcelService>();
var persistentService = container.Get <IPersistentService>();
var timeService = container.Get <ITimeService>();
// Act
parcelService.UpdateParcel(updatedParcel);
// Assert
var actualParcel = persistentService.GetEntityById <DataAccess.Parcel>(ParcelMockFactory.Parcel_1.Id);
Assert.AreEqual(RUBLES_PER_DOLLAR, actualParcel.RublesPerDollar);
Assert.AreEqual(PURCHASER_SPENT_ON_DELIVERY, actualParcel.PurchaserSpentOnDelivery);
Assert.AreEqual(TRACK_NUMBER, actualParcel.TrackingNumber);
Assert.AreEqual(sentDate, actualParcel.SentDate);
Assert.AreEqual(distributor.Id, actualParcel.DistributorId);
Assert.AreEqual(COMMENTS, actualParcel.Comments);
Assert.AreEqual(receivedDate, actualParcel.ReceivedDate);
Assert.AreEqual(createDate, actualParcel.CreateDate);
Assert.AreEqual(timeService.UtcNow, actualParcel.ChangeDate);
Assert.AreEqual(createdBy, actualParcel.CreatedBy);
Assert.AreEqual(UserMockFactory.Jenya, actualParcel.ChangedBy);
Assert.AreEqual(updatedParcel, container.Get <IDtoService>().CreateParcel(actualParcel));
}
public void GetParcels_Should_Return_Parcels_By_Dates()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var parcelService = container.Get <IParcelService>();
// Act
var parcels =
parcelService.GetParcels(
TimeServiceMockFactory.Date2, TimeServiceMockFactory.Date3, null);
// Assert
var expectedParcels =
new[]
{
dtoService.CreateParcel(ParcelMockFactory.Parcel_1),
dtoService.CreateParcel(ParcelMockFactory.Parcel_3)
};
CollectionAssert.AreEqual(expectedParcels, parcels);
}
public void GetActiveSizes_Should_Return_All_Active_Sizes_By_SubCategory_And_Brand()
{
// Arrange
var container = ContainerMockFactory.Create();
container.Get <ISecurityService>().LogInGuest();
var dtoService = container.Get <IDtoService>();
var subCategory = dtoService.CreateSubCategory(SubCategoryMockFactory.Boys_0_2);
var brand = dtoService.CreateBrand(BrandMockFactory.Carters);
var sizeService = container.Get <ISizeService>();
// Act
var sizes = sizeService.GetActiveSizes(subCategory, brand);
// Assert
var expectedSizes =
new[]
{
dtoService.CreateSize(SizeMockFactory.Carters_Boys_0_2_3M),
dtoService.CreateSize(SizeMockFactory.Carters_Boys_0_2_6M)
};
CollectionAssert.AreEqual(expectedSizes, sizes);
}
public void GetProductSizesByProduct_Should_Return_ProductSizes_By_Filter()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var productSizeService = container.Get <IProductSizeService>();
var product = dtoService.CreateProduct(ProductMockFactory.TheChildrensPlace_Girls_Sweater);
// Act
var productSizes = productSizeService.GetProductSizes(product, "6");
// Assert
var expectedProductSizes =
new[]
{
dtoService.CreateProductSize(ProductSizeMockFactory.Girls_Sweater_3_6_Months)
};
CollectionAssert.AreEqual(expectedProductSizes, productSizes);
}
public void UpdateSize_Should_Throw_Exception_When_Current_User_Is_Not_Seller()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var updatedSize =
new DTO.Size
{
Id = SizeMockFactory.Carters_Boys_0_2_3M.Id,
Name = "New Size",
SubCategory = container.Get <IDtoService>().CreateSubCategory(SubCategoryMockFactory.Girls_0_2),
Brand = container.Get <IDtoService>().CreateBrand(BrandMockFactory.Crazy8),
Weight = "New Weight",
Height = "New Height",
Active = true
};
var sizeService = container.Get <ISizeService>();
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => sizeService.UpdateSize(updatedSize),
"Only seller can change size.");
}
public void GetProductSizes_Should_Return_All_ProductSizes_When_Filter_Is_Empty()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var productSizeService = container.Get <IProductSizeService>();
// Act
var productSizes = productSizeService.GetProductSizes(null);
// Assert
var expectedProductSizes =
new[]
{
dtoService.CreateProductSize(ProductSizeMockFactory.Girls_Sweater_0_3_Months),
dtoService.CreateProductSize(ProductSizeMockFactory.Girls_Sweater_3_6_Months),
dtoService.CreateProductSize(ProductSizeMockFactory.Boys_Sweater_0_3_Months),
dtoService.CreateProductSize(ProductSizeMockFactory.Boys_Sweater_3_6_Months)
};
CollectionAssert.AreEqual(expectedProductSizes, productSizes);
}
public void GetSizes_Should_Return_All_Sizes_When_Filter_Is_Empty()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var sizeService = container.Get <ISizeService>();
// Act
var sizes = sizeService.GetSizes(null);
// Assert
var expectedSizes =
new[]
{
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_Newborn),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_3_6_Months),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Girls_0_2_Newborn),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Girls_0_2_0_3_Months),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Girls_0_2_3_6_Months),
dtoService.CreateSize(SizeMockFactory.Carters_Boys_0_2_3M),
dtoService.CreateSize(SizeMockFactory.Carters_Boys_0_2_6M),
dtoService.CreateSize(SizeMockFactory.Carters_Girls_0_2_3M),
dtoService.CreateSize(SizeMockFactory.Carters_Girls_0_2_6M)
};
CollectionAssert.AreEqual(expectedSizes, sizes);
}
public void GenerateParcelsReport_Should_Generate_Report_When_Current_User_Is_Distributor()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.OlesyaDistributor.Active = true;
UserRoleMockFactory.OlesyaPurchaser.Active = false;
UserRoleMockFactory.OlesyaAdministrator.Active = false;
UserRoleMockFactory.OlesyaSeller.Active = false;
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var reportService = container.Get <IReportService>();
// Act
var parcelReportItems = reportService.GenerateParcelsReport();
// Assert
var expectedParcelReportItems =
new[]
{
GetParcelReportItem1()
};
CollectionAssert.AreEqual(expectedParcelReportItems, parcelReportItems);
}
public void UpdateUser_Should_Update_CurrentUser_When_CurrentUser_Updates_His_Data()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var updatedUser =
new DTO.User
{
Id = UserMockFactory.Jenya.Id,
Email = "*****@*****.**",
FirstName = "New First Name",
LastName = "New Last Name",
Login = "******",
Active = true,
Roles =
new[]
{
dtoService.CreateRole(RoleMockFactory.Administrator),
dtoService.CreateRole(RoleMockFactory.Distributor)
}
};
// Act
securityService.UpdateUser(updatedUser);
// Assert
Assert.AreEqual(updatedUser, securityService.CurrentUser);
CollectionAssert.AreEqual(updatedUser.Roles, securityService.CurrentRoles);
}
public void GenerateDistributorsReport_Should_Generate_Report_When_Current_User_Is_Purchaser_And_Seller()
{
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.DianaDistributor.Active = true;
UserRoleMockFactory.DianaPurchaser.Active = false;
UserRoleMockFactory.DianaAdministrator.Active = false;
UserRoleMockFactory.DianaSeller.Active = true;
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var reportService = container.Get <IReportService>();
// Act
var distributorReportItems = reportService.GenerateDistributorsReport();
// Assert
var expectedDistributorReportItems =
new[]
{
GetDianaReportItem()
};
CollectionAssert.AreEqual(expectedDistributorReportItems, distributorReportItems);
}
public void UpdateUser_Should_Throw_Exception_When_User_With_The_Same_Login_Already_Exists()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var updatedUser =
new DTO.User
{
Id = UserMockFactory.Jenya.Id,
Email = "*****@*****.**",
FirstName = "New First Name",
LastName = "New Last Name",
Login = UserMockFactory.Olesya.Login,
Active = true,
Roles =
new[]
{
dtoService.CreateRole(RoleMockFactory.Administrator),
dtoService.CreateRole(RoleMockFactory.Purchaser),
dtoService.CreateRole(RoleMockFactory.Distributor)
}
};
// Act
// Assert
ExceptionAssert.Throw <SecurityServiceException>(
() => securityService.UpdateUser(updatedUser),
"Пользователь с заданным логином уже существует.");
}
public void CreateActionLog_Should_Create_Action_Log()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogInGuest();
var actionLogService = container.Get <IActionLogService>();
var createdActionLog =
new DTO.ActionLog
{
Text = "User Diana is changed",
DocumentId = UserMockFactory.Diana.Id,
ActionLogType = actionLogService.UserChangedType
};
// Act
actionLogService.CreateActionLog(createdActionLog);
// Assert
securityService.LogOut();
container.Get <ISecurityService>().LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var actionLog =
actionLogService
.GetActionLogs(TimeServiceMockFactory.UtcNow, TimeServiceMockFactory.UtcNow, null)
.Single();
Assert.AreEqual(createdActionLog, actionLog);
}
public void GetUsers_Should_Return_Only_Active_Distributors_When_Current_User_Is_Purchaser()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.JenyaDistributor.Active = false;
UserRoleMockFactory.JenyaPurchaser.Active = true;
UserRoleMockFactory.JenyaAdministrator.Active = false;
UserRoleMockFactory.JenyaSeller.Active = false;
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
// Act
var users = securityService.GetUsers(null);
// Assert
var expectedUsers =
new[]
{
dtoService.CreateUser(UserMockFactory.Olesya),
dtoService.CreateUser(UserMockFactory.Diana)
};
CollectionAssert.AreEqual(expectedUsers, users);
}
public void GetSizesByBrandAndSubCategory_Should_Return_All_Sizes_When_Filter_Is_Empty()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var sizeService = container.Get <ISizeService>();
var subCategory = dtoService.CreateSubCategory(SubCategoryMockFactory.Girls_0_2);
var brand = dtoService.CreateBrand(BrandMockFactory.Carters);
// Act
var sizes = sizeService.GetSizes(subCategory, brand, null);
// Assert
var expectedSizes =
new[]
{
dtoService.CreateSize(SizeMockFactory.Carters_Girls_0_2_3M),
dtoService.CreateSize(SizeMockFactory.Carters_Girls_0_2_6M)
};
CollectionAssert.AreEqual(expectedSizes, sizes);
}
public void ResetPassword_Should_Throw_Exception_When_Current_User_Is_Not_Administrator()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var changedUser = dtoService.CreateUser(UserMockFactory.Olesya);
container.Remove <IPasswordGeneratorService>();
var passwordGeneratorServiceMock = new Mock <IPasswordGeneratorService>();
passwordGeneratorServiceMock
.Setup(m => m.GenerateTemporaryPassword(changedUser.Login))
.Returns(EncryptServiceMockFactory.NewPasswordData.Password);
container.SetConstant <IPasswordGeneratorService, IPasswordGeneratorService>(passwordGeneratorServiceMock.Object);
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => securityService.ResetPassword(changedUser),
"Only administrator can reset password.");
}
public void GetSizesByBrandAndSubCategory_Should_Return_Sizes_By_Filter()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var sizeService = container.Get <ISizeService>();
var subCategory = dtoService.CreateSubCategory(SubCategoryMockFactory.Boys_0_2);
var brand = dtoService.CreateBrand(BrandMockFactory.TheChildrensPlace);
// Act
var sizes = sizeService.GetSizes(subCategory, brand, "5");
// Assert
var expectedSizes =
new[]
{
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_0_3_Months),
dtoService.CreateSize(SizeMockFactory.TheChildrensPlace_Boys_0_2_3_6_Months)
};
CollectionAssert.AreEqual(expectedSizes, sizes);
}
public void ResetPassword_Should_Throw_Exception_When_CurrentUser_Tries_To_Reset_Password_To_Himself()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Jenya.Login, EncryptServiceMockFactory.JenyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var changedUser = dtoService.CreateUser(UserMockFactory.Jenya);
container.Remove <IPasswordGeneratorService>();
var passwordGeneratorServiceMock = new Mock <IPasswordGeneratorService>();
passwordGeneratorServiceMock
.Setup(m => m.GenerateTemporaryPassword(changedUser.Login))
.Returns(EncryptServiceMockFactory.NewPasswordData.Password);
container.SetConstant <IPasswordGeneratorService, IPasswordGeneratorService>(passwordGeneratorServiceMock.Object);
// Act
// Assert
ExceptionAssert.Throw <SecurityServiceException>(
() => securityService.ResetPassword(changedUser),
"Пользователь не может сбросить себе пароль.");
}
public void GetDistributorTransfers_Should_Return_Only_Transfers_Of_Current_Distributor_When_User_Is_Distributor_And_Distributor_Is_Null()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
UserRoleMockFactory.OlesyaDistributor.Active = true;
UserRoleMockFactory.OlesyaPurchaser.Active = false;
UserRoleMockFactory.OlesyaAdministrator.Active = false;
UserRoleMockFactory.OlesyaSeller.Active = false;
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var dtoService = container.Get <IDtoService>();
var distributorTransferService = container.Get <IDistributorTransferService>();
// Act
var distributorTransfers = distributorTransferService.GetDistributorTransfers(null);
// Assert
var expectedDistributorTransfers =
new[]
{
dtoService.CreateDistributorTransfer(DistributorTransferMockFactory.Olesya_Transfer_1),
dtoService.CreateDistributorTransfer(DistributorTransferMockFactory.Olesya_Transfer_2)
};
CollectionAssert.AreEqual(expectedDistributorTransfers, distributorTransfers);
}
