public void Show_Orders_Without_Filters()
{
Guid custId = Guid.NewGuid();
Order[] orders = new Order[]
{
new Order()
{
CustomerID = Guid.NewGuid()
},
new Order()
{
CustomerID = custId
},
new Order()
{
CustomerID = custId
},
};
UnitOfWorkMock.Setup(m => m.Orders.GetAllItems()).Returns(orders);
UserManagerMock.Setup(m => m.GetUserId(It.IsAny <ClaimsPrincipal>())).Returns(custId.ToString());
var target = new OrderController(UnitOfWorkMock.Object, UserManagerMock.Object);
var resultModel = (target.Index(new OrderViewModel()) as ViewResult).Model as OrderViewModel;
Assert.Equal(2, resultModel.Orders.Count());
Assert.True(resultModel.Orders.First().CustomerID == custId);
}
public void add_table_with_same_name_faild(AddTableCommand command)
{
UnitOfWorkMock.AnyActual(
Arg.Any <Expression <Func <Table, bool> > >()).Returns(true);
Assert.Throws <InvalidOperationException>(() => Execute());
}
public RepairServiceTests()
{
_unitOfWork = new UnitOfWorkMock();
_vehicleService = new VehicleService(_unitOfWork);
_repairService = new RepairService(_unitOfWork, _vehicleService);
}
public void Show_Orders_With_Some_Filter()
{
Guid custId = Guid.NewGuid();
Order[] orders = new Order[]
{
new Order()
{
CustomerID = Guid.NewGuid(), StatusID = 1
},
new Order()
{
CustomerID = custId, StatusID = 2
},
new Order()
{
CustomerID = custId, StatusID = 3
},
};
UnitOfWorkMock.Setup(m => m.Orders.GetAllItems()).Returns(orders);
UserManagerMock.Setup(m => m.GetUserId(It.IsAny <ClaimsPrincipal>())).Returns(custId.ToString());
var target = new OrderController(UnitOfWorkMock.Object, UserManagerMock.Object);
var resultModel = (target.Index(new OrderViewModel()
{
Status = Statuses.InProgress
}) as ViewResult).Model as OrderViewModel;
Assert.Single(resultModel.Orders);
Assert.True(resultModel.Orders.First().StatusID == 2);
}
public async Task Update_User()
{
UserManagerMock.Setup(m => m.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(new IdentityUser());
UserManagerMock.Setup(m => m.UpdateAsync(It.IsAny <IdentityUser>()))
.ReturnsAsync(IdentityResult.Success);
UserValidatorMock.Setup(m => m.ValidateAsync(UserManagerMock.Object, It.IsAny <IdentityUser>()))
.ReturnsAsync(IdentityResult.Success);
UnitOfWorkMock.Setup(um => um.Customers.UpdateItem(It.IsAny <Customer>())).Verifiable();
UnitOfWorkMock.Setup(um => um.SaveChanges()).Verifiable();
var target = new UserController(UserManagerMock.Object, null, null, UserValidatorMock.Object,
UnitOfWorkMock.Object, null);
var resultAction = await target.Create(new UserInfoViewModel()
{
Customer = new Customer(),
Email = "*****@*****.**",
Password = "******",
IsAdmin = false
}) as RedirectToActionResult;
Assert.NotNull(resultAction);
UnitOfWorkMock.Verify(e => e.SaveChanges());
UnitOfWorkMock.Verify(e => e.Customers.UpdateItem(It.IsAny <Customer>()));
}
public async Task Edit_Not_Admin()
{
IdentityUser[] users = new IdentityUser[]
{
new IdentityUser("User1")
{
Id = "9E922BD2-4395-4524-8264-4F218D600E9D", Email = "*****@*****.**"
},
new IdentityUser("User2")
{
Id = "4192883F-AA46-42EA-B1DD-73E8CAA7A7B3", Email = "*****@*****.**"
}
};
UnitOfWorkMock.Setup(m => m.Customers.GetItem(It.IsAny <Guid>()))
.Returns(new Customer()
{
Name = "NameCustomer"
});
UserManagerMock.Setup(m => m.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(users[0]);
UserManagerMock.Setup(m => m.IsInRoleAsync(It.IsAny <IdentityUser>(), "Admin")).ReturnsAsync(false);
var target = new UserController(UserManagerMock.Object, null, null, null, UnitOfWorkMock.Object, null);
var resultAction = await target.Edit(Guid.Parse(users[0].Id));
var resultModel = (resultAction as ViewResult).Model as UserInfoViewModel;
Assert.True(resultModel.IsAdmin == false);
Assert.True(resultModel.Customer.Name == "NameCustomer");
Assert.True(resultModel.Email == "*****@*****.**");
}
public void Show_All_Products()
{
var products = new Product[]
{
new Product()
{
Name = "Name1"
},
new Product()
{
Name = "Name4"
},
new Product()
{
Name = "Name8"
},
new Product()
{
Name = "Name3"
},
};
UnitOfWorkMock.Setup(m => m.Products.GetAllItems()).Returns(products);
var target = new ProductController(UnitOfWorkMock.Object, Cart);
var resultModel = ((target.Index() as ViewResult)?.Model as IEnumerable <Product>).ToArray();
Assert.True(resultModel[0].Name == "Name1");
Assert.True(resultModel[1].Name == "Name4");
Assert.True(resultModel[2].Name == "Name8");
Assert.True(resultModel[3].Name == "Name3");
}
public void edit_table_by_existing_name_failed()
{
UnitOfWorkMock.AnyActual(
Arg.Any <Expression <Func <Table, bool> > >()).Returns(true);
Assert.Throws <InvalidOperationException>(() => Execute());
}
public void GetAllCategories_Test()
{
IUnitOfWork unitOfWork = new UnitOfWorkMock();
IFoodsCategories foodCategoriesManager = new FoodsCategories(unitOfWork);
FoodsCategoriesResponse response = foodCategoriesManager.GetAllCategories();
Assert.AreEqual(2, response.FoodCategories.Count);
}
public void add_table_correctly(AddTableCommand command)
{
Execute(command);
UnitOfWorkMock.Received().Add(Arg.Is <Table>(x =>
x.Title == command.Title &&
x.Description == command.Description));
}
public void TestInitialize()
{
_unitOfWorkMock = new UnitOfWorkMock();
_unitOfWorkMock.InitializeEmptyRepository <IPupilRepository, Pupil>();
_pupilService = new PupilORMService(_unitOfWorkMock.UnitOfWork);
}
public void add_user_with_table_correctly(AddTableCommand command)
{
PasswordManagerMock.CreateSecondHash(Arg.Any <string>(), Arg.Any <string>()).Returns("xyz");
Execute(command);
UnitOfWorkMock.Received().Add(Arg.Is <User>(x =>
x.Login == command.Title && x.SecondHash == "xyz"));
}
public void Init()
{
unitOfWork = new UnitOfWorkMock();
apiClient = new ApiClientMock();
cache = new CacheMock();
controller = new OrderApiController(unitOfWork, new MailHelper(new MimeMailerMock(), new RegistryReaderMock()), apiClient,
new JwtDecoderMock(), cache);
controller.Request = new HttpRequestMessage();
}
public void UserRepositoryEFTest_Create()
{
var mockDbContext = DbContextMock <DbContext> .GetMock();
var mockUnitOfWork = UnitOfWorkMock.GetMockAndSetUpContext(mockDbContext);
var userRepositoryEF = new UserRepositoryEF(mockUnitOfWork.Object);
mockDbContext.Verify(x => x.Set <User>());
}
public void UnitOfWork_BeginTransaction()
{
var unitOfWork = UnitOfWorkMock.Create();
unitOfWork.SessionFactoryMock.Setup(s => s.OpenSession()).Returns(new Mock <ISession>().Object);
unitOfWork.BeginTransaction();
unitOfWork.SessionFactoryMock.Verify(m => m.OpenSession(), Times.Once);
}
public void Init()
{
unitOfWork = new UnitOfWorkMock();
mailHelper = new MailHelperMock();
jwtDecoder = new JwtDecoderMock();
encrypter = new EncrypterMock();
cache = new CacheMock();
controller = new UserApiController(unitOfWork, mailHelper, new ApiClientMock(), jwtDecoder, encrypter, cache);
controller.Request = new HttpRequestMessage();
}
public void Make_InValid_Order()
{
var cart = new SessionCart();
var target = new CartController(UnitOfWorkMock.Object, cart, UserManagerMock.Object);
var result = target.MakeOrder("returnUrl") as RedirectResult;
Assert.Equal("returnUrl", result.Url);
UnitOfWorkMock.Verify(m => m.SaveChanges(), Times.Never);
}
public void Delete_Non_Existence_Product()
{
UnitOfWorkMock.Setup(m => m.Products.GetItem(It.IsAny <Guid>())).Returns(value: null);
UnitOfWorkMock.Setup(m => m.Products.DeleteItem(It.IsAny <Product>())).Verifiable();
var target = new ProductController(UnitOfWorkMock.Object, Cart);
target.Delete(It.IsAny <Guid>());
UnitOfWorkMock.Verify(v => v.Products.DeleteItem(It.IsAny <Product>()), Times.Never);
}
public void SetDbContextCorrectly_WhenParametersAreValid()
{
//Arrange
var dbContextMock = new Mock <IWanderlustEfDbContext>();
//Act
var uow = new UnitOfWorkMock(dbContextMock.Object);
//Assert
Assert.AreSame(dbContextMock.Object, uow.DbContext);
}
protected override void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
DependencyResolver.Reset();
ValidationServiceMock.VerifyAll();
UnitOfWorkMock.VerifyAll();
DependencyResolverMock.VerifyAll();
}
public void Edit_Product()
{
UnitOfWorkMock.Setup(m => m.Products.GetItem(It.IsAny <Guid>())).Returns(new Product()
{
Name = "Name"
});
var target = new ProductController(UnitOfWorkMock.Object, Cart);
var result = (target.Edit(It.IsAny <Guid>()) as ViewResult);
Assert.Equal("Редактирование продукта", result.ViewData["Action"]);
Assert.Equal("Name", (result.Model as Product)?.Name);
}
public void Create_return_ok()
{
IUnitOfWork unitOfWork = new UnitOfWorkMock();
IFoodsCategories foodCategoriesManager = new FoodsCategories(unitOfWork);
EditedFoodCategory category = new EditedFoodCategory()
{
Name = "New category"
};
var response = foodCategoriesManager.Create(category);
Assert.IsTrue(response.IsValid);
}
public async Task UserRepositoryEFTest_Add()
{
var user = UserDummyGenerator.Generate();
var mockDbSet = new Mock <DbSet <User> >();
var mockDbContext = DbContextMock <DbContext> .GetMockAndSetUpDbSet(mockDbSet);
var mockUnitOfWork = UnitOfWorkMock.GetMockAndSetUpContext(mockDbContext);
var repositoryUser = new UserRepositoryEF(mockUnitOfWork.Object);
await repositoryUser.AddAsync(user);
mockDbSet.Verify(m => m.AddAsync(It.Is <User>(y => y == user), It.IsAny <System.Threading.CancellationToken>()), Times.Once());
}
public async Task UserRepositoryEFTest_GetAll()
{
var users = UserDummyGenerator.GenerateCollection(5);
var mockDbSet = DbSetMock <User> .GetMockAndSetUpQueryble(users);
var mockDbContext = DbContextMock <DbContext> .GetMockAndSetUpDbSet(mockDbSet);
var mockUnitOfWork = UnitOfWorkMock.GetMockAndSetUpContext(mockDbContext);
var userRepositoryEF = new UserRepositoryEF(mockUnitOfWork.Object);
var resultUsers = await userRepositoryEF.GetAllAsync();
Assert.True(Enumerable.SequenceEqual(users.OrderBy(t => t.UserId), resultUsers.OrderBy(t => t.UserId), new UserComparer()));
}
public void Init()
{
unitOfWork = new UnitOfWorkMock();
mailHelper = new MailHelperMock();
pdfManager = new PdfManagerMock();
jwtDecoder = new JwtDecoderMock();
apiClient = new ApiClientMock();
request = new HttpRequestMessage();
webClient = new WebClientMock();
cache = new CacheMock();
controller = new InvoiceHistoryApiController(unitOfWork, mailHelper, apiClient, pdfManager, webClient, jwtDecoder, cache);
controller.Request = new HttpRequestMessage();
}
public void UnitOfWork_IsInTransaction_True()
{
var unitOfWork = UnitOfWorkMock.Create();
var sessionMock = new Mock <ISession>();
var transactionMock = new Mock <ITransaction>();
transactionMock.Setup(t => t.IsActive).Returns(true);
sessionMock.Setup(s => s.BeginTransaction()).Returns(transactionMock.Object);
unitOfWork.SessionFactoryMock.Setup(s => s.OpenSession()).Returns(sessionMock.Object);
unitOfWork.BeginTransaction();
Assert.IsTrue(unitOfWork.IsInTransaction);
}
public void Create_return_bad()
{
IUnitOfWork unitOfWork = new UnitOfWorkMock();
IFoodsCategories foodCategories = new FoodsCategories(unitOfWork);
EditedFoodCategory category = new EditedFoodCategory()
{
Name = "Registered category"
};
var response = foodCategories.Create(category);
Assert.AreEqual(response.StatusCode, 400);
Assert.IsFalse(response.IsValid);
}
public void Invalid_Delete_Order()
{
UnitOfWorkMock.Setup(m => m.Orders.GetItem(It.IsAny <Guid>())).Returns(new Order()
{
StatusID = 2
});
var target = new OrderController(UnitOfWorkMock.Object, UserManagerMock.Object);
var result = target.Delete(It.IsAny <Guid>(), It.IsAny <Statuses>()) as ViewResult;
Assert.NotNull(result);
UnitOfWorkMock.Verify(uow => uow.Orders.DeleteItem(It.IsAny <Order>()), Times.Never);
}
public void edit_not_newest_table_failed()
{
var notNewestTable = new Table();
typeof(VersionableEntity)
.GetProperty("IsNewest")
.SetValue(notNewestTable, false);
UnitOfWorkMock.Get <Table>(Arg.Any <int>()).Returns(notNewestTable);
_blockMock = true;
Assert.Throws <InvalidOperationException>(() => Execute());
}
public void CreatePropertyState_StateExists_ExceptionThrown()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var service = new PropertyStateService(unitOfWork);
var property = CreateProperty();
var propertyState = CreatePropertyState(property);
unitOfWork.GetRepository<PropertyState>().Insert(propertyState);
// Act, Assert
service.Invoking(srv => srv.CreateState(property, propertyState.Value))
.ShouldThrow<InvalidOperationException>();
}
public void edit_deleted_table_failed()
{
var deletedTable = new Table();
typeof(VersionableEntity)
.GetProperty("IsDeleted")
.SetValue(deletedTable, true);
UnitOfWorkMock.Get <Table>(Arg.Any <int>()).Returns(deletedTable);
_blockMock = true;
Assert.Throws <InvalidOperationException>(() => Execute());
}
public void UserHasPermissions_UserIsOwner_UserHasPermissions()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var package = new ContentPackage {Owner = user};
// Act
var financeService = new FinanceService(unitOfWork);
var userHasPermissions = financeService.UserHasPermissions(user, package);
// Assert
userHasPermissions.Should().BeTrue();
}
public ContentControllerTests()
{
_unitOfWork = new UnitOfWorkMock();
_fileStorageManager = new FileStorageManagerMock();
_currentUser = new User {UserName = "******"};
_currentUserProfile = new UserProfile {User = _currentUser};
_unitOfWork.GetRepository<User>().Insert(_currentUser);
_unitOfWork.GetRepository<UserProfile>().Insert(_currentUserProfile);
_controller = new ContentController(_unitOfWork,
_fileStorageManager,
new FinanceService(_unitOfWork));
_controller.ControllerContext = CreateControllerContext();
InitUnitOfWork(_unitOfWork);
}
public void CreatePropertyState_StateNotExists_StateCreated()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var service = new PropertyStateService(unitOfWork);
var property = CreateProperty();
unitOfWork.GetRepository<Property>().Insert(property);
unitOfWork.GetRepository<Property>().Insert(property);
unitOfWork.Save();
// Act
service.CreateState(property, "newValue");
// Assert
unitOfWork.GetRepository<PropertyState>().Get().Should().Contain(x => x.Value == "newValue");
}
public void CreatePropertyState_StateNotExists_NewStateReturned()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var service = new PropertyStateService(unitOfWork);
var property = CreateProperty();
unitOfWork.GetRepository<Property>().Insert(property);
unitOfWork.GetRepository<Property>().Insert(property);
unitOfWork.Save();
// Act
var newState = service.CreateState(property, "newValue");
// Assert
newState.Should().Be(unitOfWork.GetRepository<PropertyState>().Get().Last());
}
public void CreatePropertyState_StateOfSamePropertyExists_StateHasUniquePropertyStateIndex()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var service = new PropertyStateService(unitOfWork);
var property = CreateProperty();
var propertyState = CreatePropertyState(property);
propertyState.Index = 2;
unitOfWork.GetRepository<PropertyState>().Insert(propertyState);
unitOfWork.Save();
// Act
service.CreateState(property, "newValue");
// Assert
unitOfWork.GetRepository<PropertyState>().Get().Last().Index.Should().Be(3);
}
public void UserHasPermissions_UserNotOrderedPackage_UserHasNoPermissions()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var userProfile = new UserProfile {User = user};
var package = new ContentPackage {Owner = new User()};
unitOfWork.GetRepository<User>().Insert(user);
unitOfWork.GetRepository<UserProfile>().Insert(userProfile);
unitOfWork.GetRepository<ContentPackage>().Insert(package);
unitOfWork.Save();
// Act
var financeService = new FinanceService(unitOfWork);
var userHasPermissions = financeService.UserHasPermissions(user, package);
// Assert
userHasPermissions.Should().BeFalse();
}
public void Register_ModelStateNotValid_UserNotCreated()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var membershipService = new Mock<IMembershipService>(MockBehavior.Strict).Object;
var roleService = new Mock<IRoleService>().Object;
var authenticationProvider = new Mock<IAuthenticationProvider>(MockBehavior.Strict).Object;
var controller = new AccountController(unitOfWork,
membershipService,
roleService,
new ProfileService(unitOfWork),
authenticationProvider);
controller.ModelState.AddModelError("", "");
// Act
var result = (ViewResult) controller.Register(new RegisterViewModel());
// Assert
result.ViewName.Should().Be("");
}
public void Register_Simple_UserCreated()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var membershipServiceMock = MembershipServiceMock(user, MembershipCreateStatus.Success);
var roleService = new Mock<IRoleService>().Object;
var authenticationProvider = new Mock<IAuthenticationProvider>().Object;
var controller = new AccountController(unitOfWork,
membershipServiceMock.Object,
roleService,
new ProfileService(unitOfWork),
authenticationProvider);
var viewModel = new RegisterViewModel
{
UserName = "******",
Email = "[email protected]",
Password = "******",
ConfirmPassword = "******",
PhoneNumber = "000000"
};
// Act
controller.Register(viewModel);
// Assert
MembershipCreateStatus status;
membershipServiceMock.Verify(x => x.CreateUser(viewModel.UserName,
viewModel.Password,
viewModel.Email,
null,
null,
true,
out status),
Times.Once());
}
public void Register_UserCreationSucceded_UserRoleAssignedToUser()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var membershipServiceMock = MembershipServiceMock(user, MembershipCreateStatus.Success);
var roleService = new Mock<IRoleService>();
var authenticationProvider = new Mock<IAuthenticationProvider>().Object;
var controller = new AccountController(unitOfWork,
membershipServiceMock.Object,
roleService.Object,
new ProfileService(unitOfWork),
authenticationProvider);
// Act
controller.Register(new RegisterViewModel());
// Assert
roleService.Verify(rs => rs.AddUsersToRoles(new[] { user.UserName }, new[] { "user" }));
}
public void CreatePropertyState_StateOfSamePropertyNotExists_StateHasUniquePropertyStateIndex()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var service = new PropertyStateService(unitOfWork);
var propertyState = CreatePropertyState(CreateProperty(id: 1));
unitOfWork.GetRepository<PropertyState>().Insert(propertyState);
unitOfWork.Save();
// Act
service.CreateState(CreateProperty(id: 2), "newValue");
// Assert
unitOfWork.GetRepository<PropertyState>().Get().Should().Contain(x => x.Index == 1);
}
public void Register_UserCreationSucceded_UserProfileCreated()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var roleService = new Mock<IRoleService>().Object;
var membershipServiceMock = MembershipServiceMock(user, MembershipCreateStatus.Success);
var authenticationProvider = new Mock<IAuthenticationProvider>().Object;
var controller = new AccountController(unitOfWork,
membershipServiceMock.Object,
roleService,
new ProfileService(unitOfWork),
authenticationProvider);
var viewModel = new RegisterViewModel
{
PhoneNumber = "000000"
};
// Act
controller.Register(viewModel);
// Assert
var userProfile = unitOfWork.GetRepository<UserProfile>().Get().Single();
userProfile.User.Should().Be(user);
userProfile.PhoneNumber.Should().Be(viewModel.PhoneNumber);
}
public void GetState_PropertyNotExists_NullReturned()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var propertyStateService = new PropertyStateService(unitOfWork);
var property = CreateProperty();
var propertyState = CreatePropertyState(property);
unitOfWork.GetRepository<PropertyState>().Insert(propertyState);
// Act
var state = propertyStateService.GetState(2, "value");
// Assert
state.Should().BeNull();
}
public void GetState_StateExists_StateReturned()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var propertyStateService = new PropertyStateService(unitOfWork);
var property = CreateProperty();
var propertyState = CreatePropertyState(property);
unitOfWork.GetRepository<PropertyState>().Insert(propertyState);
unitOfWork.Save();
// Act
var state = propertyStateService.GetState(property.ID, propertyState.Value);
// Assert
state.Should().Be(propertyState);
}
public void GetState_StateNotExists_NullReturned()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var propertyStateService = new PropertyStateService(unitOfWork);
var property = CreateProperty();
// Act
var state = propertyStateService.GetState(property.ID, "value");
// Assert
state.Should().BeNull();
}
private void InitUnitOfWork(UnitOfWorkMock unitOfWork)
{
var property1 = new Property {Name = "property1", Order = 1, ID = 1};
var property2 = new Property {Name = "property2", Order = 2, ID = 2};
var state1 = new PropertyState {Property = property1, Value = "state1"};
var state2 = new PropertyState {Property = property1, Value = "state2"};
var state3 = new PropertyState {Property = property2, Value = "state3"};
var state4 = new PropertyState {Property = property2, Value = "state4"};
property1.States = new List<PropertyState> {state1, state2};
property2.States = new List<PropertyState> {state3, state4};
var package1 = new ContentPackage
{
ID = 1,
PropertyStates = new Collection<PropertyState> {state1, state3}
};
var package2 = new ContentPackage
{
ID = 2,
PropertyStates = new Collection<PropertyState> {state2, state4}
};
state1.ContentPackages = new Collection<ContentPackage> {package1};
state2.ContentPackages = new Collection<ContentPackage> {package2};
state3.ContentPackages = new Collection<ContentPackage> {package1};
state4.ContentPackages = new Collection<ContentPackage> {package2};
unitOfWork.GetRepository<Property>().Insert(property1);
unitOfWork.GetRepository<Property>().Insert(property2);
unitOfWork.GetRepository<PropertyState>().Insert(state1);
unitOfWork.GetRepository<PropertyState>().Insert(state2);
unitOfWork.GetRepository<PropertyState>().Insert(state3);
unitOfWork.GetRepository<PropertyState>().Insert(state4);
unitOfWork.GetRepository<ContentPackage>().Insert(package1);
unitOfWork.GetRepository<ContentPackage>().Insert(package2);
unitOfWork.Save();
}
public void Register_UserCreationFailed_UserProfileNotCreated()
{
// Arrange
var unitOfWork = new UnitOfWorkMock();
var user = new User();
var membershipServiceMock = MembershipServiceMock(user, MembershipCreateStatus.ProviderError);
var roleService = new Mock<IRoleService>().Object;
var authenticationProvider = new Mock<IAuthenticationProvider>().Object;
var controller = new AccountController(unitOfWork,
membershipServiceMock.Object,
roleService,
new ProfileService(unitOfWork),
authenticationProvider);
// Act
controller.Register(new RegisterViewModel());
// Assert
var userProfiles = unitOfWork.GetRepository<UserProfile>().Get();
userProfiles.Should().BeEmpty();
controller.ModelState.IsValid.Should().BeFalse();
}
