public async Task AddingAPreConfiguredServerHostsAndHandlesRequests()
{
//arrange
var serverHostBuilder = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services.AddGrpcServer(_server);
});
var cts = new CancellationTokenSource();
var serverHostTask = serverHostBuilder.RunConsoleAsync(cts.Token);
var request = new SampleRequest {
Value = 1
};
//act
var response = await _client.SendAsync(request);
//assert
Assert.Equal(request.Value, response.Value);
//clean up
cts.Cancel();
await serverHostTask;
}
public static object GetSample(SampleRequest sampleRequest)
{
switch (sampleRequest._sampleType)
{
case (SamplesEnum.CPU):
{
return(GetCpuSample());
}
case (SamplesEnum.MEMORY):
{
return(GetMemorySample());
}
case (SamplesEnum.PING):
{
return(GetPingSample((IPAddress)sampleRequest._parameter));
}
case (SamplesEnum.AdapterNames):
{
return(GetNetworkAdaptersNames());
}
case (SamplesEnum.AdapterStatistics):
{
return(GetNetworkAdapterStatistics(sampleRequest._parameter as string));
}
default:
{
return(-999);
}
}
}
public void SetUp()
{
requester = new SampleRequest();
mockRequester = new SampleMockRequest();
mockListRequester = new SampleListMockRequest();
errorRequester = new SampleErrorRequest();
}
public void ShouldBeAbleToReceiveResponseFromANodeWhenOtherNodesAreDown()
{
var sampleClusterConfiguration = BuildSampleClusterConfiguration();
var testServer1 = SetupTestServerForNode(sampleClusterConfiguration.Nodes[0]);
testServer1.Start();
var sut = new NetMqRpcChannel(sampleClusterConfiguration, TimeSpan.FromMilliseconds(200));
var sampleRequest = new SampleRequest("test");
var autoResetEvent = new AutoResetEvent(false);
int expectedNumberOfResponses = sampleClusterConfiguration.Nodes.Length;
var responses = new List <SampleResponse>();
sut.Broadcast <SampleRequest, SampleResponse>(sampleRequest, response =>
{
responses.Add(response);
if (responses.Count >= expectedNumberOfResponses)
{
autoResetEvent.Set();
}
});
autoResetEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, responses.Count);
Assert.IsNotNull(responses.SingleOrDefault(x => x.ResponseString == sampleClusterConfiguration.Nodes[0].Id.ToString()));
}
public SampleResponse Post(SampleRequest request)
{
return(new SampleResponse
{
Message = request.Message
});
}
public IHttpActionResult GetSampleRequest(long id)
{
SampleRequest sampleRequest = db.SampleRequest.Find(id);
CloudStorageProvider imageStorage = new CloudStorageProvider(UserManager);
return(Ok());
}
public async Task AddingASimpleServiceImplementationHostsAndHandlesRequests()
{
//arrange
var serverHostBuilder = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton <IService, EchoValueService>();
services.AddGrpcServer <DumbPipeServiceImplementation>(new[] { new ServerPort(_testRunValues.Host, _testRunValues.Port, _testRunValues.ServerCredentials) });
});
var cts = new CancellationTokenSource();
var serverHostTask = serverHostBuilder.RunConsoleAsync(cts.Token);
var request = new SampleRequest {
Value = 1
};
//act
var response = await _client.SendAsync(request);
//assert
Assert.Equal(request.Value, response.Value);
//clean up
cts.Cancel();
await serverHostTask;
}
public override async Task <SampleResponse> Login(SampleRequest request, ServerCallContext context)
{
return(new SampleResponse()
{
Verified = request.Account == "user" && request.Password == "1234"
});
}
public override object DoProcessBase(object Message)
{
try
{
//Business will be inside this function
SampleRequest sampleRequest = (SampleRequest)Message;
ContactInfo dto = new ContactInfo
{
SenderName = sampleRequest.sender_name,
SenderEmail = sampleRequest.sender_email,
SenderPhone = sampleRequest.sender_phone,
SenderMessage = sampleRequest.sender_message,
LastUpdatedTime = DateTime.Now,
};
QueryMaker.Instance.ContactInfo.Add(dto);
var r = QueryMaker.Instance.SaveChanges();
return(base.DoProcessBase(Message));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> FunctionHandlerAsync([FromBody] SampleRequest request)
{
SampleResponse response = await _mediator.Send(request);
return(response.IsSuccessStatusCode
? Ok(response.Payload)
: (IActionResult)StatusCode(response.StatusCode));
}
public void ExecuteHandler_RequestHandlerWithoutCondition_Execute()
{
var request = new SampleRequest();
var requestHandler = new Mock <FirstRequestHandler>(new ContextSample());
RequestHandlerOrchestrator.ExecuteHandler(request, requestHandler.Object);
requestHandler.Verify(p => p.HandleRequest(request));
}
public async Task <ApiResponse> Post([FromBody] SampleRequest createRequest)
{
if (!ModelState.IsValid)
{
throw new ApiProblemDetailsException(ModelState);
}
return(new ApiResponse(await _sampleApiConnect.PostDataAsync <SampleQueryResponse, SampleRequest>("/api/v1/sample", createRequest)));
}
private static void SimpleMessage()
{
var message = new SampleRequest()
{
Request = "Hello From World !",
Timestamp = DateTime.Now
};
publisher.Publish(message);
}
public override Task <SampleResponse> Ping(SampleRequest request, ServerCallContext context)
{
var response = new SampleResponse
{
Conteudo = $"{request.Conteudo}:{string.Join("", request.Conteudo.ToArray().Reverse())}",
Id = 7
};
return(Task.FromResult(response));
}
public static async Task MainAsync()
{
SampleRequest request = new SampleRequest
{
RequestType = 1
};
var res = await SampleModel.StartTouchlessTransaction(request);
Console.WriteLine(JsonConvert.SerializeObject(res, Formatting.Indented));
}
public async Task <SampleResponse> Post(SampleRequest sampleRequest)
{
await Task.CompletedTask.ConfigureAwait(false);
return(new SampleResponse
{
MassiveString = "SampleString",
UserId = "User100"
});
}
public async Task <IActionResult> Post([FromBody] SampleRequest request)
{
//Sample Business Error
if (request.ClientNo == 0)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = new Error()
{
ErrorCode = "1001", ErrorKey = "Id", ErrorMessage = "Invalid Id Passed"
}.ToErrorList(),
ErrorType = ErrorTypeCode.BusinessError
}));
}
// Sample Validation and return errors
var requestValidation = await _validator.ValidateAsync(request, ruleSet : "ValidateForPost");
if (!requestValidation.IsValid)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = requestValidation.Errors.Select(x => new Error()
{
ErrorMessage = x.ErrorMessage,
ErrorKey = x.PropertyName,
ErrorCode = x.ErrorCode
}).ToList(),
ErrorType = ErrorTypeCode.ValidationError
}));
}
//Sample Error Handling with Sub methods
(string result, Error error) = SampleSubMethod(request.ClientNo);
if (error != null)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = error.ToErrorList(),
ErrorType = ErrorTypeCode.BusinessError
}));
}
var response = new SampleResponse()
{
CarrierCode = "Test Code",
CarrierName = "Test Name",
Prefix = "Test Prefix"
};
return(Ok(response));
}
public IActionResult CreateEmployee([FromBody] SampleRequest sampleRequest)
{
var response = SampleRepository.CreateEmployee(sampleRequest);
return(new ContentResult
{
Content = JsonConvert.SerializeObject(response),
ContentType = "application/json",
StatusCode = 200
});
}
private static void SaturnMessage()
{
var message = new SampleRequest()
{
Request = "Hello From World !",
RoutingKey = "EARTH.SATURN",
Timestamp = DateTime.Now
};
publisher.Publish(message);
}
public async Task <ApiResponse> Post([FromBody] SampleRequest dto)
{
if (ModelState.IsValid)
{
return(new ApiResponse(await _sampleApiConnect.PostDataAsync <SampleResponse, SampleRequest>("/api/v1/sample", dto)));
}
else
{
throw new ApiException(ModelState.AllErrors());
}
}
public object Post(SampleRequest req)
{
if (req.ThrowException)
{
throw new ArgumentException($"Exception thrown from server - {req.Samples.Count} items in list");
}
return(new SampleResponse
{
Message = "Hello from sample service!"
});
}
public async Task WhenModelContainsErrorsShouldReturnOperationResultWithError()
{
//Arrange
var request = new SampleRequest();
//Act
var(success, exception) = await _sut.Handle(request, CancellationToken.None, null);
//Assert
Assert.False(success);
Assert.NotNull(exception);
}
public void UnicastShouldReturnNullIfServerDoesNotRespond()
{
var sampleClusterConfiguration = BuildSampleClusterConfiguration();
var sut = new NetMqRpcChannel(sampleClusterConfiguration, TimeSpan.FromMilliseconds(200));
var sampleRequest = new SampleRequest("test");
var responseReturned = sut.Unicast <SampleRequest, SampleResponse>(sampleClusterConfiguration.Nodes[0].Id, sampleRequest);
Assert.IsNull(responseReturned);
}
public async Task <bool> UpdateEntityByIdAsync(SampleRequest request, int id)
{
var entity = _mapper.Map <SampleRequest, Sample>(request);
entity.Id = id;
// In returns updated entity, you could do smth with it or just leave as it is
var updated = await _uow.SamplesRepository.UpdateAsync(entity);
var result = await _uow.SaveAsync();
return(result);
}
public async Task ReferenceImplementationWorksAsUsualWithSampleTestService()
{
//arrange
var request = new SampleRequest {
Value = 1
};
//act
var response = await _client.SendAsync(request);
//assert
Assert.Equal(request.Value, response.Value);
}
public void ExecuteHandler_RequestHandlerWithConditionFalse_NotExecute()
{
var request = new SampleRequest
{
Name = "name_test2"
};
var requestHandler = new Mock <FirstRequestHandler>(new ContextSample(), Condition());
RequestHandlerOrchestrator.ExecuteHandler(request, requestHandler.Object);
requestHandler.Verify(p => p.HandleRequest(request), Times.Never());
}
public FinalResponse CreateEmployee(SampleRequest sampleRequest)
{
using (var client = HttpClientFactory.CreateClient("RestApi"))
{
using (var response = client.PostAsJsonAsync(Config.Value.RestApi.Url, sampleRequest))
{
var responseBody = response.Result.Content.ReadAsStringAsync().Result;
var details = JsonConvert.DeserializeObject <SampleResult>(responseBody);
var sampleResponse = new FinalResponse();
sampleResponse = Mapper.Map <SampleResult, FinalResponse>(details);
return(sampleResponse);
}
}
}
public async Task DoesLoggingBehaviourWorksCorrectly()
{
var loggerFactory = TestLoggerFactory.Create();
var loggingBehaviour = new LoggingBehaviour <SampleRequest>(loggerFactory.CreateLogger <SampleRequest>());
var request = new SampleRequest
{
Version = "v2.0",
IsWorking = true
};
await loggingBehaviour.Process(request, CancellationToken.None);
loggerFactory.Sink.LogEntries.Should()
.ContainSingle(x => x.LogLevel == LogLevel.Information && x.Message == "eru Request: SampleRequest {Version = v2.0, IsWorking = True}");
}
public async Task <IActionResult> Put(int id, [FromBody] SampleRequest request)
{
if (id == 0)
{
throw new Exception("Client 0 not allowed");
}
var response = new SampleResponse()
{
CarrierCode = "Test Code",
CarrierName = "Test Name",
Prefix = "Test Prefix"
};
return(Ok(response));
}
public async Task <IActionResult> PostSomeData([FromBody] SampleRequest request) //
{
try
{
//Console.WriteLine(request.Data.Count.ToString());
return(Ok(request));
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
//return StatusCode(500);
return(Ok(ex.Message));
}
}
protected bool Equals(SampleRequest other)
{
return string.Equals(RequestString, other.RequestString);
}
static void Main()
{
var client = new Service1Client();
const string clientThumbprint = "e1 57 ef d7 49 5a 3e 44 b9 07 e4 f6 a1 50 ea 76 76 24 20 e0";
const string serviceThumbprint = "e1 57 ef d7 49 5a 3e 44 b9 07 e4 f6 a1 50 ea 76 76 24 20 e0";
var sample = new SampleRequest
{
Header = new HeaderType
{
MessageClass = MessageClassType.REQUEST,
TimeStamp = DateTime.Now,
MessageId = Guid.NewGuid().ToString(),
actor =
"http://smev.gosuslugi.ru/actors/recipient"
},
Message = new MessageType
{
Date = DateTime.Now,
Status = StatusType.REQUEST,
Originator = new orgExternalType
{
Code = "6666",
Name = "FMS"
},
Sender = new orgExternalType
{
Code = "5555",
Name = "MVD"
},
Recipient = new orgExternalType
{
Code = "3654",
Name = "XXX"
},
ExchangeType = "3"
},
MessageData = new MessageDataType
{
AppData = new AppDataType
{
Request = new RequestType
{
request = "123"
}
}
}
};
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
// Клиентский сертификат
var coll = store.Certificates.Find(X509FindType.FindByThumbprint, clientThumbprint, true);
if (coll.Count == 0)
{
throw new FileNotFoundException(string.Format("Сертификат клиент не найден. Отпечаток {0}", clientThumbprint));
}
var clientCert = coll[0];
coll = store.Certificates.Find(X509FindType.FindByThumbprint, serviceThumbprint, true);
if (coll.Count == 0)
{
throw new FileNotFoundException(string.Format("Сертификат сервера не найден. Отпечаток {0}", clientThumbprint));
}
// Сервисный сертификат
var serviceCert = coll[0];
var serverName = serviceCert.GetNameInfo(X509NameType.SimpleName, false);
if (serverName != null)
{
var endpointAddr = new EndpointAddress(new Uri("http://localhost:1622/Service1.svc"),
EndpointIdentity.CreateDnsIdentity(
serverName));
client.Endpoint.Address = endpointAddr;
}
var binding = new CustomBinding(client.Endpoint.Binding);
var textBindingElement = new Binding.SMEVMessageEncodingBindingElement();
binding.Elements.Remove<TextMessageEncodingBindingElement>();
binding.Elements.Insert(0, textBindingElement);
// Не ищем метку времени в сообщениях от сервиса
binding.Elements.Find<AsymmetricSecurityBindingElement>().LocalClientSettings.DetectReplays = false;
// Не вставляем метку времени в заголовок Security
binding.Elements.Find<AsymmetricSecurityBindingElement>().IncludeTimestamp = false;
// Устанавливаем модифицированную привязку.
client.Endpoint.Binding = binding;
// Требуется только подпись сообщения.
client.ChannelFactory.Endpoint.Contract.ProtectionLevel = System.Net.Security.ProtectionLevel.Sign;
if (client.ClientCredentials != null)
{
client.ClientCredentials.ClientCertificate.Certificate = clientCert;
client.ClientCredentials.ServiceCertificate.DefaultCertificate = serviceCert;
client.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None;
client.ClientCredentials.ServiceCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck;
}
client.GetData(sample.Header, ref sample.Message, ref sample.MessageData);
Console.WriteLine(sample.MessageData.AppData.Responce.responce);
Console.WriteLine(sample.Message.Date.ToString());
Console.WriteLine(sample.Message.Status);
Console.WriteLine("Done");
Console.ReadKey();
}
public SampleResponse Test(SampleRequest sampleRequest)
{
return SampleResponse.CreateBuilder()
.AddRangeData(CreateSampleData(_responseSize))
.Build();
}
