Bogus removed

sollygit · sollygit · commit d66e67a3ace6 · 2026-02-10T03:02:14.000+11:00
diff --git a/MockMe.API/AutoMapperProfile.cs b/MockMe.API/AutoMapperProfile.cs
@@ -14,13 +14,9 @@ public static void Initialize()
 
             Mapper.Initialize(cfg =>
             {
-                cfg.CreateMap<Asset, AssetViewModel>()
-                .ForMember(o => o.Id, map => map.MapFrom(o => o.Id))
-                .ForMember(o => o.Name, map => map.MapFrom(o => o.Name))
-                .ReverseMap();
-
                 cfg.CreateMap<AssetTrade, AssetTradeViewModel>()
-                .ForMember(o => o.Asset, map => map.MapFrom(o => o.Asset))
+                .ForMember(o => o.Id, map => map.MapFrom(o => o.Asset.Id))
+                .ForMember(o => o.Name, map => map.MapFrom(o => o.Asset.Name))
                 .ForMember(o => o.Amount, map => map.MapFrom(o => o.Amount))
                 .ForMember(o => o.Payout, map => map.MapFrom(o => o.Payout))
                 .ForMember(o => o.Direction, map => map.MapFrom(o => o.Direction))
diff --git a/MockMe.API/Controllers/TradeController.cs b/MockMe.API/Controllers/TradeController.cs
@@ -13,11 +13,13 @@ namespace MockMe.API.Controllers
     public class TradeController : ControllerBase
     {
         readonly ITradeService _tradeService;
+        readonly IAssetService _assetService;
         readonly ICountryService _countryService;
 
-        public TradeController(ITradeService tradeService, ICountryService countryService)
+        public TradeController(ITradeService tradeService, IAssetService assetService, ICountryService countryService)
         {
             _tradeService = tradeService;
+            _assetService = assetService;
             _countryService = countryService;
         }
 
@@ -45,7 +47,7 @@ public async Task<IActionResult> GetById(Guid id)
         [HttpGet("[action]")]
         public async Task<IActionResult> Generate()
         {
-            var item = await _tradeService.GenerateAsync();
+            var item = await _tradeService.GenerateSingleAsync();
             return CreatedAtAction("Generate", new { id = item.Id }, item);
         }
 
@@ -74,6 +76,13 @@ public async Task<IActionResult> Delete(Guid id)
             return new OkObjectResult(item);
         }
 
+        [HttpGet("Assets")]
+        public async Task<IActionResult> Assets()
+        {
+            var items = await _assetService.GetAssetsAsync();
+            return new OkObjectResult(items);
+        }
+
         [Authorize]
         [HttpGet("Countries")]
         public async Task<IActionResult> Countries()
diff --git a/MockMe.API/Services/TradeService.cs b/MockMe.API/Services/TradeService.cs
@@ -18,7 +18,7 @@ public interface ITradeService
         Task<AssetTrade> SaveAsync(AssetTradeViewModel entity);
         Task<AssetTrade> UpdateAsync(Guid id, AssetTradeViewModel entity);
         Task<AssetTrade> DeleteAsync(Guid id);
-        Task<AssetTrade> GenerateAsync();
+        Task<AssetTrade> GenerateSingleAsync();
     }
 
     public interface ICountryService
@@ -28,18 +28,22 @@ public interface ICountryService
 
     public interface IAssetService
     {
-        Task<IEnumerable<AssetViewModel>> GetAssets();
+        Task<IEnumerable<Asset>> GetAssetsAsync();
     }
 
-    public class TradeService : ITradeService, ICountryService, IAssetService
+    public class TradeService : ITradeService, IAssetService, ICountryService
     {
         readonly IMemoryCache _cache;
         readonly ITradeRepository _tradeRepository;
+        readonly IEnumerable<CurrencyPair> _currencyPairs;
+        readonly IEnumerable<Asset> _assets;
 
         public TradeService(IMemoryCache cache, ITradeRepository tradeRepository)
         {
             _cache = cache;
             _tradeRepository = tradeRepository;
+            _currencyPairs = Enum.GetValues(typeof(CurrencyPair)).Cast<CurrencyPair>();
+            _assets = _currencyPairs.Select(pair => new Asset((int)pair, pair.Description()));
         }
 
         public async Task<IEnumerable<AssetTrade>> GetAllAsync()
@@ -70,12 +74,22 @@ public async Task<AssetTrade> DeleteAsync(Guid id)
             return await _tradeRepository.DeleteAsync(id);
         }
 
-        public async Task<AssetTrade> GenerateAsync()
+        public async Task<AssetTrade> GenerateSingleAsync()
         {
-            var fakeTrade = await _tradeRepository.GenerateAsync();
+            var fakeTrade = await _tradeRepository.GenerateSingleAsync();
             return await _tradeRepository.SaveAsync(fakeTrade);
         }
 
+        public async Task<IEnumerable<Asset>> GetAssetsAsync()
+        {
+            // Cached Assets
+            return await _cache.GetOrCreateAsync("Assets", async e =>
+            {
+                e.SetOptions(new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24) });
+                return await Task.FromResult(_assets);
+            });
+        }
+
         public async Task<IEnumerable<Country>> GetCountriesAsync()
         {
             // Cached Countries
@@ -86,19 +100,5 @@ public async Task<IEnumerable<Country>> GetCountriesAsync()
                 return await Task.FromResult(Constants.COUNTRIES);
             });
         }
-
-        public async Task<IEnumerable<AssetViewModel>> GetAssets()
-        {
-            return await _cache.GetOrCreateAsync("Assets", async e =>
-            {
-                // Cached Assets
-                e.SetOptions(new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1) });
-
-                var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();
-                var result = currencyPairs.Select(pair =>
-                    Mapper.Map<AssetViewModel>(new Asset((int)pair, pair.Description())));
-                return await Task.FromResult(result);
-            });
-        }
     }
 }
diff --git a/MockMe.API/Startup.cs b/MockMe.API/Startup.cs
@@ -68,9 +68,10 @@ public void ConfigureServices(IServiceCollection services)
             services.AddSingleton<IJwtAuthManager, JwtAuthManager>();
             services.AddHostedService<JwtRefreshTokenCache>();
             services.AddScoped<IUserService, UserService>();
-            services.AddScoped<ITradeRepository, TradeRepository>();
             services.AddScoped<ITradeService, TradeService>();
             services.AddScoped<ICountryService, TradeService>();
+            services.AddScoped<IAssetService, TradeService>();
+            services.AddSingleton<ITradeRepository, TradeRepository>();
 
             services.AddSwaggerGen(c => {
                 c.SwaggerDoc("jwt", new OpenApiInfo { Title = "JWT Auth API" });
diff --git a/MockMe.API/ViewModels/AssetTradeViewModel.cs b/MockMe.API/ViewModels/AssetTradeViewModel.cs
@@ -2,7 +2,8 @@
 {
     public class AssetTradeViewModel
     {
-        public AssetViewModel Asset { get; set; }
+        public int Id { get; set; }
+        public string Name { get; set; }
         public int Expiration { get; set; }
         public decimal Amount { get; set; }
         public int Direction { get; set; }
diff --git a/MockMe.API/ViewModels/AssetViewModel.cs b/MockMe.API/ViewModels/AssetViewModel.cs
diff --git a/MockMe.Common/MockMe.Common.csproj b/MockMe.Common/MockMe.Common.csproj
@@ -5,7 +5,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Bogus" Version="35.6.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
 		<PackageReference Include="System.Text.Json" Version="8.0.5" />
   </ItemGroup>
diff --git a/MockMe.Repository/TradeRepository.cs b/MockMe.Repository/TradeRepository.cs
@@ -1,5 +1,4 @@
-﻿using Bogus;
-using MockMe.Common;
+﻿using MockMe.Common;
 using MockMe.Model;
 using System;
 using System.Collections.Generic;
@@ -14,32 +13,37 @@ public interface ITradeRepository
         Task<AssetTrade> SaveAsync(AssetTrade entity);
         Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity);
         Task<AssetTrade> DeleteAsync(Guid id);
-        Task<AssetTrade> GenerateAsync();
+        Task<AssetTrade> GenerateSingleAsync();
     }
 
     public class TradeRepository : ITradeRepository
     {
-        static List<AssetTrade> Trades;
+        readonly IEnumerable<CurrencyPair> _currencyPairs;
+        readonly IEnumerable<Asset> _assets;
+        readonly Random _random = new Random();
+        readonly List<AssetTrade> _trades;
 
         public TradeRepository()
         {
-            Trades ??= GenerateTrades(10);
+            _currencyPairs = Enum.GetValues(typeof(CurrencyPair)).Cast<CurrencyPair>();
+            _assets = _currencyPairs.Select(pair => new Asset((int)pair, pair.Description()));
+            _trades ??= GenerateTrades(10);
         }
 
         public async Task<IEnumerable<AssetTrade>> GetAllAsync()
         {
-            return await Task.FromResult(Trades);
+            return await Task.FromResult(_trades);
         }
 
         public async Task<AssetTrade> SaveAsync(AssetTrade entity)
         {
-            Trades.Add(entity);
+            _trades.Add(entity);
             return await Task.FromResult(entity);
         }
 
         public async Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity)
         {
-            var item = Trades.Single(p => p.Id == id.ToString());
+            var item = _trades.Single(p => p.Id == id.ToString());
 
             item.Asset = new Asset { Id = entity.Asset.Id, Name = entity.Asset.Name };
             item.Direction = entity.Direction;
@@ -52,32 +56,31 @@ public async Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity)
 
         public async Task<AssetTrade> DeleteAsync(Guid id)
         {
-            var item = Trades.Single(o => o.Id == id.ToString());
-            var entry = Trades.Remove(item);
+            var item = _trades.Single(o => o.Id == id.ToString());
+            var entry = _trades.Remove(item);
             return await Task.FromResult(item);
         }
 
-        public async Task<AssetTrade> GenerateAsync()
+        public async Task<AssetTrade> GenerateSingleAsync()
         {
-            var randomTrade = GenerateTrades(1).FirstOrDefault();
+            var asset = _assets.ElementAt(_random.Next(0, _assets.Count()));
+            var randomTrade = GenerateTrades(1, asset).FirstOrDefault();
             return await Task.FromResult(randomTrade);
         }
 
-        List<AssetTrade> GenerateTrades(int count)
+        List<AssetTrade> GenerateTrades(int count ,Asset asset = null)
         {
-            var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();
-            var trades = new Faker<AssetTrade>()
-                .RuleFor(o => o.Id, f => Guid.NewGuid().ToString())
-                .RuleFor(o => o.Asset, f => {
-                    var pair = new Faker().Random.ListItem((IList<CurrencyPair>)currencyPairs);
-                    return new Asset((int)pair, pair.Description());
+            var assetCount = _assets.Count();
+            return Enumerable.Range(0, count)
+                .Select(i => new AssetTrade 
+                {
+                    Asset = asset ?? _assets.ElementAt(i % _assets.Count()), // Cycles on assets
+                    Amount = Math.Round(_random.Next(100, 100000) * 0.01m, 2),
+                    Expiration = _random.Next(1, 1000),
+                    Payout = _random.Next(1, 1000),
+                    Direction = _random.Next(0, 2)
                 })
-                .RuleFor(o => o.Amount, f => decimal.Parse(f.Random.Decimal(1000).ToString("0.00")))
-                .RuleFor(o => o.Expiration, f => f.Random.Number(1, 1000))
-                .RuleFor(o => o.Payout, f => f.Random.Number(1, 1000))
-                .RuleFor(o => o.Direction, f => f.Random.Number(0, 1))
-                .Generate(count);
-            return trades;
+                .ToList();
         }
     }
 }
diff --git a/MockMe.UnitTest/TradeServiceTest.cs b/MockMe.UnitTest/TradeServiceTest.cs
@@ -58,7 +58,8 @@ public async Task GetAsync_Success()
             });
 
             // Act
-            var entity = new AssetTradeViewModel { Asset = new AssetViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name }, Amount = trade.Amount, Direction = trade.Direction };
+                
+            var entity = new AssetTradeViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name, Amount = trade.Amount, Direction = trade.Direction };
             await mockService.Object.SaveAsync(entity);
             var actual = await mockService.Object.GetAsync(Guid.Parse(trade.Id));
 
@@ -101,7 +102,7 @@ public async Task SaveAsync_Success()
             });
 
             // Act
-            var entity = new AssetTradeViewModel { Asset = new AssetViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name }, Amount = trade.Amount, Direction = trade.Direction };
+            var entity = new AssetTradeViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name, Amount = trade.Amount, Direction = trade.Direction };
             var actual = await mockService.Object.SaveAsync(entity);
 
             // Assert
@@ -136,7 +137,7 @@ public async Task UpdateAsync_Success()
             });
 
             // Act
-            var entity = new AssetTradeViewModel { Asset = new AssetViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name }, Amount = trade.Amount, Direction = trade.Direction };
+            var entity = new AssetTradeViewModel { Id = trade.Asset.Id, Name = trade.Asset.Name, Amount = trade.Amount, Direction = trade.Direction };
             await mockService.Object.UpdateAsync(Guid.Parse(trade.Id), entity);
 
             // Assert

Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,13 @@ namespace MockMe.API.Controllers`
`13`	`13`	`public class TradeController : ControllerBase`
`14`	`14`	`{`
`15`	`15`	`readonly ITradeService _tradeService;`
	`16`	`+ readonly IAssetService _assetService;`
`16`	`17`	`readonly ICountryService _countryService;`
`17`	`18`
`18`		`- public TradeController(ITradeService tradeService, ICountryService countryService)`
	`19`	`+ public TradeController(ITradeService tradeService, IAssetService assetService, ICountryService countryService)`
`19`	`20`	`{`
`20`	`21`	`_tradeService = tradeService;`
	`22`	`+ _assetService = assetService;`
`21`	`23`	`_countryService = countryService;`
`22`	`24`	`}`
`23`	`25`
`@@ -45,7 +47,7 @@ public async Task<IActionResult> GetById(Guid id)`
`45`	`47`	`[HttpGet("[action]")]`
`46`	`48`	`public async Task<IActionResult> Generate()`
`47`	`49`	`{`
`48`		`- var item = await _tradeService.GenerateAsync();`
	`50`	`+ var item = await _tradeService.GenerateSingleAsync();`
`49`	`51`	`return CreatedAtAction("Generate", new { id = item.Id }, item);`
`50`	`52`	`}`
`51`	`53`
`@@ -74,6 +76,13 @@ public async Task<IActionResult> Delete(Guid id)`
`74`	`76`	`return new OkObjectResult(item);`
`75`	`77`	`}`
`76`	`78`
	`79`	`+ [HttpGet("Assets")]`
	`80`	`+ public async Task<IActionResult> Assets()`
	`81`	`+ {`
	`82`	`+ var items = await _assetService.GetAssetsAsync();`
	`83`	`+ return new OkObjectResult(items);`
	`84`	`+ }`
	`85`	`+`
`77`	`86`	`[Authorize]`
`78`	`87`	`[HttpGet("Countries")]`
`79`	`88`	`public async Task<IActionResult> Countries()`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public interface ITradeService`
`18`	`18`	`Task<AssetTrade> SaveAsync(AssetTradeViewModel entity);`
`19`	`19`	`Task<AssetTrade> UpdateAsync(Guid id, AssetTradeViewModel entity);`
`20`	`20`	`Task<AssetTrade> DeleteAsync(Guid id);`
`21`		`- Task<AssetTrade> GenerateAsync();`
	`21`	`+ Task<AssetTrade> GenerateSingleAsync();`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public interface ICountryService`
`@@ -28,18 +28,22 @@ public interface ICountryService`
`28`	`28`
`29`	`29`	`public interface IAssetService`
`30`	`30`	`{`
`31`		`- Task<IEnumerable<AssetViewModel>> GetAssets();`
	`31`	`+ Task<IEnumerable<Asset>> GetAssetsAsync();`
`32`	`32`	`}`
`33`	`33`
`34`		`- public class TradeService : ITradeService, ICountryService, IAssetService`
	`34`	`+ public class TradeService : ITradeService, IAssetService, ICountryService`
`35`	`35`	`{`
`36`	`36`	`readonly IMemoryCache _cache;`
`37`	`37`	`readonly ITradeRepository _tradeRepository;`
	`38`	`+ readonly IEnumerable<CurrencyPair> _currencyPairs;`
	`39`	`+ readonly IEnumerable<Asset> _assets;`
`38`	`40`
`39`	`41`	`public TradeService(IMemoryCache cache, ITradeRepository tradeRepository)`
`40`	`42`	`{`
`41`	`43`	`_cache = cache;`
`42`	`44`	`_tradeRepository = tradeRepository;`
	`45`	`+ _currencyPairs = Enum.GetValues(typeof(CurrencyPair)).Cast<CurrencyPair>();`
	`46`	`+ _assets = _currencyPairs.Select(pair => new Asset((int)pair, pair.Description()));`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`public async Task<IEnumerable<AssetTrade>> GetAllAsync()`
`@@ -70,12 +74,22 @@ public async Task<AssetTrade> DeleteAsync(Guid id)`
`70`	`74`	`return await _tradeRepository.DeleteAsync(id);`
`71`	`75`	`}`
`72`	`76`
`73`		`- public async Task<AssetTrade> GenerateAsync()`
	`77`	`+ public async Task<AssetTrade> GenerateSingleAsync()`
`74`	`78`	`{`
`75`		`- var fakeTrade = await _tradeRepository.GenerateAsync();`
	`79`	`+ var fakeTrade = await _tradeRepository.GenerateSingleAsync();`
`76`	`80`	`return await _tradeRepository.SaveAsync(fakeTrade);`
`77`	`81`	`}`
`78`	`82`
	`83`	`+ public async Task<IEnumerable<Asset>> GetAssetsAsync()`
	`84`	`+ {`
	`85`	`+ // Cached Assets`
	`86`	`+ return await _cache.GetOrCreateAsync("Assets", async e =>`
	`87`	`+ {`
	`88`	`+ e.SetOptions(new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24) });`
	`89`	`+ return await Task.FromResult(_assets);`
	`90`	`+ });`
	`91`	`+ }`
	`92`	`+`
`79`	`93`	`public async Task<IEnumerable<Country>> GetCountriesAsync()`
`80`	`94`	`{`
`81`	`95`	`// Cached Countries`
`@@ -86,19 +100,5 @@ public async Task<IEnumerable<Country>> GetCountriesAsync()`
`86`	`100`	`return await Task.FromResult(Constants.COUNTRIES);`
`87`	`101`	`});`
`88`	`102`	`}`
`89`		`-`
`90`		`- public async Task<IEnumerable<AssetViewModel>> GetAssets()`
`91`		`- {`
`92`		`- return await _cache.GetOrCreateAsync("Assets", async e =>`
`93`		`- {`
`94`		`- // Cached Assets`
`95`		`- e.SetOptions(new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1) });`
`96`		`-`
`97`		`- var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();`
`98`		`- var result = currencyPairs.Select(pair =>`
`99`		`- Mapper.Map<AssetViewModel>(new Asset((int)pair, pair.Description())));`
`100`		`- return await Task.FromResult(result);`
`101`		`- });`
`102`		`- }`
`103`	`103`	`}`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,8 @@`
`2`	`2`	`{`
`3`	`3`	`public class AssetTradeViewModel`
`4`	`4`	`{`
`5`		`- public AssetViewModel Asset { get; set; }`
	`5`	`+ public int Id { get; set; }`
	`6`	`+ public string Name { get; set; }`
`6`	`7`	`public int Expiration { get; set; }`
`7`	`8`	`public decimal Amount { get; set; }`
`8`	`9`	`public int Direction { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using Bogus;`
`2`		`-using MockMe.Common;`
	`1`	`+using MockMe.Common;`
`3`	`2`	`using MockMe.Model;`
`4`	`3`	`using System;`
`5`	`4`	`using System.Collections.Generic;`
`@@ -14,32 +13,37 @@ public interface ITradeRepository`
`14`	`13`	`Task<AssetTrade> SaveAsync(AssetTrade entity);`
`15`	`14`	`Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity);`
`16`	`15`	`Task<AssetTrade> DeleteAsync(Guid id);`
`17`		`- Task<AssetTrade> GenerateAsync();`
	`16`	`+ Task<AssetTrade> GenerateSingleAsync();`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`public class TradeRepository : ITradeRepository`
`21`	`20`	`{`
`22`		`- static List<AssetTrade> Trades;`
	`21`	`+ readonly IEnumerable<CurrencyPair> _currencyPairs;`
	`22`	`+ readonly IEnumerable<Asset> _assets;`
	`23`	`+ readonly Random _random = new Random();`
	`24`	`+ readonly List<AssetTrade> _trades;`
`23`	`25`
`24`	`26`	`public TradeRepository()`
`25`	`27`	`{`
`26`		`- Trades ??= GenerateTrades(10);`
	`28`	`+ _currencyPairs = Enum.GetValues(typeof(CurrencyPair)).Cast<CurrencyPair>();`
	`29`	`+ _assets = _currencyPairs.Select(pair => new Asset((int)pair, pair.Description()));`
	`30`	`+ _trades ??= GenerateTrades(10);`
`27`	`31`	`}`
`28`	`32`
`29`	`33`	`public async Task<IEnumerable<AssetTrade>> GetAllAsync()`
`30`	`34`	`{`
`31`		`- return await Task.FromResult(Trades);`
	`35`	`+ return await Task.FromResult(_trades);`
`32`	`36`	`}`
`33`	`37`
`34`	`38`	`public async Task<AssetTrade> SaveAsync(AssetTrade entity)`
`35`	`39`	`{`
`36`		`- Trades.Add(entity);`
	`40`	`+ _trades.Add(entity);`
`37`	`41`	`return await Task.FromResult(entity);`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`public async Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity)`
`41`	`45`	`{`
`42`		`- var item = Trades.Single(p => p.Id == id.ToString());`
	`46`	`+ var item = _trades.Single(p => p.Id == id.ToString());`
`43`	`47`
`44`	`48`	`item.Asset = new Asset { Id = entity.Asset.Id, Name = entity.Asset.Name };`
`45`	`49`	`item.Direction = entity.Direction;`
`@@ -52,32 +56,31 @@ public async Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity)`
`52`	`56`
`53`	`57`	`public async Task<AssetTrade> DeleteAsync(Guid id)`
`54`	`58`	`{`
`55`		`- var item = Trades.Single(o => o.Id == id.ToString());`
`56`		`- var entry = Trades.Remove(item);`
	`59`	`+ var item = _trades.Single(o => o.Id == id.ToString());`
	`60`	`+ var entry = _trades.Remove(item);`
`57`	`61`	`return await Task.FromResult(item);`
`58`	`62`	`}`
`59`	`63`
`60`		`- public async Task<AssetTrade> GenerateAsync()`
	`64`	`+ public async Task<AssetTrade> GenerateSingleAsync()`
`61`	`65`	`{`
`62`		`- var randomTrade = GenerateTrades(1).FirstOrDefault();`
	`66`	`+ var asset = _assets.ElementAt(_random.Next(0, _assets.Count()));`
	`67`	`+ var randomTrade = GenerateTrades(1, asset).FirstOrDefault();`
`63`	`68`	`return await Task.FromResult(randomTrade);`
`64`	`69`	`}`
`65`	`70`
`66`		`- List<AssetTrade> GenerateTrades(int count)`
	`71`	`+ List<AssetTrade> GenerateTrades(int count ,Asset asset = null)`
`67`	`72`	`{`
`68`		`- var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();`
`69`		`- var trades = new Faker<AssetTrade>()`
`70`		`- .RuleFor(o => o.Id, f => Guid.NewGuid().ToString())`
`71`		`- .RuleFor(o => o.Asset, f => {`
`72`		`- var pair = new Faker().Random.ListItem((IList<CurrencyPair>)currencyPairs);`
`73`		`- return new Asset((int)pair, pair.Description());`
	`73`	`+ var assetCount = _assets.Count();`
	`74`	`+ return Enumerable.Range(0, count)`
	`75`	`+ .Select(i => new AssetTrade`
	`76`	`+ {`
	`77`	`+ Asset = asset ?? _assets.ElementAt(i % _assets.Count()), // Cycles on assets`
	`78`	`+ Amount = Math.Round(_random.Next(100, 100000) * 0.01m, 2),`
	`79`	`+ Expiration = _random.Next(1, 1000),`
	`80`	`+ Payout = _random.Next(1, 1000),`
	`81`	`+ Direction = _random.Next(0, 2)`
`74`	`82`	`})`
`75`		`- .RuleFor(o => o.Amount, f => decimal.Parse(f.Random.Decimal(1000).ToString("0.00")))`
`76`		`- .RuleFor(o => o.Expiration, f => f.Random.Number(1, 1000))`
`77`		`- .RuleFor(o => o.Payout, f => f.Random.Number(1, 1000))`
`78`		`- .RuleFor(o => o.Direction, f => f.Random.Number(0, 1))`
`79`		`- .Generate(count);`
`80`		`- return trades;`
	`83`	`+ .ToList();`
`81`	`84`	`}`
`82`	`85`	`}`
`83`	`86`	`}`