public void CommandFactory_Should_ReturnAppropriateDefaultCommand([ValueSource(nameof(CommandSelectionSuccessful))] CommandFactoryFixture data) { // Arrange var commandMockArray = new Mock<ICommand<object>>[data.CommandNames.Length]; var expectedCommand = null as ICommand<object>; for (var i = 0; i < data.CommandNames.Length; ++i) { var name = data.CommandNames[i]; commandMockArray[i] = new Mock<ICommand<object>>(); commandMockArray[i].Setup(x => x.Name).Returns(name); if (name == data.NameOfDefaultCommand) { expectedCommand = commandMockArray[i].Object; } } var commandArrayMock = commandMockArray.Select(x => x.Object).ToArray(); var objectUnderTest = new CommandFactory<object>(commandArrayMock, data.NameOfDefaultCommand); // Act var command = objectUnderTest.GetCommand(null as string); // Assert Assert.AreEqual(expectedCommand, command); }
public void SetupCheckpoints(params CheckpointFixture[] checkpoints) { if (checkpoints.GroupBy(h => h.Height).Any(g => g.Count() > 1)) { throw new ArgumentException("Checkpoint heights must be unique."); } if (checkpoints.Any(h => h.Height < 0)) { throw new ArgumentException("Checkpoint heights cannot be negative."); } foreach (CheckpointFixture checkpoint in checkpoints.OrderBy(h => h.Height)) { var checkpointInfo = new CheckpointInfo(checkpoint.Header.GetHash()); this.checkpoints .Setup(c => c.GetCheckpoint(checkpoint.Height)) .Returns(checkpointInfo); } this.checkpoints .Setup(c => c.GetCheckpoint(It.IsNotIn(checkpoints.Select(h => h.Height)))) .Returns((CheckpointInfo)null); this.checkpoints .Setup(c => c.GetLastCheckpointHeight()) .Returns(checkpoints.OrderBy(h => h.Height).Last().Height); }
public async Task SaveAsync_ReturnItemsToTheModifiedList() { var mocks = new Mock <IModifiedEntity> [10]; for (var i = 0; i < mocks.Length; ++i) { mocks[i] = new Mock <IModifiedEntity>(); } // the first mock will cancel the execution mocks[0] .Setup(mock => mock.Save()) .Callback(() => _queue.Cancel()); await _queue.SaveAsync(mocks.Select(item => item.Object).ToList()); mocks[0].Verify(mock => mock.Save(), Times.Once); mocks[0].Verify(mock => mock.Return(), Times.Never); mocks[0].Verify(mock => mock.Revert(), Times.Never); for (var i = 1; i < mocks.Length; ++i) { var mock = mocks[i]; mock.Verify(it => it.Save(), Times.Never); mock.Verify(it => it.Return(), Times.Once); mock.Verify(it => it.Revert(), Times.Never); } }
public void CommandFactory_Should_AlwaysProvideValidSequenceOfCommands([ValueSource(nameof(CommandSelectionSuccessful))] CommandFactoryFixture data) { // Arrange var commandMockArray = new Mock<ICommand<object>>[data.CommandNames.Length]; for (var i = 0; i < data.CommandNames.Length; ++i) { var name = data.CommandNames[i]; commandMockArray[i] = new Mock<ICommand<object>>(); commandMockArray[i].Setup(x => x.Name).Returns(name); } var commandArrayMock = commandMockArray.Select(x => x.Object).ToArray(); var objectUnderTest = new CommandFactory<object>(commandArrayMock, data.NameOfDefaultCommand); // Act var commands = objectUnderTest.Commands; // Assert foreach (var command in commandArrayMock) { Assert.IsTrue(commands.Any(x => x == command)); } }
public void ReturnsListOfParsedIncidents() { var failingParser1 = CreateParser(false); var failingParser2 = CreateParser(false); var parsedIncident1 = new ParsedIncident(Incident, "one", ComponentStatus.Degraded); var successfulParser1 = CreateParser(true, parsedIncident1); var parsedIncident2 = new ParsedIncident(Incident, "two", ComponentStatus.Down); var successfulParser2 = CreateParser(true, parsedIncident2); var parsers = new Mock <IIncidentParser>[] { failingParser1, successfulParser1, successfulParser2, failingParser2 }; var aggregateParser = new AggregateIncidentParser( parsers.Select(p => p.Object), Mock.Of <ILogger <AggregateIncidentParser> >()); var result = aggregateParser.ParseIncident(Incident); foreach (var parser in parsers) { parser.Verify(); } Assert.Equal(2, result.Count()); Assert.Contains(parsedIncident1, result); Assert.Contains(parsedIncident2, result); }
public void ShouldExecuteAllTasksInOrder() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; int j = 0; for (int i = 0; i < commands.Length; ++i) { // I cannot reference 'i' inside Callback because it will have always value 3 inside callback. // It's always referencing the same thing inside callback. meh // I need to create local variable - oh gosh. int a = i; commands[i].Setup(x => x.Execute(robotMock.Object)).Callback(() => Assert.Equal(j++, a)); } programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.Start(); Thread.Sleep(1000); Assert.True(exec.IsCompleted); }
internal static IWebHookFilterManager CreateWebHookFilterManager(int providerCount) { Mock<IWebHookFilterProvider>[] providerMocks = new Mock<IWebHookFilterProvider>[providerCount]; for (int cnt = 0; cnt < providerMocks.Length; cnt++) { providerMocks[cnt] = CreateFilterProvider(cnt); } WebHookFilterManager manager = new WebHookFilterManager(providerMocks.Select(p => p.Object)); return manager; }
internal static IWebHookFilterManager CreateWebHookFilterManager(int providerCount) { Mock <IWebHookFilterProvider>[] providerMocks = new Mock <IWebHookFilterProvider> [providerCount]; for (int cnt = 0; cnt < providerMocks.Length; cnt++) { providerMocks[cnt] = CreateFilterProvider(cnt); } WebHookFilterManager manager = new WebHookFilterManager(providerMocks.Select(p => p.Object)); return(manager); }
internal static IWebHookFilterManager CreateWebHookFilterManager(int providerCount) { var providerMocks = new Mock <IWebHookFilterProvider> [providerCount]; for (var i = 0; i < providerMocks.Length; i++) { providerMocks[i] = CreateFilterProvider(i); } var manager = new WebHookFilterManager(providerMocks.Select(p => p.Object)); return(manager); }
internal void ThrowWhenNullIndexOutOfBounds( Mock<ParameterInfo>[] parameterMocks, SpecimenProvider sut) { // Arrange List<ParameterInfo> parameters = parameterMocks.Select(pm => pm.Object).ToList(); // Act/Assert string actualParamName = Assert.Throws<ArgumentException>( () => ((ISpecimenProvider)sut).GetParameterSpecimens(parameters, parameters.Count)) .ParamName; Assert.Equal("nullIndex", actualParamName); }
private Mock <IFeed>[] SetCountVisibleFeeds(int countFeeds) { var feeds = new Mock <IFeed> [countFeeds]; for (var i = 0; i < feeds.Length; ++i) { var feed = TestUtilities.CreateMockInstance <IFeed>(); feeds[i] = feed; } _FeedManager.SetupGet(r => r.VisibleFeeds).Returns(feeds.Select(r => r.Object).ToArray()); return(feeds); }
public void CannotStartSameExecutorTwice() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.Start(); Assert.Throws <RobotsException>(() => exec.Start()); }
public void CommandFactory_Should_ThrowArgumentOutOfRangeExceptionOnInvalidNameOfDefaultCommand([ValueSource(nameof(CommandSelectionInvalidNameOfDefaultCommand))] CommandFactoryFixture data) { // Arrange var commandMockArray = new Mock<ICommand<object>>[data.CommandNames.Length]; for (var i = 0; i < data.CommandNames.Length; ++i) { var name = data.CommandNames[i]; commandMockArray[i] = new Mock<ICommand<object>>(); commandMockArray[i].Setup(x => x.Name).Returns(name); } var commandArrayMock = commandMockArray.Select(x => x.Object).ToArray(); // Act Assert.Throws<ArgumentOutOfRangeException>(() => new CommandFactory<object>(commandArrayMock, data.NameOfDefaultCommand)); // Assert }
public void CommandFactory_Should_ThrowDuplicateNameExceptionWhenCommandsWithEqualNamesArePassed([ValueSource(nameof(CommandSelectionDuplicates))] CommandFactoryFixture data) { // Arrange var commandMockArray = new Mock <ICommand <object> > [data.CommandNames.Length]; for (var i = 0; i < data.CommandNames.Length; ++i) { var name = data.CommandNames[i]; commandMockArray[i] = new Mock <ICommand <object> >(); commandMockArray[i].Setup(x => x.Name).Returns(name); } var commandArrayMock = commandMockArray.Select(x => x.Object).ToArray(); // Act Assert.Throws <DuplicateNameException>(() => new CommandFactory <object>(commandArrayMock, data.NameOfDefaultCommand)); // Assert }
private Mock <IFeed>[] SetCountVisibleFeeds(int countFeeds) { var feeds = new Mock <IFeed> [countFeeds]; for (var i = 0; i < feeds.Length; ++i) { var feed = TestUtilities.CreateMockInstance <IFeed>(); feeds[i] = feed; var aircraftList = TestUtilities.CreateMockInstance <IBaseStationAircraftList>(); feed.SetupGet(r => r.AircraftList).Returns(aircraftList.Object); var snapshotList = new List <IAircraft>(new IAircraft[0]); long unused1, unused2; aircraftList.Setup(r => r.TakeSnapshot(out unused1, out unused2)).Returns(snapshotList); } _FeedManager.SetupGet(r => r.VisibleFeeds).Returns(feeds.Select(r => r.Object).ToArray()); return(feeds); }
public void ColumnToXmlContainsRowsToXmlResult() { XNode[] expected = new XNode[3]; Mock <IRow>[] mockRows = new Mock <IRow> [3]; Mock <IColumn>[] mockCols = new Mock <IColumn> [3]; for (int i = 0; i < 3; i++) { var mockedContent = $"mockedContent[{i}]"; expected[i] = new XElement($"Row", new XElement("Column", mockedContent)); mockCols[i] = new Mock <IColumn>(); mockCols[i].Setup(c => c.Content).Returns(new Union2 <IEnumerable <IRow>, object> .Case2(mockedContent)); mockRows[i] = new Mock <IRow>(); mockRows[i].Setup(r => r.Columns).Returns(new[] { mockCols[i].Object }); } Column sut = new Column(new Union2 <IEnumerable <IRow>, object> .Case1(mockRows.Select(mr => mr.Object).ToArray())); XElement actualXElement = (XElement)sut.ToXml(); IEnumerable <XElement> actual = actualXElement.Elements(); Assert.Equal(expected.Count(), actual.Count()); Assert.True(expected.Zip(actual, (e, a) => e.ToString() == a.ToString()).All(b => b)); }
public async Task SaveAsync_ReturnEntityToTheModifiedListInCaseOfAnException() { var mocks = new Mock <IModifiedEntity> [10]; for (var i = 0; i < mocks.Length; ++i) { mocks[i] = new Mock <IModifiedEntity>(); } mocks[0] .Setup(mock => mock.Save()) .Throws(new FileNotFoundException()); mocks[1] .Setup(mock => mock.Save()) .Throws(new IOException()); mocks[2] .Setup(mock => mock.Save()) .Throws(new UnauthorizedAccessException()); mocks[3] .Setup(mock => mock.Save()) .Throws(new SecurityException()); await _queue.SaveAsync(mocks.Select(item => item.Object).ToList()); for (var i = 0; i < 4; ++i) { mocks[i].Verify(mock => mock.Save(), Times.Once); mocks[i].Verify(mock => mock.Return(), Times.Once); mocks[i].Verify(mock => mock.Revert(), Times.Never); } for (var i = 4; i < mocks.Length; ++i) { mocks[i].Verify(mock => mock.Save(), Times.Once); mocks[i].Verify(mock => mock.Return(), Times.Never); mocks[i].Verify(mock => mock.Revert(), Times.Never); } }
public void ShouldTriggerProperEvents() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; int j = 0; for (int i = 0; i < commands.Length; ++i) { commands[i].Setup(x => x.Execute(robotMock.Object)).Callback(() => ++ j); } programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.CommandExecutionStart += (_, e) => Assert.Equal(commands[j].Object, e.Command); exec.CommandExecutionEnd += (_, e) => Assert.Equal(commands[j - 1].Object, e.Command); exec.ProgramExecutionEnd += (_, e) => Assert.Equal(commands.Length, j); }
public void CreateControllerWillReturnFirstControllerResultFromFactories( string controllerName, RequestContext requestContext, IController expectedResult, Mock<IControllerFactory>[] factoryStubs) { // Fixture Setup factoryStubs[0] .Setup(x => x.CreateController(requestContext, controllerName)) .Returns((IController)null); factoryStubs[1] .Setup(x => x.CreateController(requestContext, controllerName)) .Returns(expectedResult); factoryStubs[2] .Setup(x => x.CreateController(requestContext, controllerName)) .Returns((IController)null); var sut = new CompositeControllerFactory(factoryStubs.Select(x => x.Object)); // Exercise system var result = sut.CreateController(requestContext, controllerName); // Verify outcome Assert.Equal(expectedResult, result); // Teardown }
protected override ITarget[] CreateTargetsFromParameters(MethodInfo method) { TargetMocks = method.GetParameters().Select(p => new Mock<ITarget>()).ToArray(); return TargetMocks.Select(m => m.Object).ToArray(); }
public async void Deletes_Oldest_File_If_Exceeds_Limit() { var fileSystem = new Mock <IFileSystem>(MockBehavior.Strict); var fileLogger = new LinuxAppServiceFileLogger(LogFileName, LogDirectoryPath, fileSystem.Object, false); var dirBase = new Mock <DirectoryBase>(MockBehavior.Strict); var fileInfoFactory = new Mock <IFileInfoFactory>(MockBehavior.Strict); var fileInfoBase = new Mock <FileInfoBase>(MockBehavior.Strict); var fileBase = new Mock <FileBase>(MockBehavior.Strict); var directoryInfoFactory = new Mock <IDirectoryInfoFactory>(MockBehavior.Strict); var directoryInfoBase = new Mock <DirectoryInfoBase>(MockBehavior.Strict); fileSystem.SetupGet(fs => fs.Directory).Returns(dirBase.Object); dirBase.Setup(d => d.CreateDirectory(It.Is <string>(s => string.Equals(s, LogDirectoryPath)))); fileSystem.SetupGet(fs => fs.FileInfo).Returns(fileInfoFactory.Object); fileInfoFactory.Setup(f => f.FromFileName(It.Is <string>(s => MatchesLogFilePath(s)))) .Returns(fileInfoBase.Object); fileInfoBase.Setup(f => f.Exists).Returns(true); fileInfoBase.SetupGet(f => f.Length).Returns((fileLogger.MaxFileSizeMb * 1024 * 1024) + 1); fileSystem.SetupGet(fs => fs.File).Returns(fileBase.Object); fileBase.Setup(f => f.Move(It.Is <string>(s => MatchesLogFilePath(s)), It.IsAny <string>())); var fileCount = fileLogger.MaxFileCount + 1; var fileInfosMock = new Mock <FileInfoBase> [fileCount]; for (var i = 0; i < fileCount; i++) { fileInfosMock[i] = new Mock <FileInfoBase>(MockBehavior.Strict); } fileSystem.SetupGet(fs => fs.DirectoryInfo).Returns(directoryInfoFactory.Object); directoryInfoFactory.Setup(d => d.FromDirectoryName(It.Is <string>(s => string.Equals(s, LogDirectoryPath)))) .Returns(directoryInfoBase.Object); directoryInfoBase .Setup(d => d.GetFiles(It.Is <string>(s => s.StartsWith(LogFileName)), SearchOption.TopDirectoryOnly)) .Returns(fileInfosMock.Select(f => f.Object).ToArray); fileInfosMock[0].Setup(f => f.Delete()); fileLogger.Log("LogMessgae"); await fileLogger.InternalProcessLogQueue(); fileSystem.SetupGet(fs => fs.Directory).Returns(dirBase.Object); dirBase.Setup(d => d.CreateDirectory(It.Is <string>(s => string.Equals(s, LogDirectoryPath)))); fileSystem.SetupGet(fs => fs.FileInfo).Returns(fileInfoFactory.Object); fileInfoFactory.Setup(f => f.FromFileName(It.Is <string>(s => MatchesLogFilePath(s)))) .Returns(fileInfoBase.Object); fileInfoBase.Setup(f => f.Exists).Returns(true); fileInfoBase.SetupGet(f => f.Length).Returns((fileLogger.MaxFileSizeMb * 1024 * 1024) + 1); fileSystem.SetupGet(fs => fs.File).Returns(fileBase.Object); fileBase.Setup(f => f.Move(It.Is <string>(s => MatchesLogFilePath(s)), It.IsAny <string>())); fileSystem.SetupGet(fs => fs.DirectoryInfo).Returns(directoryInfoFactory.Object); directoryInfoFactory.Setup(d => d.FromDirectoryName(It.Is <string>(s => string.Equals(s, LogDirectoryPath)))) .Returns(directoryInfoBase.Object); directoryInfoBase .Setup(d => d.GetFiles(It.Is <string>(s => s.StartsWith(LogFileName)), SearchOption.TopDirectoryOnly)) .Returns(fileInfosMock.Select(f => f.Object).ToArray); fileInfosMock[0].Setup(f => f.Delete()); }
public DefaultHttpControllerTypeResolverTracerTest() { ExpectedTypes = new List<Type> { typeof(ValidController), typeof(UsersRpcController), typeof(UsersController), }; Type[] fine1Types = new Type[] { typeof(DefaultHttpControllerTypeResolverTracerTest), null, typeof(ValidController), }; Type[] poorTypes = new Type[] { typeof(string), null, typeof(Action), null, typeof(UsersRpcController), }; Type[] fine2Types = new Type[] { typeof(DefaultHttpControllerTypeResolver), null, typeof(DefaultHttpControllerTypeResolverTracer), null, typeof(UsersController) }; Exception worseException = new Exception(ExceptionMessage); Exception poorException = new ReflectionTypeLoadException(poorTypes, new Exception[] { worseException }); ExpectedTraces = new List<TraceRecord> { new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug) { Kind = TraceKind.Begin, Operator = "DefaultHttpControllerTypeResolverProxy", // Moq type name Operation = "GetControllerTypes", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.Trace, Exception = poorException, Message = "Exception thrown while getting types from 'PoorAssembly'.", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.Trace, Exception = worseException, Message = "Exception thrown while getting types from 'WorseAssembly'.", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug) { Kind = TraceKind.End, Operator = "DefaultHttpControllerTypeResolverProxy", Operation = "GetControllerTypes", }, }; Mock<MockableAssembly> fine1Assembly = new Mock<MockableAssembly>(MockBehavior.Strict); fine1Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine1Types); fine1Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); Exception[] exceptions = new Exception[] { new Exception(ExceptionMessage), }; Mock<MockableAssembly> poorAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); poorAssembly.Setup(assembly => assembly.GetTypes()).Throws(poorException); poorAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); poorAssembly.SetupGet(assembly => assembly.FullName).Returns("PoorAssembly"); Mock<MockableAssembly> worseAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); worseAssembly.Setup(assembly => assembly.GetTypes()).Throws(worseException); worseAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); worseAssembly.SetupGet(assembly => assembly.FullName).Returns("WorseAssembly"); Mock<MockableAssembly> fine2Assembly = new Mock<MockableAssembly>(MockBehavior.Strict); fine2Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine2Types); fine2Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); Mock<MockableAssembly> dynamicAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); dynamicAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(true); Assemblies = new Mock<MockableAssembly>[] { fine1Assembly, poorAssembly, worseAssembly, fine2Assembly, dynamicAssembly, }; AssembliesResolver = new Mock<IAssembliesResolver>(MockBehavior.Strict); AssembliesResolver.Setup(resolver => resolver.GetAssemblies()).Returns( Assemblies.Select(assembly => (Assembly)assembly.Object).AsCollection()); HttpControllerTypeResolver = new Mock<DefaultHttpControllerTypeResolver>() { CallBase = true, }; }
private void InitMocks(int numArrayElements) { mockBindingsFactory = new Mock<IBindingsFactory>(); testArray = Enumerable.Range(0, numArrayElements) .Select(i => new TestClass()) .ToArray(); mockArrayItemBindings = Enumerable.Range(0, numArrayElements) .Select(i => { var mockBinding = new Mock<IArrayItemBinding>(); mockBinding .Setup(m => m.ItemIndex) .Returns(i); return mockBinding; }) .ToArray(); mockBindingsFactory .Setup(m => m.CreateArrayBindings(testArray)) .Returns(mockArrayItemBindings.Select(m => m.Object).ToArray()); }
public async Task ExportAsync_WhenRedditLinkIsWithImages_AssertUrlWasCalledOnFirstRedditImageInRedditImageCollection() { IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut(); Mock <IRedditImage>[] redditImageMockCollection = new Mock <IRedditImage>[] { BuildRedditImageMock(new Uri($"http://localhost/{Guid.NewGuid().ToString("D")}/{Guid.NewGuid().ToString("D")}")), BuildRedditImageMock(new Uri($"http://localhost/{Guid.NewGuid().ToString("D")}/{Guid.NewGuid().ToString("D")}")), BuildRedditImageMock(new Uri($"http://localhost/{Guid.NewGuid().ToString("D")}/{Guid.NewGuid().ToString("D")}")) }; Mock <IRedditLink> redditLinkMock = BuildRedditLinkMock(redditImageCollection: redditImageMockCollection.Select(redditLinkMock => redditLinkMock.Object).ToArray()); await sut.ExportAsync(redditLinkMock.Object); redditImageMockCollection[0].Verify(m => m.Url, Times.Exactly(2)); redditImageMockCollection[1].Verify(m => m.Url, Times.Never); redditImageMockCollection[2].Verify(m => m.Url, Times.Never); }
public void SetupGetAllDevices(Mock<ITelldusDevice>[] telldusDevices) { TelldusCoreMock.Setup(m => m.GetAllDevices()).Returns(telldusDevices.Select(d => d.Object).ToArray()); }