Esempio n. 1
1
        public void SetupDoesNotApplyAfterMockWasReset()
        {
            var mock = new Mock<IFooReset>();
            mock.Setup(foo => foo.Execute("ping")).Returns("ack");
            mock.Reset();

            var result = mock.Object.Execute("ping");
            Assert.Null(result);
        }
Esempio n. 2
0
        public void CalculateFrequencyTest()
        {
            var view = new Mock<IMainGameView>();

            var controller = new MainGameController(view.Object);
            controller.LoadKeysResources(TestKeyFileResource);

            view.Setup(x => x.PlaySound(It.Is<int>(f => f == 110), 100));
            controller.ProcessKey(Keys.Q); //key#0
            view.VerifyAll();

            view.Reset();
            view.Setup(x => x.PlaySound(It.Is<int>(f => f == 117), 100));
            controller.ProcessKey(Keys.W); //key#0
            view.VerifyAll();

            view.Reset();
            view.Setup(x => x.PlaySound(It.Is<int>(f => f == 175), 100));
            controller.ProcessKey(Keys.O); //key#8
            view.VerifyAll();

            view.Reset();
            view.Setup(x => x.PlaySound(It.Is<int>(f => f == 185), 100));
            controller.ProcessKey(Keys.P); //key#9
            view.VerifyAll();
        }
Esempio n. 3
0
 public void LooseNoCall()
 {
     var myMock = new Mock<IEnumerable<int>>(MockBehavior.Loose);
     myMock
         .Setup(a => a.ToString())
         .Returns("Hello");
     myMock.Reset();
     myMock.VerifyAll();
 }
Esempio n. 4
0
 public void Strict()
 {
     var myMock = new Mock<IEnumerable<int>>(MockBehavior.Strict);
     myMock
         .Setup(a => a.ToString())
         .Returns("Hello");
     myMock.Reset();
     Assert.NotEqual("Hello", myMock.Object.ToString());
     myMock.VerifyAll();
 }
        public void SetupSuspensionManager()
        {
            _plugin = new Mock<IAdapterPlugin>();

            var state = new StateManager(new Mock<ISettings>().Object, _plugin.Object);
            state.ClearState(_fixtureId);
            state.ClearState(TestHelper.GetFixtureFromResource("rugbydata_snapshot_2").Id);

            _settings = new Mock<ISettings>();
            _settings.Reset();
            _settings.Setup(x => x.ProcessingLockTimeOutInSecs).Returns(10);
        }
Esempio n. 6
0
        public void Startup_MustAutoStartBrowser()
        {
            settings.Browser.EnableBrowser = true;
            browser.SetupGet(b => b.AutoStart).Returns(true);

            sut.TryStart();

            browser.Verify(b => b.Start(), Times.Once);
            browser.Reset();
            browser.SetupGet(b => b.AutoStart).Returns(false);

            sut.TryStart();

            browser.Verify(b => b.Start(), Times.Never);
        }
Esempio n. 7
0
        public void DrawingContext_PropagatesUpdates_WithOffset()
        {
            var listener = new Mock <IDrawingContextListener>();
            var control  = new Mock <IControl>();

            var drawingContext = new DrawingContext(listener.Object, control.Object);

            drawingContext.SetLimits(new Size(10, 10), new Size(10, 10));
            drawingContext.SetOffset(new Vector(2, 2));

            listener.Reset();
            drawingContext.Update(control.Object, new Rect(1, 1, 5, 5));

            listener.Verify(l => l.OnUpdate(drawingContext, new Rect(3, 3, 5, 5)));
        }
Esempio n. 8
0
        public void SetUp()
        {
            networkControllerMock.Reset();
            unityInputProxyMock.Reset();
            unityPhysicsProxyMock.Reset();
            movementCommandMock.Reset();
            rotationCommandMock.Reset();

            controller = new LocalMovementController(unityInputProxyMock.Object, networkControllerMock.Object,
                                                     rotationCommandMock.Object, movementCommandMock.Object, unityPhysicsProxyMock.Object,
                                                     unityDebugProxyMock.Object);
            controller.SetLocalPlayer(fakeLocalPlayer);
            controller.SetSpeed(30F);
            controller.SetRotationSpeed(40F);
        }
Esempio n. 9
0
        public void Pwm_Channel_Should_Start_And_Stop_When_Starting_And_Stopping_Servo()
        {
            Mock <PwmChannel> mockPwmChannel = new Mock <PwmChannel>();
            ServoMotor        servo          = new ServoMotor(mockPwmChannel.Object);

            servo.Start();
            mockPwmChannel.Verify(channel => channel.Start());
            mockPwmChannel.VerifyNoOtherCalls();

            mockPwmChannel.Reset();

            servo.Stop();
            mockPwmChannel.Verify(channel => channel.Stop());
            mockPwmChannel.VerifyNoOtherCalls();
        }
Esempio n. 10
0
        public void SetUp()
        {
            unityGameObjectProxyMock.Reset();
            unityTimeProxyMock.Reset();
            gameStateMock.Reset();
            fakePlayerInstance = GameObjectBuilder.New()
                                 .WithPositionAndRotation(Vector3.zero, Quaternion.identity)
                                 .WithRigidbody()
                                 .Build();

            controller = new RemoteMovementController(unityGameObjectProxyMock.Object);
            controller.SetState(gameStateMock.Object);

            unityGameObjectProxyMock.Setup(x => x.Find(It.IsAny <string>())).Returns(fakePlayerInstance);
        }
Esempio n. 11
0
        public void ApplyChanges_ForInnerInjectionDetector_InvokesNotifyChanges()
        {
            // Arrange
            var detectorMock = new Mock <IInjectionDetector>();
            var sut          = GetSut(injectionDetector: detectorMock.Object);

            detectorMock.Reset();
            var testObj = sut.Object;

            // Act
            sut.ApplyChanges(obj => obj.TestInt = 5);

            // Assert
            detectorMock.Verify(detector => detector.NotifyChanges(It.Is <TestObject>(t => t == testObj)),
                                Times.Once);
        }
Esempio n. 12
0
        public void CanDeleteLastStepInRecording()
        {
            Manipulator.SetPosition(50, 100, 150);
            Manipulator.RecordStep();
            Manipulator.SetPosition(3, 400, 50);
            Manipulator.RecordStep();

            MockPresenter.Reset();
            MockController.Reset();

            Manipulator.DeleteLastStep();

            Manipulator.PlayBackSteps();
            AssertPositionIs(50, 100, 150);
            MockPresenter.Verify(r => r.NumberOfStepsInRecordingChanged(1));
        }
Esempio n. 13
0
        public void EnsureFileExists_NotCreatedIfExists()
        {
            // Arrange
            var fileMock    = new Mock <IFile>();
            var testSubject = new UserSettingsProvider(new TestLogger(), fileMock.Object, CreateMockFileMonitor("c:\\subDir1\\existingFile.txt").Object);

            fileMock.Reset();
            fileMock.Setup(x => x.Exists("c:\\subDir1\\existingFile.txt")).Returns(true);

            // Act
            testSubject.EnsureFileExists();

            // Assert
            fileMock.Verify(x => x.Exists("c:\\subDir1\\existingFile.txt"), Times.Once);
            fileMock.Verify(x => x.WriteAllText(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
        }
        public void Repeat_MustEstablishConnectionIfNotConnected()
        {
            PerformNormally();

            service.Reset();
            service.SetupGet(s => s.IsConnected).Returns(false);
            service.Setup(s => s.Connect(null, true)).Returns(true).Callback(() => service.SetupGet(s => s.IsConnected).Returns(true));
            service.Setup(s => s.StartSession(It.IsAny <ServiceConfiguration>())).Returns(new CommunicationResult(true)).Callback(() => serviceEvent.Set());

            var result = sut.Repeat();

            service.Verify(s => s.Connect(It.IsAny <Guid?>(), It.IsAny <bool>()), Times.Once);
            service.Verify(s => s.StopSession(It.IsAny <Guid>()), Times.Never);

            Assert.AreEqual(OperationResult.Success, result);
        }
Esempio n. 15
0
        private DateTime AssertPeriodLengthAfter(DateTime time, TimeSpan after, TimeSpan expectedLength)
        {
            Mock.Reset();

            time = time + after;

            SetLastInputTick(1);
            SetCurrentTime(time);

            Mock.Arrange(() => activityListenerMock.PeriodPassed(Arg.IsAny <ActivityPeriod>())).
            DoInstead((ActivityPeriod p) => Console.WriteLine("Actual " + p.Length + " expected " + expectedLength));

            activityCheckerSut.Check();
            AssertPassedPeriodLength(expectedLength);
            return(time);
        }
Esempio n. 16
0
        public void TestarResgateSomenteValorPositivo_Erro()
        {
            List <ItemValidacao> retorno = new List <ItemValidacao>();

            retorno.Add(new ItemValidacao()
            {
                NomePropriedade = "Valor",
                Mensagem        = "Não é possível realizar a operação com valor informado!"
            });

            var validacoes = ValidacaoResgatarFake(resgateValorNegativo);

            validacoes.Should().BeEquivalentTo(retorno, "A validação de somente valor positivo de ERRO falhou.");

            mock.Reset();
            mockContaCorrente.Reset();
            mockService.Reset();
        }
        public void Decorator_BeginEventWithParams_Called()
        {
            string eventName    = "blah";
            string functionName = "blah";
            string data         = "moreBlah";

            _metricsLogger.Setup(a => a.BeginEvent(eventName, functionName, data));
            _metricsLoggerDecorator.BeginEvent(eventName, functionName, data);
            _metricsLogger.Verify(a => a.BeginEvent(eventName, functionName, data), Times.Once());
            _metricsLogger.Reset();
        }
        public async Task GetGetItemsTest()
        {
            //Arrange
            _mockItemSetupManager.Reset();
            _mockItemSetupManager.Setup(b => b.GetMedicationItems())
            .ReturnsAsync(new List <MedicationItemList>());

            //Act
            var result = await _subject.GetItems();

            var okResult = result as OkObjectResult;

            //Assert
            _mockFormularyManager.Verify();
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);
        }
Esempio n. 19
0
        public void DrawingContext_UpdatesOldRect_AfterOffsetChage()
        {
            var listener = new Mock <IDrawingContextListener>();
            var control  = new Mock <IControl>();

            control.SetupGet(c => c.Size).Returns(new Size(5, 5));

            var drawingContext = new DrawingContext(listener.Object, control.Object);

            drawingContext.SetLimits(new Size(10, 10), new Size(10, 10));
            drawingContext.SetOffset(new Vector(2, 2));

            listener.Reset();
            drawingContext.SetOffset(new Vector(4, 4));

            listener.Verify(l => l.OnUpdate(drawingContext, new Rect(2, 2, 5, 5)));
        }
        public void Repeat_MustCorrectlySwitchFromDisableExplorerShellToCreateNewDesktop()
        {
            var newDesktop      = new Mock <IDesktop>();
            var originalDesktop = new Mock <IDesktop>();
            var order           = 0;
            var activate        = 0;
            var current         = 0;
            var restore         = 0;
            var start           = 0;
            var startupDesktop  = 0;

            nextSettings.Security.KioskMode = KioskMode.DisableExplorerShell;

            sut.Perform();

            desktopFactory.Reset();
            desktopFactory.Setup(f => f.GetCurrent()).Returns(originalDesktop.Object).Callback(() => current = ++order);
            desktopFactory.Setup(f => f.CreateNew(It.IsAny <string>())).Returns(newDesktop.Object);
            explorerShell.Reset();
            explorerShell.Setup(s => s.RestoreAllWindows()).Callback(() => restore = ++order);
            explorerShell.Setup(s => s.Start()).Callback(() => start = ++order);
            newDesktop.Reset();
            newDesktop.Setup(d => d.Activate()).Callback(() => activate = ++order);
            originalDesktop.Reset();
            processFactory.Reset();
            processFactory.SetupSet(f => f.StartupDesktop = It.Is <IDesktop>(d => d == newDesktop.Object)).Callback(() => startupDesktop = ++order);
            nextSettings.Security.KioskMode = KioskMode.CreateNewDesktop;

            var result = sut.Repeat();

            desktopFactory.Verify(f => f.GetCurrent(), Times.Once);
            desktopFactory.Verify(f => f.CreateNew(It.IsAny <string>()), Times.Once);
            explorerShell.Verify(s => s.RestoreAllWindows(), Times.Once);
            explorerShell.Verify(s => s.Start(), Times.Once);
            explorerShell.VerifyNoOtherCalls();
            newDesktop.Verify(d => d.Activate(), Times.Once);
            originalDesktop.VerifyNoOtherCalls();
            processFactory.VerifySet(f => f.StartupDesktop = It.Is <IDesktop>(d => d == newDesktop.Object), Times.Once);

            Assert.AreEqual(OperationResult.Success, result);
            Assert.AreEqual(1, start);
            Assert.AreEqual(2, restore);
            Assert.AreEqual(3, current);
            Assert.AreEqual(4, activate);
            Assert.AreEqual(5, startupDesktop);
        }
Esempio n. 21
0
        public void SetSelectedIssue_SelectionChanged_SelectionServiceIsCalled(bool isSelectedNull)
        {
            var selectionService = new Mock <IIssueSelectionService>();
            var testSubject      = CreateTestSubject(selectionService: selectionService.Object);

            var oldSelection = isSelectedNull ? new TaintIssueViewModel(Mock.Of <IAnalysisIssueVisualization>()) : null;
            var newSelection = isSelectedNull ? null : new TaintIssueViewModel(Mock.Of <IAnalysisIssueVisualization>());

            testSubject.SelectedIssue = oldSelection;

            selectionService.Reset();

            testSubject.SelectedIssue = newSelection;

            selectionService.VerifySet(x => x.SelectedIssue = newSelection?.TaintIssueViz, Times.Once);
            selectionService.VerifyNoOtherCalls();
        }
Esempio n. 22
0
 private void Reset()
 {
     _data.Reset();
     _datasetMapper.Reset();
     _browseCubeMapper.Reset();
     _attributeMapper.Reset();
     _taskMapper.Reset();
     _querier.Reset();
     _graphService.Reset();
     _treeBuilder.Reset();
     _arMapper.Reset();
     _processor.Reset();
     _discretizator.Reset();
     _validations.Reset();
     _handler.Reset();
     _builder.Reset();
 }
Esempio n. 23
0
        public async Task Disable_LogBotToUser()
        {
            var dialog = Chain.PostToChain().Select(m => m.Text).PostToUser().Loop();

            var mock = new Mock <IActivityLogger>(MockBehavior.Strict);

            mock
            .Setup(l => l.LogAsync(It.IsAny <IActivity>()))
            .Returns(Task.CompletedTask);

            using (var container = Build(Options.ResolveDialogFromContainer))
                using (var containerScope = container.BeginLifetimeScope(
                           builder =>
                {
                    builder.RegisterInstance(dialog).As <IDialog <object> >();
                    builder.RegisterInstance(mock.Object).As <IActivityLogger>();
                }))
                {
                    var text = "hello";

                    await AssertScriptAsync(
                        containerScope,
                        text,
                        text);

                    mock.VerifyAll();

                    using (var disablingScope = containerScope.BeginLifetimeScope(
                               builder =>
                    {
                        Conversation.Disable(typeof(LogBotToUser), builder);
                        Conversation.Disable(typeof(LogPostToBot), builder);
                    }))
                    {
                        mock.Reset();

                        await AssertScriptAsync(
                            disablingScope,
                            text,
                            text);

                        mock.VerifyAll();
                    }
                }
        }
            public async Task GetsResults_WhenIsINode()
            {
                const string identifier             = "foo";
                const string expectedStringProperty = "string";

                var mockSession     = new Mock <IAsyncSession>();
                var mockTransaction = new Mock <IAsyncTransaction>();
                var mockCursor      = new Mock <IResultCursor>();
                var mockRecord      = new Mock <IRecord>();
                var mockNode        = new Mock <INode>();

                mockNode.Setup(x => x.Properties).Returns(new Dictionary <string, object>
                {
                    { nameof(Foo.StringProperty), expectedStringProperty }
                });

                mockRecord.Setup(x => x.Keys).Returns(new List <string> {
                    identifier
                });
                mockRecord.Setup(x => x[identifier]).Returns(mockNode.Object);

                mockCursor.Setup(x => x.FetchAsync()).Returns(Task.FromResult(true))
                .Callback(() =>
                {
                    mockCursor.Reset();
                    mockCursor.Setup(x => x.Current).Returns(mockRecord.Object);
                    mockCursor.Setup(x => x.FetchAsync()).Returns(Task.FromResult(false));
                });

                mockTransaction
                .Setup(x => x.RunAsync(It.IsAny <string>(), It.IsAny <object>()))
                .Returns(Task.FromResult(mockCursor.Object));

                List <Foo> callBackResponse = null;

                mockSession
                .Setup(x => x.ReadTransactionAsync(It.IsAny <Func <IAsyncTransaction, Task <List <Foo> > > >()))
                .Callback(async(Func <IAsyncTransaction, Task <List <Foo> > > func) => callBackResponse = await func(mockTransaction.Object));

                await mockSession.Object.RunReadTransactionForObjects <Foo>("Query", null, identifier);

                callBackResponse.Should().NotBeNull();
                callBackResponse.Should().HaveCount(1);
                callBackResponse[0].StringProperty.Should().Be(expectedStringProperty);
            }
Esempio n. 25
0
        public void Control_Updates_RedrawsIfSizeChanged()
        {
            var context = new Mock <IDrawingContext>();

            context.SetupGet(c => c.MinSize).Returns(new Size(20, 20));
            context.SetupGet(c => c.MaxSize).Returns(new Size(40, 40));

            var control = new Mock <TestControl>();

            (control.Object as IControl).Context = context.Object;
            control.Object.Resize(new Size(30, 30));
            context.Reset();

            control.Object.Resize(new Size(35, 35));

            context.Verify(c => c.Redraw(control.Object));
            context.Verify(c => c.Update(control.Object, It.Ref <Rect> .IsAny), Times.Never);
        }
Esempio n. 26
0
        public void GoToBookmark_NoFile(string fileName)
        {
            var service = GetService();

            service.SetBookmark(1);

            _shellStatusBarServiceMock.Reset();
            _shellSelectionServiceMock.Reset();
            _shellSelectionServiceMock.Setup(s => s.GetActiveFileName()).Returns(fileName).Verifiable();

            var result = service.GoToBookmark(1);

            Assert.That(result, Is.False);
            _shellSelectionServiceMock.Verify(s => s.GetActiveFileName());
            _shellSelectionServiceMock.Verify(s => s.GetActiveFilePosition(), Times.Never);
            _shellSelectionServiceMock.Verify(s => s.SetActiveFilePosition(It.IsAny <int>(), It.IsAny <int>()), Times.Never);
            _shellStatusBarServiceMock.Verify(s => s.SetStatusBarText(It.IsNotNull <string>()), Times.Never);
        }
Esempio n. 27
0
        public void HasServerIssues_IssuesChanged_RaisesPropertyChanged()
        {
            var store       = new Mock <ITaintStore>();
            var testSubject = CreateTestSubject(store: store);

            var eventHandler = new Mock <PropertyChangedEventHandler>();

            testSubject.PropertyChanged += eventHandler.Object;

            RaiseStoreIssuesChangedEvent(store, Mock.Of <IAnalysisIssueVisualization>());

            VerifyPropertyChangedWasRaised(eventHandler, nameof(testSubject.HasServerIssues));
            eventHandler.Reset();

            RaiseStoreIssuesChangedEvent(store);

            VerifyPropertyChangedWasRaised(eventHandler, nameof(testSubject.HasServerIssues));
        }
Esempio n. 28
0
        public void CommandResultNotEmpty()
        {
            _botClientMock.Reset();

            var message = new Message
            {
                Text = "123",
                Chat = new Chat {
                    Id = 123
                }
            };

            _botClientMock.Setup(t => t.SendTextMessageAsync(message.Chat.Id, It.IsAny <string>(), It.IsAny <ParseMode>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <IReplyMarkup>(), It.IsAny <CancellationToken>()));
            bool result = _command.ExecuteAsync(_botClientMock.Object, message).Result;

            Assert.True(result);
            _botClientMock.Verify();
        }
Esempio n. 29
0
        public async Task CanLoadAuthorizations()
        {
            var order = new Order
            {
                Authorizations = new[]
                {
                    new Uri("http://acme.d/acct/1/authz/1"),
                    new Uri("http://acme.d/acct/1/authz/2"),
                }
            };

            var expectedPayload = new JwsSigner(Helper.GetKeyV2())
                                  .Sign("", null, location, "nonce");

            contextMock.Reset();
            httpClientMock.Reset();

            contextMock
            .Setup(c => c.GetDirectory())
            .ReturnsAsync(Helper.MockDirectoryV2);
            contextMock
            .SetupGet(c => c.AccountKey)
            .Returns(Helper.GetKeyV2());
            contextMock
            .SetupGet(c => c.BadNonceRetryCount)
            .Returns(1);
            contextMock.SetupGet(c => c.HttpClient).Returns(httpClientMock.Object);
            contextMock
            .Setup(c => c.Sign(It.IsAny <object>(), It.IsAny <Uri>()))
            .Callback((object payload, Uri loc) =>
            {
                Assert.Null(payload);
                Assert.Equal(location, loc);
            })
            .ReturnsAsync(expectedPayload);
            httpClientMock
            .Setup(m => m.Post <Order>(location, It.IsAny <JwsPayload>()))
            .Callback((Uri _, object o) =>
            {
                var p = (JwsPayload)o;
                Assert.Equal(expectedPayload.Payload, p.Payload);
                Assert.Equal(expectedPayload.Protected, p.Protected);
            })
            .ReturnsAsync(new AcmeHttpResponse <Order>(location, order, default, default));
Esempio n. 30
0
        public void BeginScopeIDependencyScopeHasProviderScope()
        {
            ServiceProviderMock.Setup(provider => provider.GetService(ServiceScopeFactoryType)).Returns(ServiceScopeFactoryMock.Object);
            ServiceScopeFactoryMock.Setup(factory => factory.CreateScope()).Returns(ServiceScopeMock.Object);
            ServiceScopeMock.Setup(scope => scope.ServiceProvider).Returns(ServiceProviderMock.Object);
            var scopedDependencyResolver = DependencyResolver.BeginScope();

            scopedDependencyResolver.GetService(ServiceType);
            ServiceProviderMock.Verify(provider => provider.GetService(ServiceScopeFactoryType), Times.Once);
            ServiceProviderMock.Verify(provider => provider.GetService(ServiceType), Times.Once);
            ServiceProviderMock.VerifyNoOtherCalls();
            ServiceProviderMock.Reset();
            ServiceScopeFactoryMock.Verify(factory => factory.CreateScope(), Times.Once);
            ServiceScopeFactoryMock.VerifyNoOtherCalls();
            ServiceScopeFactoryMock.Reset();
            ServiceScopeMock.Verify(scope => scope.ServiceProvider, Times.Once);
            ServiceScopeMock.VerifyNoOtherCalls();
            ServiceScopeMock.Reset();
        }
Esempio n. 31
0
        public void OnTagsChanged_HasSubscribersToSuggestedActionsChanged_RaisesSuggestedActionsChanged()
        {
            var selectedIssueLocationsTagAggregator = new Mock <ITagAggregator <ISelectedIssueLocationTag> >();
            var issueLocationsTagAggregator         = new Mock <ITagAggregator <IIssueLocationTag> >();

            var eventHandler = new Mock <EventHandler <EventArgs> >();

            var testSubject = CreateTestSubject(selectedIssueLocationsTagAggregator.Object, issueLocationsTagAggregator.Object);

            testSubject.SuggestedActionsChanged += eventHandler.Object;

            selectedIssueLocationsTagAggregator.Raise(x => x.TagsChanged += null, new TagsChangedEventArgs(Mock.Of <IMappingSpan>()));
            eventHandler.Verify(x => x(It.IsAny <object>(), It.IsAny <EventArgs>()), Times.Once);

            eventHandler.Reset();

            issueLocationsTagAggregator.Raise(x => x.TagsChanged += null, new TagsChangedEventArgs(Mock.Of <IMappingSpan>()));
            eventHandler.Verify(x => x(It.IsAny <object>(), It.IsAny <EventArgs>()), Times.Once);
        }
        public void Revert_MustCorrectlyRevertCreateNewDesktop()
        {
            var newDesktop      = new Mock <IDesktop>();
            var originalDesktop = new Mock <IDesktop>();
            var order           = 0;
            var activate        = 0;
            var setStartup      = 0;
            var stopMonitor     = 0;
            var close           = 0;

            currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
            nextSettings.Security.KioskMode    = KioskMode.CreateNewDesktop;
            desktopFactory.Setup(f => f.GetCurrent()).Returns(originalDesktop.Object);
            desktopFactory.Setup(f => f.CreateNew(It.IsAny <string>())).Returns(newDesktop.Object);

            var performResult = sut.Perform();

            Assert.AreEqual(OperationResult.Success, performResult);

            desktopFactory.Reset();
            desktopMonitor.Setup(m => m.Stop()).Callback(() => stopMonitor = ++order);
            explorerShell.Reset();
            originalDesktop.Reset();
            originalDesktop.Setup(d => d.Activate()).Callback(() => activate = ++order);
            processFactory.SetupSet(f => f.StartupDesktop = It.Is <IDesktop>(d => d == originalDesktop.Object)).Callback(() => setStartup = ++order);
            newDesktop.Reset();
            newDesktop.Setup(d => d.Close()).Callback(() => close = ++order);

            var revertResult = sut.Revert();

            desktopFactory.VerifyNoOtherCalls();
            explorerShell.VerifyNoOtherCalls();
            originalDesktop.Verify(d => d.Activate(), Times.Once);
            processFactory.VerifySet(f => f.StartupDesktop = originalDesktop.Object, Times.Once);
            newDesktop.Verify(d => d.Close(), Times.Once);

            Assert.AreEqual(OperationResult.Success, performResult);
            Assert.AreEqual(OperationResult.Success, revertResult);
            Assert.AreEqual(1, stopMonitor);
            Assert.AreEqual(2, activate);
            Assert.AreEqual(3, setStartup);
            Assert.AreEqual(4, close);
        }
        private void SetupChannelHandlerContext(bool allowFlush)
        {
            _ctx.Reset();

            _ctx.Setup(x => x.NewPromise()).Returns(_promise.Object);
            _ctx.Setup(x => x.NewPromise(It.IsAny <object>())).Returns(_promise.Object);
            if (allowFlush)
            {
                _ctx.Setup(x => x.Flush()).Returns(() =>
                {
                    return(_ctx.Object);
                });
            }
            else
            {
                _ctx.Setup(x => x.Flush()).Throws(new Exception("forbidden"));
            }
            _ctx.Setup(x => x.Executor).Returns(_executor.Object);
        }
        public void DisplayText_UsesCachedIssueRuleKey()
        {
            var selectedIssueMock = new Mock <IAnalysisIssueVisualization>();

            selectedIssueMock.Setup(x => x.RuleId).Returns("test rule id");

            var selectionServiceMock = new Mock <IIssueSelectionService>();

            selectionServiceMock.SetupGet(x => x.SelectedIssue).Returns(selectedIssueMock.Object);

            var testSubject = new DeselectIssueVisualizationAction(selectionServiceMock.Object);

            testSubject.DisplayText.Should().Contain("test rule id");

            selectionServiceMock.Reset();
            selectionServiceMock.SetupGet(x => x.SelectedIssue).Returns((IAnalysisIssueVisualization)null);

            testSubject.DisplayText.Should().Contain("test rule id");
        }
Esempio n. 35
0
        public void IndexTest()
        {
            mockSkillService.Setup(service => service.GetAll()).Returns(this.skills);
            mockProjectService.Setup(service => service.GetFiltered(It.IsAny <string>(), null)).Returns(this.projects);

            var controller = new PostsController(mockProjectService.Object, mockSkillService.Object);

            controller.ControllerContext = this.controllerContext;
            var result     = controller.Index("Java");
            var viewResult = Assert.IsType <ViewResult>(result);

            Assert.IsAssignableFrom <Project[]>(viewResult.ViewData.Model);

            result     = controller.Index("");
            viewResult = Assert.IsType <ViewResult>(result);
            Assert.IsAssignableFrom <Project[]>(viewResult.ViewData.Model);


            mockSkillService.Reset();
            mockProjectService.Reset();
        }
        public void ExecuteMethodCancelIsCalledWhenElementIsAlreadyExecuting()
        {
            var mockInPortMgr = new Mock<IInputPortMgr>();
            var mockOutPortMgr = new Mock<IOutputPortMgr>();
            var mockFx = new Mock<IIdentNodeCoresFx>();

            using (RecordExpectations recorder = RecorderManager.StartRecording())
            {
                recorder.ExpectAndReturn(_element.Status, ElementStatus.Executing).RepeatAlways();
                recorder.ExpectAndReturn(_element.InPortMgr, mockInPortMgr).RepeatAlways();
                recorder.ExpectAndReturn(mockInPortMgr.PortStatuses, null).RepeatAlways();
                recorder.ExpectAndReturn(_element.OutPortMgr, mockOutPortMgr).RepeatAlways();
                recorder.ExpectAndReturn(mockOutPortMgr.PortStatuses, null).RepeatAlways();
                recorder.ExpectAndReturn(_element.Fx, mockFx).RepeatAlways();
                mockOutPortMgr.Reset();
                mockFx.Reset();

                _element.Cancel();
            }

            _element.Execute();
            MockManager.Verify();
        }
Esempio n. 37
0
        public void Reset_MethodCallsBagToResetAllItems()
        {
            var mockBag = new Mock<IParamBag>();
            ISetParamBag setter = _mgr as ISetParamBag;

            using (RecordExpectations recorder = RecorderManager.StartRecording())
            {
                recorder.DefaultBehavior.Strict = StrictFlags.ArbitraryMethodsAllowed;
                recorder.ExpectAndReturn(_mgr.Bag, mockBag);
                mockBag.Reset();
            }

            setter.SetBag(mockBag);
            _mgr.Reset();
            MockManager.Verify();
        }