public EventCentricTestSpecificationRunnerSetup SpecificationRunFailsWithException(Exception exception)
{
Moq.Setup(x => x.Run(It.IsAny <EventCentricTestSpecification>()))
.Returns <EventCentricTestSpecification>(spec => spec.Fail(exception));
return(this);
}
public ExceptionCentricTestSpecificationRunnerSetup SpecificationRunPasses(Exception exception)
{
Moq.Setup(x => x.Run(It.IsAny <ExceptionCentricTestSpecification>()))
.Returns <ExceptionCentricTestSpecification>(spec => spec.Pass(exception));
return(this);
}
public ExceptionCentricTestSpecificationRunnerSetup SpecificationRunFails()
{
Moq.Setup(x => x.Run(It.IsAny <ExceptionCentricTestSpecification>()))
.Returns <ExceptionCentricTestSpecification>(spec => spec.Fail());
return(this);
}
public ExceptionCentricTestSpecificationRunnerSetup SpecificationRunFailsBecauseEvents(Fact[] events)
{
Moq.Setup(x => x.Run(It.IsAny <ExceptionCentricTestSpecification>()))
.Returns <ExceptionCentricTestSpecification>(spec => spec.Fail(events));
return(this);
}
public EventCentricTestSpecificationRunnerSetup SpecificationRunPassesWithEvents(Fact[] events)
{
Moq.Setup(x => x.Run(It.IsAny <EventCentricTestSpecification>()))
.Returns <EventCentricTestSpecification>(spec => spec.Pass(events));
return(this);
}
public void Should_execute_sql()
{
const string sql = "sql";
var @params = new[] {1, 2, 3};
_migration1.ExecuteSql(sql, @params);
_databaseMock.Verify(d => d.ExecuteSql(sql, @params));
}
public override void Given()
{
m1MessageView = Moq.Mock <IMessageView>();
m2MessageView = Moq.Mock <IMessageView>();
part = New.Part().WithMessageMaps(x => x.WithName("m1").CanBuildMessageView(() => m1MessageView),
x => x.WithName("m2").CanBuildMessageView(() => m2MessageView)).Build();
}
public void Log_should_call_ILogger_Log_method_before_and_after_executing_code()
{
var categories = new[] { "Category1", "Category2" };
var logger2 = new Mock<ILogger>();
var loggedBefore = false;
var loggedAfter = false;
logger2.Setup(l => l.Log(categories, "Before Log"))
.Callback(() => loggedBefore = true)
.AtMostOnce()
.Verifiable();
logger2.Setup(l => l.Log(categories, "After Log"))
.Callback(() => loggedAfter = true)
.AtMostOnce()
.Verifiable();
Let.Logger = () => logger2.Object;
Let.Us
.Log(categories, "Before Log", "After Log")
.Do(() =>
{
Assert.True(loggedBefore);
Assert.False(loggedAfter);
});
logger2.VerifyAll();
}
public override void Given()
{
view = Moq.Mock <IEntityView>();
presentationModel = Moq.Mock <IPresentationModel>();
presentationModel.SetupGet(x => x.Title).Returns("aaaaa");
}
public void Given_AValidBasicAuthHeader_When_TheRequestIsAuthenticated_Then_TheResult_IsSuccess_And_UsernameIsSet_And_RolesAreSet()
{
// given
string validAuthString = "Basic U2F1c2FnZTphbmQgbWFzaA==";
string username = "******";
string password = "******";
string[] userRoles = new[] { "Admin", "Manager", "Developer" };
this.request.Headers["Authorization"] = validAuthString;
this.mockAuthenticator
.Expect(auth => auth.Authenticate(It.Is<BasicAuthRequestHeader>(h => h.Username == username && h.Password == password)))
.Returns(new AuthenticationResult.Success(username, userRoles));
// when
var result = this.basicScheme.Authenticate(this.request);
// then
result.ShouldBeOfType<AuthenticationResult.Success>();
var success = result as AuthenticationResult.Success;
success.Username.ShouldBe(username);
success.Roles.ShouldHaveSameElementsAs(userRoles);
}
public void CanGenerateMultiDimensionArray()
{
int fixedValue = 9;
var factoryMock = new Mock<IFactory<int>>();
factoryMock.Setup(f => f.Generate()).Returns(fixedValue);
int[] dimension = new[] { 5,2,3,8,9};
var arrayFactory = new ArrayFactory<int>(factoryMock.Object, dimension);
var result =arrayFactory.Generate() as int[,,,,];
bool anyDiff = false;
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 2; j++)
{
for (int k = 0; k < 3; k++)
{
for (int l = 0; l < 8; l++)
{
for (int m = 0; m < 9; m++)
{
if (result[i,j,k,l,m] != fixedValue)
anyDiff = true;
}
}
}
}
}
Assert.False(anyDiff);
}
public void InitializeDefersToExecutionEngine()
{
var assemblies = new[] { GetType().Assembly };
asyncTestRunner.InitializeTestRunner(assemblies);
testExecutionEngineStub.Verify(m => m.Initialize(assemblies));
}
public void ThenTheDocumentMessageHandlerShouldBeGettable()
{
var documentationFiles = new Mock<IDocumentationFiles>();
var files = new[]
{
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/0-Overview-2-Monitoring.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/0-Overview-0-Identity.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/0-Overview.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/1-Getting Started.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/2-Front End-0-Asp.Net 5.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/0-Overview-1-Orders.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/2-Front End.md",
@"C:/_/Soloco.RealTimeWeb/git/src/Soloco.RealTimeWeb/wwwroot/documentation/3-Environment.md"
};
documentationFiles.Setup(mock => mock.GetFiles()).Returns(files);
var handler = new DocumentsQueryHandler(documentationFiles.Object);
var documents = handler.Handle(new DocumentsQuery());
documents.Result.Length.ShouldBe(4);
Verify(documents.Result, 0, "0-Overview", "Overview");
Verify(documents.Result[0].Children, 0, "0-Overview-0-Identity", "Identity");
Verify(documents.Result[0].Children, 1, "0-Overview-1-Orders", "Orders");
Verify(documents.Result[0].Children, 2, "0-Overview-2-Monitoring", "Monitoring");
Verify(documents.Result, 1, "1-Getting Started", "Getting Started");
Verify(documents.Result, 2, "2-Front End", "Front End");
Verify(documents.Result[2].Children, 0, "2-Front End-0-Asp.Net 5", "Asp.Net 5");
Verify(documents.Result, 3, "3-Environment", "Environment");
}
public void TestThatCaretPosIsOnOneOfTheSelectionBorders ()
{
var caretPos = new Position(5, 5);
var anchorPos = new[] {
new Position (1,1), new Position (1,5), new Position (1, 10),
new Position (5,1), new Position (5,5), new Position (5, 10),
new Position (10,1), new Position (10,5), new Position (10, 10)
};
var selection = GetSelectionWithCaretPos(caretPos.Row, caretPos.Column);
for (var i=0; i<anchorPos.Length; i++)
{
selection.Anchor = anchorPos[i];
var caretIsOk = selection.BeginDrawPos == caretPos || selection.EndDrawPos == caretPos;
if (!caretIsOk)
System.Console.WriteLine("Error: Caret is NOT on selection border" + " \nData: " + selection + ", Index: " + i);
var anchorIsOk = selection.BeginDrawPos == selection.Anchor || selection.EndDrawPos == selection.Anchor;
if (!anchorIsOk)
System.Console.WriteLine("Error: Anchor is NOT on selection border" + " \nData: " + selection + ", Index: " + i);
Assert.IsTrue(caretIsOk);
Assert.IsTrue(anchorIsOk);
}
}
public void ReverseRecords()
{
dataProviderMock.Setup(m => m.GetAllRecords()).Returns(new[]
{
new DataModel {MembersCount = 1},
new DataModel {MembersCount = 2},
new DataModel {MembersCount = 3}
});
var expected = new[]
{
new DataModel {MembersCount = 3},
new DataModel {MembersCount = 2},
new DataModel {MembersCount = 1}
};
var provider = new DataProvider(dataProviderMock.Object, 10, 10);
var count = provider.GetRecordsCount();
var recordsForChart = provider.GetRecordsForChart();
var recordsForTable = provider.GetRecordsForInfoTable();
Assert.AreEqual(count, 3);
CollectionAssert.AreEqual(expected, recordsForTable);
CollectionAssert.AreEqual(expected, recordsForChart);
}
public void ReturnLatestRecords()
{
var inputData = new DataModel[100];
for (var i = 0; i < 100; i++)
{
inputData[i] = new DataModel {MembersCount = i + 1};
}
dataProviderMock.Setup(m => m.GetAllRecords()).Returns(inputData);
var expectedTable = new[]
{
new DataModel {MembersCount = 100},
new DataModel {MembersCount = 99},
new DataModel {MembersCount = 98},
new DataModel {MembersCount = 97},
new DataModel {MembersCount = 96}
};
var expectedChart = new[]
{
new DataModel {MembersCount = 100},
new DataModel {MembersCount = 99},
new DataModel {MembersCount = 98}
};
var provider = new DataProvider(dataProviderMock.Object, 3, 5);
var count = provider.GetRecordsCount();
var recordsForChart = provider.GetRecordsForChart();
var recordsForTable = provider.GetRecordsForInfoTable();
Assert.AreEqual(count, 100);
CollectionAssert.AreEqual(expectedTable, recordsForTable);
CollectionAssert.AreEqual(expectedChart, recordsForChart);
}
internal LatestQueriesSetup LatestGemeentesExist(IEnumerable <MunicipalityLatestItem> gemeentes)
{
When($"[{gemeentes.Count()}] gemeentes exist\r\n[{gemeentes.ToLoggableString(LogFormatting)}]");
Moq.Setup(m => m.GetAllLatestMunicipalities()).Returns(gemeentes.AsQueryable());
return(this);
}
public override void Given()
{
view = Moq.Stub <IFieldView>();
field = Moq.Stub <IField_v2>();
field.SetupGet(x => x.Label).Returns("aaaa");
field.SetupGet(x => x.Value).Returns("bbbb");
field.SetupGet(x => x.ObservableValue).Returns(Moq.Stub <IObservable <object> >());
}
internal KadRrServiceSetup AdresMappingExistsFor(IEnumerable <AddressDetailItem> adressen, string huisnummer, string index, string rrStraatcode, string postcode)
{
When($"rr adres mapping exists for huisnummer [{huisnummer}], index [{index}], rrStraatcode [{rrStraatcode}] and postcode[{postcode}]\r\n[{adressen.ToLoggableString(LogFormatting)}]");
Moq.Setup(m => m.GetAddressesBy(huisnummer, index, rrStraatcode, postcode)).Returns(adressen);
return(this);
}
public void VerifyReadAllBytes(params string[] paths)
{
Moq.Verify(mock => mock.ReadAllBytes(It.IsAny <string>()), Times.Exactly(paths.Length));
foreach (var path in paths)
{
Moq.Verify(mock => mock.ReadAllBytes(path));
}
}
internal LatestQueriesSetup LatestAdressenExist(IEnumerable <AddressDetailItem> adressen, string straatnaamId, string huisnummer, string busnummer)
{
When($"[{adressen.Count()}] adressen exist for straatnaamId [{straatnaamId}], huisnummer [{huisnummer}] and busnummer [{busnummer}]\r\n{adressen.ToLoggableString(LogFormatting)}");
Moq.Setup(m => m.GetLatestAddressesBy(straatnaamId, huisnummer, busnummer)).Returns(adressen.AsQueryable());
return(this);
}
public override void Given()
{
base.Given();
screenToOpen = new Mock <IScreen>().Object;
screenSubject = Moq.Mock <IScreenSubject>();
screenSubject.Setup(x => x.CreateScreen(screenFactory)).Returns(screenToOpen);
}
internal KadRrServiceSetup StraatnaamExistsForRrStraatcodeAndPostcode(StreetNameLatestItem straatnaam, string rrStraatcode, string postcode)
{
When($"straatnaam exists for rrStraatcode [{rrStraatcode}] and postcode[{postcode}]\r\n[{straatnaam.ToLoggableString(LogFormatting)}]");
Moq.Setup(m => m.GetStreetNameByRrStreet(rrStraatcode, postcode)).Returns(straatnaam);
return(this);
}
public override void Given()
{
needRegionManagerScreen = Moq.Mock <INeedRegionManager>();
localRegionManager = Moq.Mock <IRegionManager>();
mainRegion.Setup(x => x.Add(It.IsAny <object>(), It.IsAny <string>(), true))
.Returns(localRegionManager);
}
public override void Given()
{
base.Given();
partPresenters = new[] { Moq.Mock <IPartPresenter>(), Moq.Mock <IPartPresenter>(), Moq.Mock <IPartPresenter>() };
partPresenters[0].Setup(x => x.CanClose()).Returns(true);
partPresenters[1].Setup(x => x.CanClose()).Returns(false);
partPresenters[2].Setup(x => x.CanClose()).Returns(true);
}
internal LatestQueriesSetup InterceptingLatestAdresQuery(Action <string, string, string> callback, IEnumerable <AddressDetailItem> returnResult)
{
When("intercepting the adres search query");
Moq.Setup(m => m.GetLatestAddressesBy(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(returnResult.AsQueryable()).Callback(callback);
return(this);
}
internal KadRrServiceSetup StraatnamenExistForKadStraatcodeAndNISCode(IEnumerable <StreetNameLatestItem> straatnamen, string kadStraatCode, string nisCode)
{
When($"[{straatnamen.Count()}] straatnamen exist for kadStraatcode [{kadStraatCode}] and nisCode[{nisCode}]\r\n{straatnamen.ToLoggableString(LogFormatting)}");
Moq.Setup(m => m.GetStreetNamesByKadStreet(kadStraatCode, nisCode)).Returns(straatnamen);
return(this);
}
public void PermutationsCountTest()
{
int[][] perms = new[] { new int[] { }, new int[] { }, new int[] { } };
permutations.Setup(perm => perm.GetPermutations()).Returns(perms);
int count = minHashService.PermutationsCount;
Assert.AreEqual(3, count);
}
public override void Given()
{
someEntity = new SomeEntity();
someEntity.Screen_Name_To_Return = "Sreen";
entityView = Moq.Mock <IEntityView <SomeEntity> >();
partPresenters = new[] { Moq.Mock <IPartPresenter>() };
}
public void ItFailsIfNoProcessorProcessesQuery()
{
QueryProcessor.Setup(qp => qp.Processes(It.IsAny<object>())).Returns(false);
var query = new {};
var executor = new SubscriptionQueryExecutor();
executor.AddProcessors(QueryProcessor.Object);
Assert.Throws<UnhandledQueryException>(() => executor.Execute(query));
}
public void VerifyCreateDirectory(params string[] paths)
{
Moq.Verify(mock => mock.CreateDirectory(It.IsAny <string>()), Times.Exactly(paths.Length));
foreach (var path in paths)
{
Moq.Verify(mock => mock.CreateDirectory(path));
}
return;
}
public override void Given()
{
messageSender = Moq.Mock <IMessageSender>();
var messageMap = Moq.Mock <IMessageMap_v2>();
messageMap.SetupGet(x => x.MessageType).Returns(typeof(ChangeOrderAttributes));
viewModel = new MessageMapViewModel(messageSender, messageMap);
}
public override void Given()
{
base.Given();
var activeScreen = screenToOpen = new Mock <IScreen>().Object;
screenSubject = Moq.Mock <IScreenSubject>();
screenSubject.Setup(x => x.Matches(activeScreen)).Returns(true);
screenCollection.SetupGet(x => x.Active).Returns(activeScreen);
}
public Given_a_project_with_a_reference_for_a_project_not_existing_in_solution()
{
var projectsInSolution = new[] { ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithoutReferences, ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences };
var parserMock = new Mock<IProjectParser>();
parserMock
.Setup(p => p.ParseProjectReferences(ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences.FullPath))
.Returns(new[] { ProjectReferenceTestSample.ReferenceFromProjectToAProjectWithSameName });
this.check = new ProjectReferenceExistsInSolutionCheck(projectsInSolution, parserMock.Object);
this.reference = ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences;
}
public void IsChangedShouldReturnFalseWhenNoItemHaveBeenChanged()
{
// arrange
var items = new[] { new MockEditableObject(), new MockEditableObject() };
// act
var changed = items.IsChanged();
// assert
Assert.False( changed );
}
public void ShouldProvideTheCorrectModel()
{
const string ID = "some sku id";
var expectedModel = new[] { new Stock(), new Stock() };
var repository = new Mock<IRepository<Stock>>();
repository.Setup(x => x.Find(ID)).Returns(expectedModel);
var controller = new StockController(repository.Object);
var result = controller.Find(ID);
Assert.That(result.Model, Is.EqualTo(expectedModel));
}
internal LatestQueriesSetup LatestStraatnamenExistForGemeentenaam(IEnumerable <StreetNameLatestItem> straatnamen, string gemeentenaam)
{
When($"[{straatnamen.Count()}] straatnamen exist for gemeentenaam [{gemeentenaam}]\r\n[{straatnamen.ToLoggableString(LogFormatting)}]");
Moq.Setup(m => m.GetLatestStreetNamesBy(new[] { gemeentenaam })).Returns(straatnamen.AsQueryable());
Moq.Setup(m => m.GetAllLatestStreetNames()).Returns(straatnamen.AsQueryable());
foreach (StreetNameLatestItem straatnaam in straatnamen)
{
Moq.Setup(m => m.FindLatestStreetNameById(straatnaam.PersistentLocalId)).Returns(straatnaam);
}
return(this);
}
public override void Given()
{
base.Given();
inActiveScreen = newScreen = Moq.Mock <IScreen>();
screenSubject = Moq.Mock <IScreenSubject>();
screenSubject.Setup(x => x.Matches(inActiveScreen)).Returns(true);
var someOtherScreen = Moq.Stub <IScreen>();
screenCollection.Setup(x => x.Active).Returns(someOtherScreen);
screenCollection.SetupGet(x => x.AllScreens).Returns(new[] { someOtherScreen, inActiveScreen });
}
public void ComputeHashTest()
{
int[][] perms = new[] { new[] { 1, 4, 8 }, new[] { 2, 3, 8 }, new[] { 7, 9, 0 } };
permutations.Setup(perm => perm.GetPermutations()).Returns(perms);
bool[] fingerprint = new[] { false, false, true, false, true, false, true, false, false, false };
byte[] hashed = minHashService.Hash(fingerprint);
Assert.AreEqual(1, hashed[0]);
Assert.AreEqual(0, hashed[1]);
Assert.AreEqual(255, hashed[2]);
}
public void SutYieldsInjectedElements()
{
var expected = new[]
{
new Mock<IReflectionElement>().Object,
new Mock<IReflectionElement>().Object,
new Mock<IReflectionElement>().Object
};
var sut = new CompositeReflectionElement(expected);
Assert.True(expected.SequenceEqual(sut));
Assert.True(
expected.Cast<object>().SequenceEqual(sut.OfType<object>()));
}
public void matches_when_all_subfilters_match()
{
var moduleFilters = new[]
{
CreateModuleFilter(true),
CreateModuleFilter(true),
CreateModuleFilter(true)
};
var compositeModuleFilter = new CompositeModuleFilter(moduleFilters);
Assert.IsTrue(compositeModuleFilter.Matches(_moduleInfo),
"Should have matched the module");
}
public void doesnt_match_when_any_subfilter_doesnt_match()
{
var moduleFilters = new[]
{
CreateModuleFilter(true),
CreateModuleFilter(false),
CreateModuleFilter(true)
};
var compositeModuleFilter = new CompositeModuleFilter(moduleFilters);
Assert.IsFalse(compositeModuleFilter.Matches(_moduleInfo),
"Shouldn't have matched the module");
}
public void ItProcessesQuery()
{
var query = new {};
var result = new {};
QueryProcessor.Setup(qp => qp.Processes(It.IsAny<object>())).Returns(true);
QueryProcessor.Setup(qp => qp.Process(It.IsAny<object>())).Returns(result);
var executor = new SubscriptionQueryExecutor();
executor.AddProcessors(QueryProcessor.Object);
Assert.Equal(result, executor.Execute(query));
QueryProcessor.Verify(qp => qp.Process(It.Is<object>(o => o.Equals(query))));
}
public void presenter_and_lunchorder_can_not_be_same_one()
{
var randomIndex = new[] {0, 0, 1};
randomNumberGenerator = new Mock<RandomNumberGenerator>(randomIndex.Length);
int index = 0;
randomNumberGenerator.Setup(o => o.Next()).Returns(() => randomIndex[index]).Callback(() => index++);
generator = new Generator();
generator.SetRandomGenerator(randomNumberGenerator.Object);
generator.AddPerson("A");
generator.AddPerson("B");
generator.AddPerson("C");
generator.Run();
Assert.AreEqual("A",generator.Presenter);
Assert.AreEqual("B",generator.LunchOrder);
}
public void CanGenerateOneDimensionArray()
{
int fixedValue = 9;
var factoryMock = new Mock<IFactory<int>>();
factoryMock.Setup(f => f.Generate()).Returns(fixedValue);
int[] dimension = new[] {5};
var arrayFactory = new ArrayFactory<int>(factoryMock.Object, dimension);
var result = (int[]) arrayFactory.Generate();
for (int i = 0; i < result.Length; i++)
{
Assert.Equal(fixedValue, result[i]);
}
}
internal static Mock<IMembershipService> GetInitialMembershipServiceMock()
{
var membershipServiceMock = new Mock<IMembershipService>();
var users = new[] {
new {
Name = Constants.ValidAdminUserName,
Password = Constants.ValidAdminPassword,
Roles = new[] { "Admin" }
},
new {
Name = Constants.ValidEmployeeUserName,
Password = Constants.ValidEmployeePassword,
Roles = new[] { "Employee" }
},
new {
Name = Constants.ValidAffiliateUserName,
Password = Constants.ValidAffiliatePassword,
Roles = new[] { "Affiliate" }
}
}.ToDictionary(
user => user.Name, user => user
);
membershipServiceMock.Setup(ms => ms.ValidateUser(
It.IsAny<string>(), It.IsAny<string>())
).Returns<string, string>(
(username, password) =>
{
var user = users.FirstOrDefault(x => x.Key.Equals(
username, StringComparison.OrdinalIgnoreCase)).Value;
var validUserContext = (user != null)
? new ValidUserContext
{
Principal = new GenericPrincipal(
new GenericIdentity(user.Name), user.Roles
)
} : new ValidUserContext();
return validUserContext;
}
);
return membershipServiceMock;
}
public WhenInitialisedWithReader()
{
var records = new[]
{
new TriangleFeedFullDataExtract {ProductName = "Comp", OriginYear = 1990, DevelopmentYear = 1990, Value = 110},
new TriangleFeedFullDataExtract {ProductName = "Comp", OriginYear = 1990, DevelopmentYear = 1991, Value = 220},
new TriangleFeedFullDataExtract {ProductName = "Non-Comp", OriginYear = 1990, DevelopmentYear = 1990, Value = 45.2},
new TriangleFeedFullDataExtract {ProductName = "Non-Comp", OriginYear = 1990, DevelopmentYear = 1991, Value = 90}
};
_mReader = new Mock<IReader<TriangleFeedFullDataExtract>>();
int readerNext = 0;
_mReader.Setup(reader => reader.Read()).Returns(() => readerNext < records.Length ? records[readerNext] : null).Callback(() => readerNext++);
_mReader.Setup(reader => reader.Peek()).Returns(() => readerNext < records.Length ? records[readerNext] : null);
_sut = BuildSUT();
}
public void IsValidShouldReturnFalseWhenAnyItemIsInvalid()
{
// arrange
var item1 = new Mock<ValidatableObject>();
var item2 = new Mock<ValidatableObject>();
item1.SetupGet( i => i.IsValid ).Returns( true );
item2.SetupGet( i => i.IsValid ).Returns( false );
var items = new[] { item1.Object, item2.Object };
// act
var valid = items.IsValid();
// assert
Assert.False( valid );
}
public void ValidateObjectWithPropertyNamesShouldNotAllowNullInstance()
{
// arrange
IComponent instance = null;
var propertyNames = new[] { "Site" };
var objectValidator = new ObjectValidator<IComponent>();
IObjectValidator<IComponent> validatorOfT = objectValidator;
IObjectValidator validator = objectValidator;
// act
var ex1 = Assert.Throws<ArgumentNullException>( () => validatorOfT.ValidateObject( instance, propertyNames ) );
var ex2 = Assert.Throws<ArgumentNullException>( () => validator.ValidateObject( instance, propertyNames ) );
// assert
Assert.Equal( "instance", ex1.ParamName );
Assert.Equal( "instance", ex2.ParamName );
}
public override void Given()
{
base.Given();
messageMap = New.MessageMap_v2("Change Order Attributes")
.Fields(x => x.Label("Ref.").Value("PO001"),
x => x.Label("Order Date").Value(new DateTime(2010, 1, 12))).Build();
var fieldV2s = messageMap.Fields.ToList();
fieldViewModelLocator = Moq.Mock <IFieldViewModelLocator>();
fieldViewModelLocator.Setup(x => x.GetViewModel(fieldV2s[0]))
.Returns((IField_v2 x) => new MessageValueFieldViewModel <string>(x));
fieldViewModelLocator.Setup(x => x.GetViewModel(fieldV2s[1]))
.Returns((IField_v2 x) => new MessageValueFieldViewModel <DateTime>(x));
}
public void IsValidShouldReturnTrueAllItemsAreValid()
{
// arrange
var item1 = new Mock<ValidatableObject>();
var item2 = new Mock<ValidatableObject>();
item1.SetupGet( i => i.IsValid ).Returns( true );
item2.SetupGet( i => i.IsValid ).Returns( true );
var items = new[] { item1.Object, item2.Object };
// act
var valid = items.IsValid();
// assert
Assert.True( valid );
}
public void CanPushToTargets()
{
var target1Mock = new Mock<Target>();
var target2Mock = new Mock<Target>();
var configuration = new PulsusConfiguration();
configuration.AddTarget("1", target1Mock.Object);
configuration.AddTarget("2", target2Mock.Object);
var eventDispatcher = new DefaultEventDispatcher(configuration);
var loggingEvent = new LoggingEvent { Text = "Event" };
var loggingEvents = new[] { loggingEvent };
eventDispatcher.Push(loggingEvents);
target1Mock.Verify(o => o.Push(loggingEvents));
target2Mock.Verify(o => o.Push(loggingEvents));
}
private static CommandFilterGrouping CreateTestableFilterGrouping()
{
var filters = new[]
{
new FilterInfo(new Mock<ICommandHandlerFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<ExceptionFilterAttribute>().Object, FilterScope.Global),
new FilterInfo(new Mock<IFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<ICommandHandlerFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<ExceptionFilterAttribute>().Object, FilterScope.Global),
new FilterInfo(new Mock<ICommandHandlerFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<IFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<ExceptionFilterAttribute>().Object, FilterScope.Global),
new FilterInfo(new Mock<ICommandHandlerFilter>().Object, FilterScope.Global),
new FilterInfo(new Mock<ExceptionFilterAttribute>().Object, FilterScope.Global),
new FilterInfo(new Mock<ExceptionFilterAttribute>().Object, FilterScope.Global)
};
CommandFilterGrouping group = new CommandFilterGrouping(filters);
return group;
}
public void RegistrarNovoInfectado()
{
var mockInfected = new Moq <IInfected>();
//Average
var infected = new InfectedDTO(
cpf: "123.456.789-00",
dataNascimento: 1997 - 06 - 03,
sexo: "M",
latitude: -25.2940369,
longitude: -54.0937847
);
//Act
var teste = mockInfected.AddInfected(infected);
//Assert
Assert.NotNull(teste);
Assert.True(teste);
}
public void NoExceptionsShouldBeThrown()
{
// three sets for three different threads
var nodes = new[] { CreateMockNodes(), CreateMockNodes(), CreateMockNodes() };
var roundRobin = new RoundRobinStrategy();
roundRobin.Initialise(nodes.SelectMany(n => n));
var results = new Exception[3];
Parallel.For(0, 3, i =>
{
results[i] = DoStuffWithNodes(roundRobin, CreateMockNodes());
});
foreach (var result in results)
{
Assert.IsNull(result);
}
}
public void ShouldUseCardDeserializerToReturnCards()
{
// Setup
var repository = GetInstance<CardRepository>();
var trelloGatewayMock = GetMock<ITrelloGateway>();
var parserMock = GetMock<IJsonParser>();
var cards = new[] { new Card(), new Card() };
trelloGatewayMock
.Setup(x => x.GetJsonData(It.IsAny<string>()))
.Returns("JSON-RESPONSE");
parserMock
.Setup(x => x.GetCards("JSON-RESPONSE"))
.Returns(cards);
// Exercise
var result = repository.GetCardsForBoard("BOARD-ID");
// Verify
Assert.That(result, Is.EqualTo(cards));
}
public override void Given()
{
base.Given();
messageMap = New.MessageMap_v2("Supplier")
.Fields(x => x.Label("Supplier Name")
.Value(new Supplier()
{
Name = "Elgar"
})
).Build();
var fieldV2s = messageMap.Fields.ToList();
var lookUpDataProvider = Moq.Mock <ILookUpDataProvider>();
lookUpDataProvider.Setup(x => x.GetLookupData <Supplier>())
.Returns(new[]
{
new Supplier()
{
Name = "Elgar"
},
new Supplier()
{
Name = "Supplier2"
},
new Supplier()
{
Name = "Supplier3"
}
});
fieldViewModelLocator = Moq.Mock <IFieldViewModelLocator>();
fieldViewModelLocator.Setup(x => x.GetViewModel(fieldV2s[0]))
.Returns((IField_v2 x) => new MessageReferenceFieldViewModel <Supplier>(x, lookUpDataProvider));
}
public With_Context()
{
partView = Moq.Mock <IEntityPartView>();
}
public override void Given()
{
screen = Moq.Mock <IScreen>();
screen.Moq().SetupGet(x => x.View).Returns(new object());
}
protected With_Empty_Screens()
{
mainRegion = Moq.Mock <IRegion>();
screenCollection = new ScreenCollection(mainRegion);
}
