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); }
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(); }
public void LooseNoCall() { var myMock = new Mock<IEnumerable<int>>(MockBehavior.Loose); myMock .Setup(a => a.ToString()) .Returns("Hello"); myMock.Reset(); myMock.VerifyAll(); }
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); }
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); }
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))); }
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); }
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(); }
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); }
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); }
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)); }
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); }
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); }
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); }
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); }
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(); }
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(); }
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); }
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); }
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); }
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)); }
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(); }
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));
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(); }
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"); }
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(); }
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(); }