public async Task StartAsync_Retries()
{
var mockExecutor = new Mock <ITriggeredFunctionExecutor>();
var collInfo = new DocumentCollectionInfo {
Uri = new Uri("http://fakeaccount"), MasterKey = "c29tZV9rZXk=", DatabaseName = "FakeDb", CollectionName = "FakeColl"
};
var leaseInfo = new DocumentCollectionInfo {
Uri = new Uri("http://fakeaccount"), MasterKey = "c29tZV9rZXk=", DatabaseName = "FakeDb", CollectionName = "leases"
};
var hostOptions = new ChangeFeedHostOptions();
var feedOptions = new ChangeFeedOptions();
var listener = new MockListener(mockExecutor.Object, collInfo, leaseInfo, hostOptions, feedOptions, NullLogger.Instance);
// Ensure that we can call StartAsync() multiple times to retry if there is an error.
for (int i = 0; i < 3; i++)
{
var ex = await Assert.ThrowsAnyAsync <InvalidOperationException>(() => listener.StartAsync(CancellationToken.None));
Assert.Equal("Failed to register!", ex.Message);
}
// This should succeed
await listener.StartAsync(CancellationToken.None);
}
public void SimpleWriteTest()
{
var listener = new MockListener();
Trace.Listeners.Add(listener);
Trace.TraceInformation("INFO INFO INFO");
Assert.AreEqual("vstest.executionengine.x86.exe INFO: INFO INFO INFO", listener.EntryWritten);
Trace.TraceWarning("WARNING WARNING WARNING");
Assert.AreEqual("vstest.executionengine.x86.exe WARN: WARNING WARNING WARNING", listener.EntryWritten);
Trace.TraceError("ERROR ERROR ERROR");
Assert.AreEqual("vstest.executionengine.x86.exe ERROR: ERROR ERROR ERROR", listener.EntryWritten);
Trace.Write("I WRITE");
Assert.AreEqual("I WRITE", listener.EntryWritten);
Trace.Write("I WRITE", "CATEGORY");
Assert.AreEqual("CATEGORY: I WRITE", listener.EntryWritten);
Trace.WriteLine("I WRITE A LINE");
Assert.AreEqual("I WRITE A LINE", listener.EntryWritten);
Trace.WriteLine("I WRITE A LINE", "CATEGORY");
Assert.AreEqual("CATEGORY: I WRITE A LINE", listener.EntryWritten);
}
public void EventsAreFilteredByVerbosity()
{
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventsAreFilteredByVerbosity1", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Informational, Keywords.Any))
{
tracer.AddEventListener(listener);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldNotReceive", metadata: null);
listener.EventNamesRead.ShouldNotContain(name => name.Equals("ShouldNotReceive"));
}
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventsAreFilteredByVerbosity2", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Any))
{
tracer.AddEventListener(listener);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldAlsoReceive"));
}
}
public void Setup()
{
_listener = new MockListener();
_server = new StompServer(_listener);
_server.Start();
}
public void SetUp()
{
db = new SqlDatabase(connectionString);
listener = new MockListener();
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(db.GetInstrumentationEventProvider(), listener);
}
public void Setup()
{
_listener = new MockListener();
_server = new StompServer(_listener);
_server.Start();
}
public void SizeRollingTest()
{
var v = new MockViewer();
var l = new MockListener();
v.LogFile = Path.Combine(_folder, "logview4net.test.txt");
v.LogRolling = "100 KB";
v.LogToFile = true;
var s = new Session(l, v);
s.AddEvent(l, "store log test");
Assert.IsTrue(File.Exists(v.LogFile), "SizeRollingTest A");
Assert.IsFalse(File.Exists(v.LogFile + ".1"), "SizeRollingTest B");
s.AddEvent(l, new String('X', 100 * 1024));
Assert.IsTrue(File.Exists(v.LogFile), "SizeRollingTest D");
Assert.IsFalse(File.Exists(v.LogFile + ".1"), "SizeRollingTest E");
s.AddEvent(l, new String('X', 10 * 1024));
Assert.IsTrue(File.Exists(v.LogFile), "SizeRollingTest G");
Assert.IsTrue(File.Exists(v.LogFile + ".1"), "SizeRollingTest H");
s.AddEvent(l, new String('X', 100 * 1024));
s.AddEvent(l, new String('X', 10 * 1024));
Assert.IsTrue(File.Exists(v.LogFile + ".2"), "SizeRollingTest I");
}
public async Task MultipleModifiedListeners()
{
MockListener.Reset();
MockListener2.Reset();
ObjectListener.Reset();
await Listen.ModifiedAsync(ent, ent2, ctx);
Assert.IsFalse(MockListener.WasOnCreatedCalled);
Assert.IsFalse(MockListener.WasOnCreationValidationFailedCalled);
Assert.IsTrue(MockListener.WasOnModifiedCalled);
Assert.IsFalse(MockListener.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener.WasOnDeletedCalled);
Assert.IsFalse(MockListener.WasOnDeletionFailedCalled);
Assert.IsFalse(MockListener2.WasOnCreatedCalled);
Assert.IsFalse(MockListener2.WasOnCreationValidationFailedCalled);
Assert.IsTrue(MockListener2.WasOnModifiedCalled);
Assert.IsFalse(MockListener2.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener2.WasOnDeletedCalled);
Assert.IsFalse(MockListener2.WasOnDeletionFailedCalled);
Assert.IsFalse(ObjectListener.WasOnCreatedCalled);
Assert.IsFalse(ObjectListener.WasOnCreationValidationFailedCalled);
Assert.IsTrue(ObjectListener.WasOnModifiedCalled);
Assert.IsFalse(ObjectListener.WasOnModificationFailedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletionFailedCalled);
Assert.IsTrue(MockListener.EntitesWereNotTheSameOnCalling.HasValue && MockListener.EntitesWereNotTheSameOnCalling.Value);
Assert.IsTrue(MockListener2.EntitesWereNotTheSameOnCalling.HasValue && MockListener2.EntitesWereNotTheSameOnCalling.Value);
Assert.IsTrue(ObjectListener.EntitesWereNotTheSameOnCalling.HasValue && ObjectListener.EntitesWereNotTheSameOnCalling.Value);
}
public async Task MultipleModifiedListeners_TestInheritance()
{
MockListener.Reset();
MockListener2.Reset();
ObjectListener.Reset();
await Listen.ModifiedAsync(new object(), new { sajt = true }, ctx);
Assert.IsFalse(MockListener.WasOnCreatedCalled);
Assert.IsFalse(MockListener.WasOnCreationValidationFailedCalled);
Assert.IsFalse(MockListener.WasOnModifiedCalled);
Assert.IsFalse(MockListener.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener.WasOnDeletedCalled);
Assert.IsFalse(MockListener.WasOnDeletionFailedCalled);
Assert.IsFalse(MockListener2.WasOnCreatedCalled);
Assert.IsFalse(MockListener2.WasOnCreationValidationFailedCalled);
Assert.IsFalse(MockListener2.WasOnModifiedCalled);
Assert.IsFalse(MockListener2.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener2.WasOnDeletedCalled);
Assert.IsFalse(MockListener2.WasOnDeletionFailedCalled);
Assert.IsFalse(ObjectListener.WasOnCreatedCalled);
Assert.IsFalse(ObjectListener.WasOnCreationValidationFailedCalled);
Assert.IsTrue(ObjectListener.WasOnModifiedCalled);
Assert.IsFalse(ObjectListener.WasOnModificationFailedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletionFailedCalled);
Assert.IsNull(MockListener.EntitesWereNotTheSameOnCalling);
Assert.IsNull(MockListener2.EntitesWereNotTheSameOnCalling);
Assert.IsTrue(ObjectListener.EntitesWereNotTheSameOnCalling.HasValue && ObjectListener.EntitesWereNotTheSameOnCalling.Value);
}
public void EventsAreFilteredByVerbosity()
{
using (JsonEtwTracer tracer = new JsonEtwTracer("Microsoft-GVFS-Test", "EventsAreFilteredByVerbosity"))
using (MockListener listener = new MockListener(EventLevel.Informational, Keywords.Any))
{
listener.EnableEvents(tracer.EvtSource, EventLevel.Verbose);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldNotReceive", metadata: null);
listener.EventNamesRead.ShouldNotContain(name => name.Equals("ShouldNotReceive"));
}
using (JsonEtwTracer tracer = new JsonEtwTracer("Microsoft-GVFS-Test", "EventsAreFilteredByVerbosity"))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Any))
{
listener.EnableEvents(tracer.EvtSource, EventLevel.Verbose);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldAlsoReceive"));
}
}
static void n_ServiceResolved_Ljavax_jmdns_ServiceEvent_(IntPtr jnienv, IntPtr native__this, IntPtr native_p0)
{
MockListener __this = Java.Lang.Object.GetObject <MockListener> (native__this, JniHandleOwnership.DoNotTransfer);
global::Javax.Jmdns.ServiceEvent p0 = Java.Lang.Object.GetObject <global::Javax.Jmdns.ServiceEvent> (native_p0, JniHandleOwnership.DoNotTransfer);
__this.ServiceResolved(p0);
}
public void SimpleWriteTest()
{
var listener = new MockListener();
Trace.Listeners.Add(listener);
Trace.TraceInformation("INFO INFO INFO");
Assert.AreEqual("vstest.executionengine.x86.exe INFO: INFO INFO INFO", listener.EntryWritten);
Trace.TraceWarning("WARNING WARNING WARNING");
Assert.AreEqual("vstest.executionengine.x86.exe WARN: WARNING WARNING WARNING", listener.EntryWritten);
Trace.TraceError("ERROR ERROR ERROR");
Assert.AreEqual("vstest.executionengine.x86.exe ERROR: ERROR ERROR ERROR", listener.EntryWritten);
Trace.Write("I WRITE");
Assert.AreEqual("I WRITE", listener.EntryWritten);
Trace.Write("I WRITE", "CATEGORY");
Assert.AreEqual("CATEGORY: I WRITE", listener.EntryWritten);
Trace.WriteLine("I WRITE A LINE");
Assert.AreEqual("I WRITE A LINE", listener.EntryWritten);
Trace.WriteLine("I WRITE A LINE", "CATEGORY");
Assert.AreEqual("CATEGORY: I WRITE A LINE", listener.EntryWritten);
}
public void SetUp()
{
db = new SqlDatabase(connectionString);
listener = new MockListener();
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(db.GetInstrumentationEventProvider(), listener);
}
public ServerTest()
{
_tokenSource = new CancellationTokenSource();
_mockSocket = new MockSocket();
_mockListener = new MockListener(_mockSocket);
_mockRequestProcessor = new MockRequestProcessor();
var mockRequestProcessorFactory = new MockRequestProcessorFactory(_mockRequestProcessor);
var logger = new FileLogger(Path.Combine(Environment.CurrentDirectory, @"..\..\..\logs\testlog.txt"));
_server = new Server(_mockListener, mockRequestProcessorFactory, logger);
}
public override IActiveRecordConfiguration GetConfigSource()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
return base.GetConfigSource()
.GetConfiguration(string.Empty)
.AddContributor(contributor)
.Source;
}
public void Welcome_OnClient_Connect()
{
var clientMock = new Mock<IWampClient>();
string sessionId = "dfgewj324908";
clientMock.SetupGet(x => x.SessionId).Returns(sessionId);
MockListener<JToken> mockListener = new MockListener<JToken>();
WampListener<JToken> listener = GetListener(mockListener, clientMock.Object);
listener.Start();
Mock<IWampConnection<JToken>> connectionMock = new Mock<IWampConnection<JToken>>();
mockListener.OnNext(connectionMock.Object);
clientMock.Verify(x => x.Welcome(sessionId, 1, "WampSharp"));
}
public async Task RemoveFailed()
{
MockListener.Reset();
await Listen.RemoveFailedAsync(ent, ctx);
Assert.IsFalse(MockListener.WasOnCreatedCalled);
Assert.IsFalse(MockListener.WasOnCreationValidationFailedCalled);
Assert.IsFalse(MockListener.WasOnModifiedCalled);
Assert.IsFalse(MockListener.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener.WasOnDeletedCalled);
Assert.IsTrue(MockListener.WasOnDeletionFailedCalled);
}
public override IActiveRecordConfiguration GetConfigSource()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
return(base.GetConfigSource()
.GetConfiguration(string.Empty)
.AddContributor(contributor)
.Source);
}
public void Listener_is_called()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
ActiveRecordStarter.AddContributor(contributor);
ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
Recreate();
Blog.FindAll();
new Blog() { Name = "Foo", Author = "Bar" }.SaveAndFlush();
Assert.IsTrue(listener.Called);
}
public void Listener_is_added_to_config()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
ActiveRecordStarter.AddContributor(contributor);
ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
Recreate();
Blog.FindAll();
var listeners = Blog.Holder.GetConfiguration(typeof(ActiveRecordBase)).EventListeners.PostInsertEventListeners;
Assert.Greater(Array.IndexOf(listeners, listener),-1);
}
public void EventMetadataWithKeywordsIsOptional()
{
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventMetadataWithKeywordsIsOptional", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Any))
{
tracer.AddEventListener(listener);
tracer.RelatedWarning(metadata: null, message: string.Empty, keywords: Keywords.Telemetry);
listener.EventNamesRead.ShouldContain(x => x.Equals("Warning"));
tracer.RelatedError(metadata: null, message: string.Empty, keywords: Keywords.Telemetry);
listener.EventNamesRead.ShouldContain(x => x.Equals("Error"));
}
}
public void WriteRollingTest()
{
var v = new MockViewer();
var l = new MockListener();
v.LogFile = Path.Combine(_folder, "logview4net.test.txt");
v.LogRolling = "100 KB";
v.LogToFile = true;
var s = new Session(l, v);
s.AddEvent(l, "store log test");
Assert.IsTrue(File.Exists(v.LogFile));
}
public async Task StartAsync_Retries()
{
var listener = new MockListener(_mockExecutor.Object, _functionId, _monitoredInfo, _leasesInfo, _processorOptions, _mockMonitoredService.Object, _mockLeasesService.Object, NullLogger.Instance);
// Ensure that we can call StartAsync() multiple times to retry if there is an error.
for (int i = 0; i < 3; i++)
{
var ex = await Assert.ThrowsAnyAsync <InvalidOperationException>(() => listener.StartAsync(CancellationToken.None));
Assert.Equal("Failed to register!", ex.Message);
}
// This should succeed
await listener.StartAsync(CancellationToken.None);
}
public void InvokerIsWiredUp()
{
Command command = new Command();
MockInvoker invoker = new MockInvoker();
EventCommandAdapter <MockInvoker> adapter = new EventCommandAdapter <MockInvoker>(invoker, "Event");
command.AddCommandAdapter(adapter);
MockListener listener = new MockListener();
command.ExecuteAction += listener.CatchCommand;
invoker.DoInvokeEvent();
Assert.IsTrue(listener.CommandFired);
}
public void StopEventIsDispatchedOnDispose()
{
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "StopEventIsDispatchedOnDispose", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Telemetry))
{
tracer.AddEventListener(listener);
using (ITracer activity = tracer.StartActivity("TestActivity", EventLevel.Informational, Keywords.Telemetry, null))
{
listener.EventNamesRead.ShouldBeEmpty();
}
listener.EventNamesRead.ShouldContain(x => x.Equals("TestActivity"));
}
}
public void Listener_is_added_to_config()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
ActiveRecordStarter.AddContributor(contributor);
ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
Recreate();
Blog.FindAll();
var listeners = Blog.Holder.GetConfiguration(typeof(ActiveRecordBase)).EventListeners.PostInsertEventListeners;
Assert.Greater(Array.IndexOf(listeners, listener), -1);
}
public void Listener_is_called()
{
var contributor = new NHEventListeners();
var listener = new MockListener();
contributor.Add(listener);
ActiveRecordStarter.AddContributor(contributor);
ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
Recreate();
Blog.FindAll();
new Blog()
{
Name = "Foo", Author = "Bar"
}.SaveAndFlush();
Assert.IsTrue(listener.Called);
}
public void CallServer_And_Receive_Call_Result()
{
MockListener<JToken> mockListener = new MockListener<JToken>();
Mock<IWampServer<JToken>> serverMock = new Mock<IWampServer<JToken>>();
serverMock.Setup(x => x.Call(It.IsAny<IWampClient>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<JToken[]>()))
.Callback((IWampClient clientParameter, string callId, string procUrl, JToken[] arguments) =>
{
clientParameter.CallResult(callId, new {stuff = "cool"});
});
WampListener<JToken> listener = GetListener(mockListener, serverMock.Object);
Mock<IWampClient<JToken>> clientMock = new Mock<IWampClient<JToken>>();
MockConnection<JToken> connection = new MockConnection<JToken>();
IWampServer client = GetClient(connection.SideAToSideB, clientMock.Object);
listener.Start();
mockListener.OnNext(connection.SideBToSideA);
clientMock.Verify(x => x.Welcome(It.IsAny<string>(),
It.IsAny<int>(),
It.IsAny<string>()));
Mock<IWampClient> userClientMock = new Mock<IWampClient>();
client.Call(userClientMock.Object, "a123123", "Test",
new
{
name = "Jack"
});
serverMock.Verify(x => x.Call(It.IsAny<IWampClient>(),
"a123123",
"Test",
It.IsAny<JToken[]>()));
clientMock.Verify(x => x.CallResult("a123123",
It.Is((JToken result) => result.Value<string>("stuff") == "cool")));
}
public void TestListening()
{
RendererModel model = new RendererModel();
// test default
MockListener listener = new MockListener();
model.Listeners.Add(listener);
Assert.IsFalse(listener.IsChanged);
model.OnStateChanged(null);
Assert.IsTrue(listener.IsChanged);
// test unregistering
listener.IsChanged = false;
Assert.IsFalse(listener.IsChanged);
model.Listeners.Remove(listener);
model.OnStateChanged(null);
Assert.IsFalse(listener.IsChanged);
}
public async Task LoadTest()
{
MockListener.Reset();
MockListener2.Reset();
ObjectListener.Reset();
var start = DateTime.Now;
List <Task> tasks = new List <Task>();
for (int i = 0; i < 500000; i++)
{
tasks.Add(Listen.ModifiedAsync(ent, ent, ctx));
}
Task.WaitAll(tasks.ToArray());
var time = DateTime.Now.Subtract(start).TotalMilliseconds;
Assert.IsTrue(time < 1500, "time < 1500");
Assert.IsFalse(MockListener.WasOnCreatedCalled);
Assert.IsFalse(MockListener.WasOnCreationValidationFailedCalled);
Assert.IsTrue(MockListener.WasOnModifiedCalled);
Assert.IsFalse(MockListener.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener.WasOnDeletedCalled);
Assert.IsFalse(MockListener.WasOnDeletionFailedCalled);
Assert.IsFalse(MockListener2.WasOnCreatedCalled);
Assert.IsFalse(MockListener2.WasOnCreationValidationFailedCalled);
Assert.IsTrue(MockListener2.WasOnModifiedCalled);
Assert.IsFalse(MockListener2.WasOnModificationFailedCalled);
Assert.IsFalse(MockListener2.WasOnDeletedCalled);
Assert.IsFalse(MockListener2.WasOnDeletionFailedCalled);
Assert.IsFalse(ObjectListener.WasOnCreatedCalled);
Assert.IsFalse(ObjectListener.WasOnCreationValidationFailedCalled);
Assert.IsTrue(ObjectListener.WasOnModifiedCalled);
Assert.IsFalse(ObjectListener.WasOnModificationFailedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletedCalled);
Assert.IsFalse(ObjectListener.WasOnDeletionFailedCalled);
}
public void DateRollingTest()
{
var v = new MockViewer();
var l = new MockListener();
v.LogFile = Path.Combine(_folder, "logview4net.test.txt");
v.LogRolling = "Daily";
v.LogToFile = true;
var s = new Session(l, v);
s.AddEvent(l, "store log test");
s._rollingStorage._lastDatePart = "foo";
s.AddEvent(l, "store log test");
Assert.IsTrue(File.Exists(v.LogFile + "." + DateTime.Now.ToString("yyyyMMdd")));
s._rollingStorage._lastDatePart = "foo";
s.AddEvent(l, "store log test");
Assert.IsTrue(File.Exists(v.LogFile + "." + DateTime.Now.ToString("yyyyMMdd") + ".1"));
}
public void EventsAreFilteredByKeyword()
{
// Network filters all but network out
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventsAreFilteredByKeyword1", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Network))
{
tracer.AddEventListener(listener);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldNotReceive", metadata: null);
listener.EventNamesRead.ShouldNotContain(name => name.Equals("ShouldNotReceive"));
}
// Any filters nothing out
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventsAreFilteredByKeyword2", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Any))
{
tracer.AddEventListener(listener);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldAlsoReceive"));
}
// None filters everything out (including events marked as none)
using (JsonTracer tracer = new JsonTracer("Microsoft-Scalar-Test", "EventsAreFilteredByKeyword3", disableTelemetry: true))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.None))
{
tracer.AddEventListener(listener);
tracer.RelatedEvent(EventLevel.Informational, "ShouldNotReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldBeEmpty();
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoNotReceive", metadata: null);
listener.EventNamesRead.ShouldBeEmpty();
}
}
public void EventsAreFilteredByKeyword()
{
// Network filters all but network out
using (JsonEtwTracer tracer = new JsonEtwTracer("Microsoft-GVFS-Test", "EventsAreFilteredByVerbosity"))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Network))
{
listener.EnableEvents(tracer.EvtSource, EventLevel.Verbose);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldNotReceive", metadata: null);
listener.EventNamesRead.ShouldNotContain(name => name.Equals("ShouldNotReceive"));
}
// Any filters nothing out
using (JsonEtwTracer tracer = new JsonEtwTracer("Microsoft-GVFS-Test", "EventsAreFilteredByVerbosity"))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.Any))
{
listener.EnableEvents(tracer.EvtSource, EventLevel.Verbose);
tracer.RelatedEvent(EventLevel.Informational, "ShouldReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldReceive"));
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoReceive", metadata: null);
listener.EventNamesRead.ShouldContain(name => name.Equals("ShouldAlsoReceive"));
}
// None filters everything out (including events marked as none)
using (JsonEtwTracer tracer = new JsonEtwTracer("Microsoft-GVFS-Test", "EventsAreFilteredByVerbosity"))
using (MockListener listener = new MockListener(EventLevel.Verbose, Keywords.None))
{
listener.EnableEvents(tracer.EvtSource, EventLevel.Verbose);
tracer.RelatedEvent(EventLevel.Informational, "ShouldNotReceive", metadata: null, keyword: Keywords.Network);
listener.EventNamesRead.ShouldBeEmpty();
tracer.RelatedEvent(EventLevel.Verbose, "ShouldAlsoNotReceive", metadata: null);
listener.EventNamesRead.ShouldBeEmpty();
}
}
public async Task StartAsync_Retries()
{
var mockExecutor = new Mock <ITriggeredFunctionExecutor>();
var monitoredCosmosDBService = new Mock <ICosmosDBService>(MockBehavior.Strict);
monitoredCosmosDBService
.Setup(m => m.GetClient())
.Returns(new DocumentClient(new Uri("http://fakeaccount"), "c29tZV9rZXk="));
var leasesCosmosDBService = new Mock <ICosmosDBService>(MockBehavior.Strict);
leasesCosmosDBService
.Setup(m => m.GetClient())
.Returns(new DocumentClient(new Uri("http://fakeaccount"), "c29tZV9rZXk="));
var collInfo = new DocumentCollectionInfo {
Uri = new Uri("http://fakeaccount"), MasterKey = "c29tZV9rZXk=", DatabaseName = "FakeDb", CollectionName = "FakeColl"
};
var leaseInfo = new DocumentCollectionInfo {
Uri = new Uri("http://fakeaccount"), MasterKey = "c29tZV9rZXk=", DatabaseName = "FakeDb", CollectionName = "leases"
};
var processorOptions = new ChangeFeedProcessorOptions();
var listener = new MockListener(mockExecutor.Object, collInfo, leaseInfo, processorOptions, monitoredCosmosDBService.Object, leasesCosmosDBService.Object, NullLogger.Instance);
// Ensure that we can call StartAsync() multiple times to retry if there is an error.
for (int i = 0; i < 3; i++)
{
var ex = await Assert.ThrowsAnyAsync <InvalidOperationException>(() => listener.StartAsync(CancellationToken.None));
Assert.Equal("Failed to register!", ex.Message);
}
// This should succeed
await listener.StartAsync(CancellationToken.None);
}
static IntPtr n_ServicesResolved(IntPtr jnienv, IntPtr native__this)
{
MockListener __this = Java.Lang.Object.GetObject <MockListener> (native__this, JniHandleOwnership.DoNotTransfer);
return(global::Android.Runtime.JavaList <global::Javax.Jmdns.ServiceEvent> .ToLocalJniHandle(__this.ServicesResolved()));
}
public void SetUp()
{
_listener = new MockListener();
_outputWriter = new StringWriter();
}
public void CallServer_And_Receive_Call_Result_ViaRpcClient()
{
MockListener<JToken> mockListener = new MockListener<JToken>();
Mock<IWampServer<JToken>> serverMock = new Mock<IWampServer<JToken>>();
serverMock.Setup(x => x.Call(It.IsAny<IWampClient>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<JToken[]>()))
.Callback((IWampClient clientParameter, string callId, string procUrl, JToken[] arguments) =>
{
clientParameter.CallResult(callId, 12);
});
WampListener<JToken> listener = GetListener(mockListener, serverMock.Object);
MockConnection<JToken> connection = new MockConnection<JToken>();
WampRpcClientFactory<JToken> factory =
new WampRpcClientFactory<JToken>(new WampRpcSerializer(new WampDelegateProcUriMapper(x => x.Name)),
new WampRpcClientHandlerBuilder<JToken>(mFormatter,
new WampServerProxyFactory<JToken>(new WampServerProxyBuilder<JToken, IWampRpcClient<JToken>, IWampServer>(new WampOutgoingRequestSerializer<JToken>(mFormatter),
new WampServerProxyOutgoingMessageHandlerBuilder<JToken, IWampRpcClient<JToken>>(new WampServerProxyIncomingMessageHandlerBuilder<JToken, IWampRpcClient<JToken>>(mFormatter))))));
listener.Start();
ICalculator calculator = factory.GetClient<ICalculator>(connection.SideAToSideB);
mockListener.OnNext(connection.SideBToSideA);
int four = 4;
int sixteen = calculator.Square(four);
Assert.That(sixteen, Is.EqualTo(12));
serverMock.Verify(x => x.Call(It.IsAny<IWampClient>(),
It.IsAny<string>(),
"Square",
It.Is((JToken[] parameters) => parameters[0].Value<int>() == four)));
}
public void CallServer_And_Receive_Call_Result_ViaRpcServer()
{
MockListener<JToken> mockListener = new MockListener<JToken>();
var wampRpcServiceHost = new WampRpcMetadataCatalog();
wampRpcServiceHost.Register(new MethodInfoWampRpcMetadata(new AddCalculator()));
WampRpcServer<JToken> rpcServer =
new WampRpcServer<JToken>(mFormatter,
wampRpcServiceHost);
WampListener<JToken> listener = GetListener(mockListener, rpcServer);
MockConnection<JToken> connection = new MockConnection<JToken>();
WampRpcClientFactory<JToken> factory =
new WampRpcClientFactory<JToken>(new WampRpcSerializer(new WampDelegateProcUriMapper(x => "http://www.yogev.com/pr/" + x.Name)),
new WampRpcClientHandlerBuilder<JToken>(mFormatter,
new WampServerProxyFactory<JToken>(new WampServerProxyBuilder<JToken, IWampRpcClient<JToken>, IWampServer>(new WampOutgoingRequestSerializer<JToken>(mFormatter),
new WampServerProxyOutgoingMessageHandlerBuilder<JToken, IWampRpcClient<JToken>>(new WampServerProxyIncomingMessageHandlerBuilder<JToken, IWampRpcClient<JToken>>(mFormatter))))));
listener.Start();
IAddCalculator calculator = factory.GetClient<IAddCalculator>(connection.SideAToSideB);
mockListener.OnNext(connection.SideBToSideA);
int sixteen = calculator.Add(10, 6);
Assert.That(sixteen, Is.EqualTo(16));
}
static void n_Reset(IntPtr jnienv, IntPtr native__this)
{
MockListener __this = Java.Lang.Object.GetObject <MockListener> (native__this, JniHandleOwnership.DoNotTransfer);
__this.Reset();
}
public void SetUp()
{
_listener = new MockListener();
_outputWriter = new StringWriter();
}
