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());
}
