public void AllowsOtherTypesOfProperties() { var mock = new Moq.Mock <IWebDriver>(); var pageModel = new EmptyPageModelWithOtherProperties(mock.Object); mock.VerifyAll(); }
public void DoesNotRequireElementProperties() { var mock = new Moq.Mock <IWebDriver>(); var pageModel = new EmptyPageModel(mock.Object); mock.VerifyAll(); }
public void InitializesElementProperty() { var mock = new Moq.Mock <IWebDriver>(); var pageModel = new TestPageModel(mock.Object); Assert.IsNotNull(pageModel.Element); mock.VerifyAll(); }
public void IgnoresIWebElementPropertiesWithoutFindByAnnotation() { var mock = new Moq.Mock <IWebDriver>(); var pageModel = new WithIWebElementNoFindBy(mock.Object); Assert.IsNull(pageModel.Heading); mock.VerifyAll(); }
public void InitializesAllProperties() { var mock = new Moq.Mock <IWebDriver>(); var pageModel = new PageModelWithMultipleProperties(mock.Object); Assert.IsNotNull(pageModel.FirstName); Assert.IsNotNull(pageModel.LastName); mock.VerifyAll(); }
public void ShouldChokeToDeathOnInvalidInput() { var userInputMock = new Moq.Mock <IUserInput>(); userInputMock.Setup(m => m.GetUserInput()).Returns('a'); var humanStrategy = new HumanMoveStrategy(userInputMock.Object); var input = humanStrategy.GetNext(); userInputMock.VerifyAll(); }
static void Main(string[] args) { // create Mock var m = new Moq.Mock <IRepository <Test> >(); // some examples m.Setup(r => r.Add(Moq.It.IsAny <Test>())); m.Setup(r => r.FindAll()).Returns(new List <Test>()); m.VerifyAll(); }
public void Dispose_WithValidHubReference_UnregistersWithHub() { var messengerMock = new Moq.Mock<ITinyMessengerHub>(); messengerMock.Setup((messenger) => messenger.Unsubscribe<TestMessage>(Moq.It.IsAny<TinyMessageSubscriptionToken>())).Verifiable(); var token = new TinyMessageSubscriptionToken(messengerMock.Object, typeof(TestMessage)); token.Dispose(); messengerMock.VerifyAll(); }
public void ShouldReadUserInput() { var userInputMock = new Moq.Mock <IUserInput>(); userInputMock.Setup(m => m.GetUserInput()).Returns('2'); var humanStrategy = new HumanMoveStrategy(userInputMock.Object); var input = humanStrategy.GetNext(); Assert.AreEqual(Move.Paper, input); userInputMock.VerifyAll(); }
public void Dispose_WithValidHubReference_UnregistersWithHub() { var messengerMock = new Moq.Mock <ITinyMessengerHub>(); messengerMock.Setup((messenger) => messenger.Unsubscribe <TestMessage>(Moq.It.IsAny <TinyMessageSubscriptionToken>())).Verifiable(); var token = new TinyMessageSubscriptionToken(messengerMock.Object, typeof(TestMessage)); token.Dispose(); messengerMock.VerifyAll(); }
public void ShowHandShouldUseProvidedStrategy() { var strategyMock = new Moq.Mock <IMoveStrategy>(); strategyMock.Setup(m => m.GetNext()).Returns(Move.Paper); var player = new Player("dummy", strategyMock.Object); var move = player.Move(); Assert.AreEqual(Move.Paper, move); strategyMock.VerifyAll(); }
public void GetTimeClock_CallRepositoryGetAll() { //arrange var mockTimeClockRepository = new Moq.Mock<ITimeClockRepository>(); mockTimeClockRepository.Setup(x => x.GetAll()); var timeClockController = new TimeClockController(mockTimeClockRepository.Object); //act timeClockController.GetTimeClock(); //assert mockTimeClockRepository.VerifyAll(); }
public void TestGetOrCreateHomeWithExingHomeShouldReturnThatInstance() { var mockPersistance = new Moq.Mock<IPersistanceFramework>(); mockPersistance.Setup(m => m.CreateQueryContext<Home>()).Returns( TestHomes); var repository = new HomeRepository(mockPersistance.Object); var results = repository.GetOrCreateHome("first address",1,1); Assert.AreEqual(TestHomes.First().Id, results.Id); mockPersistance.VerifyAll(); }
public void CheckValuednessDelegatesToValuednessValidator() { using (var reader = XmlReader.Create(new StringReader(XML_CONTENT))) { var navigator = new XPathDocument(reader).CreateNavigator(); var mock = new Moq.Mock <ValuednessValidator>(navigator, null); XPathNavigatorExtensions.ValuednessValidatorFactory = (_, _) => mock.Object; mock.Setup(m => m.Validate()).Returns(false); navigator.CheckValuedness(null).Should().BeFalse(); mock.VerifyAll(); } }
public void GetTimeClock_PassingAnUserNameThatDoesntExistis_ReturnNull() { //arrange var userName = "******"; var mockTimeClockRepository = new Moq.Mock<ITimeClockRepository>(); mockTimeClockRepository.Setup(x => x.GetByUserName(userName)).Returns<TimeClock>(null); var timeClockController = new TimeClockController(mockTimeClockRepository.Object); //act timeClockController.GetTimeClock(userName); //assert mockTimeClockRepository.VerifyAll(); }
public void ShouldCallConverterForEachFile() { var converter = new Moq.Mock<ICsvToSqlInsertConverter>(); var tableFactory = new Moq.Mock<ICsvTableFactory>(); var table1 = new Moq.Mock<ICsvTable>().Object; var table2 = new Moq.Mock<ICsvTable>().Object; tableFactory.Setup(tf => tf.CreateCsvTable("a")).Returns(table1); tableFactory.Setup(tf => tf.CreateCsvTable("b")).Returns(table2); converter.Setup(c => c.Convert(table1)); converter.Setup(c => c.Convert(table2)); new CsvFileProcessor(new string[] {"a", "b"}, converter.Object, tableFactory.Object).Process(); tableFactory.VerifyAll(); converter.VerifyAll(); }
public void CreateBerlinClockImplClassWithProvidedTime() { // Arrange var timeParser = new Moq.Mock <ITimeParser>(); timeParser.Setup(parser => parser.GetTimeFromString(Moq.It.IsAny <String>())).Returns(Time.FromInt32(123456)).Verifiable(); var builder = new ClockBuilder(timeParser.Object); // Act IBerlinClock clock = builder.BuildClocks("Dummy"); // Assert Assert.IsNotNull(clock); Assert.IsInstanceOfType(clock, typeof(BerlinClockImpl)); timeParser.VerifyAll(); }
public void TestGetOrCreateHomeWithNewHomeShouldCreateANewHome() { var mockPersistance = new Moq.Mock<IPersistanceFramework>(); mockPersistance.Setup(m => m.CreateQueryContext<Home>()).Returns( TestHomes); var homeToBeCreated = new Home(); mockPersistance.Setup(m => m.Create<Home>()).Returns(homeToBeCreated); var repository = new HomeRepository(mockPersistance.Object); var results = repository.GetOrCreateHome("new address", 1, 1); Assert.AreNotEqual(TestHomes.First().Id, results.Id); homeToBeCreated.AddressFull = "new address"; mockPersistance.VerifyAll(); }
[ExpectedException(typeof(ArgumentException))] // Assert public void ThrowArgumentExceptionInBuildClocksOnIncorrectTimeProvided() { // Arrange var timeParser = new Moq.Mock <ITimeParser>(); timeParser.Setup(parser => parser.GetTimeFromString(Moq.It.IsAny <String>())).Returns(Time.Incorrect).Verifiable(); var builder = new ClockBuilder(timeParser.Object); // Act try { builder.BuildClocks("Dummy"); } finally { timeParser.VerifyAll(); } }
public void PostClocking_WithoutKnownTimeClock_ShouldCreateATimeClock() { //arrange var clocking = new Clocking() { Date = "10-10-2012 11:11", UserName = "******" }; var expectedTimeClock = new TimeClock(clocking.UserName); expectedTimeClock.AddTime(clocking.Date); var mockTimeClockRepository = new Moq.Mock<ITimeClockRepository>(); mockTimeClockRepository.Setup(x => x.GetByUserName(clocking.UserName)).Returns<TimeClock>(null); mockTimeClockRepository.Setup(x => x.Store(expectedTimeClock)); var clockingController = new ClockingController(mockTimeClockRepository.Object); //act clockingController.PostClocking(clocking); //assert mockTimeClockRepository.VerifyAll(); }
public void Search_Wildcard() { var foundFiles = new string[] { "z:\\abc\\def.exe" }; var wildcard = "*.exe"; var s = new DumbSearch.Service.Searcher(); var m = new Moq.Mock<DumbSearch.Service.IExplorer>(MockBehavior.Strict); m.Setup(e => e.Explore(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), wildcard)) .Returns(new List<string>(foundFiles)); s.Explorer = m.Object; var expected = new List<string>(foundFiles); var actual = s.Search(wildcard); Assert.AreEqual(expected.Count, actual.Count); Assert.AreEqual(expected[0], actual[0]); m.VerifyAll(); }
public void CreateOrUpdateFreeStandardAccount_AccountExists_UpdateTimestamp_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock <IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny <String>())) .Returns(true); //mock account repository var mockAccountsRepository = new Moq.Mock <IAccountsRepository>(); mockAccountsRepository.Setup(a => a.Where(Moq.It.IsAny <Func <Account, bool> >())).Returns(() => { var accounts = new List <Account>(); accounts.Add(new Account() { Email = "*****@*****.**" }); return(accounts); }); //update timestamp mockAccountsRepository.Setup(a => a.Update(Moq.It.IsAny <Account>())).Returns(new Account()); //moq unit of work var mockUnitOfWork = new Moq.Mock <IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.NotNull(result); mockEmailHelper.VerifyAll(); mockAccountsRepository.VerifyAll(); mockUnitOfWork.VerifyAll(); }
public void TestCreatingUserHomeWithNewHome() { var mock = new Moq.Mock<IPersistanceFramework>(); var controller = new UserHomeController(); new PrivateObject(controller).SetFieldOrProperty("Persistance",mock.Object); mock.Setup(p => p.CreateQueryContext<Home>()).Returns(HomesList); var newHomeThatShouldBeCreated = new Home(); mock.Setup(p => p.Create<Home>()).Returns(newHomeThatShouldBeCreated); mock.Setup(p => p.SaveChanges()); var enteredHome = new UserHome(); enteredHome.Name = "TestName"; var userId = Guid.NewGuid(); controller.CreateChildByAddress(userId, enteredHome, "TestAddress", 1, 1); Assert.AreEqual(userId, enteredHome.AppUserId); Assert.AreEqual("TestAddress", enteredHome.Home.AddressFull); mock.VerifyAll(); }
public void CreateOrUpdateFreeStandardAccount_InvalidEmailAddress_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock <IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny <String>())) .Returns(false); //moq unit of work var mockUnitOfWork = new Moq.Mock <IUnitOfWork>(); var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act //create user var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.IsNull(result); mockEmailHelper.VerifyAll(); }
public void BuildClockFromStringAndRenderClockProperly() { // Arrange String expected = "testString"; IBerlinClock result = new Moq.Mock <IBerlinClock>().Object; var builderMock = new Moq.Mock <IClockBuilder>(); builderMock.Setup(b => b.BuildClocks(Moq.It.IsAny <String>())).Returns(result).Verifiable(); var rendererMock = new Moq.Mock <IClockRenderer <String> >(); rendererMock.Setup(m => m.RenderClocks(Moq.It.Is <IBerlinClock>(clock => result.Equals(clock)))).Returns(expected).Verifiable(); var converter = new TimeConverter(rendererMock.Object, builderMock.Object); // Act String actual = converter.ConvertTime("InputTime"); // Assert Assert.AreEqual(actual, expected); builderMock.VerifyAll(); rendererMock.VerifyAll(); }
public void DisplayResultsTest() { IEnumerable <Employee> employees = new List <Employee> { new Employee() { FirstName = "Niesha", LastName = "Throssell", City = "Wilmington" }, new Employee() { FirstName = "Peter", LastName = "Teplica", City = "Marldon" } }; var employeeRepositoryMock = new Moq.Mock <IEmployeeRepository>(); employeeRepositoryMock.Setup(x => x.GetEmployees()).Returns(employees).Verifiable(); HomeController controller = new HomeController(employeeRepositoryMock.Object); var results = controller.DisplayResults(); employeeRepositoryMock.VerifyAll(); }
public void CreateFreeStandardAccount_CreateAccount_Test() { //arrange var newAccountGuid = Guid.NewGuid(); //mock account repository var mockAccountsRepository = new Moq.Mock<IAccountsRepository>(); mockAccountsRepository.Setup(a => a.Create(Moq.It.IsAny<Account>())).Returns(new Account() { AccountID = newAccountGuid }); //mock account type repository Func<AccountType, bool> actualAccountsTypeExpression = null; Func<AccountType, bool> expectedAccountsTypeExpression = at => at.Type == "Standard"; var mockAccountsTypeRepository = new Moq.Mock<IAccountTypesRepository>(); mockAccountsTypeRepository.Setup(a => a.Where(Moq.It.IsAny<Func<AccountType, bool>>())).Returns(() => { var accounts = new List<AccountType>(); accounts.Add(new AccountType() { AccountTypeID = Guid.NewGuid(), Type = "Standard" }); return accounts; }).Callback((Func<AccountType, bool> x) => actualAccountsTypeExpression = x); //mock account payment plan account repository Func<PaymentPlanAccount, bool> actualPaymentPlanAccountsExpression = null; Func<PaymentPlanAccount, bool> expectedPaymentPlanAccountsExpression = ppa => ppa.Name == "Free"; var mockPaymentPlanAccountsRepository = new Moq.Mock<IPaymentPlanAccountsRepository>(); mockPaymentPlanAccountsRepository.Setup(a => a.Where(Moq.It.IsAny<Func<PaymentPlanAccount, bool>>())).Returns(() => { var accounts = new List<PaymentPlanAccount>(); accounts.Add(new PaymentPlanAccount() { PaymentPlanAccountID = Guid.NewGuid(), Name = "Free" }); return accounts; }).Callback((Func<PaymentPlanAccount, bool> x) => actualPaymentPlanAccountsExpression = x); //mock account status type repository Func<AccountStatusType, bool> actualAccountStatusTypeExpression = null; Func<AccountStatusType, bool> expectedAccountStatusTypeExpression = ast => ast.Type == "Active"; var mockAccountStatusTypeRepository = new Moq.Mock<IAccountStatusTypesRepository>(); mockAccountStatusTypeRepository.Setup(a => a.Where(Moq.It.IsAny<Func<AccountStatusType, bool>>())).Returns(() => { var accounts = new List<AccountStatusType>(); accounts.Add(new AccountStatusType() { AccountStatusTypeID = Guid.NewGuid(), Type = "Active" }); return accounts; }).Callback((Func<AccountStatusType, bool> x) => actualAccountStatusTypeExpression = x); //mock account meta data repository var mockAccountMetaDataRepository = new Moq.Mock<IAccountMetaDatasRepository>(); mockAccountMetaDataRepository.Setup(a => a.Create(Moq.It.IsAny<AccountMetaData>())).Returns(new AccountMetaData()); //moq unit of work var mockUnitOfWork = new Moq.Mock<IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountTypesRepository).Returns(mockAccountsTypeRepository.Object); mockUnitOfWork.Setup(a => a.PaymentPlanAccountsRepository).Returns(mockPaymentPlanAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountMetaDatasRepository).Returns(mockAccountMetaDataRepository.Object); mockUnitOfWork.Setup(a => a.AccountStatusTypesRepository).Returns(mockAccountStatusTypeRepository.Object); //service var service = new AccountsService(mockUnitOfWork.Object); //act var result = service.CreateFreeStandardAccount("*****@*****.**"); //assert Assert.AreEqual(result.AccountID, newAccountGuid); mockPaymentPlanAccountsRepository.VerifyAll(); mockAccountsTypeRepository.VerifyAll(); mockAccountsRepository.VerifyAll(); mockAccountMetaDataRepository.VerifyAll(); mockAccountStatusTypeRepository.VerifyAll(); //make sure that the input of the Func<T,bool> are the expected inputs Assert.AreEqual(expectedAccountsTypeExpression.ToString(), actualAccountsTypeExpression.ToString()); Assert.AreEqual(expectedPaymentPlanAccountsExpression.ToString(), actualPaymentPlanAccountsExpression.ToString()); Assert.AreEqual(expectedAccountStatusTypeExpression.ToString(), actualAccountStatusTypeExpression.ToString()); }
public void CreateOrUpdateFreeStandardAccount_AccountExists_UpdateTimestamp_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock<IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny<String>())) .Returns(true); //mock account repository var mockAccountsRepository = new Moq.Mock<IAccountsRepository>(); mockAccountsRepository.Setup( a => a.Where(Moq.It.IsAny<Func<Account,bool>>())).Returns(()=>{ var accounts = new List<Account>(); accounts.Add(new Account(){ Email = "*****@*****.**" }); return accounts; }); //update timestamp mockAccountsRepository.Setup( a => a.Update(Moq.It.IsAny<Account>())).Returns(new Account()); //moq unit of work var mockUnitOfWork = new Moq.Mock<IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.NotNull(result); mockEmailHelper.VerifyAll(); mockAccountsRepository.VerifyAll(); mockUnitOfWork.VerifyAll(); }
public void CreateOrUpdateFreeStandardAccount_CreateAccount_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock<IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny<String>())) .Returns(true); //mock account repository var mockAccountsRepository = new Moq.Mock<IAccountsRepository>(); mockAccountsRepository.Setup(a => a.Where(Moq.It.IsAny<Func<Account, bool>>())).Returns(new List<Account>()); mockAccountsRepository.Setup(a => a.Create(Moq.It.IsAny<Account>())).Returns(new Account()); //mock account type repository var mockAccountsTypeRepository = new Moq.Mock<IAccountTypesRepository>(); mockAccountsTypeRepository.Setup(a => a.Where(Moq.It.IsAny<Func<AccountType, bool>>())).Returns(() => { var accounts = new List<AccountType>(); accounts.Add(new AccountType() { AccountTypeID = Guid.NewGuid(), Type = "Standard" }); return accounts; }); //mock account payment plan account repository var mockPaymentPlanAccountsRepository = new Moq.Mock<IPaymentPlanAccountsRepository>(); mockPaymentPlanAccountsRepository.Setup(a => a.Where(Moq.It.IsAny<Func<PaymentPlanAccount, bool>>())).Returns(() => { var accounts = new List<PaymentPlanAccount>(); accounts.Add(new PaymentPlanAccount() { PaymentPlanAccountID = Guid.NewGuid(), Name = "Free" }); return accounts; }); //mock account status type repository var mockAccountStatusTypeRepository = new Moq.Mock<IAccountStatusTypesRepository>(); mockAccountStatusTypeRepository.Setup(a => a.Where(Moq.It.IsAny<Func<AccountStatusType, bool>>())).Returns(() => { var accountStatusTypes = new List<AccountStatusType>(); accountStatusTypes.Add(new AccountStatusType() { AccountStatusTypeID = Guid.NewGuid(), Type = "Active" }); return accountStatusTypes; }); //mock account meta data repository var mockAccountMetaDataRepository = new Moq.Mock<IAccountMetaDatasRepository>(); mockAccountMetaDataRepository.Setup(a => a.Create(Moq.It.IsAny<AccountMetaData>())).Returns(new AccountMetaData()); //moq unit of work var mockUnitOfWork = new Moq.Mock<IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountTypesRepository).Returns(mockAccountsTypeRepository.Object); mockUnitOfWork.Setup(a => a.PaymentPlanAccountsRepository).Returns(mockPaymentPlanAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountMetaDatasRepository).Returns(mockAccountMetaDataRepository.Object); mockUnitOfWork.Setup(a => a.AccountStatusTypesRepository).Returns(mockAccountStatusTypeRepository.Object); //service var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.NotNull(result); mockPaymentPlanAccountsRepository.VerifyAll(); mockAccountsTypeRepository.VerifyAll(); mockAccountsRepository.VerifyAll(); mockEmailHelper.VerifyAll(); mockAccountMetaDataRepository.VerifyAll(); mockAccountStatusTypeRepository.VerifyAll(); }
public void CreateOrUpdateFreeStandardAccount_InvalidEmailAddress_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock<IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny<String>())) .Returns(false); //moq unit of work var mockUnitOfWork = new Moq.Mock<IUnitOfWork>(); var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act //create user var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.IsNull(result); mockEmailHelper.VerifyAll(); }
public void CreateOrUpdateFreeStandardAccount_CreateAccount_Test() { //arrange //mock email helper var mockEmailHelper = new Moq.Mock <IEmailHelper>(); mockEmailHelper.Setup(a => a.IsValidEmail(Moq.It.IsAny <String>())) .Returns(true); //mock account repository var mockAccountsRepository = new Moq.Mock <IAccountsRepository>(); mockAccountsRepository.Setup(a => a.Where(Moq.It.IsAny <Func <Account, bool> >())).Returns(new List <Account>()); mockAccountsRepository.Setup(a => a.Create(Moq.It.IsAny <Account>())).Returns(new Account()); //mock account type repository var mockAccountsTypeRepository = new Moq.Mock <IAccountTypesRepository>(); mockAccountsTypeRepository.Setup(a => a.Where(Moq.It.IsAny <Func <AccountType, bool> >())).Returns(() => { var accounts = new List <AccountType>(); accounts.Add(new AccountType() { AccountTypeID = Guid.NewGuid(), Type = "Standard" }); return(accounts); }); //mock account payment plan account repository var mockPaymentPlanAccountsRepository = new Moq.Mock <IPaymentPlanAccountsRepository>(); mockPaymentPlanAccountsRepository.Setup(a => a.Where(Moq.It.IsAny <Func <PaymentPlanAccount, bool> >())).Returns(() => { var accounts = new List <PaymentPlanAccount>(); accounts.Add(new PaymentPlanAccount() { PaymentPlanAccountID = Guid.NewGuid(), Name = "Free" }); return(accounts); }); //mock account status type repository var mockAccountStatusTypeRepository = new Moq.Mock <IAccountStatusTypesRepository>(); mockAccountStatusTypeRepository.Setup(a => a.Where(Moq.It.IsAny <Func <AccountStatusType, bool> >())).Returns(() => { var accountStatusTypes = new List <AccountStatusType>(); accountStatusTypes.Add(new AccountStatusType() { AccountStatusTypeID = Guid.NewGuid(), Type = "Active" }); return(accountStatusTypes); }); //mock account meta data repository var mockAccountMetaDataRepository = new Moq.Mock <IAccountMetaDatasRepository>(); mockAccountMetaDataRepository.Setup(a => a.Create(Moq.It.IsAny <AccountMetaData>())).Returns(new AccountMetaData()); //moq unit of work var mockUnitOfWork = new Moq.Mock <IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountTypesRepository).Returns(mockAccountsTypeRepository.Object); mockUnitOfWork.Setup(a => a.PaymentPlanAccountsRepository).Returns(mockPaymentPlanAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountMetaDatasRepository).Returns(mockAccountMetaDataRepository.Object); mockUnitOfWork.Setup(a => a.AccountStatusTypesRepository).Returns(mockAccountStatusTypeRepository.Object); //service var service = new AccountsService(mockUnitOfWork.Object, mockEmailHelper.Object); //act var result = service.CreateOrUpdateFreeStandardAccount("*****@*****.**"); //assert Assert.NotNull(result); mockPaymentPlanAccountsRepository.VerifyAll(); mockAccountsTypeRepository.VerifyAll(); mockAccountsRepository.VerifyAll(); mockEmailHelper.VerifyAll(); mockAccountMetaDataRepository.VerifyAll(); mockAccountStatusTypeRepository.VerifyAll(); }
public void CreateFreeStandardAccount_CreateAccount_Test() { //arrange var newAccountGuid = Guid.NewGuid(); //mock account repository var mockAccountsRepository = new Moq.Mock <IAccountsRepository>(); mockAccountsRepository.Setup(a => a.Create(Moq.It.IsAny <Account>())).Returns(new Account() { AccountID = newAccountGuid }); //mock account type repository Func <AccountType, bool> actualAccountsTypeExpression = null; Func <AccountType, bool> expectedAccountsTypeExpression = at => at.Type == "Standard"; var mockAccountsTypeRepository = new Moq.Mock <IAccountTypesRepository>(); mockAccountsTypeRepository.Setup(a => a.Where(Moq.It.IsAny <Func <AccountType, bool> >())).Returns(() => { var accounts = new List <AccountType>(); accounts.Add(new AccountType() { AccountTypeID = Guid.NewGuid(), Type = "Standard" }); return(accounts); }).Callback((Func <AccountType, bool> x) => actualAccountsTypeExpression = x); //mock account payment plan account repository Func <PaymentPlanAccount, bool> actualPaymentPlanAccountsExpression = null; Func <PaymentPlanAccount, bool> expectedPaymentPlanAccountsExpression = ppa => ppa.Name == "Free"; var mockPaymentPlanAccountsRepository = new Moq.Mock <IPaymentPlanAccountsRepository>(); mockPaymentPlanAccountsRepository.Setup(a => a.Where(Moq.It.IsAny <Func <PaymentPlanAccount, bool> >())).Returns(() => { var accounts = new List <PaymentPlanAccount>(); accounts.Add(new PaymentPlanAccount() { PaymentPlanAccountID = Guid.NewGuid(), Name = "Free" }); return(accounts); }).Callback((Func <PaymentPlanAccount, bool> x) => actualPaymentPlanAccountsExpression = x); //mock account status type repository Func <AccountStatusType, bool> actualAccountStatusTypeExpression = null; Func <AccountStatusType, bool> expectedAccountStatusTypeExpression = ast => ast.Type == "Active"; var mockAccountStatusTypeRepository = new Moq.Mock <IAccountStatusTypesRepository>(); mockAccountStatusTypeRepository.Setup(a => a.Where(Moq.It.IsAny <Func <AccountStatusType, bool> >())).Returns(() => { var accounts = new List <AccountStatusType>(); accounts.Add(new AccountStatusType() { AccountStatusTypeID = Guid.NewGuid(), Type = "Active" }); return(accounts); }).Callback((Func <AccountStatusType, bool> x) => actualAccountStatusTypeExpression = x); //mock account meta data repository var mockAccountMetaDataRepository = new Moq.Mock <IAccountMetaDatasRepository>(); mockAccountMetaDataRepository.Setup(a => a.Create(Moq.It.IsAny <AccountMetaData>())).Returns(new AccountMetaData()); //moq unit of work var mockUnitOfWork = new Moq.Mock <IUnitOfWork>(); mockUnitOfWork.Setup(a => a.AccountsRepository).Returns(mockAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountTypesRepository).Returns(mockAccountsTypeRepository.Object); mockUnitOfWork.Setup(a => a.PaymentPlanAccountsRepository).Returns(mockPaymentPlanAccountsRepository.Object); mockUnitOfWork.Setup(a => a.AccountMetaDatasRepository).Returns(mockAccountMetaDataRepository.Object); mockUnitOfWork.Setup(a => a.AccountStatusTypesRepository).Returns(mockAccountStatusTypeRepository.Object); //service var service = new AccountsService(mockUnitOfWork.Object); //act var result = service.CreateFreeStandardAccount("*****@*****.**"); //assert Assert.AreEqual(result.AccountID, newAccountGuid); mockPaymentPlanAccountsRepository.VerifyAll(); mockAccountsTypeRepository.VerifyAll(); mockAccountsRepository.VerifyAll(); mockAccountMetaDataRepository.VerifyAll(); mockAccountStatusTypeRepository.VerifyAll(); //make sure that the input of the Func<T,bool> are the expected inputs Assert.AreEqual(expectedAccountsTypeExpression.ToString(), actualAccountsTypeExpression.ToString()); Assert.AreEqual(expectedPaymentPlanAccountsExpression.ToString(), actualPaymentPlanAccountsExpression.ToString()); Assert.AreEqual(expectedAccountStatusTypeExpression.ToString(), actualAccountStatusTypeExpression.ToString()); }