public void CoinChecker_ValidCoinInserted_ReturnsValidCoin()
{
var fixture = new Fixture()
.Customize(new AutoMoqCustomization());
var checker = fixture.Freeze <Mock <ICoinRepository> >();
checker.Setup(x => x.GetAcceptedCoins()).Returns(
new List <ValidCoin>()
{
ValidCoin.Nickel
});
var sut = fixture.Create <CoinChecker>();
var insertedCoin = new InsertedCoin()
{
Diameter = ValidCoin.Nickel.Diameter,
Weight = ValidCoin.Nickel.Weight
};
var result = sut.CheckCoin(insertedCoin);
Assert.Equal(ValidCoin.Nickel, result);
}
public void CoinChecker_InvalidCoinInserted_ReturnsUnknownCoin()
{
var fixture = new Fixture()
.Customize(new AutoMoqCustomization());
var repository = fixture.Freeze <Mock <ICoinRepository> >();
repository.Setup(x => x.GetAcceptedCoins()).Returns(
new List <ValidCoin>()
{
ValidCoin.Dime
});
var sut = fixture.Create <CoinChecker>();
var insertedCoin = new InsertedCoin()
{
Diameter = 200f,
Weight = 100f
};
var result = sut.CheckCoin(insertedCoin);
Assert.Equal(ValidCoin.Unknown, result);
}
public int CoinInserted(InsertedCoin coin)
{
// add the coin to the machine
var coinsInMachine = GetCoinsInMachine();
if (coinsInMachine == null)
{
coinsInMachine = new List <InsertedCoin>();
}
// make sure coin is valid
var coinValue = _coinService.GetCoinValue(coin);
if (coinValue == null)
{
throw new Exception("The inserted coin is not valid.");
}
// add the coin to the machine
coinsInMachine.Add(coin);
RemoveCoinsCache();
_cache.Add(new CacheItem(_cache_coinsInMachine, coinsInMachine), new CacheItemPolicy());
// return the new value of all the coins in the machine
return(_coinService.GetCoinsTotalValue(coinsInMachine));
}
public void VendingMachine_InValidCoinInserted_DisplaysInsertCoin()
{
var fixture = new Fixture()
.Customize(new AutoMoqCustomization());
var checker = fixture.Freeze <Mock <ICoinChecker> >();
var repository = fixture.Freeze <Mock <ICoinRepository> >();
checker.Setup(x => x.CheckCoin(It.IsAny <InsertedCoin>())).Returns(ValidCoin.Unknown);
repository.Setup(x => x.GetAllCoinBins())
.Returns(ValidCoin.List().Select(coin => new CoinBin()
{
Amount = 25, CoinType = coin
}));
var sut = fixture.Create <VendingMachine>();
var insertedCoin = new InsertedCoin()
{
Diameter = 100f,
Weight = 100f
};
sut.InsertCoin(insertedCoin);
Assert.Equal("Insert Coin", sut.CoinDisplay);
}
public void VendingMachine_ValidCoinInserted_DisplaysValueOfCoin()
{
var fixture = new Fixture()
.Customize(new AutoMoqCustomization());
var checker = fixture.Freeze <Mock <ICoinChecker> >();
var repository = fixture.Freeze <Mock <ICoinRepository> >();
checker.Setup(x => x.CheckCoin(It.IsAny <InsertedCoin>())).Returns(ValidCoin.Nickel);
repository.Setup(x => x.GetAllCoinBins())
.Returns(ValidCoin.List().Select(coin => new CoinBin()
{
Amount = 25, CoinType = coin
}));
var sut = fixture.Create <VendingMachine>();
var insertedCoin = new InsertedCoin()
{
Diameter = ValidCoin.Nickel.Diameter,
Weight = ValidCoin.Nickel.Weight
};
var result = sut.InsertCoin(insertedCoin);
Assert.Equal($"{result.Value:C}", sut.CoinDisplay);
}
/// <summary>
/// Helper function to get maximum change using specified coin, as well as to update running totals
/// </summary>
/// <param name="coinToUse">Coin to use</param>
/// <param name="change">Change to be made</param>
/// <param name="amountOfChange">The amount of change to make</param>
/// <param name="makeChangeFrom">Pool of money to make change from</param>
/// <param name="coinAppraiser">Provides values for coins</param>
/// <returns>Remaining change to make</returns>
private decimal CreateChange(
InsertedCoin coinToUse,
IDictionary<InsertedCoin, int> change,
decimal amountOfChange,
IDictionary<InsertedCoin, int> makeChangeFrom,
ICoinAppraiser coinAppraiser)
{
decimal retVal = amountOfChange;
// If the coinage exists within our pool to make change from, then do our adjustments
if ((makeChangeFrom.ContainsKey(coinToUse)) && (retVal > 0))
{
decimal coinValue = coinAppraiser.GetCoinValue(coinToUse);
int numCoins = (int)(retVal / coinValue);
numCoins = Math.Min(numCoins, makeChangeFrom[coinToUse]);
retVal -= (numCoins * coinValue);
makeChangeFrom[coinToUse] -= numCoins;
if (change.ContainsKey(coinToUse))
{
change[coinToUse] += numCoins;
}
else if (numCoins > 0)
{
change.Add(coinToUse, numCoins);
}
}
// Return what's left
return retVal;
}
public int?GetCoinValue(InsertedCoin insertedCoin)
{
return(_coinDimensionsToCoinValueMap
.Where(x => x.Item1 == insertedCoin.Diameter)
.Where(x => x.Item2 == insertedCoin.Thickness)
.Where(x => x.Item3 == insertedCoin.Weight)
.FirstOrDefault()?.Item4);
}
public Coin GetCoin(InsertedCoin insertedCoin)
{
var coinValue = GetCoinValue(insertedCoin);
if (coinValue == null)
{
return(null);
}
return(_coins.Where(x => x.Value == coinValue)
.FirstOrDefault());
}
public IHttpActionResult Insert(InsertedCoin coin)
{
// save the new coin in the machine
// return the value of the amount of coins in the machine
if (coin == null)
{
return(BadRequest());
}
return(Ok(_vendingMachineStateManager.CoinInserted(coin)));
}
public ValidCoin InsertCoin(InsertedCoin newCoin)
{
var coinType = this.coinChecker.CheckCoin(newCoin);
if (coinType == ValidCoin.Unknown)
{
return(ValidCoin.Unknown);
}
this.currentCoinValue += coinType.Value;
this.CoinBins.First(x => x.CoinType == coinType).Amount++;
return(coinType);
}
public decimal GetCoinValue(InsertedCoin coin)
{
if (coin == InsertedCoin.Nickel)
{
return (decimal)0.05;
}
if (coin == InsertedCoin.Dime)
{
return (decimal)0.10;
}
if (coin == InsertedCoin.Quarter)
{
return (decimal)0.25;
}
return (decimal)0.00;
}
private void InsertCoin(int coinIndex)
{
var coinList = ValidCoin.List().ToList();
if (coinIndex >= coinList.Count)
{
return;
}
var insertedCoin = new InsertedCoin()
{
Diameter = coinList[coinIndex].Diameter, Weight = coinList[coinIndex].Weight
};
this.machine.InsertCoin(insertedCoin);
}
/// <summary>
/// Adds coin(s) to coin return
/// </summary>
/// <param name="coin">The type of coin to place in the coin return</param>
/// <param name="quantity">The number of coins</param>
private void AddToCoinReturn(InsertedCoin coin, int quantity = 1)
{
if (this.CoinReturn.ContainsKey(coin))
{
this.CoinReturn[coin] += quantity;
}
else
{
this.CoinReturn.Add(coin, quantity);
}
}
