Unit test

Refactoring/Store.cs

@@ -32,7 +32,7 @@ public void Purchase(string productId, int quantity)
                 throw new OutOfStockException();
             }
 
-            product.Quantity = product.Quantity - quantity+1;
+            product.Quantity = product.Quantity - quantity;
             user.Balance = user.Balance - product.Price * quantity;
 
             dataManager.SaveUser(user);

UnitTestProject/AuthenticatorTests.cs

@@ -0,0 +1,212 @@
+using NUnit.Framework;
+using Refactoring;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnitTestProject
+{
+    [TestFixture]
+    class AuthenticatorTests
+    {
+        private User expectedUser = new User();
+
+        private User createTestUser(string name, string password, double balance) {
+            User testUser = new User();
+            testUser.Name = name;
+            testUser.Password = password;
+            testUser.Balance = balance;
+
+            return testUser;
+        }
+
+        private Authenticator createAuthenticator(bool validUser)
+        {
+            expectedUser = null;
+            if (validUser) { 
+                List<User> users = new List<User>();
+                expectedUser = createTestUser("Test", "Test", 99.99);
+                users.Add(expectedUser);
+
+                return new Authenticator(users);
+            }
+            return new Authenticator(null);
+        }
+
+        [Test]
+        public void Test_AuthenticateValidUsernameAndPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("Test", "Test");
+
+            Assert.IsNotNull(actualUser);
+            Assert.AreEqual(expectedUser.Name, actualUser.Name);
+            Assert.AreEqual(expectedUser.Password, actualUser.Password);
+            Assert.AreEqual(expectedUser.Balance, actualUser.Balance);
+        }
+
+        [Test]
+        public void Test_AuthenticateInvalidUsernameAndInvalidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("asdf", "asdf");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateInvalidUsernameAndValidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("asdf", "Test");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateValidUsernameAndInvalidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("Test", "adsdf");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateNullUsernameAndNullPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate(null, null);
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateNullUsernameAndValidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate(null, "Test");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateNullUsernameAndInvalidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate(null, "asd");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateValidUsernameAndNullPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("Test", null);
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateInvalidUsernameAndNullPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("asdf", null);
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateEmptyUsernameAndEmptyPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("", "");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateEmptyUsernameAndValidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("", "Test");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateEmptyUsernameAndInvalidPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("", "asd");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateValidUsernameAndEmptyPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("Test", "");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateInvalidUsernameAndEmptyPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("asdf", "");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateEmptyUsernameAndNullPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("", null);
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticatNullUsernameAndEmptyPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("", null);
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateReturnNullIfCaseIsNotCorrectForPassword()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("Test", "test");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateReturnNullIfCaseIsNotCorrectForUsername()
+        {
+            Authenticator authenticator = createAuthenticator(true);
+            User actualUser = authenticator.Authenticate("test", "Test");
+
+            Assert.IsNull(actualUser);
+        }
+
+        [Test]
+        public void Test_AuthenticateReturnNullIfListOfUserIsNullPassedIn()
+        {
+            Authenticator authenticator = createAuthenticator(false);
+            User actualUser = authenticator.Authenticate("test", "Test");
+
+            Assert.IsNull(actualUser);
+        }
+    }
+}

UnitTestProject/IntegrationTests.cs

@@ -10,7 +10,7 @@
 namespace UnitTestProject
 {
     [TestFixture]
-    //[Ignore("Disable integration tests")]
+    [Ignore("Disable integration tests")]
     public class IntegrationTests
     {
         private List<User> users;

UnitTestProject/StoreTests.cs

@@ -13,6 +13,11 @@ namespace UnitTestProject
     [TestFixture]
     class StoreTests
     {
+        private const string TEST_PRODUCT_ID = "1";
+        private const int QUANTITY_OF_PRODUCT = 10;
+        private List<Product> products;
+        private List<User> users;
+
         private User createTestUser(string name, string password, double balance)
         {
             User testUser = new User();
@@ -34,20 +39,22 @@ private Product createTestProduct(string id, string name, double price, int quan
             return testProduct;
         }
 
+        private Store setupStore(int numberOfProducts, double priceOfProduct, double userBalance)
+        {
+            users = new List<User>();
+            users.Add(createTestUser("Test User", "", userBalance));
+            products = new List<Product>();
+            products.Add(createTestProduct(TEST_PRODUCT_ID, "Product", priceOfProduct, numberOfProducts));
+
+            var dataManager = new DataManager(users, products);
+            return new Store(users[0], dataManager);
+        }
+
         [Test]
         public void Test_PurchaseThrowsNoErrorForValidFunds()
         {
             //Arrange
-            const string TEST_PRODUCT_ID = "1";
-
-            var users = new List<User>();
-            users.Add(createTestUser("Test User", "", 99.99));
-
-            var products = new List<Product>();
-            products.Add(createTestProduct(TEST_PRODUCT_ID, "Product", 9.99, 10));
-
-            var dataManager = new DataManager(users, products);
-            var store = new Store(users[0], dataManager);
+            var store = setupStore(QUANTITY_OF_PRODUCT, 9.99, 99.99);
 
             //Act
             store.Purchase(TEST_PRODUCT_ID, 10);
@@ -60,34 +67,102 @@ public void Test_PurchaseThrowsNoErrorForValidFunds()
         public void Test_PurchaseRemovesProductFromStore()
         {
             //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 9.99, 99.99);
 
             //Act
-
+            store.Purchase(TEST_PRODUCT_ID, 9);
             //Assert 
             //(choose the appropriate statement(s))
-            //Assert.AreEqual(1, products[0].Quantity);
+            Assert.AreEqual(1, products[0].Quantity);
             //Assert.AreSame(1, products[0].Quantity);
             //Assert.IsTrue(products[0].Quantity == 1);
         }
 
         [Test]
+        [ExpectedException(typeof(InsufficientFundsException))]
         public void Test_PurchaseThrowsExceptionWhenBalanceIsTooLow()
         {
             //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 1.01, 1.00);
 
             //Act
+            store.Purchase(TEST_PRODUCT_ID, 1);
+        }
 
+        [Test]
+        public void Test_PurchaseThrowsExceptionWhenBalanceIsTooLowVersion2()
+        {
+            //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 1.01, 1.00);
+            //Act
+            bool exception = false;
             //Assert
+            try
+            {
+                store.Purchase(TEST_PRODUCT_ID, 1);
+                Assert.Fail();
+            }
+            catch (InsufficientFundsException)
+            {
+                exception = true;
+            }
+            catch (Exception)
+            {
+                Assert.Fail();
+            }
+            Assert.IsTrue(exception);
         }
 
         [Test]
-        public void Test_PurchaseThrowsExceptionWhenBalanceIsTooLowVersion2()
+        [ExpectedException(typeof(OutOfStockException))]
+        public void Test_PurchaseThrowsExceptionWhenYouTryToPurcahseToMuch()
         {
             //Arrange
+            var store = setupStore(1, 1.00, 5.00);
 
             //Act
+            store.Purchase(TEST_PRODUCT_ID, 2);
+        }
+
+        [Test]
+        public void Test_GetProductListSucceed()
+        {
+            //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 9.99, 99.99);
+            string expectedProductList = "\nWhat would you like to buy?\n1: Product ($9.99)\nType quit to exit the application\n";
+
+            //Act
+            string actualProductList = store.GetProductList();
+
+            //Assert
+            Assert.AreEqual(expectedProductList, actualProductList);
+        }
+
+
+        [Test]
+        public void Test_NumberOfProductsSucceed()
+        {
+            //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 9.99, 99.99);
+            int expectedNumberOfProducts = 1;
+            //Act
+            int actualNumberOfProducts = store.NumberOfProducts();
+
+            //Assert
+            Assert.AreEqual(expectedNumberOfProducts, actualNumberOfProducts);
+        }
+
+
+        [Test]
+        public void Test_ContainsProduct_ReturnWithExactMatch()
+        {
+            //Arrange
+            var store = setupStore(QUANTITY_OF_PRODUCT, 9.99, 99.99);
+            //Act
+            bool expectedProduct = store.ContainsProduct(TEST_PRODUCT_ID);
 
             //Assert
+            Assert.IsTrue(expectedProduct);
         }
 
 

UnitTestProject/UnitTestProject.csproj

@@ -70,6 +70,7 @@
     <Otherwise />
   </Choose>
   <ItemGroup>
+    <Compile Include="AuthenticatorTests.cs" />
     <Compile Include="StoreTests.cs" />
     <Compile Include="IntegrationTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />