public async void Must_use_name_from_attribute()
{
NameResult result = await _mapper.MapAsync(typeof(Endpoint), typeof(Endpoint).GetMethod("Method"));
Assert.That(result.Name, Is.EqualTo("name"));
Assert.That(result.ResultType, Is.EqualTo(NameResultType.NameMapped));
}
/// <summary>
///
/// </summary>
/// <param name="currency_name">base coin or quote coin name</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public virtual async ValueTask <NameResult> LoadCurrencyNickAsync(string currency_name, Dictionary <string, object> args = null)
{
var _result = new NameResult();
var _markets = await this.LoadMarketsAsync();
if (_markets.success == true)
{
if (publicClient.ExchangeInfo.CurrencyNicks.ContainsKey(currency_name) == true)
{
_result.result = publicClient.ExchangeInfo.CurrencyNicks[currency_name];
_result.SetResult(_markets);
}
else
{
_result.SetFailure(
$"not exist currency name '{currency_name}' in currencies",
ErrorCode.NotSupported
);
}
}
else
{
_result.SetResult(_markets);
}
return(await Task.FromResult(_result));
}
/// <summary>
///
/// </summary>
/// <param name="currency_name">base coin or quote coin name</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public virtual async Task <NameResult> LoadCurrencyId(string currency_name, Dictionary <string, object> args = null)
{
var _result = new NameResult();
var _markets = await this.LoadMarkets();
if (_markets.success == true)
{
if (_markets.CurrencyNames.ContainsValue(currency_name) == true)
{
_result.result = _markets.GetCurrencyId(currency_name);
_result.SetResult(_markets);
}
else
{
_result.SetFailure(
$"not exist currency name '{currency_name}' in currencies",
ErrorCode.NotSupported
);
}
}
else
{
_result.SetResult(_markets);
}
return(await Task.FromResult(_result));
}
protected bool SingleQuery(int idx)
{
try
{
NameResult result = Extract.DownloadName(idx);
switch (result.Response)
{
case NameResponse.Unknown:
ProcessUnknownResult(idx);
return(false);
case NameResponse.Success:
ProcessSuccessResult(idx, result.Name);
return(true);
case NameResponse.InvalidId:
ProcessInvalidResult(idx);
return(false);
}
}
catch (DbException ex)
{
ProcessSQLException(idx, ex);
}
catch (Exception ex)
{
ProcessNonSQLException(idx, ex);
}
return(false);
}
public dynamic Post([FromBody] Name Name)
{
if (Name != null)
{
var names = new names();
// Classe e metodo para conversão do Nome do autor!
var AuthorName = names.nameProcessPrint(Name.name);
//Verificação se o nome é valido após o processamento!
if (AuthorName != null)
{
//ORM Entity Framework Core!
using (var dataBase = new DatabaseContext())
{
//Entity Model
var tblNomes = new TblNames();
tblNomes.Name = AuthorName;
dataBase.TblNames.Add(tblNomes);
//Save no database
dataBase.SaveChanges();
var nameResult = new NameResult();
nameResult.result = true;
nameResult.Names = dataBase.TblNames.OrderByDescending(a => a.Id).ToList();
//Retorna lista seguido do resultado para o FrontEnd Angular em Json.
return(Ok(nameResult));
}
}
return(BadRequest());
}
return(BadRequest());
}
public async void Must_name_correctly(bool makeLowercase, string wordSeparator, string methodName, string expectedName)
{
var mapper = new NameAfterRelativeClassNamespaceAndClassNameAndMethodNameMapper("Junior.Route.UnitTests.AutoRouting", makeLowercase, wordSeparator);
NameResult result = await mapper.MapAsync(typeof(Endpoint), typeof(Endpoint).GetMethod("Get"));
Assert.That(result.Name, Is.EqualTo(expectedName));
Assert.That(result.ResultType, Is.EqualTo(NameResultType.NameMapped));
}
public async void Must_name_correctly(bool makeLowercase, string wordSeparator, string expectedName)
{
var mapper = new NameAfterRelativeClassNamespaceAndClassNameMapper("System", makeLowercase, wordSeparator);
NameResult result = await mapper.MapAsync(typeof(HttpRequestBase), typeof(HttpRequestBase).GetMethod("Abort"));
Assert.That(result.Name, Is.EqualTo(expectedName));
Assert.That(result.ResultType, Is.EqualTo(NameResultType.NameMapped));
}
public override Task <NameResult> Hello(NameResult request, ServerCallContext context)
{
Console.WriteLine($"from grpc {request.Name} call Hello! [{ServiceName}]");
request.Name = $"from grpc hello {request.Name} [{ServiceName}]";
return(Task.FromResult <NameResult>(request));
}
private static void ValidateNameLeandroResult(NameResult leandro)
{
leandro.Should().NotBeNull();
leandro.Details.Should().NotBeNull();
var leandro1930 = leandro.Details.FirstOrDefault(x => x.Period == "1930[");
leandro1930.Should().NotBeNull();
leandro1930.Frequency.Should().Be(339);
}
public override Task <NameResult> ShowHello(RpcContractGrpc.HelloResult request, ServerCallContext context)
{
Console.WriteLine($"from grpc {request.Name} call SayHello! [{ServiceName}]");
var result = new NameResult
{
Name = $"from grpc name:{request.Name}；gender:{request.Gender}；avatar:{request.Head} [{ServiceName}]"
};
return(Task.FromResult <NameResult>(result));
}
public override Task <RpcContractGrpc.HelloResult> SayHello(NameResult request, ServerCallContext context)
{
Console.WriteLine($"from grpc {request.Name} call SayHello! [{ServiceName}]");
var result = new RpcContractGrpc.HelloResult
{
Name = $"from grpc {request.Name} [{ServiceName}]",
Gender = "male",
Head = "head.png"
};
return(Task.FromResult <RpcContractGrpc.HelloResult>(result));
}
public dynamic Get()
{
using (var dataBase = new DatabaseContext())
{
//Entity Model
var tblNomes = new TblNames();
var nameResult = new NameResult();
nameResult.result = true;
nameResult.Names = dataBase.TblNames.OrderByDescending(a => a.Id).ToList();
//Retorna lista seguido do resultado para o FrontEnd Angular em Json.
return(Ok(nameResult));
}
}
/// <summary>
/// Get deposit methods
/// </summary>
/// <param name="currency_id"></param>
/// <returns></returns>
private async Task <NameResult> getDepositMethod(string currency_id)
{
var _result = new NameResult();
if (depositMethods.ContainsKey(currency_id) == false)
{
var _params = new Dictionary <string, object>();
{
_params.Add("asset", currency_id);
}
#if DEBUG
if (XApiClient.TestXUnitMode != XUnitMode.UseExchangeServer)
{
_result.result = currency_id;
depositMethods.Add(currency_id, _result.result);
}
else
{
#endif
var _json_value = await privateClient.CallApiPost1Async("/0/private/DepositMethods", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JToken>(_json_value.Content);
{
_result.result = _json_data["result"][0]["method"].Value <string>();
depositMethods.Add(currency_id, _result.result);
}
}
_result.SetResult(_json_result);
#if DEBUG
}
#endif
}
else
{
_result.result = depositMethods[currency_id];
_result.SetSuccess();
}
return(_result);
}
private async Task <string> GetNameAsync(Type matchingType, MethodInfo matchingMethod)
{
foreach (INameMapper nameMapper in _nameMappers)
{
NameResult result = (await nameMapper.MapAsync(matchingType, matchingMethod));
if (result.ResultType == NameResultType.NameMapped)
{
return(result.Name);
}
}
return(null);
}
public override Task <RpcContractGrpc.Void> CallName(NameResult request, ServerCallContext context)
{
try
{
Console.WriteLine($"from grpc CallName {request.Name} call Hello! [{ServiceName}]");
return(Task.FromResult(new RpcContractGrpc.Void()));
}
catch (Exception ex)
{
var md = new Metadata();
md.Add("err", ex.Message);
context.WriteResponseHeadersAsync(md);
return(Task.FromResult(new RpcContractGrpc.Void()));
}
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper = MockRepository.GenerateMock <IIdMapper>();
_idMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper
.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = (NameResult.NameMapped(Guid.NewGuid().ToString())).AsCompletedTask())
.Return(null);
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper);
}
public override Task <RpcContractGrpc.Void> CallName(NameResult request, ServerCallContext context)
{
Console.WriteLine($"from grpc CallName {request.Name} call Hello! [{ServiceName}]");
return(Task.FromResult(new RpcContractGrpc.Void()));
}
public void SetUp()
{
_result = NameResult.NameNotMapped();
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_methodFilter = MockRepository.GenerateMock <IMethodFilter>();
_methodFilter
.Stub(arg => arg.MatchesAsync(Arg <MethodInfo> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = (((MethodInfo)arg.Arguments.First()).Name == "IncludedMethod").AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper = MockRepository.GenerateMock <IIdMapper>();
_idMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(NameResult.NameMapped("name").AsCompletedTask());
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_responseMapper = MockRepository.GenerateMock <IResponseMapper>();
_responseMapper
.Stub(arg => arg.MapAsync(Arg <Func <IContainer> > .Is.Anything, Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything))
.Return(Task.Factory.Empty());
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.MethodFilters(_methodFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.ResponseMapper(_responseMapper);
_routes = _autoRouteCollection.GenerateRouteCollectionAsync().Result.ToArray();
}
public void SetUp()
{
_result = NameResult.NameMapped("name");
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper = MockRepository.GenerateMock <IIdMapper>();
_idMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(NameResult.NameMapped(Guid.NewGuid().ToString()).AsCompletedTask());
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_responseMapper = MockRepository.GenerateMock <IResponseMapper>();
_responseMapper
.Stub(arg => arg.MapAsync(Arg <Func <IContainer> > .Is.Anything, Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything))
.Return(Task.Factory.Empty());
_httpRuntime = MockRepository.GenerateMock <IHttpRuntime>();
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(typeof(Endpoint).Assembly)
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.RestrictUsingAttributes <UrlRelativePathAttribute>()
.RestrictRelativePathsToRelativeClassNamespaceAndClassName("")
.ResponseMapper(_responseMapper)
.RestrictionContainer(new DefaultRestrictionContainer(_httpRuntime));
_routes = _autoRouteCollection.GenerateRouteCollectionAsync().Result.ToArray();
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper = MockRepository.GenerateMock <IIdMapper>();
_idMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(NameResult.NameMapped("name").AsCompletedTask());
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_authenticationProvider = MockRepository.GenerateMock <IAuthenticationProvider>();
_authenticationProvider
.Stub(arg => arg.AuthenticateAsync(Arg <HttpRequestBase> .Is.Anything, Arg <HttpResponseBase> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything))
.Return(AuthenticationResult.AuthenticationSucceeded.AsCompletedTask());
_authenticationStrategy = MockRepository.GenerateMock <IAuthenticationStrategy>();
_authenticationStrategy.Stub(arg => arg.MustAuthenticateAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(true.AsCompletedTask());
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.Authenticate(_authenticationProvider, _authenticationStrategy);
_routes = _autoRouteCollection.GenerateRouteCollectionAsync().Result.ToArray();
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper = MockRepository.GenerateMock <IIdMapper>();
_idMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(NameResult.NameMapped("name").AsCompletedTask());
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_responseMapper = MockRepository.GenerateMock <IResponseMapper>();
_responseMapper
.Stub(arg => arg.MapAsync(Arg <Func <IContainer> > .Is.Anything, Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything))
.Return(Task.Factory.Empty());
_restrictionMapper1 = MockRepository.GenerateMock <IRestrictionMapper>();
_restrictionMapper1
.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything, Arg <IContainer> .Is.Anything))
.WhenCalled(arg => ((Route.Routing.Route)arg.Arguments.Skip(2).First()).RestrictByMethods("GET").AsCompletedTask())
.Return(Task.Factory.Empty());
_restrictionMapper2 = MockRepository.GenerateMock <IRestrictionMapper>();
_restrictionMapper2
.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything, Arg <IContainer> .Is.Anything))
.WhenCalled(arg => ((Route.Routing.Route)arg.Arguments.Skip(2).First()).RestrictByMethods("POST").AsCompletedTask())
.Return(Task.Factory.Empty());
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.ResponseMapper(_responseMapper)
.RestrictionMappers(_restrictionMapper1, _restrictionMapper2);
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock <IClassFilter>();
_classFilter
.Stub(arg => arg.MatchesAsync(Arg <Type> .Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((Type)arg.Arguments.First() == typeof(Endpoint)).AsCompletedTask())
.Return(false.AsCompletedTask());
_idMapper1 = MockRepository.GenerateMock <IIdMapper>();
_idMapper1.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.Parse("1dffe3ee-1ade-4aa2-835a-9cb91b7e31c4")).AsCompletedTask());
_idMapper2 = MockRepository.GenerateMock <IIdMapper>();
_idMapper2.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(IdResult.IdMapped(Guid.Parse("493e725c-cbc1-4ea4-b6d1-350018d4542d")).AsCompletedTask());
_nameMapper = MockRepository.GenerateMock <INameMapper>();
_nameMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(NameResult.NameMapped("name").AsCompletedTask());
_resolvedRelativeUrlMapper = MockRepository.GenerateMock <IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.MapAsync(Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative").AsCompletedTask());
_responseMapper = MockRepository.GenerateMock <IResponseMapper>();
_responseMapper
.Stub(arg => arg.MapAsync(Arg <Func <IContainer> > .Is.Anything, Arg <Type> .Is.Anything, Arg <MethodInfo> .Is.Anything, Arg <Route.Routing.Route> .Is.Anything))
.Return(Task.Factory.Empty());
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper1)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.ResponseMapper(_responseMapper);
_routes = _autoRouteCollection.GenerateRouteCollectionAsync().Result.ToArray();
}
