/// <summary>
/// Adds an HttpResponseMessage to the response queue.
/// </summary>
/// <param name="content">The simulated response body content (optional).</param>
/// <param name="status">The simulated HTTP status. Default is 200.</param>
/// <param name="headers">The simulated response headers (optional).</param>
/// <param name="cookies">The simulated response cookies (optional).</param>
/// <returns>The current HttpTest object (so more responses can be chained).</returns>
public HttpTest RespondWith(HttpContent content = null, int status = 200, object headers = null, object cookies = null)
{
var response = new HttpResponseMessage {
StatusCode = (HttpStatusCode)status,
Content = content
};
if (headers != null)
{
foreach (var kv in headers.ToKeyValuePairs())
{
response.Headers.Add(kv.Key, kv.Value.ToInvariantString());
}
}
if (cookies != null)
{
foreach (var kv in cookies.ToKeyValuePairs())
{
var value = new Cookie(kv.Key, kv.Value.ToInvariantString()).ToString();
response.Headers.Add("Set-Cookie", value);
}
}
ResponseQueue.Enqueue(response);
return(this);
}
internal HttpResponseMessage GetNextResponse()
{
return(ResponseQueue.Any() ? ResponseQueue.Dequeue() : new HttpResponseMessage {
StatusCode = HttpStatusCode.OK,
Content = new StringContent("")
});
}
private MscMcomQueue GetQueueData(String queueName, ResponseQueue responseQueue)
{
MscMcomQueue mscMcomQueue = new MscMcomQueue();
mscMcomQueue.AcquirerId = responseQueue.acquirerId;
mscMcomQueue.Arn = responseQueue.acquirerRefNum;
mscMcomQueue.CardNo = responseQueue.primaryAccountNum;
mscMcomQueue.ClaimId = responseQueue.claimId;
mscMcomQueue.ClaimType = responseQueue.claimType;
mscMcomQueue.ClaimAmount = Convert.ToDecimal(responseQueue.claimValue.Split(' ')[0], CultureInfo.GetCultureInfo("en-US"));
mscMcomQueue.ClaimCurrency = GetCurrencyCode(responseQueue.claimValue.Split(' ')[1]);
mscMcomQueue.ClearingDueDate = DateTime.ParseExact(responseQueue.clearingDueDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
mscMcomQueue.ClearingNetwork = responseQueue.clearingNetwork;
mscMcomQueue.CreateDate = DateTime.ParseExact(responseQueue.createDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
mscMcomQueue.DueDate = DateTime.ParseExact(responseQueue.dueDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
mscMcomQueue.TransactionId = responseQueue.transactionId;
mscMcomQueue.IsAccurate = Convert.ToBoolean(responseQueue.isAccurate);
mscMcomQueue.IsAcquirer = Convert.ToBoolean(responseQueue.isAcquirer);
mscMcomQueue.IsIssuer = Convert.ToBoolean(responseQueue.isIssuer);
mscMcomQueue.IsOpen = Convert.ToBoolean(responseQueue.isOpen);
mscMcomQueue.IssuerId = responseQueue.issuerId;
mscMcomQueue.LastModifiedBy = responseQueue.lastModifiedBy;
mscMcomQueue.LastModifiedDate = DateTime.ParseExact(responseQueue.lastModifiedDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
mscMcomQueue.MerchantId = responseQueue.merchantId;
mscMcomQueue.ProgressState = responseQueue.progressState;
mscMcomQueue.QueueName = queueName;
mscMcomQueue.ProcessedStatus = "N";
mscMcomQueue.ProcessedDate = DateTime.ParseExact("19000101", "yyyyMMdd", CultureInfo.InvariantCulture);
mscMcomQueue.InsertDate = DateTime.Now;
mscMcomQueue.InsertTime = Convert.ToInt32(DateTime.Now.ToString("hhMMss"));
return(mscMcomQueue);
}
/// <summary>
/// Adds an HttpResponseMessage to the response queue with the given HTTP status code and the given data serialized to JSON as the content body.
/// </summary>
public HttpTest RespondWithJson(int status, object data)
{
ResponseQueue.Enqueue(new HttpResponseMessage {
StatusCode = (HttpStatusCode)status,
Content = new CapturedJsonContent(FlurlHttp.GlobalSettings.JsonSerializer.Serialize(data))
});
return(this);
}
/// <summary>
/// Adds an HttpResponseMessage to the response queue with the given HTTP status code and content body.
/// </summary>
public HttpTest RespondWith(int status, string body)
{
ResponseQueue.Enqueue(new HttpResponseMessage {
StatusCode = (HttpStatusCode)status,
Content = new StringContent(body)
});
return(this);
}
//Thread Safe Queuing System
static public void AddResponse(ResponsePacket _packet)
{
lock (ResponseQueue)
{
ResponseQueue.Enqueue(_packet);
}
WorkerWriteAvailable.Set();
}
/// <summary>
/// Adds an HttpResponseMessage to the response queue with the given HTTP status code and the given data serialized to JSON as the content body.
/// </summary>
public HttpTest RespondWithJson(int status, object data)
{
ResponseQueue.Enqueue(new HttpResponseMessage {
StatusCode = (HttpStatusCode)status,
Content = new CapturedJsonContent(data)
});
return(this);
}
/// <inheritdoc />
public new HttpTest RespondWithJson(int status, object data)
{
ResponseQueue.Enqueue(new HttpResponseMessage
{
StatusCode = (HttpStatusCode)status,
Content = new CapturedJsonContent(OpenStackNet.Configuration.FlurlHttpSettings.JsonSerializer.Serialize(data))
});
return(this);
}
private RestResponse HandleInSequence()
{
if (ResponseQueue.Count == 0)
{
throw new ArgumentOutOfRangeException("No responses queued");
}
var nextQueuedResponse = ResponseQueue.Dequeue();
return(CreateResponse(nextQueuedResponse));
}
public Task <ResponseQueue> CreateQueue(string fila)
{
var canalEscolhido = CreateChannel();
var queueCriada = new ResponseQueue(canalEscolhido.QueueDeclare(queue: fila,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null));
canalEscolhido.Dispose();
return(Task.FromResult(queueCriada));
}
public static int Main(String[] args)
{
var requestQueue = new RequestQueue();
var responseQueue = new ResponseQueue();
responseDaemon = new ResponseDaemon(responseQueue);
serverDaemon = new ServerDaemon(requestQueue);
commandDaemon = new CommandDaemon(requestQueue, responseQueue);
responseDaemon.Start();
commandDaemon.Start();
serverDaemon.Start();
Console.ReadKey();
return(0);
}
public IEnumerable <Response> ExecuteRequests()
{
InternetConnectivityCheck();
InitiateInternetConnectivityCheckInterval();
Log.Debug("Executing Requests.");
var distributorCancellationSource = new CancellationTokenSource();
try
{
this.InitializeWorkers();
foreach (Object produce in this.ResponseQueue.GetConsumingEnumerable(distributorCancellationSource.Token))
{
if (produce is Response response)
{
string successString = response.Body != null ? "Y" : "N";
Log.Info($"Response yielded. Success? {successString} URL: {response.Request.URL} ");
yield return(response);
}
else if (produce is DistributionWorker worker)
{
this.Workers.Remove(worker);
}
if (this.Workers.Count == 0 && this.ResponseQueue.Count == 0)
{
Log.Debug("No workers or responses present.");
ResponseQueue.CompleteAdding();
}
}
}
finally
{
Log.Debug("Stopping execution of this thread.");
this.StopProcessingRequests();
}
}
public void QueueResponse(int?status)
{
ResponseQueue.Enqueue(status);
}
public void QueueResponse(Exception ex)
{
ResponseQueue.Enqueue(ex);
}
public void QueueResponse(RestResponse response)
{
ResponseQueue.Enqueue(response);
}
public IActionResult UpdatePayment(UpdateResponse updateResponse)
{
ResponseQueue.Enqueue(updateResponse);
return(Ok());
}
/// <summary>
/// Adds a simulated timeout response to the response queue.
/// </summary>
public HttpTest SimulateTimeout()
{
ResponseQueue.Enqueue(new TimeoutResponseMessage());
return(this);
}
public void EnqueueResponse(Object response)
{
ResponseQueue.Add(response);
}
public ResponseDaemon(ResponseQueue responseQueue)
{
this.responseQueue = responseQueue;
this.numberOfProcessors = 4;
}
public CommandDaemon(RequestQueue requestQueue, ResponseQueue responseQueue)
{
this.requestQueue = requestQueue;
this.responseQueue = responseQueue;
}
