public async Task GetLatestPrice_ReturnLatestPriceBySymbol()
{
IQueryable <HourlyShareRate> hourRates = new List <HourlyShareRate> {
new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
},
new HourlyShareRate
{
Symbol = "CBI",
Rate = 333.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 1, 0)
}
}.AsQueryable();
// Arrange
_dbSetHourlyShareRate.As <IQueryable <HourlyShareRate> >().Setup(m => m.Provider).Returns(hourRates.Provider);
_dbSetHourlyShareRate.As <IQueryable <HourlyShareRate> >().Setup(m => m.Expression).Returns(hourRates.Expression);
_dbSetHourlyShareRate.As <IQueryable <HourlyShareRate> >().Setup(m => m.ElementType).Returns(hourRates.ElementType);
_dbSetHourlyShareRate.As <IQueryable <HourlyShareRate> >().Setup(m => m.GetEnumerator()).Returns(hourRates.GetEnumerator());
_exchangeContext.Setup(p => p.Shares).Returns(_dbSetHourlyShareRate.Object);
// Act
HourlyShareRate hourlyShare = _shareRepository.GetLatestPrice("CBI");
// Assert
Assert.NotNull(hourlyShare);
Assert.AreEqual(hourlyShare.Symbol, "CBI");
Assert.AreEqual(hourlyShare.TimeStamp, new DateTime(2018, 08, 17, 5, 1, 0));
Assert.AreEqual(hourlyShare.Rate, 333.0M);
}
public async Task Post_ShouldRetrunOK()
{
TradeModel model = new TradeModel
{
Action = "BUY",
NoOfShares = 50,
Symbol = "REL",
PortfolioId = 1
};
// Arrange
HourlyShareRate share = new HourlyShareRate()
{
Id = 1,
Rate = 90,
Symbol = "REL",
TimeStamp = DateTime.Now
};
// Arrange
_shareRepositoryMock.Setup(x => x.GetLatestPrice(It.IsAny <string>())).ReturnsAsync(share);
// Act
var result = await _tradeController.Post(model);
// Assert
Assert.NotNull(result);
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
}
public async Task Put_UpdateLastHourlySharePrice_NotExist_NotFoundResult()
{
// Arrange
var hourRate = new HourlyShareRateModel
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2019, 04, 07, 5, 0, 0)
};
HourlyShareRate ret = null;
_shareServiceMock.Setup(t => t.UpdateLastPriceAsync(hourRate.Symbol, hourRate.Rate))
.Returns(Task.FromResult(ret));
// Act
var result = await _shareController.UpdateLastPrice(hourRate.Symbol, hourRate.Rate);
// Assert
Assert.NotNull(result);
var notFoundResult = result as NotFoundResult;
Assert.AreEqual(404, notFoundResult.StatusCode);
}
public async Task <IActionResult> Post([FromBody] TradeModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HourlyShareRate r = null;
Portfolio pf = null;
Parallel.Invoke(
() => { r = GetLatestRate(model.Symbol); },
() => { pf = GetPortfolio(model.PortfolioId); });
if (r == null)
{
return(BadRequest("no symbol"));
}
if (pf == null)
{
return(BadRequest("no portfolio"));
}
if (model.Action.Equals("SELL", StringComparison.OrdinalIgnoreCase))
{
return(await Sell(model, r, pf));
}
else
{
return(await Buy(model, r, pf));
}
}
public void HourlyShareRateValidateData()
{
var HourlyShareRateNotValid = new HourlyShareRate
{
TimeStamp = new DateTime(),
Symbol = "REL",
Rate = -1
};
var context1 = new ValidationContext(HourlyShareRateNotValid, null, null);
var results1 = new List <ValidationResult>();
var isModelStateNotValid = Validator.TryValidateObject(HourlyShareRateNotValid, context1, results1, true);
var HourlyShareRateValid = new HourlyShareRate
{
TimeStamp = new DateTime(),
Symbol = "REL",
Rate = 10
};
var context = new ValidationContext(HourlyShareRateValid, null, null);
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(HourlyShareRateValid, context, results, true);
// Assert
Assert.False(isModelStateNotValid);
Assert.True(isModelStateValid);
}
private async Task <IActionResult> Sell(TradeModel model, HourlyShareRate r, Portfolio pf)
{
IEnumerable <Trade> t = GetTrades(model.PortfolioId, model.Symbol);
var aShares = 0;
for (int i = 0; i < t.Count(); i++)
{
aShares += (t.ElementAt(i).Action.Equals("SELL", StringComparison.OrdinalIgnoreCase) ? -1 : 1) *
t.ElementAt(i).NoOfShares;
}
if (aShares < model.NoOfShares)
{
return(NotFound("not enough shares"));
}
var result = new Trade()
{
Price = model.NoOfShares * r.Rate,
NoOfShares = model.NoOfShares,
Action = "SELL",
PortfolioId = model.PortfolioId,
Symbol = model.Symbol
};
await _tradeRepository.InsertAsync(result);
return(Created("Trade", result));
}
private HourlyShareRateModel Map(HourlyShareRate rate)
{
return(new HourlyShareRateModel()
{
Id = rate.Id,
TimeStamp = rate.TimeStamp,
Rate = rate.Rate,
Symbol = rate.Symbol
});
}
private Trade MapToDb(TradeModel model, HourlyShareRate shareDetail)
{
var trade = new Trade();
trade.PortfolioId = model.PortfolioId;
trade.Symbol = model.Symbol;
trade.NoOfShares = model.NoOfShares;
trade.Price = model.NoOfShares * shareDetail.Rate;
trade.Action = model.Action;
return(trade);
}
public async Task <IActionResult> Post([FromBody] HourlyShareRate value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _shareRepository.InsertAsync(value);
return(Created($"Share/{value.Id}", value));
}
public void ShouldTestHourlyShareRate()
{
CheckPropertyValidation cpv = new CheckPropertyValidation();
HourlyShareRate hsr = new HourlyShareRate();
hsr.Id = 5;
var errorCount = cpv.myValidation(hsr).Count;
Assert.AreEqual(1, errorCount);
}
private async Task <IActionResult> Buy(TradeModel model, HourlyShareRate r, Portfolio pf)
{
var result = new Trade()
{
Price = model.NoOfShares * r.Rate,
NoOfShares = model.NoOfShares,
Action = "BUY",
PortfolioId = model.PortfolioId,
Symbol = model.Symbol
};
await _tradeRepository.InsertAsync(result);
return(Created("Trade", result));
}
public void InserttHourlyPriceAsyncTest_Error()
{
// Arrange
ArrangeRates();
HourlyShareRate value = new HourlyShareRate()
{
Rate = 553,
Symbol = "CBI",
TimeStamp = new DateTime(2018, 08, 17, 6, 0, 0)
};
// Act & Assert
Assert.ThrowsAsync <ApplicationException>(async() => await _shareService.InserttHourlyPriceAsync(value));
}
public async Task Post_ShouldInsertFailedHourlySharePriceWhenSymbolMissingAsync()
{
// Arrange
var hourRate = new HourlyShareRate
{
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
_shareController.ModelState.AddModelError("Symbol", "Required");
// Act
var result = await _shareController.Post(hourRate);
// Assert
Assert.IsTrue(result is BadRequestObjectResult);
}
public async Task Post_ShouldInsertHourlySharePrice()
{
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
var result = await _shareController.Post(hourRate);
Assert.NotNull(result);
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
}
public async Task InserttHourlyPriceAsyncTest_Insert()
{
// Arrange
ArrangeRates();
HourlyShareRate value = new HourlyShareRate()
{
Rate = 553,
Symbol = "CBI",
TimeStamp = new DateTime(2019, 08, 17, 6, 0, 0)
};
// Act & Assert
await _shareService.InserttHourlyPriceAsync(value);
Assert.True(value.Rate == 553); //TO DO: Not perfectly right
}
private ExchangeContext GetContextWithData()
{
var options = new DbContextOptionsBuilder <ExchangeContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var dbContext = new ExchangeContext(options);
var share =
new HourlyShareRate {
Id = 1, Rate = 90, Symbol = "REL", TimeStamp = DateTime.Now
};
dbContext.Add(share);
dbContext.SaveChanges();
return(dbContext);
}
public async Task GetAsync_WhenExists_ReturnsHourlyShareRate()
{
// Arrange
var expected = new HourlyShareRate
{
Id = 10, Symbol = "CBI", Rate = 96, TimeStamp = new DateTime(2018, 08, 13, 02, 00, 00)
};
// Act
var result = await _shareRepository.GetAsync(10);
// Assert
Assert.NotNull(result);
Assert.AreEqual(expected.Id, result.Id);
Assert.AreEqual(expected.Symbol, result.Symbol);
Assert.AreEqual(expected.Rate, result.Rate);
Assert.AreEqual(expected.TimeStamp, result.TimeStamp);
}
public async Task Post_ShouldValidateModelStates()
{
//Arrange
var hourRate = new HourlyShareRate
{
//Symbol = "CBI",
//Rate = 330.0M,
//TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
_shareController.ModelState.AddModelError("Error", "Error");
//Act
var result = await _shareController.Post(hourRate) as ObjectResult;
// Assert
Assert.AreEqual(400, result.StatusCode);
}
public async Task Get_ShouldReturnsHourlyShareWhenExists()
{
// Arrange
var hourRateSymbol = "CBI";
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
await _shareRepository.InsertAsync(hourRate);
// Act
var result = await _shareController.Get(hourRateSymbol);
// Assert
Assert.IsTrue(result is OkObjectResult);
}
public async Task Post_ShouldInsertHourlySharePrice()
{
// Arrange
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
_shareController.ModelState.Clear();
// Act
var result = await _shareController.Post(hourRate);
// Assert
Assert.IsTrue(result is CreatedResult);
}
public async Task <IActionResult> Post([FromBody] HourlyShareRateModel model)
{
if (!ModelState.IsValid || model == null)
{
return(BadRequest(ModelState));
}
HourlyShareRate share = new HourlyShareRate
{
Rate = model.Rate,
Symbol = model.Symbol,
TimeStamp = model.TimeStamp
};
await _shareRepository.InsertAsync(share);
return(Created($"Share/{share.Id}", share));
}
public async Task Post_ShouldThrowError()
{
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
_shareController.ModelState.AddModelError("", "Error");
var result = await _shareController.Post(hourRate);
Assert.NotNull(result);
var createdResult = result as BadRequestObjectResult;
Assert.NotNull(createdResult);
Assert.AreEqual(400, createdResult.StatusCode);
}
public async Task <IActionResult> UpdateLastPrice([FromRoute] string symbol)
{
var shares = await _shareRepository.Query().Where(x => x.Symbol.Equals(symbol)).ToListAsync();
if (shares.Count > 0)
{
var share = shares.OrderByDescending(x => x.Rate).FirstOrDefault();
HourlyShareRate _newShare = new HourlyShareRate
{
Symbol = share.Symbol,
Rate = share.Rate + 10,
TimeStamp = DateTime.Now
};
await _shareRepository.InsertAsync(_newShare);
return(Ok());
}
return(BadRequest());
}
public async Task Post_InserShare()
{
var p = new HourlyShareRate()
{
Symbol = "REL", Rate = 50, TimeStamp = DateTime.Now.AddDays(-1)
};
_shareRepositoryMock.Setup(x => x.InsertAsync(new HourlyShareRate()
{
Symbol = "REL", Rate = 50, TimeStamp = DateTime.Now.AddDays(-1)
}));
var result = await _shareController.Post(p) as CreatedResult;
Assert.NotNull(result);
var result_share = result.Value as HourlyShareRate;
Assert.AreEqual(result_share.Symbol, "REL");
}
public async Task Post_ShouldInsertHourlySharePrice()
{
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
};
// Arrange
// Act
var result = await _shareController.Post(hourRate);
// Assert
Assert.NotNull(result);
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
}
public async Task Post_Should_Return_Share_Created()
{
// Arrange
var hourRate = new HourlyShareRate
{
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
// Act
var result = await _shareController.Post(hourRate);
// Assert
var createdResult = (result as CreatedResult).Value as HourlyShareRate;
Assert.NotNull(createdResult);
Assert.AreEqual(hourRate, createdResult);
}
public async Task UpdateLatestPrice_ShouldUpdateMostRecentPrice()
{
// Arrange
var hourRates = new List <HourlyShareRate>()
{
new HourlyShareRate {
Symbol = "CBI",
Rate = 330.0M,
TimeStamp = new DateTime(2019, 08, 17, 5, 0, 0)
},
new HourlyShareRate {
Symbol = "CBI",
Rate = 130.0M,
TimeStamp = new DateTime(2020, 08, 17, 5, 0, 0)
},
new HourlyShareRate {
Symbol = "CBI",
Rate = 430.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
}
};
var mockSet = new Mock <DbSet <HourlyShareRate> >();
mockSet.MockDbSet <HourlyShareRate>(hourRates);
HourlyShareRate share = null;
var mockContext = new Mock <ExchangeContext>();
var mockRepository = new Mock <ShareRepository>(mockContext.Object);
var shareController = new ShareController(mockRepository.Object);
mockContext.Setup(i => i.Set <HourlyShareRate>()).Returns(mockSet.Object);
mockRepository.Setup(i => i.UpdateAsync(It.IsAny <HourlyShareRate>())).Returns(Task.FromResult <object>(null)).Callback <HourlyShareRate>((p) => { share = p; });
// Act
shareController.UpdateLastPrice("CBI");
// Assert
Assert.AreEqual(new DateTime(2020, 08, 17, 5, 0, 0), share.TimeStamp);
Assert.AreEqual(10.0M, share.Rate);
}
public async Task <IActionResult> Post([FromBody] HourlyShareRate value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Validate: Symbol must be three characters
if (value.Symbol.Length != 3)
{
return(BadRequest());
}
else
{
value.Symbol = value.Symbol.ToUpper();
value.Rate = System.Math.Round(value.Rate, 2);
await _shareRepository.InsertAsync(value);
return(Created($"Share/{value.Id}", value));
}
}
public async Task Post_ShouldValidateSymbol()
{
var hourRate = new HourlyShareRate
{
Symbol = "CBIXX",
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
// Arrange
// Act
var result = await _shareController.Post(hourRate);
// Assert
Assert.NotNull(result);
var badRequestResult = result as BadRequestResult;
Assert.NotNull(badRequestResult);
Assert.AreEqual(400, badRequestResult.StatusCode);
}
public async Task Post_ModelInvalid()
{
var hourRate = new HourlyShareRate
{
Rate = 330.0M,
TimeStamp = new DateTime(2018, 08, 17, 5, 0, 0)
};
// Arrange
_shareController.ModelState.AddModelError("", "Error");
// Act
var result = await _shareController.Post(hourRate);
// Assert
Assert.NotNull(result);
BadRequestObjectResult badRequestResult = result as BadRequestObjectResult;
Assert.NotNull(badRequestResult);
Assert.AreEqual(400, badRequestResult.StatusCode);
}
