public void PopulateStocks_EmptyArray()
        {
            // Arrange
            string[] stockPrices = new string[0];

            // Act
            List <Stock> stocksOutput = StockBuilder.BuildStocks(stockPrices);

            // Assert
            stocksOutput.Count.Should().Be(0);
        }
        public ActionResult Buy_SI_Stocks_dispatcher(StockBuilder builder)
        {
            var containsInt = builder.stock_symbol.Any(char.IsDigit);

            if (builder.stock_symbol is string && builder.stock_symbol == builder.stock_symbol.ToUpper() && builder.quantity is int && builder.price is decimal && containsInt == false && builder.quantity != 0 && builder.price != 0)
            {
                Buy_SI_Stocks(builder.stock_symbol, builder.quantity, builder.price, builder.email);
                return(Ok());
            }

            return(BadRequest());
        }
Ejemplo n.º 3
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            var categoryBuilder = new CategoryBuilder(modelBuilder.Entity <Category>());
            var customerBuilder = new CustomerBuilder(modelBuilder.Entity <Customer>());
            var personelBuilder = new PersonelBuilder(modelBuilder.Entity <Personel>());
            var productBuilder  = new ProductBuilder(modelBuilder.Entity <Product>());
            var saleBuilder     = new SaleBuilder(modelBuilder.Entity <Sale>());
            var shipmentBuilder = new ShipmentBuilder(modelBuilder.Entity <Shipment>());
            var stockBuilder    = new StockBuilder(modelBuilder.Entity <Stock>());

            modelBuilder.Conventions.Remove <OneToManyCascadeDeleteConvention>();
        }
        public void PopulateStocks_EmptyStringArray()
        {
            // Arrange
            // Simulate empty file being loaded
            string[] stockPrices = new string[] { "" };

            try
            {
                // Act
                StockBuilder.BuildStocks(stockPrices);
            }
            catch (Exception e)
            {
                // Assert
                e.Message.Should().Contain("The following value:  is not valid");
            }
        }
        public void PopulateStocks_InvalidDecimal()
        {
            // Arrange
            // Value that can't be parsed as a double
            string invalidInput = "Test";

            string[] stockPrices = new string[] { invalidInput };

            try
            {
                // Act
                StockBuilder.BuildStocks(stockPrices);
            }
            catch (Exception e)
            {
                // Assert
                e.Message.Should().Contain($"The following value: {invalidInput} is not valid");
            }
        }
        public void PopulateStocks_Valid()
        {
            // Arrange
            string stockPrice = "1.0";

            string[] stockPrices = { stockPrice };

            List <Stock> expectedstocks = new List <Stock>
            {
                new Stock
                {
                    Day   = 1,
                    Price = 1.0
                }
            };

            // Act
            List <Stock> actualStocks = StockBuilder.BuildStocks(stockPrices);

            // Assert
            expectedstocks.Should().BeEquivalentTo(actualStocks);
        }