public async Task GetValidRawMaterialByID()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "Muskmelon", RawMaterialCode = "MML", RawMaterialPrice = 40
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial);

            bool   isDisplayed  = false;
            string errorMessage = null;

            //Act
            try
            {
                RawMaterial rawMaterial1 = await rawMaterialBL.GetRawMaterialByRawMaterialIDBL(rawMaterial.RawMaterialID);

                if (rawMaterial.RawMaterialID == rawMaterial1.RawMaterialID)
                {
                    isDisplayed = true;
                }
            }
            catch (Exception ex)
            {
                isDisplayed  = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsTrue(isDisplayed, errorMessage);
            }
        }
        public async Task DeleteValidRawMaterial()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Coffee", RawMaterialCode = "Cof", RawMaterialPrice = 20
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            bool   isDeleted    = false;
            string errorMessage = null;

            //Act
            try
            {
                isDeleted = await rawMaterialBL.DeleteRawMaterialBL(rawMaterial1.RawMaterialID);
            }
            catch (Exception ex)
            {
                isDeleted    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsTrue(isDeleted, errorMessage);
            }
        }
        public async Task GetAllValidRawMaterials()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "Grape", RawMaterialCode = "GRP", RawMaterialPrice = 60
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial);

            bool   isDisplayed  = false;
            string errorMessage = null;

            //Act
            try
            {
                List <RawMaterial> rawMaterialList = await rawMaterialBL.GetAllRawMaterialsBL();

                if (rawMaterialList.Count > 0)
                {
                    isDisplayed = true;
                }
            }
            catch (Exception ex)
            {
                isDisplayed  = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsTrue(isDisplayed, errorMessage);
            }
        }
        public async Task RawMaterialCodeDoesNotExist()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "Salt", RawMaterialCode = "SAL", RawMaterialPrice = 15
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial);

            bool   isDisplayed  = false;
            string errorMessage = null;

            //Act
            try
            {
                RawMaterial rawMaterial1 = await rawMaterialBL.GetRawMaterialByRawMaterialCodeBL("SomeCode");
            }
            catch (Exception ex)
            {
                isDisplayed  = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isDisplayed, errorMessage);
            }
        }
        public async Task RawMaterialCodeCanNotBeNull()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "Mango", RawMaterialCode = null, RawMaterialPrice = 20
            };
            bool   isAdded      = false;
            string errorMessage = null;

            //Act
            try
            {
                isAdded = await rawMaterialBL.AddRawMaterialBL(rawMaterial);
            }
            catch (Exception ex)
            {
                isAdded      = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isAdded, errorMessage);
            }
        }
        public async Task RawMaterialIDDoesNotExist()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "WaterMelon", RawMaterialCode = "WTM", RawMaterialPrice = 20
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial);

            bool   isDisplayed  = false;
            string errorMessage = null;

            //Act
            try
            {
                RawMaterial rawMaterial1 = await rawMaterialBL.GetRawMaterialByRawMaterialIDBL(default(Guid));
            }
            catch (Exception ex)
            {
                isDisplayed  = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isDisplayed, errorMessage);
            }
        }
        public async Task RawMaterialNameShouldContainAtLeastTwoCharacters()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "M", RawMaterialCode = "Man", RawMaterialPrice = 20
            };
            bool   isAdded      = false;
            string errorMessage = null;

            //Act
            try
            {
                isAdded = await rawMaterialBL.AddRawMaterialBL(rawMaterial);
            }
            catch (Exception ex)
            {
                isAdded      = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isAdded, errorMessage);
            }
        }
        public async Task AddValidRawMaterial()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial   = new RawMaterial()
            {
                RawMaterialName = "Coconut", RawMaterialCode = "COC", RawMaterialPrice = 35
            };
            bool   isAdded      = false;
            string errorMessage = null;

            //Act
            try
            {
                isAdded = await rawMaterialBL.AddRawMaterialBL(rawMaterial);
            }
            catch (Exception ex)
            {
                isAdded      = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsTrue(isAdded, errorMessage);
            }
        }
        public async Task RawMaterialIDDoesNotExist()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Kiwi", RawMaterialCode = "KIW", RawMaterialPrice = 50
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            bool   isDeleted    = false;
            string errorMessage = null;

            //Act
            try
            {
                isDeleted = await rawMaterialBL.DeleteRawMaterialBL(default(Guid));
            }
            catch (Exception ex)
            {
                isDeleted    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isDeleted, errorMessage);
            }
        }
示例#10
0
        public async Task RawMaterialIDDoesNotExist()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Citricaciddd", RawMaterialCode = "CITTA", RawMaterialPrice = 40
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = default(Guid), RawMaterialName = "CitriccA", RawMaterialCode = "CITZ", RawMaterialPrice = 45
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isUpdated, errorMessage);
            }
        }
示例#11
0
        public async Task RawMaterialCodeCanNotBeNull()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Honey", RawMaterialCode = "HON", RawMaterialPrice = 40
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = rawMaterial1.RawMaterialID, RawMaterialName = "Honeyy", RawMaterialCode = null, RawMaterialPrice = 45
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isUpdated, errorMessage);
            }
        }
示例#12
0
        public async Task RawMaterialCodeShouldContainAtLeastTwoCharacters()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Fructose", RawMaterialCode = "FRUC", RawMaterialPrice = 70
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = rawMaterial1.RawMaterialID, RawMaterialName = "Fructos", RawMaterialCode = "F", RawMaterialPrice = 80
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isUpdated, errorMessage);
            }
        }
示例#13
0
        public async Task UpdateValidRawMaterial()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Ppya", RawMaterialCode = "PUP", RawMaterialPrice = 20
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = rawMaterial1.RawMaterialID, RawMaterialName = "Paapaayaa", RawMaterialCode = "PPY", RawMaterialPrice = 25
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsTrue(isUpdated, errorMessage);
            }
        }
示例#14
0
        public async Task RawMaterialPriceCanNotBeLessThanZero()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Sugarcane", RawMaterialCode = "SUGC", RawMaterialPrice = 20
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = rawMaterial1.RawMaterialID, RawMaterialName = "SCane", RawMaterialCode = "SCA", RawMaterialPrice = -10
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isUpdated, errorMessage);
            }
        }
示例#15
0
        public async Task RawMaterialPriceCanNotBeZero()
        {
            //Arrange
            RawMaterialBL rawMaterialBL = new RawMaterialBL();
            RawMaterial   rawMaterial1  = new RawMaterial()
            {
                RawMaterialName = "Lactone", RawMaterialCode = "LAC", RawMaterialPrice = 100
            };
            await rawMaterialBL.AddRawMaterialBL(rawMaterial1);

            RawMaterial rawMaterial2 = new RawMaterial()
            {
                RawMaterialID = rawMaterial1.RawMaterialID, RawMaterialName = "Preservative", RawMaterialCode = "PRES", RawMaterialPrice = 0
            };
            bool   isUpdated    = false;
            string errorMessage = null;

            //Act
            try
            {
                isUpdated = await rawMaterialBL.UpdateRawMaterialBL(rawMaterial2);
            }
            catch (Exception ex)
            {
                isUpdated    = false;
                errorMessage = ex.Message;
            }
            finally
            {
                //Assert
                Assert.IsFalse(isUpdated, errorMessage);
            }
        }
示例#16
0
        public async Task <IHttpActionResult> PostRawMaterials(RawMaterial rawMaterial)
        {
            try
            {
                bool isAdded = await rawMaterialBL.AddRawMaterialBL(rawMaterial);

                return(Ok());
            }
            catch (Exception)
            {
                throw;
            }
        }
示例#17
0
 private static void AddRawMaterial()
 {
     try
     {
         RawMaterial newRawMaterial = new RawMaterial();
         Console.WriteLine("Enter Raw Material ID :");
         newRawMaterial.RawMaterialID = Console.ReadLine();
         Console.WriteLine("Enter Raw Material Name :");
         newRawMaterial.RawMaterialName = Console.ReadLine();
         bool getCodeIfNameExists = false;
         foreach (RawMaterial item in RawMaterialDAL.rawMaterialList)
         {
             if (item.RawMaterialName == newRawMaterial.RawMaterialName)
             {
                 newRawMaterial.RawMaterialCode = item.RawMaterialCode;
                 getCodeIfNameExists            = true;
             }
         }
         if (getCodeIfNameExists == false)
         {
             Console.WriteLine("Enter Raw Material Code :");
             newRawMaterial.RawMaterialCode = Console.ReadLine();
         }
         RawMaterialBL rawMaterialBL    = new RawMaterialBL();
         bool          rawMaterialAdded = rawMaterialBL.AddRawMaterialBL(newRawMaterial);
         if (rawMaterialAdded)
         {
             Console.WriteLine("Raw Material Added");
         }
         else
         {
             Console.WriteLine("Raw Material not Added");
         }
     }
     catch (SystemException ex)
     {
         Console.WriteLine(ex.Message);
     }
 }
示例#18
0
        static void Main(string[] args)
        {
            RawMaterial rawMaterial1 = new RawMaterial()
            {
                RawMaterialID = "RM101", RawMaterialName = "Mango", RawMaterialCode = "MGO"
            };
            RawMaterialBL rawMaterialBL = new RawMaterialBL();

            rawMaterialBL.AddRawMaterialBL(rawMaterial1);
            Product product1 = new Product()
            {
                ProductID = "P101", ProductName = "MJUICE", ProductCode = "JC", ProductMFD = "12-09-2019", ProductEXP = "12-09-2020", ProductType = "Juice"
            };
            ProductBL productBL = new ProductBL();

            productBL.AddProductBL(product1);

            int choice;

            do
            {
                PrintMenu();
                Console.WriteLine("Enter your Choice:");
                choice = Convert.ToInt32(Console.ReadLine());
                switch (choice)
                {
                case 1:
                    AddRawMaterial();
                    break;

                case 2:
                    ListAllRawMaterial();
                    break;

                case 3:
                    SearchRawMaterialByID();
                    break;

                case 4:
                    SearchRawMaterialByName();
                    break;

                case 5:
                    SearchRawMaterialByCode();
                    break;

                case 6:
                    UpdateRawMaterial();
                    break;

                case 7:
                    DeleteRawMaterial();
                    break;

                case 8:
                    AddProduct();
                    break;

                case 9:
                    ListAllProduct();
                    break;

                case 10:
                    SearchProductByID();
                    break;

                case 11:
                    SearchProductByType();
                    break;

                case 12:
                    SearchProductByCode();
                    break;

                case 13:
                    UpdateProduct();
                    break;

                case 14:
                    DeleteProduct();
                    break;

                case 15:
                    SerializeRawMaterial();
                    break;

                case 16:
                    DeserializeRawMaterial();
                    break;

                case 17:
                    SerializeProduct();
                    break;

                case 18:
                    DeserializeProduct();
                    break;

                case 19:
                    return;

                default:
                    Console.WriteLine("Invalid Choice");
                    break;
                }
            } while (choice != -1);
        }