public void RequestSoda_ShouldSayOutOfStock()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
string user = "******";
SodaModel expectedSoda = new SodaModel {
Name = "Fanta", SlotOccupied = "4"
};
var initialState = da.MachineInfo;
da.UserCredit[user] = 0.75M;
var results = logic.RequestSoda(expectedSoda, user);
Assert.Null(results.soda);
Assert.Equal(0.75M, da.UserCredit[user]);
Assert.Equal(initialState.cashOnHand, da.MachineInfo.cashOnHand);
Assert.Equal(initialState.totalIncome, da.MachineInfo.totalIncome);
Assert.False(string.IsNullOrWhiteSpace(results.errorMessage));
Assert.True(results.change.Count() == 0);
}
public void RequestSoda_ShouldReturnSodaWithNoChange()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
string user = "******";
SodaModel expcetedSoda = new SodaModel {
Name = "Coke", SlotOccupied = "1"
};
var initialState = da.MachineInfo;
da.UserCredit[user] = 0.75M;
var results = logic.RequestSoda(expcetedSoda, user);
Assert.Equal(expcetedSoda.Name, results.soda.Name);
Assert.Equal(expcetedSoda.SlotOccupied, results.soda.SlotOccupied);
Assert.Equal(0, da.UserCredit[user]);
Assert.Equal(initialState.cashOnHand + 0.75M, da.MachineInfo.cashOnHand);
Assert.Equal(initialState.totalIncome + 0.75M, da.MachineInfo.totalIncome);
Assert.True(string.IsNullOrWhiteSpace(results.errorMessage));
Assert.True(results.change.Count() == 0);
}
public void RequestSoda_ShouldSayNotEnoughChange()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
string user = "******";
SodaModel expcetedSoda = new SodaModel {
Name = "Coke", SlotOccupied = "1"
};
var initialState = da.MachineInfo;
da.UserCredit[user] = 1.75M;
da.CoinInventory.Clear();
var results = logic.RequestSoda(expcetedSoda, user);
Assert.Null(results.soda);
Assert.Equal(1.75M, da.UserCredit[user]);
Assert.Equal(initialState.cashOnHand, da.MachineInfo.cashOnHand);
Assert.Equal(initialState.totalIncome, da.MachineInfo.totalIncome);
Assert.False(string.IsNullOrWhiteSpace(results.errorMessage));
Assert.True(results.change.Count() == 0);
}
public void RequestSoda_ShouldReturnSodaWithAlternativeChange()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
string user = "******";
SodaModel expcetedSoda = new SodaModel {
Name = "Coke", SlotOccupied = "1"
};
var initialState = da.MachineInfo;
da.UserCredit[user] = 1M;
da.CoinInventory.RemoveAll(x => x.Amount == 0.25M);
var results = logic.RequestSoda(expcetedSoda, user);
Assert.Equal(expcetedSoda.Name, results.soda.Name);
Assert.Equal(expcetedSoda.SlotOccupied, results.soda.SlotOccupied);
Assert.Equal(0, da.UserCredit[user]);
Assert.Equal(initialState.cashOnHand + 1M, da.MachineInfo.cashOnHand);
Assert.Equal(initialState.totalIncome + 1M, da.MachineInfo.totalIncome);
Assert.True(string.IsNullOrWhiteSpace(results.errorMessage));
// Dime + Dime + Nickle = Quarter
Assert.True(results.change.Count() == 3);
}
public void AddToCoinInventory_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
List <CoinModel> coins = new List <CoinModel>
{
new CoinModel {
Name = "Quarter", Amount = 0.25M
},
new CoinModel {
Name = "Quarter", Amount = 0.25M
},
new CoinModel {
Name = "Dime", Amount = 0.1M
}
};
logic.AddToCoinInventory(coins);
int expected = 6;
int actual = da.CoinInventory.Where(x => x.Name == "Quarter").Count();
Assert.Equal(expected, actual);
}
public void GetVertexById(bool pFound)
{
const long id = 13241235;
var app = (pFound ? new App() : null);
vMockAcc = MockDataAccess.Create(mda => {
MockDataAccessCmd cmd = mda.GetCommand(0);
Assert.AreEqual(GetVertexByIdScript, cmd.Script, "Incorrect Query.Script.");
TestUtil.CheckParams(cmd.Params, "_P", new List <object> {
id
});
});
vMockAcc.MockResult.SetupToElement(app);
vMockCache.Setup(x => x.FindVertex <App>(id)).Returns((App)null);
vMockCache.Setup(x => x.AddVertex(app, null));
vMockCache.Setup(x => x.RemoveVertex <App>(id)).Returns((App)null);
vMockFact.Setup(x => x.Create(null, false, true)).Returns(vMockAcc.Object);
App result = vData.GetVertexById <App>(id);
Assert.AreEqual(app, result, "Incorrect result.");
vMockCache.Verify(x => x.FindVertex <App>(id), Times.Once);
if (pFound)
{
vMockCache.Verify(x => x.RemoveVertex <App>(id), Times.Never);
vMockCache.Verify(x => x.AddVertex(app, null), Times.Once);
}
else
{
vMockCache.Verify(x => x.RemoveVertex <App>(id), Times.Once);
vMockCache.Verify(x => x.AddVertex(app, null), Times.Never);
}
}
public void GetMemberByRefresh(int pResultCount)
{
const long appId = 125125235;
const string code = "asdugalsdgualsdkgulsdkug";
var mem = new Member();
var mockDataAcc = MockDataAccess.Create(mda => {
Assert.AreEqual(MockDataAccess.SessionStart, mda.GetCommand(0).SessionAction,
"Incorrect Command 0 SessionAction.");
string expectScript = "m=g.V('" + DbName.Vert.OauthAccess.Refresh + "',_P)" +
".outE('" + DbName.Edge.OauthAccessAuthenticatesMemberName + "').inV;" +
"(m?m=m.next():null);";
var expectParam = new List <object> {
code
};
TestUtil.CheckWeaverScript(mda.GetCommand(1), expectScript, "_P", expectParam);
expectScript = "m.outE('" + DbName.Edge.MemberDefinedByAppName + "')" +
".inV.property('" + DbName.Vert.Vertex.VertexId + "');";
expectParam = new List <object>();
TestUtil.CheckWeaverScript(mda.GetCommand(2), expectScript, "_P", expectParam);
Assert.AreEqual(MockDataAccess.SessionClose, mda.GetCommand(3).SessionAction,
"Incorrect Command 3 SessionAction.");
Assert.AreEqual("OauthAccess-GetMemberByRefresh",
mda.Object.ExecuteName, "Incorrect ExecuteName.");
});
mockDataAcc.MockResult
.Setup(x => x.GetCommandResultCount(pResultCount))
.Returns(1);
mockDataAcc.MockResult
.Setup(x => x.ToElementAt <Member>(1, 0))
.Returns(mem);
mockDataAcc.MockResult
.Setup(x => x.ToLongAt(2, 0))
.Returns(appId);
vMockData
.Setup(x => x.Build(null, true, true))
.Returns(mockDataAcc.Object);
OauthMember result = vTasks.GetMemberByRefresh(vMockData.Object, code);
if (pResultCount == 0)
{
Assert.Null(result, "Result should be null.");
return;
}
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(mem, result.Member, "Incorrect Member.");
Assert.AreEqual(appId, result.AppId, "Incorrect AppId.");
}
public void TestCalculateExpirationDate()
{
IPackageRepository packageRepository = new MockPackageRepository();
PackageService packageService = new PackageService(packageRepository);
StandardPackageType packageType = MockDataAccess.GetPackageType(3);
DateTime todaysDate = DateTime.Today;
DateTime expirationDate = packageService.CalculateExpirationDate(packageType, todaysDate);
Assert.AreEqual <DateTime>(todaysDate.AddMonths(packageType.ShelfLifeUnits), expirationDate);
}
/*--------------------------------------------------------------------------------------------*/
private void OnExecuteGetMember(MockDataAccess pData)
{
MockDataAccessCmd cmd = pData.GetCommand(0);
string expect = TestUtil.InsertParamIndexes(MemberForOauthToken, "_P");
Assert.AreEqual(expect, cmd.Script, "Incorrect Query.Script.");
TestUtil.CheckParams(cmd.Params, "_P", new List <object> {
vToken, vExpire
});
}
public void GetCurrentIncome_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
var(_, expected, _) = da.MachineInfo;
decimal actual = logic.GetCurrentIncome();
Assert.Equal(expected, actual);
}
public void GetTotalIncome_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
decimal actual = logic.GetTotalIncome();
decimal expected = da.MachineInfo.totalIncome;
Assert.Equal(expected, actual);
}
public void ListTypesOfSoda_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
var expected = 3;
int actual = logic.ListTypesOfSoda().Count();
Assert.Equal(expected, actual);
}
private Result SendPackage(int packageId, int senderCenterId, int receiverCenterId)
{
IPackageRepository _mockPackageRepository = new MockPackageRepository();
PackageService _packageServices = new PackageService(_mockPackageRepository);
Package _package = MockDataAccess.GetPackage(packageId);
DistributionCentre _senderLocation = MockDataAccess.GetDistributionCentre(senderCenterId);
DistributionCentre _destinationLocation = MockDataAccess.GetDistributionCentre(receiverCenterId);
return(_packageServices.Send(_package, _senderLocation, _destinationLocation, DateTime.Today));
}
public void GetSodaInventory_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
int actual = logic.GetSodaInventory().Count();
int expected = 8;
Assert.Equal(expected, actual);
}
public void TestReceivePackage_BarcodeNotFound()
{
MockPackageRepository myMockPackageRepo = new MockPackageRepository();
PackageService packageService = new PackageService(myMockPackageRepo);
DistributionCentre myReceiverCentre = MockDataAccess.GetDistributionCentre(3);
string bCode = "0001015042500004"; // package1.BarCode; //
Result res = packageService.Receive(bCode, myReceiverCentre, DateTime.Today);
Assert.AreEqual <bool>(res.Success, false);
Assert.AreEqual <string>(res.ErrorMessage, TransitResult.BarCodeNotFound);
}
public Package GetPackageWidthBarCode(string BarCode) // (P. 05-04-2015)
{
foreach (Package p in MockDataAccess.GetAllPackages())
{
if (p.BarCode == BarCode)
{
return(p);
}
}
return(null);
}
// Try to send Package into the Sender Centre location
public void TestSendPackage_SameLocation()
{
IPackageRepository _mockPackageRepository = new MockPackageRepository();
PackageService _packageServices = new PackageService(_mockPackageRepository);
Package _package = MockDataAccess.GetPackage(3);
DistributionCentre _senderLocation = MockDataAccess.GetDistributionCentre(2);
DateTime _sendDate = DateTime.Today;
var _result = _packageServices.Send(_package, _senderLocation, _senderLocation, _sendDate);
Assert.AreEqual <bool>(false, _result.Success);
}
private Result DiscardPackage(int currentCentreId, string userName, string barCode)
{
MockPackageRepository packageRepository = new MockPackageRepository();
PackageService _packageService = new PackageService(packageRepository);
Employee employee = MockDataAccess.GetEmployee(userName);
Package package = MockDataAccess.GetPackage(barCode);
package.CurrentLocation = MockDataAccess.GetDistributionCentre(currentCentreId);
StandardPackageType spt2 = _packageService.GetStandardPackageType(package.PackageType.PackageTypeId);
return(_packageService.Discard(package.BarCode, employee.Location, employee, package.ExpirationDate, spt2, package.PackageId));
}
// Try to send Package which is not abvailable
public void TestSendPackage_PackageNotFond()
{
IPackageRepository _mockPackageRepository = new MockPackageRepository();
PackageService _packageServices = new PackageService(_mockPackageRepository);
DistributionCentre _senderLocation = MockDataAccess.GetDistributionCentre(1);
DistributionCentre _destinationLocation = MockDataAccess.GetDistributionCentre(2);
DateTime _sendDate = DateTime.Today;
Package _package = null;
var _result = _packageServices.Send(_package, _senderLocation, _destinationLocation, _sendDate);
Assert.AreEqual <string>(_result.ErrorMessage, "Bar Code not found");
}
public void TestReceivePackage_CancelTransit()
{
MockPackageRepository myMockPackageRepo = new MockPackageRepository();
PackageService packageService = new PackageService(myMockPackageRepo);
Package package1 = MockDataAccess.GetPackage(3);
DistributionCentre myReceiverCentre = MockDataAccess.GetDistributionCentre(3);
int newTransitId = InsertMockTransit(package1, 2, 3); // insert transit
Result res = packageService.CancelTransit(package1.BarCode, DateTime.Today); // cancel transit
int foundTransits = myMockPackageRepo.GetActiveTransitsByPackage(package1).Count;
Assert.IsTrue(res.Success && foundTransits == 0);
}
// Try to send package to null destination centre
public void TestSendPackage_SendToNullCentre()
{
IPackageRepository _mockPackageRepository = new MockPackageRepository();
PackageService _packageServices = new PackageService(_mockPackageRepository);
DistributionCentre _senderLocation = MockDataAccess.GetDistributionCentre(1);
DistributionCentre _destinationLocation = MockDataAccess.GetDistributionCentre(2);
DateTime _sendDate = DateTime.Today;
Package _package = MockDataAccess.GetPackage(15);
var _result = _packageServices.Send(_package, _package.CurrentLocation, null, _sendDate);
Assert.AreEqual <string>("Please Select the Correct Receiver Centre", _result.ErrorMessage);
}
public void GetCoinInventory_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
var coins = logic.GetCoinInventory();
var expected = da.CoinInventory.Where(x => x.Name == "Quarter").Count();
var actual = coins.Where(x => x.Name == "Quarter").Count();
Assert.Equal(expected, actual);
}
public void TestReceivePackage_ReceiveDateTooEarly()
{
MockPackageRepository myMockPackageRepo = new MockPackageRepository();
PackageService packageService = new PackageService(myMockPackageRepo);
Package package1 = MockDataAccess.GetPackage(3);
DistributionCentre myReceiverCentre = MockDataAccess.GetDistributionCentre(3);
int newTransitId = InsertMockTransit(package1, 2, 3); // insert transit
Result res = packageService.Receive(package1.BarCode, myReceiverCentre, DateTime.Today.AddMonths(-1)); // receive
Assert.AreEqual <bool>(res.Success, false);
Assert.AreEqual <string>(res.ErrorMessage, PackageResult.ReceiveDateCannotBeEarlierThanSend);
}
public void IssueFullRefund_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
string user = "******";
da.UserCredit[user] = 0.65M;
logic.IssueFullRefund(user);
Assert.True(da.UserCredit[user] == 0);
}
public List <PackageTransit> GetActiveTransitsByPackage(Package xPackage)
{
List <PackageTransit> filteredList = new List <PackageTransit>();
foreach (PackageTransit t in MockDataAccess.GetAllPackageTransits())
{
if (t.Package == xPackage && t.DateReceived == null && t.DateCancelled == null)
{
filteredList.Add(t);
}
}
return(filteredList);
}
public void GetMoneyInsertedTotal_ShouldWork()
{
MockDataAccess da = new MockDataAccess();
SodaMachineLogic logic = new SodaMachineLogic(da);
decimal expected = 0.65M;
da.UserCredit.Add("test", expected);
decimal actual = logic.GetMoneyInsertedTotal("test");
Assert.Equal(expected, actual);
}
public void TestReceivePackage_Successfully()
{
MockPackageRepository myMockPackageRepo = new MockPackageRepository();
PackageService packageService = new PackageService(myMockPackageRepo);
Package package1 = MockDataAccess.GetPackage(3);
DistributionCentre myReceiverCentre = MockDataAccess.GetDistributionCentre(3);
int newTransitId = InsertMockTransit(package1, 2, 3); // insert transit
packageService.Receive(package1.BarCode, myReceiverCentre, DateTime.Today);
PackageTransit finishedTransit = MockDataAccess.GetPackageTransit(newTransitId);
Debug.WriteLine(finishedTransit.ToString());
Assert.IsTrue(finishedTransit.ReceiverCentre == myReceiverCentre);
}
public void TestRegisterPackage()
{
IPackageRepository packageRepository = new MockPackageRepository();
PackageService packageService = new PackageService(packageRepository);
StandardPackageType packageType = MockDataAccess.GetPackageType(3);
DistributionCentre location = MockDataAccess.GetDistributionCentre(2);
DateTime expirationDate = DateTime.Today.AddMonths(2);
string barCode;
var result = packageService.Register(packageType, location, expirationDate, out barCode);
int newPackageId = result.Id;
string compareBarCode = string.Format("{0:D5}{1:yyMMdd}{2:D5}", packageType.PackageTypeId, expirationDate, newPackageId);
Assert.AreEqual <string>(compareBarCode, barCode);
}
public void TestRegisterPackageExpirationDateTooEarly()
{
IPackageRepository packageRepository = new MockPackageRepository();
PackageService packageService = new PackageService(packageRepository);
StandardPackageType packageType = MockDataAccess.GetPackageType(3);
DistributionCentre location = MockDataAccess.GetDistributionCentre(2);
DateTime expirationDate = DateTime.Today.AddDays(-1);
string barCode;
var result = packageService.Register(packageType, location, expirationDate, out barCode);
int newPackageId = result.Id;
Assert.AreEqual <bool>(result.Success, false);
Assert.AreEqual <string>(result.ErrorMessage, PackageResult.ExpirationDateCannotBeEarlierThanToday);
}
public int InsertMockTransit(Package Package, int SenderId, int ReceiverId)
{
DistributionCentre mySenderCentre = MockDataAccess.GetDistributionCentre(SenderId);
DistributionCentre myReceiverCentre = MockDataAccess.GetDistributionCentre(ReceiverId);
PackageTransit newTransit = new PackageTransit();
newTransit.Package = Package;
newTransit.DateSent = DateTime.Today.AddDays(-2);
newTransit.SenderCentre = mySenderCentre;
newTransit.ReceiverCentre = myReceiverCentre;
int newTransitId = MockDataAccess.InsertPackageTransit(newTransit);
return(newTransitId);
}
