public async Task PostBondTest()
        {
            // Arrange
            var mockRepo = new Mock <IBondRepository>();
            var newBond  = new Bond
            {
                Id = 6, ItemId = 1, CharacterId = 7
            };

            mockRepo.Setup(repo => repo.Insert(newBond));
            var controller = new BondsController(mockRepo.Object);

            // Act
            var result = await controller.PostBond(newBond);

            Assert.IsNotNull(result);
            var retResult = result.Result as CreatedAtActionResult;

            Assert.IsNotNull(retResult);
            var objResult = retResult.Value as Bond;

            Assert.IsNotNull(objResult);
            Assert.AreEqual(newBond.Id, objResult.Id);
            Assert.AreEqual(newBond.CharacterId, objResult.CharacterId);
            Assert.AreEqual(newBond.ItemId, objResult.ItemId);
        }
Esempio n. 2
0
        public async Task DeleteTest()
        {
            // Arrange
            var mockBondRepo = new Mock <IBondRepository>();
            var mockBondServ = new Mock <IBondService>();
            var charId       = 1;

            mockBondRepo.Setup(repo => repo.Get(charId)).ReturnsAsync(TestData.Bonds().FirstOrDefault(b => b.Id == charId));
            var controller = new BondsController(mockBondRepo.Object, null, null, mockBondServ.Object);

            // Act
            var result = await controller.Delete(charId);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(ViewResult));
            var viewResult = result as ViewResult;

            Assert.IsNotNull(viewResult);
            var model = viewResult.ViewData.Model;

            Assert.IsNotNull(model);
            var bond = model as Bond;

            Assert.IsNotNull(bond);
            Assert.AreEqual(charId, bond.Id);
        }
Esempio n. 3
0
        public async Task DeleteConfirmedTest()
        {
            // Arrange
            var mockBondRepo = new Mock <IBondRepository>();
            var mockBondServ = new Mock <IBondService>();
            var charId       = 1;

            mockBondRepo.Setup(repo => repo.Get(charId)).ReturnsAsync(TestData.Bonds().FirstOrDefault(b => b.Id == charId));
            var controller = new BondsController(mockBondRepo.Object, null, null, mockBondServ.Object);

            // Act
            var result = await controller.DeleteConfirmed(charId);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
        }
        public async Task GetBondTest()
        {
            // Arrange
            var mockRepo = new Mock <IBondRepository>();
            var bondId   = 3;

            mockRepo.Setup(repo => repo.Get(bondId))
            .Returns(Task.FromResult(TestData.Bonds().FirstOrDefault(b => b.Id == bondId)));
            var controller = new BondsController(mockRepo.Object);

            // Act
            var result = await controller.GetBond(bondId);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Value);
            var bond     = result.Value;
            var testItem = TestData.Bonds().FirstOrDefault(b => b.Id == bondId);

            Assert.AreEqual(testItem.CharacterId, bond.CharacterId);
            Assert.AreEqual(testItem.ItemId, bond.ItemId);
        }
Esempio n. 5
0
        public async Task IndexTest()
        {
            // Arrange
            var mockBondRepo = new Mock <IBondRepository>();
            var mockBondServ = new Mock <IBondService>();

            mockBondRepo.Setup(repo => repo.GetAll()).ReturnsAsync(TestData.Bonds());

            var controller = new BondsController(mockBondRepo.Object, null, null, mockBondServ.Object);

            // Act
            var result = await controller.Index();

            // Assert
            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(ViewResult));
            var viewResult = result as ViewResult;
            var model      = viewResult.ViewData.Model;

            Assert.IsNotNull(model);
            var modelList = model as IEnumerable <Bond>;

            Assert.AreEqual(TestData.Bonds().Count, modelList.Count());
        }