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);
        }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        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);
            }
Esempio n. 6
0
        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;
 }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
        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);
        }
Esempio n. 11
0
        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);
        }
Esempio n. 12
0
        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
        }
Esempio n. 15
0
        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));
        }
Esempio n. 17
0
        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);
            }
        }
Esempio n. 18
0
        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();
 }
Esempio n. 21
0
        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());
        }
Esempio n. 24
0
        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());
 }