public void RemoveMoneyFromAccountDoesReturnValue()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));
            Assert.AreEqual(100m, card.RemoveFromBalance(100m));
        }
        public void RemoveMoneyFromAccountDoesNotThrow()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));
            Assert.DoesNotThrow(() => card.RemoveFromBalance(100m));
        }
        public void RemoveMoneyFromAccountReturnsAmountBack(decimal expected)
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));
            Assert.AreEqual(expected, card.RemoveFromBalance(expected));
        }
        public void CheckPinCodeIsRight()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 0M, 4322, new DateTime(2030, 10, 5));
            Assert.IsTrue(card.CheckPin(4322));
        }
        static void Main(string[] args)
        {
            MasterCard mc = new MasterCard();

            mc.Parcelas = 12;
            System.Console.WriteLine(mc.Parcelas);
        }
Example #6
0
        public void TestCase1()
        {
            var visa     = new Visa(100);
            var mc       = new MasterCard(100);
            var discover = new Discover(100);

            _wallet.Cards.Add(visa);
            _wallet.Cards.Add(mc);
            _wallet.Cards.Add(discover);

            _person.Wallets.Add(_wallet);

            var correctVisaInterest     = _visaInterest * 100;
            var correctMcInterest       = _masterCardInterest * 100;
            var correctDiscoverInterest = _discoverInterest * 100;
            var correctTotalInterest    = correctVisaInterest + correctMcInterest + correctDiscoverInterest;

            var actualVisaInterest     = _calculator.CalculateInterestForCard(visa);
            var actualMcInterest       = _calculator.CalculateInterestForCard(mc);
            var actualDiscoverInterest = _calculator.CalculateInterestForCard(discover);
            var actualTotalInterest    = _calculator.CalculateInterestForPerson(_person);

            Assert.AreEqual(correctVisaInterest, actualVisaInterest);
            Assert.AreEqual(correctMcInterest, actualMcInterest);
            Assert.AreEqual(correctDiscoverInterest, actualDiscoverInterest);
            Assert.AreEqual(correctTotalInterest, actualTotalInterest);
        }
        public void TestCase2()
        {
            Person testPerson = new Person()
            {
                FirstName = "Test", LastName = "Person1"
            };
            Wallet wallet1 = new Wallet();

            testPerson.Wallets.Add(wallet1);

            Visa VisaCC = new Visa();

            VisaCC.Balance = 100;
            wallet1.CreditCards.Add(VisaCC);

            Discover DiscoverCC = new Discover();

            DiscoverCC.Balance = 100;
            wallet1.CreditCards.Add(DiscoverCC);

            Wallet wallet2 = new Wallet();

            testPerson.Wallets.Add(wallet2);

            MasterCard MasterCC = new MasterCard();

            MasterCC.Balance = 100;
            wallet2.CreditCards.Add(MasterCC);

            Assert.AreEqual(16, testPerson.TotalInterest());
            Assert.AreEqual(11, wallet1.TotalInterest());
            Assert.AreEqual(5, wallet2.TotalInterest());
        }
        /// <summary>
        /// Executes processing of the authorization event info.
        /// </summary>
        public ResultCode Execute()
        {
            ResultCode result = ResultCode.None;

            SharedAuthorizationLogic sharedAuthorizationLogic = new SharedAuthorizationLogic(Context,
                                                                                             CommerceOperationsFactory.AuthorizationOperations(Context));

            // Marshal MasterCard Authorization request object into partner-agnostic model.
            Authorization authorization = new Authorization();

            Context[Key.Authorization] = authorization;
            MasterCard masterCard = new MasterCard(Context);

            masterCard.MarshalAuthorization();

            // Add the authorization even to the data store.
            result = sharedAuthorizationLogic.AddAuthorization();

            // Build the response to send back to MasterCard based on the result of adding the Authorization.
            Context[Key.ResultCode] = result;
            masterCard.BuildAuthorizationResponse();

            // If the authorization event was successfully committed to the data store, send user notifications.
            if (result == ResultCode.Created)
            {
                Context.Log.Verbose("MasterCard Authorization successfully persisted. Sending notifications asynchronously.");
                NotifyAuthorization notifyAuthorization = new NotifyAuthorization(Context);
                Context[Key.CardBrand] = CardBrand.MasterCard;
                Task.Run(new Action(notifyAuthorization.SendNotification));
            }

            return(result);
        }
Example #9
0
        public void InsertCardDoesNotThrow()
        {
            IATM  atm  = new ATM();
            ICard card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            Assert.DoesNotThrow(() => atm.InsertCard(card));
        }
Example #10
0
        public void InsertCardInEmptyATMReturnsTrue()
        {
            IATM  atm  = new ATM();
            ICard card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            Assert.IsTrue(atm.InsertCard(card));
        }
        public void CheckPinCodeIsWrong()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 0M, 4322, new DateTime(2030, 10, 5));
            Assert.IsFalse(card.CheckPin(4212));
        }
Example #12
0
        public void Case3_WhenCalled_ReturnTotalInterestOn2WalletFor2PersonWith2CardEachOne()
        {
            var person1    = new Person();
            var wallet1    = new Wallet();
            var mastercard = new MasterCard();

            wallet1.AddCardToWallet(mastercard);
            var visacard = new VisaCard();

            wallet1.AddCardToWallet(visacard);
            person1.AddWalletToPerson(wallet1);

            var person2   = new Person();
            var wallet2   = new Wallet();
            var visacard2 = new VisaCard();

            wallet2.AddCardToWallet(visacard2);
            var mastercard2 = new MasterCard();

            wallet2.AddCardToWallet(mastercard2);
            person2.AddWalletToPerson(wallet2);


            var resultforperson1 = person1.TotalInterest();
            var resultforperson2 = person2.TotalInterest();


            Assert.AreEqual(15, resultforperson1);
            Assert.AreEqual(15, resultforperson2);
        }
        static void Main(string[] args)
        {
            MasterCard m = new MasterCard();//instanciamento da subclasse MasterCard

            mc.Parcelas = 12;
            System.Console.WriteLine(mc.Parcelas)
        }
        public void TestCaseThree()
        {
            MasterCard person1MasterCard1 = new MasterCard(100m);
            MasterCard person1MasterCard2 = new MasterCard(100m);

            WalletType person1Wallet = new WalletType();

            person1Wallet.AddCard(person1MasterCard1)
            .AddCard(person1MasterCard2);

            WalletPerson person1 = new WalletPerson();

            person1.AddWallet(person1Wallet);

            MasterCard person2MasterCard = new MasterCard(100m);
            Visa       person2Visa       = new Visa(100m);

            WalletType person2Wallet = new WalletType();

            person2Wallet.AddCard(person2MasterCard)
            .AddCard(person2Visa);

            WalletPerson person2 = new WalletPerson();

            person2.AddWallet(person2Wallet);

            Assert.Equal(10m, person1.CalculateTotalInterest());
            Assert.Equal(10m, person1Wallet.CalculateTotalInterest());
            Assert.Equal(15m, person2.CalculateTotalInterest());
            Assert.Equal(15m, person2Wallet.CalculateTotalInterest());
        }
        public void TestCase1()
        {
            //Arrange
            decimal bal  = 100m;
            var     visa = new Visa(bal);
            var     mc   = new MasterCard(bal);
            var     disc = new Discover(bal);

            Wallet homersWallet = new Wallet();

            homersWallet.AddCard(visa);
            homersWallet.AddCard(mc);
            homersWallet.AddCard(disc);

            Person homer = new Person("Homer J Simpson", new List <Wallet>()
            {
                homersWallet
            });

            //Act
            decimal interestHomer = InterestCalculator.CalculatePersonSimpleInterest(homer);

            decimal interestVisa       = InterestCalculator.CalculateSimpleInterest(visa.CurrentBalance, visa.InterestRate);
            decimal interestMasterCard = InterestCalculator.CalculateSimpleInterest(mc.CurrentBalance, mc.InterestRate);
            decimal interestDiscover   = InterestCalculator.CalculateSimpleInterest(disc.CurrentBalance, disc.InterestRate);

            //Assert
            Assert.Equal(16m, interestHomer);       //Total simple interest for the person

            Assert.Equal(10m, interestVisa);        //Simple interest per card
            Assert.Equal(5m, interestMasterCard);
            Assert.Equal(1m, interestDiscover);

            Assert.Equal(interestHomer, interestVisa + interestMasterCard + interestDiscover); //Total should equal the sum of all cards
        }
        public void CheckPinCodeDoesNotThrow()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 0M, 4322, new DateTime(2030, 10, 5));
            Assert.DoesNotThrow(() => card.CheckPin(4212));
        }
Example #17
0
        public void InsertCardSavesCardInATM()
        {
            IATM  atm  = new ATM();
            ICard card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            atm.InsertCard(card);
            Assert.NotNull(atm.CardInserted);
        }
 

        [TestMethod] 
 public void TestCase1() 

 {
     
 var mc = new MasterCard(100m); 
 var visa = new Visa(100m); 
 var disc = new Discover(100m); 

 wallet.Cards = new List <Card> {
         mc, visa, disc
     }; 
 person.Wallets = new List <Wallet> {
         wallet
     }; 

 Assert.AreEqual(16, person.CalculateInterest()); 

 Assert.AreEqual(10, visa.CalculateInterest()); 
 Assert.AreEqual(5, mc.CalculateInterest()); 
 Assert.AreEqual(1, disc.CalculateInterest()); 

 }
        public void CheckCardIsInValid()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 5500m, 4322, new DateTime(1995, 10, 5));

            Assert.IsFalse(card.CheckCardValidity());
        }
        public void CardNumberIsNullWhenItShouldNot()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            Assert.AreNotEqual(null, card.CardNumber);
        }
        public void StartingBalanceCanStartOnZero()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 0M, 4322, new DateTime(2030, 10, 5));

            Assert.AreEqual(0M, card.GetBalance());
        }
        public void GetAccountBalanceReturnsStartingBalance()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            Assert.AreEqual(1000M, card.GetBalance());
        }
        public void GetAccountBalanceDoesNotThrow()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            Assert.DoesNotThrow(() => card.GetBalance());
        }
Example #24
0
        public void InsertingTwoCardsShouldReturnFalse()
        {
            IATM  atm  = new ATM();
            ICard card = new MasterCard("5555555555555555", 1000M, 4322, new DateTime(2030, 10, 5));

            atm.InsertCard(card);
            Assert.IsFalse(atm.InsertCard(new MasterCard("4219273519234215", 1000M, 4322, new DateTime(2030, 10, 5))));
        }
Example #25
0
        public void CalculateInterest_NegativeBalance_ReturnsZero()
        {
            ICreditCard masterCard = new MasterCard(-100);

            decimal interestOnCard = masterCard.CalculateSimpleInterest();

            Assert.Equal(0, interestOnCard);
        }
        public void CheckChardIsValidTheSameDayAsExpiry()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 5500m, 4322, DateTime.Today);

            Assert.IsTrue(card.CheckCardValidity());
        }
Example #27
0
        public void CalculateInterest_ValidBalanceAndInterest_ReturnsInterest()
        {
            ICreditCard masterCard = new MasterCard(100);

            decimal interestOnCard = masterCard.CalculateSimpleInterest();

            Assert.Equal(5, interestOnCard);
        }
        static void Main(string[] args)
        {
            MasterCard m = new MasterCard();

            m.Parcelas = 12;

            Console.WriteLine(m.Bandeira);
        }
        public void CheckCardIsValid()
        {
            ICard card;

            card = new MasterCard("5555555555555555", 5500m, 4322, new DateTime(2030, 10, 5));

            Assert.IsTrue(card.CheckCardValidity());
        }
Example #30
0
        public void RetrieveInterestForWallet_OneCreditCard_ReturnsInterest()
        {
            ICreditCard masterCard = new MasterCard(100);
            IWallet     wallet     = new Wallet(masterCard);

            decimal totalInterest = wallet.RetrieveInterestForWallet();

            Assert.Equal(5, totalInterest);
        }