public void FixtureSetup()
{
Client = new RestContactClient(MockClient.User(), MockClient.Password());
ContactId = 165251012001;
ContactListId = 188505001;
QueryContact = new CfQueryContacts(1000, 0, null, null, null);
GetContactHistory = new CfGetContactHistory(1000, 0, ContactId);
var contact1 = new CfContact(null, "Contact1_Name", "Contact1_LastName", null, "14252163710", null, null, null, null, null);
var contact2 = new CfContact(null, "Contact2_Name", "Contact2_LastName", null, "14252163710", null, null, null, null, null);
CfContact[] contacts = { contact1, contact2 };
CreateContactList = new CfCreateContactList(null, "NewContactListTest", false, new CfContactSource(contacts));
object[] contacts2 = { ContactId };
CreateContactList2 = new CfCreateContactList(null, "NewContactListTest", false, new CfContactSource(contacts2));
var contactNumbers = new CfContactSourceNumbers("14252163710", new[] { "homePhone" });
CfContactSourceNumbers[] contacts3 = { contactNumbers };
CreateContactList3 = new CfCreateContactList(null, "NewContactListTest3", false, new CfContactSource(contacts3));
QueryContactLists = new CfQuery();
const long contactId = 165332795001;
const long contactListId = 188518001;
object[] contact = { contactId };
AddContactsToList = new CfContactListRequest(contactListId, false, new CfContactSource(contact));
RemoveContactsFromList = new CfRemoveContactsFromList(contactListId, contactId);
ContactLastName = "ContactLastNameRest";
ContactFirstName = "ContactFirstNameRest";
}
static void TestAggregatedOrderBookStreamOnMocks()
{
IExchangeClient exchangeA = new MockClient(0);
IExchangeClient exchangeB = new MockClient(1);
IExchangeClient exchangeC = new MockClient(2);
IObservable <IOrderBook> mergedOrderBookStream = Observable.Merge(exchangeA.OrderBookStream,
exchangeB.OrderBookStream,
exchangeC.OrderBookStream);
IObservable <AggregatedOrderBook> aggregatedOrderBookStream = mergedOrderBookStream.Scan(
new AggregatedOrderBook(),
(aob, orderBook) => aob.InsertBook(orderBook));
using (var consoleSubscription = aggregatedOrderBookStream.Subscribe(Console.WriteLine))
{
Console.WriteLine("press any key to stop");
var exchanges = new IExchangeClient[3] {
exchangeA, exchangeB, exchangeC
};
exchanges.ToList().ForEach(ex => { ex.Connect(); ((MockClient)ex).StartRandomOrders(); });
Console.ReadKey();
exchanges.ToList().ForEach(ex => { ex.Disconnect(); ((MockClient)ex).StopRandomOrders(); });
}
Console.WriteLine("stopped. Press any key to close window");
Console.ReadKey();
}
public async Task DeletesUnreferencedClientsInInaccessibleWorkspaces()
{
var accessibleWorkspace = new MockWorkspace(1000, isInaccessible: false);
var inaccessibleWorkspace = new MockWorkspace(2000, isInaccessible: true);
var client1 = new MockClient(1001, accessibleWorkspace, SyncStatus.InSync);
var client2 = new MockClient(1002, accessibleWorkspace, SyncStatus.SyncNeeded);
var client3 = new MockClient(2001, inaccessibleWorkspace, SyncStatus.SyncNeeded);
var client4 = new MockClient(2002, inaccessibleWorkspace, SyncStatus.InSync);
var project1 = new MockProject(101, accessibleWorkspace, client1, syncStatus: SyncStatus.InSync);
var project2 = new MockProject(102, accessibleWorkspace, client2, syncStatus: SyncStatus.InSync);
var project3 = new MockProject(201, inaccessibleWorkspace, client3, syncStatus: SyncStatus.InSync);
var clients = new[] { client1, client2, client3, client4 };
var projects = new[] { project1, project2, project3 };
var unreferencedClients = new[] { client4 };
var neededClients = clients.Where(client => !unreferencedClients.Contains(client));
configureDataSource(clients, projects);
await state.Start().SingleAsync();
clientsDataSource.Received().DeleteAll(Arg.Is <IEnumerable <IThreadSafeClient> >(arg =>
arg.All(client => unreferencedClients.Contains(client)) &&
arg.None(client => neededClients.Contains(client))));
}
public SqlVirtualMachineTestContext(object suiteObject, [CallerMemberName] string testName = "error_determining_test_name")
{
location = Constants.location;
_mockContext = MockContext.Start(suiteObject.GetType(), testName);
client = new MockClient(_mockContext);
resourceGroup = CreateResourceGroup(location);
}
public void InvokeMethodGrpcAsync_CanInvokeMethodWithNoReturnTypeAndData()
{
var request = new Request()
{
RequestParameter = "Hello "
};
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = Any.Pack(data),
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.Build();
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Returns(response);
FluentActions.Awaiting(async() => await client.DaprClient.InvokeMethodGrpcAsync <Request>("test", "test", request)).Should().NotThrow();
}
private async Task <(MockClient, HealthCheckResult)> RunHealthCheckAsync(HttpHealthCheckParameters parameters, HttpResponseMessage response)
{
Accessor <ServiceContext> accessor = new Accessor <ServiceContext>();
Mock <IHttpClientFactory> factoryMock = new Mock <IHttpClientFactory>();
MockClient clientMock = new MockClient(response);
factoryMock.Setup(f => f.CreateClient(HttpEndpointHealthCheck.HttpClientLogicalName))
.Returns(clientMock);
HttpEndpointHealthCheck healthCheck = new HttpEndpointHealthCheck(
parameters,
factoryMock.Object,
accessor,
new NullLogger <HttpEndpointHealthCheck>(),
new SimpleScopeProvider());
HealthCheckContext checkContext = HealthCheckContextHelper.CreateCheckContext();
HealthCheckResult uninitializedResult = await healthCheck.CheckHealthAsync(checkContext);
Assert.AreEqual(HealthStatus.Degraded, uninitializedResult.Status,
FormattableString.Invariant($"Should return {HealthStatus.Degraded} if accessor not set"));
Mock <ICodePackageActivationContext> mock = new Mock <ICodePackageActivationContext>();
mock.Setup(c => c.GetEndpoint(parameters.EndpointName)).Returns(new System.Fabric.Description.EndpointResourceDescription());
ServiceContext context = MockStatelessServiceContextFactory.Create(mock.Object, "", new Uri("http://localhost"), Guid.Empty, 0);
(accessor as IAccessorSetter <ServiceContext>).SetValue(context);
HealthCheckResult result = await healthCheck.CheckHealthAsync(checkContext);
return(clientMock, result);
}
/// <summary>
/// Connection to a mock client during a unit test.
/// </summary>
public MockConnection(MockClient client)
: base(null)
{
Client = client;
//client.DataSent += message => Receive(message);
DataSent += message => client.Receive(message);
}
public MainWindowViewModel()
{
//Create ExchangeClients
var mockExchangeClient0 = new MockClient(0);
var mockExchangeClient1 = new MockClient(1);
var mockExchangeClient2 = new MockClient(2);
//store them in an array
var exchanges = new IExchangeClient[3] {
mockExchangeClient0, mockExchangeClient1, mockExchangeClient2
};
//instantiate the corresponding ViewModels
//these controls allow to connect and disconnect from the underlying exchanges at will.
ExchangeVMs = exchanges.Select(e => new ExchangeViewModel(e)).ToList();
//merge their orderbook streams
var simpleOrderBookStream = Observable.Merge(ExchangeVMs.Select(e => e.UnderlyingExchange.OrderBookStream));
//scan the resulting stream into a stream of aggregated orderbooks (orderbooks with orders coming from different exchanges)
var aggregatedOrderBookStream = simpleOrderBookStream.Scan(new AggregatedOrderBook(), (aob, ob) => aob.InsertBook(ob));
//subscribe to the aggregatedOrderBookStream.
//each time a new aggregated orderbook is received, the list of bids and asks is updated in the UI.
//ATTENTION: no elements will be observed until at leat one individual exchange is connected to
aggregateStreamSubscription = aggregatedOrderBookStream.SubscribeOn(NewThreadScheduler.Default)
.ObserveOnDispatcher()
.Subscribe((aob) =>
{
Bids = aob.Bids.ToList();
Asks = aob.Asks.ToList();
});
}
private void ReadingTimerHandler(object sender, ElapsedEventArgs args)
{
var randomIndex = Enumerable.Range(0, this.mocks.Count).OrderBy(x => Guid.NewGuid()).ToList();
int i = 0;
while (this.readingCancellationToken != CancellationToken.None &&
!this.readingCancellationToken.IsCancellationRequested &&
i < randomIndex.Count)
{
MockClient mock = null;
try
{
QuerySetting querySetting = GetRandomQuerySetting();
this.stat.AddReadRequestCount(querySetting.Index, 1);
mock = this.mocks[randomIndex[i]];
Task.Factory.StartNew(() => ReadingJob(mock, querySetting, this.readingCancellationToken));
}
catch (Exception ex)
{
AddLog($"OpeningTimerHandler, mock index = {randomIndex[i]}, {ex.ToString()}, {ex.Message}");
this.stat.AddErrorCount();
}
finally
{
i++;
}
}
}
private Client CreateConnectedClient()
{
var client = new MockClient(server);
client.Connect("Target", 0);
return(client);
}
public void WhenAClientSendsAnInvalidCommand_ItShouldBeIgnored()
{
var client = new MockClient();
_listener.OnConnect(client);
client.OnMessage(new StompMessage("INVALID"));
}
public void InvokeMethodAsync_CanInvokeMethodWithNoReturnTypeAndData()
{
Request request = new Request()
{
RequestParameter = "Hello "
};
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = TypeConverters.ToAny(data)
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.Build();
// Setup the mock client to throw an Rpc Exception with the expected details info
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Returns(response);
FluentActions.Awaiting(async() => await client.DaprClient.InvokeMethodAsync <Request>("test", "test", request)).Should().NotThrow();
}
static void Main(string[] args)
{
Logger = new Logger()
{
MinLogLevelToDisplay = Configurations.Config.MinLogLevelToDisplay,
MinLogLevelToSave = Configurations.Config.MinLogLevelToSave
};
Services.Services.RegisterSingeleton(typeof(ILogger), Logger);
LoadCommandLineArgs(args);
Services.Services.RegisterSingeleton(typeof(IWalletService), new WalletService());
Server = new P2PServer();
Services.Services.RegisterSingeleton(typeof(IP2PServer), Server);
Services.Services.RegisterSingeleton(typeof(IMappingService), new MappingService());
Server.Start();
Logger.Log("Starting up node...");
if (true)
{
var mck = new MockClient();
mck.MockTest();
}
Console.ReadLine();
}
public async Task InvokeMethodAsync_CanInvokeMethodWithReturnTypeNoData_ThrowsExceptionNonSuccess()
{
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = TypeConverters.ToAny(data)
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.Build();
const string rpcExceptionMessage = "RPC exception";
const StatusCode rpcStatusCode = StatusCode.Unavailable;
const string rpcStatusDetail = "Non success";
var rpcStatus = new Status(rpcStatusCode, rpcStatusDetail);
var rpcException = new RpcException(rpcStatus, new Metadata(), rpcExceptionMessage);
// Setup the mock client to throw an Rpc Exception with the expected details info
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Throws(rpcException);
await FluentActions.Awaiting(async() => await client.DaprClient.InvokeMethodAsync <Response>("test", "test")).Should().ThrowAsync <RpcException>();
}
public void SuccessfulTaskCallsCallResultWithResult(WampRpcCall call, object result)
{
MockRawFormatter formatter = new MockRawFormatter();
MockRpcCatalog catalog = new MockRpcCatalog();
call.CallId = Guid.NewGuid().ToString();
MockRpcMethod mockMethod = GetMockMethod(call);
mockMethod.Result = result;
catalog.MapMethod(mockMethod);
WampRpcServer <MockRaw> server =
new WampRpcServer <MockRaw>(formatter, catalog);
MockClient client = new MockClient();
server.Call(client, call.CallId, call.ProcUri,
SerializeArguments(call, formatter));
Assert.That(client.GetCallErrorByCallId(call.CallId),
Is.Null);
Assert.That(client.GetResultByCallId(call.CallId),
Is.EqualTo(result));
}
public void FixtureSetup()
{
Client = new SoapLabelClient(MockClient.User(), MockClient.Password());
BroadcastClient = new SoapBroadcastClient(MockClient.User(), MockClient.Password());
var localTimeZoneRestriction = new CfLocalTimeZoneRestriction(DateTime.Now, DateTime.Now);
CfResult[] result = { CfResult.Received };
CfRetryPhoneType[] phoneTypes = { CfRetryPhoneType.FirstNumber };
var broadcastConfigRestryConfig = new CfBroadcastConfigRetryConfig(1000, 2, result, phoneTypes);
var expectedTextBroadcastConfig = new CfTextBroadcastConfig(1, DateTime.Now, null, localTimeZoneRestriction, broadcastConfigRestryConfig, "Test", CfBigMessageStrategy.DoNotSend);
var expectedBroadcast = new CfBroadcast(14898, "broadcastSoap", CfBroadcastStatus.Running, DateTime.Now, CfBroadcastType.Text, expectedTextBroadcastConfig);
var broadcastRequest = new CfBroadcastRequest("", expectedBroadcast);
BroadcastId = BroadcastClient.CreateBroadcast(broadcastRequest);
LabelName = "New SoapLabel";
Broadcast = new CfBroadcast
{
Name = "Name",
Type = CfBroadcastType.Text,
Item = new CfTextBroadcastConfig
{
FromNumber = VerifyShortCode,
RetryConfig = new CfBroadcastConfigRetryConfig
{
RetryPhoneTypes = new[] { CfRetryPhoneType.FirstNumber },
RetryResults = new[] { CfResult.NoAns }
},
Message = "Message Test",
},
};
}
public void InitializeServer()
{
mockServer = new MockServer();
server = new LocalhostLogServer(mockServer);
mockClient = new MockClient(mockServer);
mockClient.Connect("localhost", 1);
server.Start();
}
public void WhenAClientSendsAnInvalidCommand_ItShouldBeIgnored()
{
var client = new MockClient();
_listener.OnConnect(client);
client.OnMessage(new StompMessage("INVALID"));
}
public void SendTestMessageWithoutServerShouldNotCrash()
{
using (var client = new MockClient(null))
{
Assert.IsFalse(client.IsConnected);
client.Send(new TextMessage(""));
}
}
public void AddingAClient_ShouldAddTheClientToTheClientList()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
Assert.That(q.Clients.Contains(mockClient));
}
public void AddingAClient_ShouldAddTheClientToTheClientList()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
Assert.That(q.Clients.Contains(mockClient));
}
public void AddingAClient_ShouldSubscribeToTheOnCloseAction()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
mockClient.OnClose += () => { };
q.AddClient(mockClient, string.Empty);
Assert.AreEqual(mockClient.OnClose.GetInvocationList().Length, 2);
}
public void AddingAClient_ShouldSubscribeToTheOnCloseAction()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
mockClient.OnClose += () => { };
q.AddClient(mockClient, string.Empty);
Assert.AreEqual(mockClient.OnClose.GetInvocationList().Length, 2);
}
public void AddingAClientTwice_ShouldAddTheClientToTheClientListOnce()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
q.AddClient(mockClient, string.Empty);
Assert.That(q.Clients.Contains(mockClient));
Assert.AreEqual(q.Clients.Length, 1);
}
public void ConnectToServer()
{
var server = new MockServer();
using (var client = new MockClient(server))
{
client.Connect("localhost", 1);
Assert.IsTrue(client.IsConnected);
}
}
public async Task TryDeleteStateAsync_NullEtagThrowsArgumentException()
{
var client = new MockClient();
var response = client.CallStateApi<string>()
.Build();
await FluentActions.Awaiting(async () => await client.DaprClient.TryDeleteStateAsync("test", "test", null))
.Should().ThrowAsync<ArgumentException>();
}
private ActionTest(FaultAnalysisServiceMessageProcessor messageProcessor, ActionStore actionStore, IReliableStateManager stateManager, IReliableDictionary <string, string> internalTestsStarted)
{
ThrowIf.Null(internalTestsStarted, "internalTestsStarted");
this.actionStore = actionStore;
this.stateManager = stateManager;
this.internalTestsStarted = internalTestsStarted;
this.mockClient = new MockClient(messageProcessor);
}
public MongoProviderMockHelper()
{
this.MockProvider = new Mock <IMongoProvider <IMongoClient> >();
this.MockClient = new Mock <IMongoClient>();
this.MockDatabase = new Mock <IMongoDatabase>();
this.Db = new FakeDB();
MockClient.Setup(m => m.GetDatabase(It.IsAny <string>(), It.IsAny <MongoDatabaseSettings>())).Returns(MockDatabase.Object);
MockProvider.Setup(m => m.GetClient()).Returns(MockClient.Object);
}
public void FixtureSetup()
{
var region = new CfRegion(null, null, null, null, null, null, null, null, null, null);
Client = new SoapNumberClient(MockClient.User(), MockClient.Password());
RegionQuery = new CfRegionQuery(100, 0, region);
SearchAvailableKeywords = new CfSearchAvailableKeywords(string.Empty);
SearchAvailableNumbers = new CfSearchAvailableNumbers(null, true, 100);
QueryKeywords = new CfQuery();
QueryNumbers = new CfQueryNumbers(100, 0, region, null);
}
public async void AddDetection_Options_Disable_False()
{
using var server = MockServer.Server(options => { options.Responsive.Disable = false; });
var client = server.CreateClient();
var request = MockClient.CreateRequest(Device.Mobile);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Assert.Contains("mobile", await response.Content.ReadAsStringAsync(), StringComparison.OrdinalIgnoreCase);
}
public void WhenAClientDisconnects_ItShouldBeRemovedFromTheQueue()
{
var q = GetStompQueue("/queue/test");
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
Assert.IsNotEmpty(q.Clients);
mockClient.OnClose();
Assert.IsEmpty(q.Clients);
}
public void AddingAClientTwice_ShouldAddTheClientToTheClientListOnce()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
q.AddClient(mockClient, string.Empty);
Assert.That(q.Clients.Contains(mockClient));
Assert.AreEqual(q.Clients.Length, 1);
}
public void SendTestMessageToServer()
{
var server = new MockServer();
var client = new MockClient(server);
client.Connect("localhost", 1);
client.Send(new TextMessage("Hi"));
var serverMessage = server.LastMessage as TextMessage;
Assert.IsNotNull(serverMessage);
Assert.AreEqual("Hi", serverMessage.Text);
}
public async void Invoke_HttpContext_ResponsiveService_Success()
{
using var server = MockServer.Server();
var request = MockClient.CreateRequest(Device.Desktop);
var client = server.CreateClient();
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Assert.Contains(
"desktop",
await response.Content.ReadAsStringAsync(),
StringComparison.OrdinalIgnoreCase);
}
public void ClientIsDisconnected()
{
var server = new MockServer();
var client = new MockClient(server);
bool isConnected = false;
client.Connected += () => isConnected = true;
client.Disconnected += () => isConnected = false;
client.Connect("localhost", 1);
Assert.IsTrue(isConnected);
client.Dispose();
Assert.IsFalse(isConnected);
}
public void RemovingAAClient_ShouldRemoveTheClientFromTheClientListAndUnsubscribeFromTheOnCloseEvent()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
mockClient.OnClose += () => { };
q.AddClient(mockClient, string.Empty);
Assert.That(q.Clients.Contains(mockClient));
q.RemoveClient(mockClient);
Assert.IsEmpty(q.Clients);
Assert.AreEqual(mockClient.OnClose.GetInvocationList().Length, 1);
}
public void RemovingTheLastClient_ShouldTriggerTheLastClientRemovedEvent()
{
var q = GetStompQueue(string.Empty);
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
var fired = false;
q.OnLastClientRemoved += x => fired = true;
Assert.IsFalse(fired);
q.RemoveClient(mockClient);
Assert.IsTrue(fired);
}
public void WhenAClientConnects_ItShouldGetAConnectedResponseMessage()
{
var client = new MockClient();
_listener.OnConnect(client);
StompMessage r = null;
client.OnServerMessage += m => r = m;
client.OnMessage(new StompMessage("CONNECT"));
Assert.IsNotNull(r);
Assert.AreEqual(r.Command, "CONNECTED");
Assert.AreEqual(r.Body, string.Empty);
Assert.AreEqual(r["session-id"], client.SessionId.ToString());
Assert.IsTrue(client.IsConnected());
}
public void WhenAnUnconnectedClientIssuesACommandOtherThenConnect_AnErrorShouldBeReturned()
{
var client = new MockClient();
_listener.OnConnect(client);
StompMessage r = null;
client.OnServerMessage += m => r = m;
client.OnMessage(new StompMessage("SUBSCRIBE"));
Assert.IsNotNull(r);
Assert.AreEqual(r.Command, "ERROR");
Assert.AreEqual(r.Body, "Please connect before sending 'SUBSCRIBE'");
}
public void WhenAClientDisconnects_ItShouldBeRemovedFromTheQueue()
{
var q = GetStompQueue("/queue/test");
var mockClient = new MockClient();
q.AddClient(mockClient, string.Empty);
Assert.IsNotEmpty(q.Clients);
mockClient.OnClose();
Assert.IsEmpty(q.Clients);
}
