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);
}
