public void ForceBuild_when_using_weburl_should_call_api_with_parameters()
{
Mocks mocks = new Mocks();
SetupDefaultMockState(mocks);
var target = CreateTestTarget(mocks);
target.WebURL = new Uri(@"http://test");
target.Initialize(new BuildServer(), "TestProjectName", new Settings());
Dictionary<string, string> parameters = new Dictionary<string, string>()
{
{"SomeParameter", "SomeValue"}
};
string userName = "******";
// Act
target.ForceBuild("", parameters, userName);
// Assert
mocks.MockJenkinsApi
.Verify(x => x.ForceBuild(It.IsAny<Uri>(),
parameters),
Times.Once);
}
private async Task ReceiveMessageAsync(Mocks.CloudBlobStorageProviderMock cloudStorage, Mocks.InboxHttpHandlerMock inboxMock, CryptoSettings receiverCrypto, OwnEndpoint receiverEndpoint)
{
Requires.NotNull(cloudStorage, "cloudStorage");
Requires.NotNull(receiverCrypto, "receiverCrypto");
Requires.NotNull(receiverEndpoint, "receiverEndpoint");
var httpHandler = new Mocks.HttpMessageHandlerMock();
cloudStorage.AddHttpHandler(httpHandler);
inboxMock.Register(httpHandler);
var channel = new Channel
{
HttpClient = new HttpClient(httpHandler),
HttpClientLongPoll = new HttpClient(httpHandler),
CloudBlobStorage = cloudStorage,
CryptoServices = receiverCrypto,
Endpoint = receiverEndpoint,
Logger = this.logger,
};
var messages = await channel.ReceiveAsync();
Assert.Equal(1, messages.Count);
Assert.Equal(Valid.Message, messages[0].Payload);
}
public void BlogCategory()
{
var category = new CategoryModel { Id = 1, Title = "Test Category", Slug = "test-category" };
var mocks = new Mocks();
Assert.AreEqual("/blog/category/test-category", BlogUrlHelperExtensions.BlogCategory(mocks.UrlHelper, category, 1));
Assert.AreEqual("/blog/category/test-category/page-2", BlogUrlHelperExtensions.BlogCategory(mocks.UrlHelper, category, 2));
}
private async Task SendMessageAsync(Mocks.CloudBlobStorageProviderMock cloudStorage, Mocks.InboxHttpHandlerMock inboxMock, CryptoSettings senderCrypto, OwnEndpoint senderEndpoint, Endpoint receiverEndpoint)
{
Requires.NotNull(cloudStorage, "cloudStorage");
Requires.NotNull(senderCrypto, "senderCrypto");
Requires.NotNull(senderEndpoint, "senderEndpoint");
Requires.NotNull(receiverEndpoint, "receiverEndpoint");
var httpHandler = new Mocks.HttpMessageHandlerMock();
cloudStorage.AddHttpHandler(httpHandler);
inboxMock.Register(httpHandler);
var sentMessage = Valid.Message;
var channel = new Channel()
{
HttpClient = new HttpClient(httpHandler),
CloudBlobStorage = cloudStorage,
CryptoServices = senderCrypto,
Endpoint = senderEndpoint,
Logger = this.logger,
};
await channel.PostAsync(sentMessage, new[] { receiverEndpoint }, Valid.ExpirationUtc);
}
private async Task TestGoodDataAsync(string[] messageData, string expectedData, bool eightBitClean)
{
Mocks mocks = new Mocks();
if (eightBitClean)
{
mocks.Connection.SetupGet(c => c.ReaderEncoding).Returns(Encoding.UTF8);
}
MemoryMessage.Builder messageBuilder = new MemoryMessage.Builder();
mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(messageBuilder);
mocks.ServerBehaviour.Setup(b => b.GetMaximumMessageSize(It.IsAny<IConnection>())).Returns((long?)null);
int messageLine = 0;
mocks.Connection.Setup(c => c.ReadLineAsync()).Returns(() => Task.FromResult(messageData[messageLine++]));
DataVerb verb = new DataVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("DATA"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.StartMailInputEndWithDot);
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
using (StreamReader dataReader = new StreamReader(messageBuilder.GetData(), eightBitClean ? Encoding.UTF8 : new ASCIISevenBitTruncatingEncoding()))
{
Assert.Equal(expectedData, dataReader.ReadToEnd());
}
}
public void ShouldProperlyInitializeMembers()
{
var mocks = new Mocks();
var repl = GetRepl(mocks);
repl.FileSystem.ShouldEqual(mocks.FileSystem.Object);
repl.ScriptEngine.ShouldEqual(mocks.ScriptEngine.Object);
repl.Console.ShouldEqual(mocks.Console.Object);
}
public void ExecuteWithLargerStackIfRequiredWithNoNewThread()
{
var mocks = new Mocks();
var environment = mocks.CreateReactEnvironment();
environment.ExecuteWithLargerStackIfRequired<int>("foo");
mocks.Engine.Verify(x => x.CallFunction<int>("foo"), Times.Exactly(1));
}
public async Task Process_RecordsClientName()
{
Mocks mocks = new Mocks();
EhloVerb ehloVerb = new EhloVerb();
await ehloVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO foobar"));
mocks.Session.VerifySet(s => s.ClientName = "foobar");
}
public void ExecuteWithLargerStackIfRequiredWithNoNewThread()
{
var mocks = new Mocks();
var environment = mocks.CreateReactEnvironment();
environment.ExecuteWithLargerStackIfRequired<int>("1+1");
mocks.Engine.Verify(x => x.Evaluate<int>("1+1"));
}
public void Noop()
{
Mocks mocks = new Mocks();
NoopVerb verb = new NoopVerb();
verb.Process(mocks.Connection.Object, new SmtpCommand("NOOP"));
mocks.VerifyWriteResponse(StandardSmtpResponseCode.OK);
}
public async Task Quit_RespondsWithClosingChannel()
{
Mocks mocks = new Mocks();
QuitVerb quitVerb = new QuitVerb();
await quitVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("QUIT"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.ClosingTransmissionChannel);
}
public async Task Process_NoArguments_Accepted()
{
Mocks mocks = new Mocks();
EhloVerb ehloVerb = new EhloVerb();
await ehloVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
mocks.Session.VerifySet(s => s.ClientName = "");
}
public async Task Noop()
{
Mocks mocks = new Mocks();
NoopVerb verb = new NoopVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("NOOP"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
}
public void Init()
{
_left = new AGSEdge { Value = 100 };
_right = new AGSEdge { Value = 200 };
_top = new AGSEdge { Value = 200 };
_bottom = new AGSEdge { Value = 100 };
_edges = new AGSEdges (_left, _right, _top, _bottom);
_mocks = Mocks.Init();
}
public void ShouldNotTransformJsxIfNoAnnotationPresent()
{
var mocks = new Mocks();
var environment = mocks.CreateReactEnvironment();
var input = "<div>Hello World</div>";
var output = environment.TransformJsx(input);
Assert.Equal(input, output);
}
public TheInitializeMethod()
{
_tempPath = Path.GetTempPath();
_mocks = new Mocks();
_repl = GetRepl(_mocks);
_mocks.FileSystem.Setup(x => x.CurrentDirectory).Returns(_tempPath);
var paths = new[] { Path.Combine(_tempPath, "path" ) };
_repl.Initialize(paths, new[] { _mocks.ScriptPack.Object });
}
public async Task SayHeloTwice_ReturnsError()
{
Mocks mocks = new Mocks();
mocks.Session.SetupGet(s => s.ClientName).Returns("already.said.helo");
HeloVerb verb = new HeloVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("HELO foo.blah"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.BadSequenceOfCommands);
}
public async Task ProcessAsync_UnregisteredSubCommand_ErrorResponse()
{
Mocks mocks = new Mocks();
Mock<VerbWithSubCommands> verbWithSubCommands = new Mock<VerbWithSubCommands>() { CallBase = true };
await verbWithSubCommands.Object.ProcessAsync(mocks.Connection.Object, new SmtpCommand("VERB SUBCOMMAND1"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.CommandParameterNotImplemented);
}
public async Task SayHelo()
{
Mocks mocks = new Mocks();
HeloVerb verb = new HeloVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("HELO foo.blah"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
mocks.Session.VerifySet(s => s.ClientName = "foo.blah");
}
public async Task ProcessAsync()
{
Mocks mocks = new Mocks();
RsetVerb verb = new RsetVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("RSET"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
mocks.Connection.Verify(c => c.AbortMessage());
}
public void SayHelo()
{
Mocks mocks = new Mocks();
HeloVerb verb = new HeloVerb();
verb.Process(mocks.Connection.Object, new SmtpCommand("HELO foo.blah"));
mocks.VerifyWriteResponse(StandardSmtpResponseCode.OK);
mocks.Session.VerifySet(s => s.ClientName, "foo.bar");
}
public async Task Process_SaidHeloAlready_Allowed()
{
Mocks mocks = new Mocks();
EhloVerb verb = new EhloVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO foo.blah"));
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO foo.blah"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
}
public async Task NoCertificateAvailable_ReturnsErrorResponse()
{
Mocks mocks = new Mocks();
mocks.ServerBehaviour.Setup(b => b.GetSSLCertificate(It.IsAny<IConnection>())).Returns<X509Certificate>(null);
StartTlsVerb verb = new StartTlsVerb();
await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("STARTTLS"));
mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.CommandNotImplemented);
}
public void ExecuteWithBabelShouldThrowIfBabelDisabled()
{
var mocks = new Mocks();
mocks.Config.Setup(x => x.LoadBabel).Returns(false);
var environment = mocks.CreateReactEnvironment();
Assert.Throws<BabelNotLoadedException>(() =>
{
environment.ExecuteWithBabel<string>("foobar");
});
}
public async Task ProcessResponse_Response_BadBase64()
{
await Assert.ThrowsAsync<BadBase64Exception>(async () =>
{
Mocks mocks = new Mocks();
CramMd5MechanismProcessor cramMd5MechanismProcessor = Setup(mocks);
await cramMd5MechanismProcessor.ProcessResponseAsync(null);
await cramMd5MechanismProcessor.ProcessResponseAsync("rob blah");
});
}
public void GeneratesContainerIdIfNotProvided()
{
var mocks = new Mocks();
var environment = mocks.CreateReactEnvironment();
mocks.Config.Setup(x => x.Scripts).Returns(new List<string>());
var component1 = environment.CreateComponent("ComponentName", new { });
var component2 = environment.CreateComponent("ComponentName", new { });
Assert.AreEqual("react1", component1.ContainerId);
Assert.AreEqual("react2", component2.ContainerId);
}
public async Task ProcessRepsonse_ChallengeReponse_BadFormat()
{
await Assert.ThrowsAsync<SmtpServerException>(async () =>
{
Mocks mocks = new Mocks();
string challenge = string.Format("{0}.{1}@{2}", FAKERANDOM, FAKEDATETIME, FAKEDOMAIN);
CramMd5MechanismProcessor cramMd5MechanismProcessor = Setup(mocks, challenge);
AuthMechanismProcessorStatus result = await cramMd5MechanismProcessor.ProcessResponseAsync("BLAH");
});
}
private CramMd5MechanismProcessor Setup(Mocks mocks, string challenge = null)
{
Mock<IRandomIntegerGenerator> randomMock = new Mock<IRandomIntegerGenerator>();
randomMock.Setup(r => r.GenerateRandomInteger(It.IsAny<int>(), It.IsAny<int>())).Returns(FAKERANDOM);
Mock<ICurrentDateTimeProvider> dateMock = new Mock<ICurrentDateTimeProvider>();
dateMock.Setup(d => d.GetCurrentDateTime()).Returns(new DateTime(FAKEDATETIME));
mocks.ServerBehaviour.SetupGet(b => b.DomainName).Returns(FAKEDOMAIN);
return new CramMd5MechanismProcessor(mocks.Connection.Object, randomMock.Object, dateMock.Object, challenge);
}
private void TestGoodAddress(string address, string expectedAddress)
{
Mocks mocks = new Mocks();
Message message = new Message(mocks.Session.Object);
mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(message);
RcptToVerb verb = new RcptToVerb();
verb.Process(mocks.Connection.Object, new SmtpCommand("TO " + address));
mocks.VerifyWriteResponse(StandardSmtpResponseCode.OK);
Assert.AreEqual(expectedAddress, message.To[0]);
}
private void TestBadAddress(string address)
{
Mocks mocks = new Mocks();
Message message = new Message(mocks.Session.Object);
mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(message);
RcptToVerb verb = new RcptToVerb();
verb.Process(mocks.Connection.Object, new SmtpCommand("TO " + address));
mocks.VerifyWriteResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments);
Assert.AreEqual(0, message.To.Length);
}
public void InitializeTest()
{
var mocks = new Mocks();
var channel = mocks.CreateChannelMock();
channel.State = LocalChannelState.FundingLocked;
mocks.SetupMocks();
mocks.ChannelService.Setup(c => c.Channels)
.Returns(() => new List <LocalChannel>()
{
channel
}.AsReadOnly());
var service = mocks.CreateServiceMock();
service.Initialize(NetworkParameters.BitcoinTestnet);
mocks.BlockchainMonitorService
.Verify(bms => bms.WatchForTransactionId(
It.Is <string>(id => id == channel.FundingTransactionId),
It.Is <ushort>(id => id == channel.MinimumDepth)),
Times.Once());
}
public static TestableXunitTestInvoker Create(
IMessageBus?messageBus = null,
string displayName = "MockDisplayName",
IReadOnlyList <BeforeAfterTestAttribute>?beforeAfterAttributes = null,
Action?lambda = null)
{
var testCase = TestData.XunitTestCase <ClassUnderTest>("Passing", uniqueID: "case-id");
var test = Mocks.Test(testCase, displayName, "test-id");
return(new TestableXunitTestInvoker(
test,
messageBus ?? new SpyMessageBus(),
typeof(ClassUnderTest),
new object[0],
typeof(ClassUnderTest).GetMethod(nameof(ClassUnderTest.Passing)) !,
new object[0],
beforeAfterAttributes ?? new List <BeforeAfterTestAttribute>(),
new ExceptionAggregator(),
new CancellationTokenSource(),
lambda
));
}
public void SuccessfulWithoutPayments()
{
// data
var id = Guid.NewGuid();
var invoice = new Core.Data.Model.Invoice {
Id = id
};
// mocks
var invoicePersistor = Mocks.StrictMock <Core.Data.Persistor.Invoice>();
var bll = Mocks.StrictMock <Core.Logic.InvoiceLogic>(invoicePersistor, null, null);
bll.Expect(b => b.Delete(id)).CallOriginalMethod(OriginalCallOptions.NoExpectation);
invoicePersistor.Expect(d => d.Get(id)).Return(invoice);
invoicePersistor.Expect(d => d.Delete(id));
invoicePersistor.Expect(d => d.Commit()).Return(1);
// record
Mocks.ReplayAll();
bll.Delete(id);
}
public void LogsTestNameWithExceptionAndStackTraceAndOutput()
{
var message = Mocks.TestFailed("This is my display name \t\r\n", 1.2345M, output: "This is\t" + Environment.NewLine + "output");
SetupFailureInformation(message);
var handler = TestableDefaultRunnerReporterWithTypesMessageHandler.Create();
handler.OnMessageWithTypes(message, null);
Assert.Collection(handler.Messages,
msg => Assert.Equal("[Err @ SomeFolder\\SomeClass.cs:18] => This is my display name \\t\\r\\n [FAIL]", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => ExceptionType : This is my message \t", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => Message Line 2", msg),
msg => Assert.Equal("[--- @ SomeFolder\\SomeClass.cs:18] => Stack Trace:", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => Line 1", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => SomeFolder\\SomeClass.cs(18,0): at SomeClass.SomeMethod()", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => Line 3", msg),
msg => Assert.Equal("[--- @ SomeFolder\\SomeClass.cs:18] => Output:", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => This is\t", msg),
msg => Assert.Equal("[Imp @ SomeFolder\\SomeClass.cs:18] => output", msg)
);
}
public void RoutingStopsAfterResponseIsSentByDefault()
{
var executed = false;
var context = Mocks.HttpContext();
var routes = new List <IRoute>
{
new Route(ctx =>
{
context.WasRespondedTo.Returns(true);
return(ctx);
}),
new Route(ctx =>
{
executed = true;
return(ctx);
})
};
new Router().Route(context, routes);
executed.ShouldBeFalse();
}
public async Task HrefJavaScriptOnClick(string clickNodeId)
{
var signal = new AutoResetEvent(false);
var console = new Mock <IConsole>();
console.Setup(x => x.Log(1d)).Callback(() => signal.Set());
var resourceProvider = Mocks.ResourceProvider("http://loc/",
"<html><body><a id=a href='JavaScript:console.log(1)'><div id=d></div></a></body></html>");
var engine = EngineBuilder.New()
.SetResourceProvider(resourceProvider)
.UseJint()
.Window(w => w.SetConsole(console.Object))
.Build();
var page = await engine.OpenUrl("http://loc/");
((HtmlElement)page.Document.GetElementById(clickNodeId)).Click();
Assert.IsTrue(signal.WaitOne(1000), "Logged");
}
public async Task CreateAsync_QueryAndQueryFileBothSet_ArgumentExceptionThrown()
{
var tableName = CreateTableName();
string queryFileName = null;
try
{
queryFileName = CreateQueryFile(tableName);
var configuration =
Mocks
.Of <ISqlDataSourceAdapterConfiguration>()
.Where(c =>
c.ConnectionString == ConnectionString &&
c.Query == String.Format(TestResources.SimpleSelectQueryFormat, tableName) &&
c.QueryFile == queryFileName)
.First();
try
{
using (var adapter = await new SqlDataSourceAdapterFactory()
.CreateAsync(configuration, DataTransferContextMock.Instance, CancellationToken.None))
{
Assert.Fail(TestResources.AmbiguousQueryDidNotFail);
}
}
catch (ArgumentException)
{
return;
}
}
finally
{
if (!String.IsNullOrEmpty(queryFileName) && File.Exists(queryFileName))
{
File.Delete(queryFileName);
}
}
}
public static void LogsTestName()
{
var testPassed = Substitute.For <ITestPassed>();
var test = Mocks.Test(null, "???");
testPassed.Test.Returns(test);
testPassed.ExecutionTime.Returns(1.2345M);
var formatter = Substitute.For <TeamCityDisplayNameFormatter>();
formatter.DisplayName(test).Returns("This is my display name \t\r\n");
var logger = new SpyConsoleLogger();
using (var visitor = new TeamCityVisitor(logger, null, null, _ => "myFlowId", formatter))
{
visitor.OnMessage(testPassed);
Assert.Collection(logger.Messages,
msg => Assert.Equal("##teamcity[testFinished name='This is my display name \t|r|n' duration='1234' flowId='myFlowId']", msg)
);
}
}
public void ThrowsExceptionWhenRouteNotFound()
{
var logger = new InMemoryLogger();
logger.Logs.Count.ShouldBe(0);
using (var server = new RestServer(Substitute.For <IHttpListener>())
{
Logger = logger
})
{
server.EnableThrowingExceptions = true;
var context = Mocks.HttpContext();
context.Server.Returns(server);
Should.Throw <RouteNotFoundException>(() => server.TestRouteContext(context));
}
logger.Logs.Count.ShouldBe(1);
logger.Logs[0].Exception.GetType().ShouldBe(typeof(RouteNotFoundException));
}
public async Task ProcessResponse_PasswordAcceptedAfterUserNameInInitialRequest()
{
Mocks mocks = new Mocks();
LoginMechanismProcessor processor = Setup(mocks);
AuthMechanismProcessorStatus result = await processor.ProcessResponseAsync(EncodeBase64("rob"));
Assert.Equal(AuthMechanismProcessorStatus.Continue, result);
mocks.Connection.Verify(c =>
c.WriteResponseAsync(
It.Is <SmtpResponse>(r =>
VerifyBase64Response(r.Message, "Password:"******"password"));
Assert.Equal(AuthMechanismProcessorStatus.Success, result);
}
public async Task CompleteAsyncOrDispose_CleansUpAfterTransfer()
{
var clientMock = new DocumentDbWriteClientMock();
var configurationMock = Mocks
.Of <IDocumentDbBulkSinkAdapterInstanceConfiguration>(m =>
m.Collection == "TestCollection" &&
m.StoredProcName == "test" &&
m.BatchSize == 5 &&
m.MaxScriptSize == 1024)
.First();
using (var adapter = new DocumentDbBulkSinkAdapter(clientMock, PassThroughTransformation.Instance, configurationMock))
{
await adapter.InitializeAsync(CancellationToken.None);
await adapter.CompleteAsync(CancellationToken.None);
}
CollectionAssert.AreEquivalent(clientMock.CreatedStoredProcedures.ToArray(), clientMock.DeletedStoredProcedures.ToArray(),
TestResources.BulkSinkAdapterDidNotCleanup);
}
public void Given_Get_call_When_repos_and_data_are_valid_return_data()
{
// Arrange
var mockCustomerRepo = Mocks.GetMockCustomerRepo().Object;
var mockGenderRepo = Mocks.GetMockGenderRepo().Object;
var mockCategoryRepo = Mocks.GetMockCategoryRepo().Object;
var mockCountryRepo = Mocks.GetMockCountryRepo().Object;
var controller = new CustomersController(
mockCustomerRepo,
mockGenderRepo,
mockCategoryRepo,
mockCountryRepo);
var expectedCount = 3;
// Act
var result = controller.Get();
// Assert
Assert.AreEqual(expectedCount, result.Count());
}
public void Sends404WhenRouteNotFound()
{
var logger = new InMemoryLogger();
logger.Logs.Count.ShouldBe(0);
using (var server = new RestServer(Substitute.For <IHttpListener>())
{
Logger = logger
})
{
var context = Mocks.HttpContext();
context.Server.Returns(server);
server.TestRouteContext(context);
context.Response.Received().SendResponse(HttpStatusCode.NotFound);
}
logger.Logs.Count.ShouldBe(1);
logger.Logs[0].Exception.GetType().ShouldBe(typeof(RouteNotFoundException));
}
public void XmlHttpRequestThis()
{
var console = new Mock <IConsole>();
var resourceProvider = Mocks.ResourceProvider("http://localhost/", @"<html><script>
var xhr = new XMLHttpRequest();
xhr.open('GET', 'data.json', false);
xhr.responseType = 'json';
xhr.onload = function () {
console.log(xhr == this);
};
xhr.send(null);</script></html>" )
.Resource("http://localhost/data.json", "");
var engine = Builder(resourceProvider, console.Object).Build();
((Navigator)engine.Window.Navigator).UserAgent = "My favorite browser";
engine.OpenUrl("http://localhost").Wait();
console.Verify(x => x.Log(true), Times.Once);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @After public void tearDown()
public virtual void tearDown()
{
Mocks.reset();
foreach (Group group in identityService.createGroupQuery().list())
{
identityService.deleteGroup(group.Id);
}
foreach (User user in identityService.createUserQuery().list())
{
identityService.deleteUser(user.Id);
}
foreach (Task task in taskService.createTaskQuery().list())
{
if (string.ReferenceEquals(task.ProcessInstanceId, null))
{
taskService.deleteTask(task.Id, true);
}
}
identityService.clearAuthentication();
}
public async Task LinkOnLoad()
{
var resourceProvider = Mocks.ResourceProvider("http://loc/",
@"<html><body></body>
<script>
document.body.onload=function(){console.log('body onload');};
var link = document.createElement('link');
link.onload = function(){console.log('ok')};
link.onerror = function(){console.log('link onerror')};
link.rel='stylesheet';
link.href='mystylesheet.css';
document.head.appendChild(link);
console.log('added');
</script>
</html>").Resource("http://loc/mystyesheet.css", "*{border:1px solid black}");
var console = new TestingConsole();
var engine = TestingEngine.BuildJint(resourceProvider, console);
await engine.OpenUrl("http://loc/");
Assert.AreEqual(new[] { "added", "ok", "body onload" }, console.LogHistory);
}
public static TestableXunitTestInvoker Create(
IMessageBus messageBus = null,
string displayName = null,
IReadOnlyList <BeforeAfterTestAttribute> beforeAfterAttributes = null,
Action lambda = null)
{
var testCase = Mocks.XunitTestCase <ClassUnderTest>("Passing");
var test = Mocks.Test(testCase, displayName);
return(new TestableXunitTestInvoker(
test,
messageBus ?? new SpyMessageBus(),
typeof(ClassUnderTest),
new object[0],
typeof(ClassUnderTest).GetMethod("Passing"),
new object[0],
beforeAfterAttributes ?? new List <BeforeAfterTestAttribute>(),
new ExceptionAggregator(),
new CancellationTokenSource(),
lambda
));
}
public void Successful()
{
// data
var clientId = Guid.NewGuid();
var client = new Core.Data.Model.Client {
Id = clientId
};
// mocks
var clientPersistor = Mocks.StrictMock <Core.Data.Persistor.Client>();
var bll = Mocks.StrictMock <Core.Logic.ClientLogic>(clientPersistor, null);
bll.Expect(b => b.Get(client.Id)).CallOriginalMethod(OriginalCallOptions.NoExpectation);
clientPersistor.Expect(d => d.Get(client.Id)).Return(client);
// record
Mocks.ReplayAll();
var result = bll.Get(clientId);
Assert.Equal(clientId, result.Id);
}
public async Task GetImageRawData()
{
var resourceProvider =
Mocks.ResourceProvider("http://localhost/", "")
.Resource("http://localhost/image.bmp", new byte[] { 1, 2, 3, 2, 1 }, "image/bmp");
var engine = TestingEngine.BuildJint(resourceProvider);
var page = await engine.OpenUrl("http://localhost");
var img = (HtmlImageElement)page.Document.CreateElement(TagsNames.Img);
var loadSignal = new ManualResetEvent(false);
img.OnLoad += evt => { loadSignal.Set(); };
img.Src = "image.bmp";
Assert.IsTrue(loadSignal.WaitOne(1000));
var data = new MemoryStream();
img.ImageData.Data.CopyTo(data);
Assert.IsTrue(img.Complete);
Assert.AreEqual(new byte[] { 1, 2, 3, 2, 1 }, data.ToArray());
}
public void Process_Success()
{
// Arrange
var testDocumentationContent = "Test documentation content.";
Configuration.DocumentationConfiguration.Setup(c => c.Disabled).Returns(false);
var htmlBuilder = Mocks.Create <IHtmlBuilder>();
htmlBuilder.Setup(b => b.CreateDocumentationPageHtml()).Returns(testDocumentationContent);
var processor = new DocumentationPageRequestProcessor(Configuration.Object, htmlBuilder.Object);
// Act
var result = processor.Process(null);
// Assert
Assert.That(result, Is.Not.Null, "A valid ResponseState should be returned.");
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK), "The request should be successful.");
Assert.That(result.ContentType, Is.EqualTo(ContentTypes.Html), "The response should contain HTML.");
Assert.That(result.Content, Is.EqualTo(testDocumentationContent), "The response content should contain the HtmlBuilder result.");
}
public void Authorize_Success()
{
// Arrange
var httpRequest = Mocks.Create <HttpRequestBase>();
var httpContext = Mocks.Create <HttpContextBase>();
httpContext.Setup(c => c.Request).Returns(httpRequest.Object);
Configuration.EditHelpConfiguration.Setup(c => c.IsDisabled).Returns(false);
Configuration.EditHelpConfiguration.Setup(c => c.RequireAuthentication).Returns(false);
Configuration.EditHelpConfiguration.Setup(c => c.RequireLocalConnection).Returns(false);
var authorizer = new EditAuthorizer(httpContext.Object, Configuration.Object);
// Act
var result = authorizer.Authorize();
// Assert
Assert.That(result, Is.True, "Authorization should succeed.");
Mocks.VerifyAll();
}
public static async void Messages()
{
var summary = new RunSummary {
Total = 4, Failed = 2, Skipped = 1, Time = 21.12m
};
var messageBus = new SpyMessageBus();
var testCase = Mocks.TestCase <ClassUnderTest>("Passing");
var runner = TestableTestClassRunner.Create(messageBus, new[] { testCase }, result: summary);
var result = await runner.RunAsync();
Assert.Equal(result.Total, summary.Total);
Assert.Equal(result.Failed, summary.Failed);
Assert.Equal(result.Skipped, summary.Skipped);
Assert.Equal(result.Time, summary.Time);
Assert.False(runner.TokenSource.IsCancellationRequested);
Assert.Collection(
messageBus.Messages,
msg =>
{
var starting = Assert.IsType <_TestClassStarting>(msg);
Assert.Equal("assembly-id", starting.AssemblyUniqueID);
Assert.Equal("TestClassRunnerTests+ClassUnderTest", starting.TestClass);
Assert.Equal("class-id", starting.TestClassUniqueID);
Assert.Equal("collection-id", starting.TestCollectionUniqueID);
},
msg =>
{
var finished = Assert.IsType <_TestClassFinished>(msg);
Assert.Equal("assembly-id", finished.AssemblyUniqueID);
Assert.Equal(21.12m, finished.ExecutionTime);
Assert.Equal("class-id", finished.TestClassUniqueID);
Assert.Equal("collection-id", finished.TestCollectionUniqueID);
Assert.Equal(2, finished.TestsFailed);
Assert.Equal(4, finished.TestsRun);
Assert.Equal(1, finished.TestsSkipped);
}
);
}
public DynamicContentWorkflowTests()
{
app = Mocks.App(appId);
var simpleWorkflow = new Workflow(
Status.Draft,
new Dictionary <Status, WorkflowStep>
{
[Status.Draft] =
new WorkflowStep(
new Dictionary <Status, WorkflowTransition>
{
[Status.Published] = WorkflowTransition.Always
},
StatusColors.Draft),
[Status.Published] =
new WorkflowStep(
new Dictionary <Status, WorkflowTransition>
{
[Status.Draft] = WorkflowTransition.Always
},
StatusColors.Published)
},
new List <DomainId> {
simpleSchemaId.Id
});
var workflows = Workflows.Empty.Set(workflow).Set(DomainId.NewGuid(), simpleWorkflow);
A.CallTo(() => appProvider.GetAppAsync(appId.Id, false))
.Returns(app);
A.CallTo(() => app.Workflows)
.Returns(workflows);
var memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
sut = new DynamicContentWorkflow(new JintScriptEngine(memoryCache), appProvider);
}
public async Task Should_remove_schema_from_index_on_delete()
{
var schemaGrain = A.Fake <ISchemaGrain>();
var schemaState = Mocks.Schema(appId, schemaId);
A.CallTo(() => grainFactory.GetGrain <ISchemaGrain>(schemaId.Id, null))
.Returns(schemaGrain);
A.CallTo(() => schemaGrain.GetStateAsync())
.Returns(J.AsTask(schemaState));
var context =
new CommandContext(new DeleteSchema {
SchemaId = schemaId.Id
}, commandBus)
.Complete();
await sut.HandleAsync(context);
A.CallTo(() => index.RemoveSchemaAsync(schemaId.Id))
.MustHaveHappened();
}
public void CommandWithActivity()
{
var activity = new Activity("test");
activity.AddBaggage("bag", "cup");
activity.Start();
try {
var mocks = new Mocks();
mocks.Telemetry.OnCommandStarted(CreateFindStartedEvent(4));
// Complete the command and check telemetry was recorded
mocks.Telemetry.OnCommandSucceeded(CreateFindSucceededEvent(4));
var telemetry = mocks.GetSingleTelemetry();
telemetry.Success.Should().BeTrue();
telemetry.Data.Should().Be("{ \"find\" : { \"field\" : \"blah\" } }");
telemetry.Context.Operation.Id.Should().Be(activity.RootId);
telemetry.Context.Operation.ParentId.Should().Be(null);
}
finally {
activity.Stop();
}
}
public void SynchronizeThreads()
{
AutoResetEvent signalFromBackgroundThread = new AutoResetEvent(false);
AutoResetEvent signalFromForegroundThread = new AutoResetEvent(false);
Mock <IHelloWorld> helloWorld = Mocks.CreateMock <IHelloWorld>();
helloWorld.Expects.One.Method(_ => _.Hello()).Will(Signal.EventWaitHandle(signalFromBackgroundThread));
ThreadPool.QueueUserWorkItem(delegate
{
if (signalFromForegroundThread.WaitOne(1000, false))
{
helloWorld.MockObject.Hello(); // this will set the signal
}
});
signalFromForegroundThread.Set();
bool signaled = signalFromBackgroundThread.WaitOne(1000, false);
Assert.IsTrue(signaled, "did not receive signal from background thread.");
}
public void ExecutesOnBeforeRoutingBeforeRouting()
{
var firingOrder = new List <string>();
var context = Mocks.HttpContext();
RoutingEventHandler one = ctx => { firingOrder.Add("1"); };
RoutingEventHandler two = ctx => { firingOrder.Add("2"); };
var router = new Router().Register(ctx =>
{
context.WasRespondedTo.Returns(true);
return(ctx);
});
router.BeforeRouting += one;
router.BeforeRouting += two;
router.Route(context);
firingOrder.Count.ShouldBe(2);
firingOrder[0].ShouldBe("1");
firingOrder[1].ShouldBe("2");
}
public void Process_RespondsWith250()
{
Mocks mocks = new Mocks();
Mock <IExtensionProcessor> mockExtensionProcessor1 = new Mock <IExtensionProcessor>();
mockExtensionProcessor1.SetupGet(ep => ep.EHLOKeywords).Returns(new[] { "EXTN1" });
Mock <IExtensionProcessor> mockExtensionProcessor2 = new Mock <IExtensionProcessor>();
mockExtensionProcessor2.SetupGet(ep => ep.EHLOKeywords).Returns(new[] { "EXTN2A", "EXTN2B" });
mocks.Connection.SetupGet(c => c.ExtensionProcessors).Returns(new[]
{
mockExtensionProcessor1.Object,
mockExtensionProcessor2.Object
});
EhloVerb ehloVerb = new EhloVerb();
ehloVerb.Process(mocks.Connection.Object, new SmtpCommand("EHLO foobar"));
mocks.VerifyWriteResponse(StandardSmtpResponseCode.OK);
}
private (PeerMessageHandler Handler, Mocks Mocks) GetFixture(string username = null, IPEndPoint endpoint = null, SoulseekClientOptions options = null)
{
var mocks = new Mocks(options);
endpoint = endpoint ?? new IPEndPoint(IPAddress.None, 0);
mocks.ServerConnection.Setup(m => m.Username)
.Returns(username ?? "username");
mocks.ServerConnection.Setup(m => m.IPEndPoint)
.Returns(endpoint);
mocks.PeerConnection.Setup(m => m.Username)
.Returns(username ?? "username");
mocks.PeerConnection.Setup(m => m.IPEndPoint)
.Returns(endpoint);
var handler = new PeerMessageHandler(
mocks.Client.Object,
mocks.Diagnostic.Object);
return(handler, mocks);
}
public void Successful()
{
// data
var id = Guid.NewGuid();
System.Linq.Expressions.Expression <Func <Core.Data.Model.UserService, bool> > expr = u => u.Id == id;
var services = new List <Core.Data.Model.UserService>();
// mocks
var userServicePersistor = Mocks.StrictMock <Core.Data.Persistor.UserService>();
var bll = Mocks.StrictMock <Core.Logic.UserServiceLogic>(userServicePersistor);
bll.Expect(b => b.GetList(expr)).CallOriginalMethod(OriginalCallOptions.NoExpectation);
userServicePersistor.Expect(d => d.Get(expr)).Return(services.AsQueryable());
// record
Mocks.ReplayAll();
var results = bll.GetList(expr);
Assert.Equal(services, results);
}
