public void Send_And_Receive_Standard_Request()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
Assert.IsTrue(t1.TotalPendingOutgoingMessages == 1);
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request, new ResonanceRequestConfig()
{
LoggingMode = ResonanceMessageLoggingMode.Content
});
t1.Dispose(true);
t2.Dispose(true);
Assert.AreEqual(response.Sum, request.A + request.B);
}
public void Service_Handles_No_Input_Method_Async()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.MessageAcknowledgmentBehavior = ResonanceMessageAckBehavior.ReportErrors;
t2.MessageAcknowledgmentBehavior = ResonanceMessageAckBehavior.ReportErrors;
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
String s = proxy.GetStringNoInputAsync().GetAwaiter().GetResult();
Assert.AreEqual(s, "Test");
t1.Dispose(true);
t2.Dispose(true);
}
public void Service_Handles_Request_Method_With_Rpc_Attribute_Timeout_Throws_Exception()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
Assert.ThrowsException <TimeoutException>(() =>
{
var response = proxy.CalculateWithAttributeShortTimeout(request);
});
t1.Dispose(true);
t2.Dispose(true);
}
public void Singleton_Service_1()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
var response = proxy.Calculate(request);
Assert.AreEqual(response.Sum, request.A + request.B);
t1.Dispose(true);
t2.Dispose(true);
}
public void Transient_Service_3()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
bool funcExecuted = false;
t2.RegisterService <ITestService, TestService>(RpcServiceCreationType.Transient, () =>
{
funcExecuted = true;
return(new TestService());
});
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
var response = proxy.Calculate(request);
response = proxy.Calculate(request);
Assert.IsTrue(funcExecuted);
Assert.IsTrue(TestService.InstanceCount == 2);
t1.Dispose(true);
t2.Dispose(true);
}
public CalculateResponse Calculate(CalculateRequest request)
{
return(new CalculateResponse()
{
Sum = request.A + request.B
});
}
public void VoidNoInput()
{
receivedRequest = new CalculateRequest()
{
A = 100
};
}
private void BrowseClick(object sender, RoutedEventArgs e)
{
OpenFileDialog fileDialog = new OpenFileDialog();
if (fileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
FilePathText.Text = fileDialog.FileName;
String hands = File.ReadAllText(fileDialog.FileName);
CalculateRequest calculateRequest = new CalculateRequest();
calculateRequest.Api = "1";
calculateRequest.HackData = hands;
if (AuthCheckbox.IsChecked.GetValueOrDefault())
{
calculateRequest.Token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJIYXBweVNhaWxhIn0.IIDVkUYHojF8Uy2xi3JtS8I5GBHX2vKNZNx8awegNt8";
}
else
{
calculateRequest.Token = "";
}
CalculateResponse calculateResponse = MaltaBEClient.Calculate(calculateRequest);
OutputText.Text = calculateResponse.Data;
}
}
public override Task <CalculateReply> Calculate(CalculateRequest request, ServerCallContext context)
{
long result = -1;
switch (request.Op)
{
case "+":
result = request.X + request.Y;
break;
case "-":
result = request.X - request.Y;
break;
case "*":
result = request.X * request.Y;
break;
case "/":
if (request.Y != 0)
{
result = (long)request.X / request.Y;
}
break;
default:
break;
}
return(Task.FromResult(new CalculateReply {
Result = result
}));
}
public void Decoder_Exception_Throws_Exception()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Decoder = new CorruptedDecoder();
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest; //Should be calculate response...
t2.SendResponse(new CalculateResponse(), e.Message.Token);
};
var request = new CalculateRequest();
Assert.ThrowsException <CorruptedDecoderException>(() =>
{
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
});
t1.Dispose(true);
t2.Dispose(true);
}
public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
{
try
{
if (ModelState.IsValid)
{
ForecastRequestDto requestDto = _requestMapper.MapCalculation(request);
ForecastResponseDto responseDto = await _orchestrator.Orchestration(requestDto);
CalculateResponse response = _responseMapper.MapCalculationResponse(responseDto);
return(Ok(response));
}
var errors = MapModelValidationErrors(ModelState);
return(BadRequest(new CalculateResponse(errors)));
}
catch (Exception ex)
{
//logging
return(BadRequest(new CalculateResponse(new List <string>()
{
"Exception"
})));
}
}
public void Transporter_Failes_With_Adapter()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.FailsWithAdapter = true;
t1.Connect();
var request = new CalculateRequest()
{
A = 10, B = 15
};
try
{
var response = t1.SendRequest(request);
Assert.Fail("Expected an exception.");
}
catch { }
Assert.IsTrue(t1.State == ResonanceComponentState.Failed);
Assert.IsTrue(t1.FailedStateException.InnerException is KeyNotFoundException);
Assert.IsTrue(t1.FailedStateException.InnerException == t1.Adapter.FailedStateException);
t1.Dispose(true);
}
public void Request_Timeout_Throws_Exception()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
Thread.Sleep(1000);
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
Assert.ThrowsException <TimeoutException>(() =>
{
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request, new ResonanceRequestConfig()
{
Timeout = TimeSpan.FromSeconds(0.5)
});
});
t1.Dispose(true);
t2.Dispose(true);
}
public void Send_And_Receive_Standard_Request_With_Compression()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Encoder.CompressionConfiguration.Enabled = true;
t2.Encoder.CompressionConfiguration.Enabled = true;
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
t1.Dispose(true);
t2.Dispose(true);
Assert.AreEqual(response.Sum, request.A + request.B);
}
public static CalculateResponse Calculate(CalculateRequest request)
{
CalculateResponse response = new CalculateResponse();
switch (request.Operation)
{
case EnumOperation.Sum:
response.Result = request.ValueX + request.ValueY;
break;
case EnumOperation.Sub:
response.Result = request.ValueX - request.ValueY;
break;
case EnumOperation.Div:
response.Result = request.ValueX / request.ValueY;
break;
case EnumOperation.Mult:
response.Result = request.ValueX * request.ValueY;
break;
default:
break;
}
return(response);
}
public CalculateResult Calculate(CalculateRequest request)
{
_lastRequest = request;
switch (request.Type)
{
case CalculateType.Add:
return(new CalculateResult {
Result = request.FirstNumber + request.SecondNumber
});
case CalculateType.Subtract:
return(new CalculateResult {
Result = request.FirstNumber - request.SecondNumber
});
case CalculateType.Multiply:
return(new CalculateResult {
Result = request.FirstNumber * request.SecondNumber
});
case CalculateType.Divide:
return(new CalculateResult {
Result = request.FirstNumber / request.SecondNumber
});
default:
return(null);
}
}
public void Service_Handles_Object_Property_Get_Set()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.MessageAcknowledgmentBehavior = ResonanceMessageAckBehavior.ReportErrors;
t2.MessageAcknowledgmentBehavior = ResonanceMessageAckBehavior.ReportErrors;
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
CalculateRequest request = new CalculateRequest()
{
A = 1, B = 2
};
Assert.IsTrue(proxy.CalculateRequestProperty == null);
proxy.CalculateRequestProperty = request;
var value = proxy.CalculateRequestProperty;
Assert.AreEqual(value.A + value.B, request.A + request.B);
t1.Dispose(true);
t2.Dispose(true);
}
public void SendCalculateRequest(CalculateRequest calculateRequest)
{
if (this.calculateRequestConnection == null)
{
this.calculateRequestConnection = this.factory.CreateConnection();
}
if (this.calculateRequestChannel == null)
{
this.calculateRequestChannel = this.calculateRequestConnection.CreateModel();
}
Dictionary <string, object> args = new Dictionary <string, object>();
args.Add("x-max-length", 1);
args.Add("x-message-ttl", 60000);
this.calculateRequestChannel.QueueDeclare(queue: QUEUE_REQUEST,
durable: false,
exclusive: false,
autoDelete: false,
arguments: args);
var message = JsonConvert.SerializeObject(calculateRequest);
var body = Encoding.UTF8.GetBytes(message);
this.calculateRequestChannel.BasicPublish(exchange: "",
routingKey: QUEUE_REQUEST,
basicProperties: null,
body: body);
Console.WriteLine(" [x] Sent {0}", message);
}
public Task <CalculateResponse> CalculateAsync(CalculateRequest request)
{
return(Task.FromResult(new CalculateResponse()
{
Sum = request.A + request.B
}));
}
public void Calculate_ValidChange_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 1000;
request.PaidAmount = 2576;
//uint expected100Bills = 0;
//uint expected50Bills = 0;
//uint expected20Bills = 0;
uint expected10Bills = 1;
uint expected5Bills = 1;
//uint expected2Bills = 0;
//uint expected100Coins = 15;
uint expected50Coins = 1;
uint expected25Coins = 1;
uint expected1Coins = 1;
CalculateResponse response = changeCalculator.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.ErrorReportCollection.Any());
Assert.AreEqual(5, response.Change.Count());
Assert.AreEqual(expected10Bills, response.Change[1000]);
Assert.AreEqual(expected5Bills, response.Change[500]);
Assert.AreEqual(expected50Coins, response.Change[50]);
Assert.AreEqual(expected25Coins, response.Change[25]);
Assert.AreEqual(expected1Coins, response.Change[1]);
}
public void CalculateMultiParameterVoid(double a, double b)
{
receivedRequest = new CalculateRequest()
{
A = a, B = b
};
}
public async Task <CalculateResponse> Calculate([FromBody] CalculateRequest request)
{
var operation = CalcOperationFactory.GetOperation(request);
var result = await _calculationService.Calculate(operation);
return(result);
}
public void Singleton_Service_2()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
t2.RegisterService <ITestService, TestService>(RpcServiceCreationType.Singleton);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
var response = proxy.Calculate(request);
response = proxy.Calculate(request);
Assert.IsTrue(TestService.InstanceCount == 1);
t1.Dispose(true);
t2.Dispose(true);
}
public static Operation GetOperation(CalculateRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
switch (request.Operation)
{
case OperationType.Add:
return(new AddOperation(request.FirstValue, request.SecondValue));
case OperationType.Sub:
return(new SubOperation(request.FirstValue, request.SecondValue));
case OperationType.Div:
return(new DivOperation(request.FirstValue, request.SecondValue));
case OperationType.Mult:
return(new MultOperation(request.FirstValue, request.SecondValue));
default:
throw new ArgumentException("Operation type should be specified");
}
}
public void Service_Handles_Request_Async_Method()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
var response = proxy.CalculateAsync(request).GetAwaiter().GetResult();
Assert.AreEqual(response.Sum, request.A + request.B);
t2.UnregisterService <ITestService>();
Assert.ThrowsException <ResonanceResponseException>(() =>
{
proxy.CalculateAsync(request).GetAwaiter().GetResult();
});
t1.Dispose(true);
t2.Dispose(true);
}
public IActionResult Calculate(CalculateRequest request)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
// Loosely Typed View Data
ViewData["StartTime"] = DateTime.Now;
// Strongly Typed Model
var model = _mathService.Calculate(request);
// Loosely Typed View Bag
ViewBag.EndTime = DateTime.Now;
// Loosely Typed Temp Data (Read Once)
var lastRequest = $"The last request was to {request.Type} {request.FirstNumber} and {request.SecondNumber}";
TempData["LastRequest"] = lastRequest;
// Setting in the session to be reused
_httpContext.HttpContext.Session.SetString("lastRequest", lastRequest);
// Setting in the cookie (always in the response)
_httpContext.HttpContext.Response.Cookies.Append("lastRequest", lastRequest);
return(View(model));
}
public void Service_Handles_Request_Method_With_Rpc_Attribute_Timeout()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
var response = proxy.CalculateWithAttributeTimeout(request); //The timeout is 10 seconds while the service method delay is 6 and default timeout is 5 or 2.
t1.Dispose(true);
t2.Dispose(true);
}
public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
{
try
{
if (ModelState.IsValid)
{
RequestDTO requestDto = MapForecastRequestViewModel(request);
IEnumerable <ForecastResponseDTO> responseDto = await _orchestrator.Orchestration(requestDto);
CalculateResponse response = MapForecastResponseDto(responseDto);
return(Ok(response));
}
var errors = ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage).ToList();
return(BadRequest(new CalculateResponse(errors)));
}
catch (Exception ex)
{
//logging
return(BadRequest("Exception"));
}
}
public void Service_Handles_Request_Method_Throws_Exception()
{
Reset();
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
var testService = new TestService();
t2.RegisterService <ITestService, TestService>(testService);
var proxy = t1.CreateClientProxy <ITestService>();
var request = new CalculateRequest()
{
A = 10, B = 5
};
Assert.ThrowsException <ResonanceResponseException>(() =>
{
proxy.CalculateThrows(request);
}, "Test Error");
t2.UnregisterService <ITestService>();
t1.Dispose(true);
t2.Dispose(true);
}
public void Send_Standard_Message()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.Connect();
t2.Connect();
bool received = false;
t2.MessageReceived += (s, e) =>
{
Assert.IsTrue(t1.TotalPendingOutgoingMessages == 0);
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
Assert.IsTrue(receivedRequest.A == 10 && receivedRequest.B == 15);
received = true;
};
t1.Send(new CalculateRequest()
{
A = 10, B = 15
});
Thread.Sleep(500);
Assert.IsTrue(received);
t1.Dispose(true);
t2.Dispose(true);
}
