public void AllowMatchersForArgs() { var mock = new Mock<FooBase>(); mock.Protected() .Setup<string>("StringArg", ItExpr.IsNull<string>()) .Returns("null"); Assert.Equal("null", mock.Object.DoStringArg(null)); mock.Protected() .Setup<string>("StringArg", ItExpr.Is<string>(s => s == "bar")) .Returns("baz"); Assert.Equal("baz", mock.Object.DoStringArg("bar")); mock = new Mock<FooBase>(); mock.Protected() .Setup<string>("StringArg", ItExpr.Is<string>(s => s.Length >= 2)) .Returns("long"); mock.Protected() .Setup<string>("StringArg", ItExpr.Is<string>(s => s.Length < 2)) .Returns("short"); Assert.Equal("short", mock.Object.DoStringArg("f")); Assert.Equal("long", mock.Object.DoStringArg("foo")); mock = new Mock<FooBase>(); mock.CallBase = true; mock.Protected() .Setup<string>("TwoArgs", ItExpr.IsAny<string>(), 5) .Returns("done"); Assert.Equal("done", mock.Object.DoTwoArgs("foobar", 5)); Assert.Equal("echo", mock.Object.DoTwoArgs("echo", 15)); mock = new Mock<FooBase>(); mock.CallBase = true; mock.Protected() .Setup<string>("TwoArgs", ItExpr.IsAny<string>(), ItExpr.IsInRange(1, 3, Range.Inclusive)) .Returns("inrange"); Assert.Equal("inrange", mock.Object.DoTwoArgs("foobar", 2)); Assert.Equal("echo", mock.Object.DoTwoArgs("echo", 4)); }
public void InitMethodMustCallProtectedInit() { var presenter = new Mock<PresenterBase<object>>(MockBehavior.Strict); presenter.Protected().Setup("Init"); presenter.Object.Init(new object()); presenter.Protected().Verify("Init", Times.Once()); }
public void HttpRouteCollection_Dispose_UniquifiesHandlers() { // Arrange var collection = new HttpRouteCollection(); var handler1 = new Mock<HttpMessageHandler>(); handler1.Protected().Setup("Dispose", true).Verifiable(); var handler2 = new Mock<HttpMessageHandler>(); handler1.Protected().Setup("Dispose", true).Verifiable(); var route1 = new Mock<IHttpRoute>(); route1.SetupGet(r => r.Handler).Returns(handler1.Object); var route2 = new Mock<IHttpRoute>(); route2.SetupGet(r => r.Handler).Returns(handler1.Object); var route3 = new Mock<IHttpRoute>(); route3.SetupGet(r => r.Handler).Returns(handler2.Object); collection.Add("route1", route1.Object); collection.Add("route2", route2.Object); collection.Add("route3", route3.Object); // Act collection.Dispose(); // Assert handler1.Protected().Verify("Dispose", Times.Once(), true); handler2.Protected().Verify("Dispose", Times.Once(), true); }
public void Can_Execute_FFmpegComd() { // Arrange var ffmpegCmdMock = new Mock<FFmpegCommand>(); ffmpegCmdMock.Protected().Setup("manipulateWithProcess", ItExpr.IsAny<Process>()); string output = null; string error = null; ffmpegCmdMock.Protected() .Setup("processResult", ItExpr.IsAny<string>(), ItExpr.IsAny<string>()) .Callback((string o, string e) => { output = o; error = e; }); FFmpegCommand ffmpegCmd = ffmpegCmdMock.Object; // Act ffmpegCmd.Execute(); // Assert ffmpegCmdMock.Protected().Verify("manipulateWithProcess", Times.Once(), ItExpr.IsAny<Process>()); ffmpegCmdMock.Protected().Verify("processResult", Times.Once(), ItExpr.IsAny<string>(), ItExpr.IsAny<string>()); Assert.IsNotNull(output); Assert.IsTrue(output.Contains("built on")); Console.WriteLine("Output: "); Console.Write(Enumerable.Repeat("-", 20).Aggregate((sum, element) => sum + element) + Environment.NewLine); Console.WriteLine(output); Assert.IsNotNull(error); Console.WriteLine("Error: "); Console.Write(Enumerable.Repeat("-", 20).Aggregate((sum, element) => sum + element) + Environment.NewLine); Console.WriteLine(error); }
public void TryConvertTest() { Mock<BaseFromStreamConverter<int>> target = new Mock<BaseFromStreamConverter<int>>(); target.Protected().Setup<bool>("CheckParameter", ItExpr.IsAny<string>()).Returns(true); target.Protected().Setup<int>("GetObject", ItExpr.IsAny<string>()).Returns(1); Assert.AreEqual<int>(1, target.Object.TryConvert("0000")); }
public void TryConvertThrowsPlcException4Test() { Mock<BaseFromStreamConverter<int>> target = new Mock<BaseFromStreamConverter<int>>(); target.Protected().Setup<bool>("CheckParameter", ItExpr.IsAny<string>()).Returns(true); target.Protected().Setup<int>("GetObject", ItExpr.IsAny<string>()).Throws(new PlcException()); target.Object.TryConvert("0000"); }
public void TryConvertThrowsPlcException5Test() { Mock<BaseToStreamConverter<int>> target = new Mock<BaseToStreamConverter<int>>(); target.Protected().Setup<bool>("CheckParameter", ItExpr.IsAny<int>()).Returns(true); target.Protected().Setup<int>("GetLength", ItExpr.IsAny<int>()).Returns(1); target.Protected().Setup<string>("GetStream", ItExpr.IsAny<int>()).Throws(new PlcException()); target.Object.TryConvert(0); }
public void Command_line_is_added_after_ini_file_to_configuration() { var mock = new Mock<Program>() { CallBase = true }; mock.Protected() .Setup<IConfigurationSourceContainer>("CreateConfiguration") .Returns( () => { var configurationMock = new Mock<IConfigurationSourceContainer>(); var callCount = 0; configurationMock .Setup(m => m.Add(It.IsAny<IConfigurationSource>())) .Callback<IConfigurationSource>( s => { if (s is IniFileConfigurationSource) { Assert.Equal(0, callCount); } else { Assert.True(s is CommandLineConfigurationSource); Assert.Equal(1, callCount); } callCount++; }); return configurationMock.Object; }); mock.Protected() .Setup<MigrationTool>("CreateMigrationTool") .Returns( () => { var toolMock = new Mock<MigrationTool>() { CallBase = true }; toolMock.Setup(m => m.CreateMigration(It.IsAny<IConfigurationSourceContainer>())); return toolMock.Object; }); var args = new[] { "--ConfigFile=MyConfigFile.ini", "--MigrationName=MyMigration" }; mock.Object.CreateMigration(args); mock.Protected().Verify<MigrationTool>("CreateMigrationTool", Times.Once()); mock.Protected().Verify<IConfigurationSourceContainer>("CreateConfiguration", Times.Once()); }
public void TryConvertTest() { Mock<BaseToStreamConverter<int>> target = new Mock<BaseToStreamConverter<int>>(); target.Protected().Setup<bool>("CheckParameter", ItExpr.IsAny<int>()).Returns(true); target.Protected().Setup<int>("GetLength", ItExpr.IsAny<int>()).Returns(1); target.Protected().Setup<string>("GetStream", ItExpr.IsAny<int>()).Returns("0000"); PlcWriteStream result = target.Object.TryConvert(0); Assert.AreEqual<int>(1, result.Length); Assert.AreEqual<string>("0000", result.Stream); }
public void should_call_protected_method() { var mock = new Mock<OneClass>(); mock.Protected().Setup("OneProtectedMethod").Callback(() => Console.WriteLine("Goodbye")); var o = new OneClass(); o.DoMethod(); mock.Protected().Verify("OneProtectedMethod", Times.Once()); }
private BusinessConfiguratorFactory CreateBusinessConfiguratorFactory() { m_configuratorMock = new Mock<BusinessConfigurator>(); var configurators = new List<Tuple<CrmPluginEvent, BusinessConfigurator>>() { new Tuple<CrmPluginEvent, BusinessConfigurator>(TestPluginEvent, m_configuratorMock.Object) }; var factoryMock = new Mock<BusinessConfiguratorFactory> { CallBase = true }; factoryMock.Protected().Setup<List<Tuple<CrmPluginEvent, BusinessConfigurator>>>("CreateConfiguratorEntries") .Returns(configurators); factoryMock.Protected().Setup<string>("GetFactoryName").Returns(TestFactoryName); return factoryMock.Object; }
public void AuthenticateWithInvalidImplementation() { var syncManagerMock = new Mock<SyncManager>(authenticatorMock.Object); syncManagerMock .Protected() .Setup("OnException", ItExpr.IsAny<AuthenticatedTicket>(), ItExpr.IsAny<Exception>()); syncManagerMock.CallBase = true; syncManagerMock.Object.Authenticate("user", "password"); syncManagerMock .Protected() .Verify("OnException", Times.Once(), ItExpr.Is<AuthenticatedTicket>(m => m == null), ItExpr.Is<Exception>(m => m.Message == "GetAuthenticationFromLogin must return a ticket.")); }
public void TestAppendTableData() { var tableDesc = new Mock<TableDataDesc>(It.IsAny<Table>()); tableDesc.Protected().Setup<IEnumerable<string>>("GetSmoTableDataScript", ItExpr.IsAny<Table>()) .Returns(Resources.TableScript.Split(Environment.NewLine.ToCharArray())); tableDesc.Protected().Setup<IEnumerable<string>>("GetSmoTablePrimaryColumns", ItExpr.IsAny<Table>()) .Returns(new string[] { }); tableDesc.CallBase = true; var builder = new TableScriptBuilder(); builder.Append(tableDesc.Object); var script = builder.GetScript(); Trace.WriteLine(script); Assert.AreEqual(Resources.MergeTableScript, script); }
public void HandleQuestion_ShouldUseTheInjectedStateService() { // Arrange var question = _fixture.Create<IThermometerQuestion>(); var stateService = _fixture.Create<IStateService>(); var sut = new Mock<StateServiceBaseHandler>(stateService) {CallBase = true}; sut.Protected().Setup("HandleQuestion", question, stateService); var func = sut.Object.Handler; var result = func(question); sut.Protected().Verify("HandleQuestion", Times.Once(), question, stateService); }
public void ExecuteSql_dispatches_to_interceptors() { var mockCommand = new Mock<DbCommand>(); mockCommand.Setup(m => m.ExecuteNonQuery()).Returns(2013); var mockConnection = new Mock<DbConnection>(); mockConnection.Protected().Setup<DbCommand>("CreateDbCommand").Returns(mockCommand.Object); var mockTransaction = new Mock<DbTransaction>(MockBehavior.Strict); mockTransaction.Protected().Setup<DbConnection>("DbConnection").Returns(mockConnection.Object); var migrator = new DbMigrator(); var statement = new MigrationStatement { Sql = "Some Sql" }; var providerFactoryServiceMock = new Mock<IDbProviderFactoryResolver>(); providerFactoryServiceMock.Setup(m => m.ResolveProviderFactory(It.IsAny<DbConnection>())) .Returns(FakeSqlProviderFactory.Instance); MutableResolver.AddResolver<IDbProviderFactoryResolver>(k => providerFactoryServiceMock.Object); var mockInterceptor = new Mock<DbCommandInterceptor> { CallBase = true }; DbInterception.Add(mockInterceptor.Object); var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { new MigratorLoggingDecorator(migrator, new Mock<MigrationsLogger>().Object) .ExecuteSql(mockTransaction.Object, statement, new DbInterceptionContext()); } finally { MutableResolver.ClearResolvers(); DbInterception.Remove(mockInterceptor.Object); DbInterception.Remove(transactionInterceptorMock.Object); } mockInterceptor.Verify(m => m.NonQueryExecuting(mockCommand.Object, It.IsAny<DbCommandInterceptionContext<int>>()), Times.Once()); mockInterceptor.Verify(m => m.NonQueryExecuted(mockCommand.Object, It.IsAny<DbCommandInterceptionContext<int>>()), Times.Once()); transactionInterceptorMock.Verify( m => m.ConnectionGetting(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Exactly(2)); transactionInterceptorMock.Verify( m => m.ConnectionGot(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Exactly(2)); mockTransaction.Protected().Verify<DbConnection>("DbConnection", Times.Exactly(2)); }
public void CustomerQueryWithPreviousIterator() { var authenticatedTicket = new AuthenticatedTicket { Ticket = Guid.NewGuid().ToString(), CurrentStep = "step4" }; var iteratorID = "123456"; var iteratorKey = StepQueryWithIterator<CustomerQueryRqType, CustomerQueryRsType>.IteratorKey; var updateCustomerMock = new Mock<StepQueryWithIterator<CustomerQueryRqType, CustomerQueryRsType>>(); updateCustomerMock .Protected() .Setup<string>("RetrieveMessage", ItExpr.Is<string>(s => s == authenticatedTicket.Ticket), ItExpr.Is<string>(s => s == authenticatedTicket.CurrentStep), ItExpr.Is<string>(s => s == iteratorKey)) .Returns(iteratorID); updateCustomerMock.CallBase = true; var xml = updateCustomerMock.Object.SendXML(authenticatedTicket); XmlDocument requestXmlDoc = new XmlDocument(); requestXmlDoc.LoadXml(xml); var node = requestXmlDoc.SelectSingleNode("//CustomerQueryRq"); Assert.IsNotNull(node); Assert.AreEqual("Continue", node.Attributes.GetNamedItem("iterator").Value); Assert.AreEqual(iteratorID, node.Attributes.GetNamedItem("iteratorID").Value); }
public static Mock<ModelItem> CreateModelItem(Guid uniqueID, Guid serviceID, Guid environmentID, params ModelProperty[] modelProperties) { var startIndex = 0; if (modelProperties == null) { modelProperties = new ModelProperty[3]; } else { startIndex = modelProperties.Length; Array.Resize(ref modelProperties, startIndex + 3); } modelProperties[startIndex++] = CreateModelProperty("UniqueID", uniqueID.ToString()).Object; modelProperties[startIndex++] = CreateModelProperty("ResourceID", serviceID).Object; modelProperties[startIndex] = CreateModelProperty("EnvironmentID", new InArgument<Guid>(environmentID)).Object; var properties = new Mock<ModelPropertyCollection>(); foreach (var modelProperty in modelProperties) { properties.Protected().Setup<ModelProperty>("Find", modelProperty.Name, true).Returns(modelProperty); } var modelItem = new Mock<ModelItem>(); modelItem.Setup(mi => mi.Properties).Returns(properties.Object); modelItem.Setup(mi => mi.ItemType).Returns(typeof(DsfActivity)); return modelItem; }
public void AppExceptionHandlerHandleWithExceptionWhileHandlingExpectedShutdownCalled() { //Initialize var e = GetException(); var mockHandler = new Mock<AppExceptionHandlerAbstract>(); // DON'T SETUP CreatePopupController to force secondary exception mockHandler.Protected().Setup("ShutdownApp").Verifiable(); //Execute mockHandler.Object.Handle(e); //Assert mockHandler.Protected().Verify("ShutdownApp", Times.Once()); }
public void Validate_SetsMemberName_OnValidationContext_ForProperties( ModelMetadata metadata, object container, object model, string expectedMemberName) { // Arrange var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Callback((object o, ValidationContext context) => { Assert.Equal(expectedMemberName, context.MemberName); }) .Returns(ValidationResult.Success) .Verifiable(); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var results = validator.Validate(validationContext); // Assert Assert.Empty(results); attribute.VerifyAll(); }
public async Task Calls_children_unprovision_in_correct_order() { var seq = String.Empty; var p1 = new Mock<HarshProvisioner>(); var p2 = new Mock<HarshProvisioner>(); p1.Protected() .Setup<Task>("OnUnprovisioningAsync") .Returns(HarshTask.Completed) .Callback(() => seq += "1"); p2.Protected() .Setup<Task>("OnUnprovisioningAsync") .Returns(HarshTask.Completed) .Callback(() => seq += "2"); var ctx = Context.AllowDeleteUserData(); var composite = new HarshProvisioner() { Children = { p1.Object, p2.Object } }; await composite.UnprovisionAsync(ctx); Assert.Equal("21", seq); }
public void TestBlocksPropertySearch() { Mock<TaskExpressionTranslatorBase> mock = new Mock<TaskExpressionTranslatorBase> { CallBase = true }; mock.Setup(m => m.Execute()).Returns(new List<Task>()); Mock<TaskQueryContext> ctxMock = new Mock<TaskQueryContext> { CallBase = true }; ctxMock.Protected().Setup<TaskExpressionTranslatorBase>("InstantiateTranslator").Returns(mock.Object); QuerableTaskService tasks = new QuerableTaskService(ctxMock.Object); var t = from task in tasks where (task.ActualOwner == new IdentityId().GetIdentity()||task.ActualOwner==new IdentityId().GetIdentity()) || (task.Subject!="Test" && task.Name=="TestName") && (task.Priority==Priority.High||task.Priority==Priority.Normal||task.Name.StartsWith("A")) select task; foreach (Task task in t) { //execute the query } }
public void Verify_CloseArtifact_removes_artifact_from_model_manager() { var artifactUri = new Uri("c:\\artifact.edmx"); var mockModelManager = new Mock<ModelManager>(null, null) { CallBase = true }; var mockArtifact = new Mock<EFArtifact>(mockModelManager.Object, artifactUri, new Mock<XmlModelProvider>().Object); mockArtifact.Setup(a => a.Uri).Returns(artifactUri); mockModelManager .Setup(m => m.GetNewOrExistingArtifact(artifactUri, It.IsAny<XmlModelProvider>())) .Returns(mockArtifact.Object); mockModelManager .Setup(m => m.GetArtifact(artifactUri)) .Returns(mockArtifact.Object); var mockPackage = new Mock<IXmlDesignerPackage>(); mockPackage.Setup(p => p.ModelManager).Returns(mockModelManager.Object); var mockEditingContextMgr = new Mock<EditingContextManager>(mockPackage.Object) { CallBase = true }; mockEditingContextMgr .Protected() .Setup<EFArtifact>("GetNewOrExistingArtifact", artifactUri) .Returns(mockArtifact.Object); var editingContext = mockEditingContextMgr.Object.GetNewOrExistingContext(artifactUri); Assert.NotNull(editingContext.GetEFArtifactService()); mockEditingContextMgr.Object.CloseArtifact(artifactUri); mockModelManager.Verify(m => m.ClearArtifact(artifactUri), Times.Once()); Assert.Null(editingContext.GetEFArtifactService()); }
public void CanPostLargeMessage() { var messageTail = new string('A', ushort.MaxValue); var encodedMessage = string.Empty; var response = new HttpResponseMessage(HttpStatusCode.Accepted); var mockHttpHandler = new Mock<HttpMessageHandler>(); mockHttpHandler.Protected() .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>()) .Callback<HttpRequestMessage, CancellationToken>((r, t) => encodedMessage = r.Content.ReadAsStringAsync().Result) .Returns(Task.FromResult(response)); var mockHttpClient = new Mock<DefaultHttpClient> {CallBase = true}; mockHttpClient.Protected() .Setup<HttpMessageHandler>("CreateHandler") .Returns(mockHttpHandler.Object); var httpClient = mockHttpClient.Object; httpClient.Initialize(Mock.Of<IConnection>()); var postData = new Dictionary<string, string> { { "data", " ," + messageTail } }; httpClient.Post("http://fake.url", r => { }, postData, isLongRunning: false); Assert.Equal("data=+%2c" + messageTail, encodedMessage); }
public void WhenCreateCalculatorAndAddSomeOperatorWecanUseIt() { var parser = new Mock<Parser>(); parser.Protected().Setup<OperatorCollection>("DefaultConfiguration").Returns(new OperatorCollection()); var calculator = new Calculator(parser.Object, x => x.Add(Operator.Create<FakeOperation>("+", Priority.Low)));//var calculator = new Calculator(_parser).Configure(x => x.Add(op)); Assert.IsTrue(calculator.Operators.Count() > 0); }
public void ProcessRequestRemovesOptionalParametersFromRouteValueDictionary() { // Arrange Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>(); contextMock.ExpectMvcVersionResponseHeader(); RouteData rd = new RouteData(); rd.Values.Add("controller", "foo"); rd.Values.Add("optional", UrlParameter.Optional); RequestContext requestContext = new RequestContext(contextMock.Object, rd); MvcHandler mvcHandler = new MvcHandler(requestContext); Mock<ControllerBase> controllerMock = new Mock<ControllerBase>(); controllerMock.Protected().Setup("Execute", requestContext).Verifiable(); ControllerBuilder cb = new ControllerBuilder(); Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>(); controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object); controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object)); cb.SetControllerFactory(controllerFactoryMock.Object); mvcHandler.ControllerBuilder = cb; // Act mvcHandler.ProcessRequest(contextMock.Object); // Assert controllerMock.Verify(); Assert.IsFalse(rd.Values.ContainsKey("optional"), "Optional value should have been removed."); }
public void AppExceptionHandlerHandleWithOneExceptionExpectedHandledAndAppNotRestarted() { //Initialize var e = GetException(); var mockHandler = new Mock<AppExceptionHandlerAbstract>(); var popupController = new Mock<IAppExceptionPopupController>(); mockHandler.Protected().Setup<IAppExceptionPopupController>("CreatePopupController").Returns(popupController.Object); mockHandler.Protected().Setup("RestartApp").Verifiable(); //Execute var actual = mockHandler.Object.Handle(e); //Assert mockHandler.Protected().Verify("RestartApp", Times.Never()); Assert.IsTrue(actual, "AppExceptionHandlerAbstract failed to handle valid exception"); }
public void ProcessRequestAddsServerHeaderCallsExecute() { // Arrange Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>(); contextMock.ExpectMvcVersionResponseHeader().Verifiable(); RouteData rd = new RouteData(); rd.Values.Add("controller", "foo"); RequestContext requestContext = new RequestContext(contextMock.Object, rd); MvcHandler mvcHandler = new MvcHandler(requestContext); Mock<ControllerBase> controllerMock = new Mock<ControllerBase>(); controllerMock.Protected().Setup("Execute", requestContext).Verifiable(); ControllerBuilder cb = new ControllerBuilder(); Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>(); controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object); controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object)); cb.SetControllerFactory(controllerFactoryMock.Object); mvcHandler.ControllerBuilder = cb; // Act mvcHandler.ProcessRequest(contextMock.Object); // Assert contextMock.Verify(); controllerMock.Verify(); }
public void CustomerNameFormatter_From_Remove_Underscore_From_Full_Name() { //Arrange var mocked = new Mock<CustomerNameFormatter>(); mocked.Protected() .Setup<string>("RemoveUnderScoreFrom", ItExpr.IsAny<string>()) .Returns("mohamed") .Verifiable(); //Act mocked.Object.From(new Customer("mohamed", "ahmed")); //Assert mocked.Protected().Verify<string>("RemoveUnderScoreFrom", Times.Exactly(2),ItExpr.IsAny<string>()); }
public void AuthenticateAuthError() { var reporterMock = new Mock<IntelReporter>(MockBehavior.Loose) { CallBase = true }; reporterMock.Protected() .Setup<IntelSession>("GetSession", ItExpr.IsAny<bool>()) .Throws<AuthenticationException>(); TestHelpers.CreateRequestMock(serviceUri, "500 ERROR AUTH"); TestHelpers.CreateRequestMock(channelListUri, channelBody); using (var testDir = new TempDirectory()) { using (var reporter = reporterMock.Object) { reporter.Path = testDir.FullName; reporter.ServiceUri = serviceUri; reporter.ChannelListUri = channelListUri; reporter.Start(); Thread.Sleep(100); Assert.AreEqual(IntelStatus.AuthenticationError, reporter.Status); reporter.Authenticate("username", "password"); Thread.Sleep(100); } } }
public void TestReadMonoSamplesFromFile() { Mock<WaveStream> waveStream = new Mock<WaveStream>(MockBehavior.Strict); naudioFactory.Setup(factory => factory.GetStream("path-to-audio-file")).Returns(waveStream.Object); const int Mono = 1; WaveFormat waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(SampleRate, Mono); waveStream.Setup(stream => stream.WaveFormat).Returns(waveFormat); waveStream.Setup(stream => stream.Close()); const int StartAt = 20; waveStream.Setup(stream => stream.Seek(SampleRate * waveFormat.BitsPerSample / 8 * StartAt, SeekOrigin.Begin)) .Returns(440960); Mock<MediaFoundationTransform> resampler = new Mock<MediaFoundationTransform>( MockBehavior.Strict, new object[] { waveStream.Object, waveFormat }); resampler.Protected().Setup("Dispose", new object[] { true }); naudioFactory.Setup(factory => factory.GetResampler(waveStream.Object, SampleRate, Mono)).Returns(resampler.Object); float[] samplesArray = TestUtilities.GenerateRandomFloatArray(1024); const int SecondsToRead = 10; samplesAggregator.Setup( agg => agg.ReadSamplesFromSource(It.IsAny<NAudioSamplesProviderAdapter>(), SecondsToRead, SampleRate)).Returns( samplesArray); var result = sourceReader.ReadMonoFromSource("path-to-audio-file", SampleRate, SecondsToRead, StartAt); Assert.AreSame(samplesArray, result); }
private ConverterSvc GetMockBitcoinConverterService() { var handlerMock = new Mock <HttpMessageHandler>(); var response = new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent(MOCK_RESPONSE_JSON), }; handlerMock .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(response); var httpClient = new HttpClient(handlerMock.Object); var converter = new ConverterSvc(httpClient); return(converter); }
public async Task TimerFlush_CalledOnExpectedInterval() { int flushInterval = 10; Mock <IEventGenerator> mockGenerator = new Mock <IEventGenerator>(); Mock <MetricsEventManager> mockEventManager = new Mock <MetricsEventManager>(_settingsManager, mockGenerator.Object, flushInterval, flushInterval) { CallBase = true }; MetricsEventManager eventManager = mockEventManager.Object; int numFlushes = 0; mockEventManager.Protected().Setup("TimerFlush", ItExpr.IsAny <object>()) .Callback <object>((state) => { numFlushes++; }); // here we're just verifying that we're called multiple times await TestHelpers.Await(() => numFlushes >= 5, timeout : 2000, pollingInterval : 100, userMessageCallback : () => $"Expected numFlushes >= 5; Actual: {numFlushes}"); mockEventManager.VerifyAll(); }
public void TestIsCalledWhenActionIsNavigationAndSuccessful() { var page = new Mock <IPage>(MockBehavior.Strict); var pageMapper = new Mock <IPageMapper>(MockBehavior.Strict); var logger = new Mock <ILogger>(); var browser = new Mock <IBrowser>(MockBehavior.Strict); var action = new PageNavigationAction(browser.Object, logger.Object, pageMapper.Object); var context = new PageNavigationAction.PageNavigationActionContext("testproperty", PageNavigationAction.PageAction.NavigateToPage); var postAction = new Mock <NavigationPostAction>(MockBehavior.Strict); postAction.Protected().Setup("OnPageNavigate", page.Object, PageNavigationAction.PageAction.NavigateToPage, ItExpr.IsNull <Dictionary <string, string> >()); var result = ActionResult.Successful(page.Object); postAction.Object.PerformPostAction(action, context, result); postAction.VerifyAll(); pageMapper.VerifyAll(); browser.VerifyAll(); page.VerifyAll(); }
public void MoqTestProtected() { Robot robot; // Now that you've implemented the RandomDamage class test the Robot again // TODO // create Mock for RandomDamage // Assign new Robot to robot variable, and provide Mock.Object as a parameter to the constructor. // Setup proper protected function respond (use Moq.Protected) var Mock = new Mock <RandomDamage>(); robot = new Robot(Mock.Object); Mock.Protected() .Setup <int>("damageRand") .Returns(7); // You can't make any changes below this line. // ----------------------------------------------- Assert.AreEqual(7, robot.Damage()); }
public async Task ThrowsOnUnexpectedException() { // Arrange var target = new Mock <ModbusTransport>(new Mock <IPipeResource>().Object, Mock.Of <IModbusLogger>(), Mock.Of <ITransactionIdProvider>()) { CallBase = true }; var exception = new Exception(); target.Object.Retries = 2; target.SetupThrowsWriteRequestAsync(exception); // Act var ex = await Assert.ThrowsAnyAsync <Exception>(() => target.Object.SendAsync <ReadHoldingRegistersResponse>( new ReadHoldingRegistersRequest(1, 1, 1))); // Assert Assert.Equal(exception, ex); target.Protected().As <IModbusTransportMock>() .Verify(x => x.WriteRequestAsync(It.IsAny <IModbusRequest>(), It.IsAny <CancellationToken>()), Times.Exactly(1)); }
private Mock <HttpMessageHandler> SetupBackend( Expression <Func <HttpRequestMessage, bool> > match = null, Mock <HttpMessageHandler> mock = null, string response = null) { mock = mock ?? new Mock <HttpMessageHandler>(); var reqMatch = match != null ? ItExpr.Is <HttpRequestMessage>(match) : ItExpr.IsAny <HttpRequestMessage>(); mock.Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", reqMatch, ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StringContent(response ?? DefaultOkResponse) }) .Verifiable(); return(mock); }
public MockedCloudinary() : base("cloudinary://*****:*****@test_cloud") { HandlerMock = new Mock <HttpMessageHandler>(); HandlerMock.Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Callback <HttpRequestMessage, CancellationToken>( (httpRequestMessage, cancellationToken) => { HttpRequestContent = httpRequestMessage.Content? .ReadAsStringAsync() .GetAwaiter() .GetResult(); }) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent("{}") }); ApiShared.Client = new HttpClient(HandlerMock.Object); }
public void TestBlockMined() { ResetMocks(); var blockProvider = new Mock <BlockProvider> { CallBase = true }; var descriptor = new BlockDescriptor { Id = 10, Coordinates = Coordinates3D.Zero }; blockProvider.Object.BlockMined(descriptor, BlockFace.PositiveY, World.Object, User.Object); EntityManager.Verify(m => m.SpawnEntity(It.Is <ItemEntity>(e => e.Item.Id == 10))); World.Verify(w => w.SetBlockId(Coordinates3D.Zero, 0)); blockProvider.Protected() .Setup <ItemStack[]>("GetDrop", ItExpr.IsAny <BlockDescriptor>(), ItExpr.IsAny <ItemStack>()) .Returns(() => new[] { new ItemStack(12) }); blockProvider.Object.BlockMined(descriptor, BlockFace.PositiveY, World.Object, User.Object); EntityManager.Verify(m => m.SpawnEntity(It.Is <ItemEntity>(e => e.Item.Id == 12))); World.Verify(w => w.SetBlockId(Coordinates3D.Zero, 0)); }
public WidgetRepositoryTests() { _handlerMock = new Mock <HttpClientHandler>(); _handlerMock .Protected() // Setup the PROTECTED method to mock .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) // prepare the expected response of the mocked http call .ReturnsAsync(new HttpResponseMessage() { StatusCode = HttpStatusCode.OK }) .Verifiable(); _options = new ApiOptions(); _options.ApiKey = "123"; _options.Server = "https://serverTest.com"; }
public void Factory_DisposeHandler_DoesNotDisposeInnerHandler() { // Arrange Options.CurrentValue.HttpMessageHandlerBuilderActions.Add(b => { var mockHandler = new Mock <HttpMessageHandler>(); mockHandler .Protected() .Setup("Dispose", ItExpr.IsAny <bool>()) .Throws(new Exception("Dispose should not be called")); b.PrimaryHandler = mockHandler.Object; }); var factory = new TestHttpClientFactory(Services, ScopeFactory, LoggerFactory, Options, EmptyFilters); // Act using (factory.CreateHandler()) { } // Assert (does not throw) }
public void Delete_ValidCall() { //Prepare Users mockedUser = new Users() { user_id = 1, name = "John", age = 12 }; int id = 1; var baseMock = new Mock <UsersEntitiesData>(); var userMock = new Mock <ServerController>(baseMock.Object); userMock.Protected().Setup <Users>("ReturnById", id).Returns(mockedUser); baseMock.Setup(x => x.Users.Remove(It.IsAny <Users>())).Returns((Users u) => u); var usersService = userMock.Object; // Act usersService.Delete(id); // Assert baseMock.Verify(x => x.SaveChanges(), Times.Once); }
public void Factory_DisposeClient_DoesNotDisposeHandler() { // Arrange Options.CurrentValue.HttpMessageHandlerBuilderActions.Add(b => { var mockHandler = new Mock <HttpMessageHandler>(); mockHandler .Protected() .Setup("Dispose", true) .Throws(new Exception("Dispose should not be called")); b.PrimaryHandler = mockHandler.Object; }); var factory = new DefaultHttpClientFactory(Services, Options, EmptyFilters); // Act using (factory.CreateClient()) { } // Assert (does not throw) }
public void GetAllProducts_NullContent_NoProductsFoundException() { // arrange var handler = new Mock <HttpMessageHandler>(); handler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK))); Fixture.Inject <HttpMessageHandler>(handler.Object); Fixture.Freeze <Mock <ICache> >() .Setup(x => x.Get <IList <Product> >(It.IsAny <string>())) .Returns(() => null); var sut = Fixture.Create <DefaultProductService>(); // act var result = sut.GetAllProducts(); // assert. Assert.IsNull(result); }
public async Task DeveRetornarListaVaziaAoTomarNotFound() { var mockHttpMessageHandler = new Mock <HttpMessageHandler>(); mockHttpMessageHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.NotFound, }); var client = new HttpClient(mockHttpMessageHandler.Object); _httpClientFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(client); RendaFixaService service = new RendaFixaService(_config, _mapper, _cache.Object, _httpClientFactory.Object); var result = await service.GetInvestments(); Assert.IsTrue(result.Count == 0); }
private static Mock <IHttpClientFactory> MockHttpClientFactory_For_Authenticate() { var mockFactory = new Mock <IHttpClientFactory>(); var mockHttpMessageHandler = new Mock <HttpMessageHandler>(); mockHttpMessageHandler.Protected() .SetupSequence <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent("{\"access_token\": \"123\", \"user_id\": 123}"), }) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent("{\"account_type\":\"BUSINESS\",\"id\":\"123\",\"media_count\":116,\"username\":\"solrevdev\"}"), }); var client = new HttpClient(mockHttpMessageHandler.Object); mockFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(client); return(mockFactory); }
///<summary> /// Creates a Moq.Mock of HttpRequestMessage to use with HttpClient /// The Mock Returns HttpResponseMessage with StatusCode set to provided code. ///</summary> private Mock <HttpMessageHandler> NewMoqHttpHandler(HttpStatusCode code) { // Define a Mock to use with the httpclient var moqHandler = new Mock <HttpMessageHandler>(MockBehavior.Strict); moqHandler .Protected() // Setup the PROTECTED method to mock .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) // prepare the expected response of the mocked http call .ReturnsAsync(new HttpResponseMessage() { StatusCode = code, Content = vaultRespBody }) .Verifiable(); return(moqHandler); }
private static DbCommand CreateTestCommand(TestResultSet[] data, bool throwOnExecute, bool throwOnRead) { var commandMock = new Mock <DbCommand> { CallBase = true }; var commandMockSetup = commandMock.Protected() .Setup <DbDataReader>("ExecuteDbDataReader", It.IsAny <CommandBehavior>()); // Setup the expected execute behavior if (throwOnExecute) { var mockException = new Mock <DbException>(); mockException.SetupGet(dbe => dbe.Message).Returns("Message"); commandMockSetup.Throws(mockException.Object); } else { commandMockSetup.Returns(new TestDbDataReader(data, throwOnRead)); } return(commandMock.Object); }
private static void SetupHttpClient(Mock <IHttpClientFactory> mockHttpClientFactory) { var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict); handlerMock .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent( "{\"resourceType\":\"CapabilityStatement\",\"version\":\"1.2.7\",\"name\":\"GP Connect\",\"status\":\"active\"}") }) .Verifiable(); var httpClient = new HttpClient(handlerMock.Object); mockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(httpClient).Verifiable(); }
public void GetWebRequestDesignerViewModel_SetHeaders_StringWithOneVariables_PreviewInputsCountIsOne() { var properties = new Dictionary <string, Mock <ModelProperty> >(); var propertyCollection = new Mock <ModelPropertyCollection>(); var headers = new Mock <ModelProperty>(); headers.SetupProperty(p => p.ComputedValue, ""); // start "tracking" sets/gets to this property properties.Add("Headers", headers); propertyCollection.Protected().Setup <ModelProperty>("Find", "Headers", true).Returns(headers.Object); var modelItemMock = new Mock <ModelItem>(); modelItemMock.Setup(s => s.Properties).Returns(propertyCollection.Object); var sut = new GetWebRequestDesignerViewModel(modelItemMock.Object); headers.Object.ComputedValue = "ContentType=[[contenttype]]"; modelItemMock.Raise(mi => mi.PropertyChanged += null, new PropertyChangedEventArgs("Headers")); Assert.IsTrue(sut.PreviewViewModel.Inputs.Count == 1); Assert.AreEqual(sut.PreviewViewModel.InputsVisibility, Visibility.Visible); }
public void FindFunctions_creates_function_descriptors_for_extension_methods() { var mockType = new Mock<Type>(); mockType .Setup(t => t.GetMethods(It.IsAny<BindingFlags>())) .Returns(new[] {typeof (StaticFake).GetMethod("ExtensionMethod")}); mockType .Protected() .Setup<TypeAttributes>("GetAttributeFlagsImpl") .Returns(TypeAttributes.Abstract | TypeAttributes.Sealed); var functionDescriptor = new FunctionDiscovery(CreateModel(), mockType.Object) .FindFunctions().SingleOrDefault(); Assert.NotNull(functionDescriptor); Assert.Equal("ExtensionMethod", functionDescriptor.Name); Assert.Single(functionDescriptor.Parameters); Assert.Equal("param", functionDescriptor.Parameters.First().Name); Assert.Equal("Edm.String", functionDescriptor.Parameters.First().EdmType.FullName); Assert.Equal("Edm.Int32", functionDescriptor.ReturnTypes[0].FullName); Assert.Equal(StoreFunctionKind.TableValuedFunction, functionDescriptor.StoreFunctionKind); }
public void SetUp() { _mockRepository = new(MockBehavior.Default); _handlerMock = _mockRepository.Create <HttpMessageHandler>(); _handlerMock .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent("") }) .Verifiable(); _mockLogger = _mockRepository.Create <ILogger <NotificationClient> >(); _mockBlogConfig = _mockRepository.Create <IBlogConfig>(); _magicHttpClient = new(_handlerMock.Object); }
public void GetMovie_On401Response_MustThrowUnauthorizedApiAccessException_WithMoq() { var unauthorizedResponse = new Mock <HttpMessageHandler>(); unauthorizedResponse.Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.Unauthorized }); var httpClient = new HttpClient(unauthorizedResponse.Object); var testableClass = new TestableClassesWithApiAccess(httpClient); var cancellationTokenSource = new CancellationTokenSource(); Assert.ThrowsAsync <UnauthorizedApiAccessException>(() => testableClass.GetMovie(cancellationTokenSource.Token)); }
public void ActorOverrideReceiveToHandleAllTest() { //setup using (var actorSystem = new ActorSystem(ActorSystemOptions.Default)) { var actorMock = new Mock <Actor>(actorSystem, "Test Actor") { CallBase = true }; actorMock.Protected().Setup <bool>("Receive", ItExpr.IsAny <Envelope>()).Returns(true); using (var actor = actorMock.Object) { //execute actor.Self.Tell("TST1", ActorRefs.Empty); actor.Self.Tell("TST2", ActorRefs.Empty); Thread.Sleep(200); //check actorSystem.DeadLetters.Count.Should().Be(0); } } }
protected override HttpClient OnCreateHttpClient() { var handlerMock = new Mock <HttpMessageHandler>(); handlerMock .Protected() .Setup <Task <HttpResponseMessage> >( nameof(HttpClient.SendAsync), ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StringContent(QueryResponse), }) .Verifiable(); return(new HttpClient(handlerMock.Object) { BaseAddress = new Uri(TestParameters.KsqlDBUrl) }); }
private PageRetriever InitPageRetriever(HttpStatusCode responseStatus, string responseContent) { var handlerMock = new Mock <HttpMessageHandler>(); var response = new HttpResponseMessage { StatusCode = responseStatus, Content = new StringContent(responseContent) }; handlerMock.Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(response); var client = new HttpClient(handlerMock.Object); var mockFactory = new Mock <IHttpClientFactory>(); mockFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(client); return(new PageRetriever(mockFactory.Object)); }
/// TEST FOR RESPONSES OF BANK SERVICE WHEN IT'S INACCESSIBLE public void ExecutePaymentWhenBankServiceInaccessible() { var httpMessageHandlerMock = new Mock <HttpMessageHandler>(); httpMessageHandlerMock .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()).Throws(new HttpRequestException()); var httpClient = new HttpClient(httpMessageHandlerMock.Object); var httpClientFactory = new Mock <IHttpClientFactory>(); httpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(httpClient); var body = GenerateRequestBody(Guid.NewGuid(), Status.APPROVED); var bankService = GetBankService(body, httpClientFactory); // Check if it throws BankServiceException when unable to connect Assert.ThrowsAsync <BankServiceException>( async() => await ExecuteBankService(bankService)); }
public void ReferFraudRisk() { Mock <IFrequentFlyerNumberValidator> mockValidator = new Mock <IFrequentFlyerNumberValidator>(); Mock <FraudLookup> mockFraudLookup = new Mock <FraudLookup>(); //mockFraudLookup.Setup(x => x.IsFraudRisk(It.IsAny<CreditCardApplication>())) // .Returns(true); mockFraudLookup.Protected() .Setup <bool>("CheckApplication", ItExpr.IsAny <CreditCardApplication>()) .Returns(true); var sut = new CreditCardApplicationEvaluator(mockValidator.Object, mockFraudLookup.Object); var application = new CreditCardApplication(); CreditCardApplicationDecision decision = sut.Evaluate(application); Assert.Equal(CreditCardApplicationDecision.ReferredToHumanFraudRisk, decision); }
private async Task GetCaptchaResponseAsync_OnCentainHttpResponseValues_ReturnsCorrectBoolean(double score, bool success, bool expected) { _responseObject = new RecaptchaVerificationResponseModel() { Score = score, Success = success, }; string responseJsonContent = JsonConvert.SerializeObject(_responseObject); HttpContent content = new StringContent(responseJsonContent, Encoding.UTF8, "application/json"); HttpResponseMessage httpResponse = new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = content }; _fakeHttpMessageHandlerMock.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(httpResponse); bool result = await _service.VerifyCaptchaAsync(_testToken, _testIp); Assert.Equal(expected, result); }
public void UnprotectInvokesTheDataProtectorWhenAPurposeIsPassed(string data, string purpose) { var dataBytes = new byte[] { 0x11, 0x22, 0x12, 0x21 }; var serializer = new Mock <IDataSerializer <string> >(); var protector = new Mock <IDataProtector>(); var formatter = new Mock <OpenIdConnectNonceStringDataFormat>(serializer.Object, protector.Object) { CallBase = false }; protector .Setup(instance => instance.CreateProtector(It.Is <string>(val => val == purpose))) .Returns(protector.Object); formatter .Protected() .Setup <byte[]>("DecodeProtectedData", ItExpr.Is <string>(val => val == data)) .Returns(dataBytes); formatter.Object.Unprotect(data, purpose); protector.Verify(instance => instance.Unprotect(It.Is <byte[]>(val => val == dataBytes)), Times.Once); }
public void TryOpenBlock_ReturnsBlockStateNoneIfCurrentLineIsNeitherAColumnDefinitionsLineNorARowLine() { // Arrange const string dummyText = "dummyText"; BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor(); dummyBlockProcessor.Line = new StringSlice(dummyText); Mock <ExposedBasicFlexiTableBlockParser> mockTestSubject = CreateMockExposedBasicFlexiTableBlockParser(); mockTestSubject.CallBase = true; mockTestSubject. Protected(). Setup <List <ColumnDefinition> >("TryParseColumnDefinitionsLine", ItExpr.Is <StringSlice>(line => line.Text == dummyText), '|', -1). Returns((List <ColumnDefinition>)null); mockTestSubject.Setup(t => t.TryParseRowLine(dummyBlockProcessor, 0, -1)).Returns((Row)null); // Act BlockState result = mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor); // Assert _mockRepository.VerifyAll(); Assert.Equal(BlockState.None, result); }