public void ComputePriceBasedOnBottle(
int buyerId,
int amount,
decimal expectedPrice
)
{
// arrange
using var mock = AutoMock.GetStrict(builder =>
builder.RegisterInstance(MapperProvider.GetMapper()));
mock.Mock <IBottleRepository>()
.Setup(repo => repo.GetBottleForPriceModel(100))
.Returns(Task.FromResult(GetBottle()));
var transaction = new TransactionForAdditionDto
{
BuyerId = buyerId,
Amount_ml = amount,
BottleId = 100
};
var operation = mock.Create <GetTransactionPriceOperation>();
// act
decimal actualPrice = operation.Run(transaction).Result;
// assert
Assert.AreEqual(expectedPrice, actualPrice, $"Computed price is different from expected price (expected: {expectedPrice}, actual: {actualPrice})");
}
public Task Consume(ConsumeContext <AppLogCreatedEvent> context)
{
return(Task.Run(() =>
{
if (context.Message != null)
{
try
{
var repository = MongoRepository <AppLog> .Instance;
AppLog appLog = MapperProvider.MapTo <AppLog>(context.Message);
//appLog.CTime = appLog.CTime.AddHours(8); // UTC时间转换
var obj = repository.Add(appLog);
//保存应用名和标签到缓存集合
using (ICacheProvider cacheObj = CacheFactory.Instance.GetClient())
{
if (!string.IsNullOrEmpty(appLog.Application))
{
cacheObj.AddItemToSet(CacheAppLogSet.Application, appLog.Application);
}
if (appLog.Tags != null)
{
cacheObj.AddRangeToSet(CacheAppLogSet.Tags, appLog.Tags);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
Console.WriteLine($"Recevied By AppLogCreatedEventConsumer:{context.Message.Guid}");
}));
}
public DaoTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var initialisers = new IMapperInitializer[]
{
new ProtocolMessageMapperInitialiser(),
new ConfidentialEntryMapperInitialiser(),
new CandidateDeltaBroadcastMapperInitialiser(),
new ProtocolErrorMessageMapperInitialiser(),
new PeerIdMapperInitialiser(),
new SigningContextMapperInitialiser(),
new DeltaMapperInitialiser(),
new CandidateDeltaBroadcastMapperInitialiser(),
new DeltaDfsHashBroadcastMapperInitialiser(),
new FavouriteDeltaBroadcastMapperInitialiser(),
new CoinbaseEntryMapperInitialiser(),
new PublicEntryMapperInitialiser(_hashProvider),
new ConfidentialEntryMapperInitialiser(),
new TransactionBroadcastMapperInitialiser(),
new SignatureMapperInitialiser()
};
_mapperProvider = new MapperProvider(initialisers);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddMvc().AddJsonOptions(opcoes =>
{
opcoes.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
});
services.AddSingleton <IProdutoService, ProdutoService>();
services.AddTransient <IProdutoRepository, ProdutoRepository>();
//Configuração de propriedades do middleware de compressão
services.Configure <GzipCompressionProviderOptions>(opcoes =>
{
opcoes.Level = CompressionLevel.Optimal;
});
services.AddResponseCompression(opcoes =>
{
opcoes.Providers.Add <GzipCompressionProvider>();
opcoes.EnableForHttps = true;
});
//AutoMapper
IMapper mapper = MapperProvider.RegisterMappings().CreateMapper();
services.AddSingleton(mapper);
// Service Bus
services.AddTransient <IServiceBus, ServiceBus>();
ServiceBusHandler.RegistrarCapturaMensagem(Configuration);
}
public async void Should_Return_Filtered_Vehicles()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var vehiclesMock = vehicles.AsQueryable().BuildMock();
var filter = new VehicleFilter
{
Manufacturer = "Ford"
};
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.Get()).Returns(vehiclesMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
Mock.Of <IGenericRepository <Booking, int> >(),
Mock.Of <IGenericRepository <Insurance, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleController.Get(filter);
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
var dtos = result.Value as List <VehicleListItemDto>;
Assert.NotNull(dtos);
Assert.True(dtos.Count == 2);
}
public async void Should_Return_Vehicle_By_Id()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var bookingsMock = new List <Booking>().AsQueryable().BuildMock();
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicles.SingleOrDefault(v => v.Id == id)));
var bookingRepositoryMock = new Mock <IGenericRepository <Booking, int> >();
bookingRepositoryMock.Setup(m => m.Get())
.Returns(bookingsMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
bookingRepositoryMock.Object,
Mock.Of <IGenericRepository <Insurance, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleController.GetById(1);
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
}
public DaoTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_mappers = new IMapperInitializer[]
{
new ProtocolMessageDao(),
new ConfidentialEntryDao(),
new CandidateDeltaBroadcastDao(),
new ProtocolErrorMessageSignedDao(),
new PeerIdDao(),
new SigningContextDao(),
new DeltaDao(),
new CandidateDeltaBroadcastDao(),
new DeltaDfsHashBroadcastDao(),
new FavouriteDeltaBroadcastDao(),
new CoinbaseEntryDao(),
new PublicEntryDao(),
new ConfidentialEntryDao(),
new TransactionBroadcastDao(),
new ContractEntryDao(),
new SignatureDao(),
new BaseEntryDao(),
};
var map = new MapperProvider(_mappers);
map.Start();
}
protected void Application_Start()
{
ScrumerInitializationHandler.Initialize();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var mapper = MapperProvider.Initialize().CreateMapper();
// Dependency injection:
var builder = new ContainerBuilder();
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Register types:
builder.RegisterType <ScrumerContext>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterInstance(mapper);
var container = builder.Build();
// Register resolver for asp.net mvc:
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// Gets the number of pages based on the specified
/// </summary>
/// <param name="PageSize">Page size</param>
/// <param name="Parameters">Parameters to search by</param>
/// <typeparam name="ObjectType">Object type to get the page count of</typeparam>
/// <returns>The number of pages that the table contains for the specified page size</returns>
public int PageCount <ObjectType>(int PageSize = 25, params IParameter[] Parameters)
where ObjectType : class
{
Parameters = Parameters.Check(new IParameter[] { });
string KeyName = typeof(ObjectType).GetName() + "_PageCount_" + PageSize.ToString(CultureInfo.InvariantCulture) + "_" + Parameters.ToString(x => x.ToString(), "_");
Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
if (Cache.ContainsKey(KeyName))
{
return((int)Cache[KeyName]);
}
foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
{
IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
if (Mapping != null)
{
int Count = QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType))
.PageCount(PageSize, Parameters)
.Execute()[0]
.FirstOrDefault()
.Total;
if (Count > 0)
{
int ReturnValue = (Count / PageSize) + (Count % PageSize > 0 ? 1 : 0);
Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
return(ReturnValue);
}
}
}
return(0);
}
protected TDestination TestMapping <TSource, TDestination>(TSource input, TDestination expected, Action <TDestination, TDestination> additionalAssert, params string[] exceptProperties)
{
// arrange
var mapper = MapperProvider.GetMapper();
// act
var actual = mapper.Map <TDestination>(input);
// assert
additionalAssert?.Invoke(expected, actual);
var propertiesToCheck =
typeof(TDestination)
.GetProperties()
.Where(p => !exceptProperties.Contains(p.Name));
foreach (var prop in propertiesToCheck)
{
Assert.AreEqual(prop.GetValue(expected), prop.GetValue(actual),
$"Unexpected value of property {typeof(TDestination).Name}.{prop.Name}");
}
// return mapping
return(actual);
}
public void NoMapping()
{
var provider = new MapperProvider();
provider.RegisterAssembly(Assembly.GetExecutingAssembly());
Assert.Throws <ArgumentOutOfRangeException>(() => provider.GetMapper <string>());
}
public void SingleMapping()
{
var provider = new MapperProvider();
provider.RegisterAssembly(Assembly.GetExecutingAssembly());
Assert.NotNull(provider.GetMapper <MapperProviderTests>());
}
/// <summary>
/// 编辑用户信息
/// </summary>
/// <param name="id"></param>
/// <param name="model"></param>
/// <returns></returns>
public async Task <Result> EditUserInfo(string id, UserModel model)
{
var redis = this.RedisProvider.GetDatabase();
var originalModel = redis.JsonGet <UserModel>(TOKEN_KEY + id);
await redis.StringSetAsync(TOKEN_KEY + id, JsonConvert.SerializeObject(MapperProvider.Map(model, originalModel)));
return(Result.SuccessResult(model));
}
public void DuplicateMappings()
{
var provider = new MapperProvider();
provider.RegisterAssembly(Assembly.GetExecutingAssembly());
Assert.Throws <MappingException>(() => provider.Register(new CustomMapper()));
}
public static AppBootProgram RegisterAutoMappe(this AppBootProgram app)
{
MapperProvider.SetMapper(new AutoMapperMapper());
if (!app.MapperCollection.Any())
{
return(app);
}
MapperProvider.Current.Initialize(app.MapperCollection);
return(app);
}
private void CreateMapper()
{
var config = new MapperConfiguration(o =>
{
o.AddProfile(new ProjectMapping());
o.AddProfile(new SdlcSystemMapping());
});
mapperProvider = new MapperProvider(config.CreateMapper());
}
public void IEnumerable_Map_calls_AutoMapper_Map()
{
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(a => a.Map <IEnumerable <ClassA>, IEnumerable <ClassB> >(It.IsAny <IEnumerable <ClassA> >())).Verifiable();
var sut = new MapperProvider(mapperMock.Object);
sut.Map <ClassA, ClassB>(new List <ClassA>());
mapperMock.Verify(a => a.Map <IEnumerable <ClassA>, IEnumerable <ClassB> >(It.IsAny <IEnumerable <ClassA> >()), Times.Once);
}
protected virtual Expression <Func <TEntity, bool> > GetEntityPredicateExpression <TEntity>(
IDictionary <string, object> whereArguments)
where TEntity : class
{
var entityMapper = MapperProvider.GetEntityMapper <TEntity>();
var parameterExpr = Expression.Parameter(typeof(TEntity), "entity");
var predicateBodyExpr = GetEntityPredicateExpression(entityMapper, parameterExpr, whereArguments);
return(Expression.Lambda <Func <TEntity, bool> >(predicateBodyExpr, parameterExpr));
}
public PeerRepositoryTests(ITestOutputHelper output) : base(output)
{
var mappers = new IMapperInitializer[]
{
new PeerIdDao(),
new PeerDao()
};
var map = new MapperProvider(mappers);
map.Start();
}
private void SortMappings()
{
foreach (IDatabase Database in Mappings.Keys.OrderBy(x => x.Order))
{
var Order = 0;
var Graph = MapperProvider.GetStructure(Database.GetType());
foreach (var Mapping in KahnSort(Graph.Copy()).Reverse())
{
Mapping.Order = Order;
++Order;
}
}
}
public void MapperProvider_ProvidesMap()
{
// Arrange
var mappingProvider = new MapperProvider(null);
// Act
var mapping = mappingProvider.GetMapper();
// Assert
mapping.Should().NotBeNull();
mapping.ConfigurationProvider.Should().NotBeNull();
mapping.ConfigurationProvider.GetAllTypeMaps().Length.Should().Be(24);
}
protected TDestination TestMapping <TSource, TDestination>(TSource input, TDestination expected) where TDestination : IEquatable <TDestination>
{
// arrange
var mapper = MapperProvider.GetMapper();
// act
var actual = mapper.Map <TDestination>(input);
// assert
Assert.AreEqual(expected, actual);
// return mapping
return(actual);
}
public Task Consume(ConsumeContext <TrackLogCreatedEvent> context)
{
return(Task.Run(() =>
{
if (context.Message != null)
{
var repository = MongoRepository <TrackLog> .Instance;
TrackLog trackLog = MapperProvider.MapTo <TrackLog>(context.Message);
trackLog.CreateTime = trackLog.CreateTime.AddHours(8); // UTC时间转换
trackLog.RequestTime = trackLog.RequestTime.AddHours(8); // UTC时间转换
var obj = repository.Add(trackLog);
}
Console.WriteLine($"Recevied By TrackLogCreatedEventConsumer:{context.Message.GUID}");
}));
}
private static void SetAuto()
{
var proxyListProviders = MapperProvider.Load("mappers").ToList();
Random d = new Random();
int index = d.Next(0, proxyListProviders.Count - 1);
IProxyListProvider provider = proxyListProviders[index];
List <Proxy> proxies = provider.GetProxyList().ToList();
int proxyIndex = d.Next(0, proxies.Count - 1);
Proxy proxy = proxies[proxyIndex];
var proxySetter = GetProxySetter();
if (proxySetter != null)
{
proxySetter.Set(proxy.Host, proxy.Port);
}
}
public async void Should_Return_404_For_Bad_Id()
{
// Arrange
var vehicleModels = DataProvider.GetVehicleModels();
var vehicleModelRepositoryMock = new Mock <IGenericRepository <VehicleModel, int> >();
vehicleModelRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicleModels.SingleOrDefault(vm => vm.Id == id)));
var vehicleModelController = new VehicleModelController(vehicleModelRepositoryMock.Object,
Mock.Of <IGenericRepository <Vehicle, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleModelController.GetById(9001);
var result = request as NotFoundObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 404);
}
public TransactionBroadcastRepositoryTests(ITestOutputHelper output) : base(output)
{
var mappers = new IMapperInitializer[]
{
new ProtocolMessageDao(),
new ConfidentialEntryDao(),
new ProtocolErrorMessageSignedDao(),
new PeerIdDao(),
new SigningContextDao(),
new CoinbaseEntryDao(),
new PublicEntryDao(),
new ConfidentialEntryDao(),
new TransactionBroadcastDao(),
new ContractEntryDao(),
new SignatureDao(),
new BaseEntryDao(),
};
var map = new MapperProvider(mappers);
map.Start();
}
public async void Should_Update_Vehicle()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var vehiclesMock = DataProvider.GetVehicles().AsQueryable().BuildMock();
var insurancesMock = new List <Insurance>().AsQueryable().BuildMock();
var updatedVehicle = new VehicleDto
{
Id = 1,
VehicleModelId = 3,
LocationCode = "333"
};
bool updated = false;
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.Get()).Returns(vehiclesMock.Object);
vehicleRepositoryMock.Setup(m => m.Exists(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicles.SingleOrDefault(v => v.Id == id) != null));
vehicleRepositoryMock.Setup(m => m.Update(It.IsAny <Vehicle>()))
.Returns(Task.FromResult(true))
.Callback((Vehicle vehicle) => { updated = true; });
var insuranceRepositoryMock = new Mock <IGenericRepository <Insurance, int> >();
insuranceRepositoryMock.Setup(m => m.Get()).Returns(insurancesMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
Mock.Of <IGenericRepository <Booking, int> >(),
insuranceRepositoryMock.Object,
MapperProvider.GetMapper());
// Act
var request = await vehicleController.Update(updatedVehicle.Id, updatedVehicle);
var result = request as OkResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
Assert.True(updated);
}
public async void Should_Return_VehicleModels()
{
// Arrange
var vehicleModelsQueryable = DataProvider.GetVehicleModels().AsQueryable().BuildMock();
var vehicleModelRepositoryMock = new Mock <IGenericRepository <VehicleModel, int> >();
vehicleModelRepositoryMock.Setup(m => m.Get())
.Returns(vehicleModelsQueryable.Object);
var vehicleModelController = new VehicleModelController(vehicleModelRepositoryMock.Object,
Mock.Of <IGenericRepository <Vehicle, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleModelController.Get(new VehicleModelFilter());
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
var dtos = result.Value as List <VehicleModelDto>;
Assert.NotNull(dtos);
Assert.True(dtos.Count == 3);
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<ProvinceMapper>();
province = GetProvince();
}
public DataFacade(MapperProvider mappperProvider)
{
this.countryMapper = mappperProvider.GetMapper<CountryMapper>();
this.provinceMapper = mappperProvider.GetMapper<ProvinceMapper>();
this.userMapper = mappperProvider.GetMapper<UserMapper>();
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<UserMapper>();
user = GetUser();
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = new DataFacade(mapperProvider);
}
/// <summary>
/// Returns all items that match the criteria
/// </summary>
/// <typeparam name="ObjectType">Type of the object</typeparam>
/// <param name="Parameters">Parameters used in the where clause</param>
/// <returns>All items that match the criteria</returns>
public IEnumerable <ObjectType> All <ObjectType>(params IParameter[] Parameters)
where ObjectType : class
{
Parameters = Parameters.Check(new IParameter[] { });
var ReturnValue = new List <Dynamo>();
string KeyName = typeof(ObjectType).GetName() + "_All_" + Parameters.ToString(x => x.ToString(), "_");
Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
if (Cache.ContainsKey(KeyName))
{
return(GetListCached <ObjectType>(ref ReturnValue, KeyName));
}
foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
{
IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
if (Mapping != null)
{
foreach (Dynamo Item in QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).All(Parameters).Execute()[0])
{
var IDProperty = Mapping.IDProperties.FirstOrDefault();
CopyOrAdd(ReturnValue, IDProperty, Item);
}
}
}
Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
return(ConvertValues <ObjectType>(ReturnValue));
}
/// <summary>
/// Saves an object to the database
/// </summary>
/// <typeparam name="ObjectType">Object type</typeparam>
/// <typeparam name="PrimaryKeyType">Primary key type</typeparam>
/// <param name="Object">Object to save</param>
public void Save <ObjectType, PrimaryKeyType>(ObjectType Object)
where ObjectType : class
{
Cache.RemoveByTag(typeof(ObjectType).GetName());
foreach (ISourceInfo Source in SourceProvider.Where(x => x.Writable).OrderBy(x => x.Order))
{
IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
if (Mapping != null)
{
var Generator = QueryProvider.Generate <ObjectType>(Source, MapperProvider[typeof(ObjectType), Source], MapperProvider.GetStructure(Mapping.DatabaseConfigType));
var TempBatch = QueryProvider.Batch(Source);
CascadeSave <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
TempBatch.Execute();
TempBatch = QueryProvider.Batch(Source);
TempBatch.AddCommand(Generator.Save <PrimaryKeyType>(Object));
TempBatch.Execute();
TempBatch = QueryProvider.Batch(Source);
JoinsDelete <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
JoinsSave <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
TempBatch.RemoveDuplicateCommands().Execute();
}
}
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<CountryMapper>();
country = GetCountry();
}
