public void ItemNotFound_ReturnsFalse()
        {
            // Arrange
            var dataStoreMock = new Mock <IDataStore>(MockBehavior.Strict);

            dataStoreMock.SetupProperty(p => p.Items, new List <Item>());

            var bidService = new BidService(dataStoreMock.Object);

            var unknownId = _randomInteger.GeneratePositiveValue().ToString();
            var userId    = _randomString.GenerateValue(8);

            var serviceModel = new BidCreateServiceModel
            {
                Amount = _randomDecimal.GeneratePositiveValue(),
                ItemId = unknownId,
                UserId = userId,
                MadeOn = DateTime.UtcNow
            };

            // Act
            var result = bidService.CreateBid(serviceModel);

            // Assert
            Assert.IsFalse(result, "Incorrect result returned");
        }
        public async Task CreateBidAsync_WithValidModel_ShouldReturnTrue()
        {
            // Arrange
            var model = new BidCreateServiceModel {
                Amount = SampleAmount, UserId = SampleUserId, ItemId = SampleItemId, MadeOn = SampleMadeOnDate
            };
            // Act
            var result = await this.bidService.CreateBidAsync(model);

            // Assert
            result
            .Should()
            .Be(true);
        }
Beispiel #3
0
        public bool CreateBid(BidCreateServiceModel model)
        {
            var item = _dataStore.Items.FirstOrDefault(i => i.Id == model.ItemId);

            if (item == null)
            {
                return(false);
            }

            item.Price  = model.Amount;
            item.UserId = model.UserId;

            return(true);
        }
Beispiel #4
0
        public async Task CreateBidAsync(string bidAmount, string consoleId)
        {
            if (bidAmount == null || consoleId == null)
            {
                return;
            }

            var isParsed = decimal.TryParse(bidAmount, out var parsedBidAmount);

            if (!isParsed)
            {
                return;
            }

            var item = await this.itemsService.GetByIdAsync <ItemDetailsServiceModel>(consoleId);

            if (item == null)
            {
                return;
            }
            var canBid = this.bidService.CanBid(item);

            if (!canBid || item.StartingPrice > parsedBidAmount)
            {
                return;
            }

            var userId       = this.Context.UserIdentifier;
            var serviceModel = new BidCreateServiceModel
            {
                Amount = parsedBidAmount,
                MadeOn = DateTime.UtcNow,
                ItemId = item.Id,
                UserId = userId
            };

            var isSucceeded = await this.bidService.CreateBidAsync(serviceModel);

            if (!isSucceeded)
            {
                return;
            }

            await this.Clients.Groups(consoleId).SendAsync("ReceivedMessage", parsedBidAmount, userId);
        }
Beispiel #5
0
        public async Task CreateBidAsync(string bidAmount, string consoleId)
        {
            if (bidAmount == null || consoleId == null)
            {
                return;
            }

            var isParsed = decimal.TryParse(bidAmount, out var parsedBidAmount);

            if (!isParsed)
            {
                return;
            }

            var item = _itemsService.GetById(consoleId);

            if (item == null)
            {
                return;
            }

            if (item.Price >= parsedBidAmount)
            {
                return;
            }

            var userId       = Context.UserIdentifier;
            var serviceModel = new BidCreateServiceModel
            {
                Amount = parsedBidAmount,
                MadeOn = DateTime.UtcNow,
                ItemId = item.Id,
                UserId = userId
            };

            var succeeded = _bidService.CreateBid(serviceModel);

            if (!succeeded)
            {
                return;
            }

            await Clients.Groups(consoleId).SendAsync("ReceivedMessage", parsedBidAmount, userId);
        }
Beispiel #6
0
        public async Task <bool> CreateBidAsync(BidCreateServiceModel model)
        {
            if (!this.IsEntityStateValid(model))
            {
                return(false);
            }

            var bid = Mapper.Map <Bid>(model);

            try
            {
                await this.Context.Bids.AddAsync(bid);

                await this.Context.SaveChangesAsync();

                return(true);
            }
            catch
            {
                return(false);
            }
        }
        public void ItemFound_Updated_ReturnsTrue()
        {
            // Arrange
            var          description1 = _randomString.GenerateValue(50);
            var          description2 = _randomString.GenerateValue(50);
            var          endTime1     = DateTime.Now.AddHours(3);
            var          endTime2     = DateTime.Now.AddHours(4);
            var          id1          = _randomInteger.GeneratePositiveValue();
            var          id2          = _randomInteger.GeneratePositiveValue();
            const string picturePath1 = "ABC";
            const string picturePath2 = "XYZ";
            var          price1       = _randomDecimal.GeneratePositiveValue();
            var          price2       = _randomDecimal.GeneratePositiveValue();
            var          startTime1   = DateTime.Now.AddHours(-13);
            var          startTime2   = DateTime.Now.AddHours(-20);
            var          title1       = _randomString.GenerateValue(10);
            var          title2       = _randomString.GenerateValue(10);
            var          userId1      = _randomString.GenerateValue(8);
            var          userId2      = _randomString.GenerateValue(8);

            var dataStoreMock = new Mock <IDataStore>(MockBehavior.Strict);

            dataStoreMock.SetupProperty(p => p.Items, new List <Item>
            {
                new Item
                {
                    Description = description1,
                    EndTime     = endTime1,
                    Id          = id1.ToString(),
                    PicturePath = picturePath1,
                    Price       = price1,
                    StartTime   = startTime1,
                    Title       = title1,
                    UserId      = userId1
                },
                new Item
                {
                    Description = description2,
                    EndTime     = endTime2,
                    Id          = id2.ToString(),
                    PicturePath = picturePath2,
                    Price       = price2,
                    StartTime   = startTime2,
                    Title       = title2,
                    UserId      = userId2
                }
            });

            var bidService = new BidService(dataStoreMock.Object);

            var serviceModel = new BidCreateServiceModel
            {
                Amount = price1 + 10,
                ItemId = id1.ToString(),
                UserId = userId1,
                MadeOn = DateTime.UtcNow
            };

            // Act
            var result = bidService.CreateBid(serviceModel);

            // Assert
            Assert.IsTrue(result, "Incorrect result returned");
        }