public async void GetAssetsByAuthor_ValidAuthor_ReturnsAllAssetsByAuthor()
        {
            using (var context = _factory.UseSqlite())
            {
                //Arrange
                ILogger <LibraryAssetService> logger = new NullLogger <LibraryAssetService>();

                context.AddRange(GetAllAssets());
                context.Add(GetAsset());
                context.Add(GetAuthor());
                context.Add(new Author {
                    Id = 2
                });
                context.SaveChanges();

                //Act
                var service = new LibraryAssetService(context, _logger);
                var actual  = await service.GetAssetsByAuthor(GetAuthor().Id);

                var assets = GetAllAssets().ToList();

                //Assert
                Assert.Equal(3, actual.ToList().Count);
            }
        }
Example #2
0
    public async void GetAssetById_ExistingAsset_ReturnAsset()
    {
        // Arrange
        using (var context = _factory.Create())
        {
            var asset = new LibraryAsset
            {
                Id     = 40,
                Author = new Author {
                    Id = 1
                },
                Photo = new Photo {
                    Id = 1
                }
            };
            context.Add(asset);
            context.SaveChanges();
        }
        // Act
        using (var context = _factory.Create())
        {
            var service = new LibraryAssetService(context);
            var actual  = await service.GetAsset(40);

            // Assert
            Assert.Equal(40, actual.Id);
            Assert.Equal(1, actual.Author.Id);
            Assert.Equal(1, actual.Photo.Id);
        }
    }
Example #3
0
        public void GetAuthorOrDirectorReturnsForBookOrVideo()
        {
            // Arrange
            var options = new DbContextOptionsBuilder <ILSContext>()
                          .UseInMemoryDatabase(databaseName: "GetAuthorOrDirectorReturnsForBookOrVideo")
                          .Options;

            using (var context = new ILSContext(options))
            {
                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Book",
                    Title          = "The Republic",
                    Author         = "Plato",
                    DeweyIndex     = "820.119",
                    ISBN           = "9780758320209",
                    Year           = -380,
                    Cost           = 11,
                    ImageUrl       = "/images/republic.png",
                    NumberOfCopies = 2,
                    LocationId     = 2,
                    StatusId       = 2
                });

                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Video",
                    Title          = "The Matrix",
                    Director       = "Lana / Lilly Wachowski",
                    Year           = 1999,
                    Cost           = 15,
                    ImageUrl       = "/images/thematrix.png",
                    NumberOfCopies = 2,
                    LocationId     = 1,
                    StatusId       = 1
                });

                context.SaveChanges();
            }

            string video;
            string book;

            // Act
            using (var context = new ILSContext(options))
            {
                var libraryAssetService = new LibraryAssetService(context);
                book  = libraryAssetService.GetAuthorOrDirector(1);
                video = libraryAssetService.GetAuthorOrDirector(2);
            }

            // Assert
            Assert.IsNotNull(video);
            Assert.IsNotNull(book);
            Assert.AreEqual(video, "Lana / Lilly Wachowski");
            Assert.AreEqual(book, "Plato");
        }
Example #4
0
        public void GetDeweyIndexReturnsCorrectIndex()
        {
            // Arrange
            var options = new DbContextOptionsBuilder <ILSContext>()
                          .UseInMemoryDatabase(databaseName: "GetDeweyIndexReturnsCorrectIndex")
                          .Options;

            using (var context = new ILSContext(options))
            {
                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Book",
                    Title          = "The Republic",
                    Author         = "Plato",
                    DeweyIndex     = "820.119",
                    ISBN           = "9780758320209",
                    Year           = -380,
                    Cost           = 11,
                    ImageUrl       = "/images/republic.png",
                    NumberOfCopies = 2,
                    LocationId     = 2,
                    StatusId       = 2
                });

                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Book",
                    Title          = "Jane Eyre",
                    Author         = "Charlotte Brontë",
                    DeweyIndex     = "822.133",
                    ISBN           = "9781519133977",
                    Year           = 1847,
                    Cost           = 15,
                    ImageUrl       = "/images/janeeyre.png",
                    NumberOfCopies = 5,
                    LocationId     = 1,
                    StatusId       = 1
                });

                context.SaveChanges();
            }

            string result;

            // Act
            using (var context = new ILSContext(options))
            {
                var libraryAssetService = new LibraryAssetService(context);
                result = libraryAssetService.GetDeweyIndex(2);
            }

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual("822.133", result);
        }
        public async Task AddAsset_NonExistingAsset_ShouldThrowNoValuesfoundException()
        {
            using (var context = _factory.UseInMemory())
            {
                // Arrange
                var service = new LibraryAssetService(context, _logger);

                // Assert
                await Assert.ThrowsAsync <NoValuesFoundException>(() => service.DeleteAsset(GetAsset().Id));
            }
        }
        public void Get_Dewey_Index_NA_For_Video()
        {
            var mockSet = BuildMock();
            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);
            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetDeweyIndex(234);

            queryResult.Should().Be("N/A");
        }
        public void Get_Director_Given_Video()
        {
            var mockSet = BuildMock();
            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetAuthorOrDirector(234);

            queryResult.Should().Be("WB");
        }
        public void Get_Isbn_For_Book()
        {
            var mockSet = BuildMock();
            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetIsbn(-903);

            queryResult.Should().Be("FOO");
        }
Example #9
0
        public void Get_Asset_Type_Given_Video()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryDbContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetType(234);

            queryResult.Should().Be("Video");
        }
        public void Return_NA_ISBN_For_NonBook_Asset()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetIsbn(234);

            queryResult.Should().Be("N/A");
        }
        public void Get_Asset_Title()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetTitle(234);

            queryResult.Should().Be("The Matrix");
        }
Example #12
0
        public void Get_Dewey_Index_For_Book()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryDbContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetDeweyIndex(1223);

            queryResult.Should().Be("WAL111");
        }
        public void Get_All_Assets()
        {
            var mockSet = BuildMock();
            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetAll().ToList();

            queryResult.Should().AllBeAssignableTo(typeof(LibraryAsset));
            queryResult.Should().HaveCount(3);
            queryResult.Should().Contain(a => a.Title == "Infinite Jest");
        }
        public void Get_Current_Location()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetCurrentLocation(-903);

            queryResult.Should().BeEquivalentTo(new LibraryBranch {
                Id = 200
            });
        }
        public async Task AddAsset_ExistingAsset_ShouldDeleteAsset()
        {
            using (var context = _factory.UseInMemory())
            {
                // Arrange
                var service = new LibraryAssetService(context, _logger);
                context.Add(GetAsset());
                context.SaveChanges();

                // Act
                await service.DeleteAsset(GetAsset().Id);

                // Assert
                Assert.Equal(0, context.LibraryAssets.Count());
            }
        }
        public void Add_New_Asset()
        {
            var options = new DbContextOptionsBuilder <LibraryContext>()
                          .UseInMemoryDatabase("Add_asset_writes_to_database")
                          .Options;

            using (var context = new LibraryContext(options))
            {
                var service = new LibraryAssetService(context);

                service.Add(new Book
                {
                    Id = -27
                });

                Assert.AreEqual(-27, context.LibraryAssets.Single().Id);
            }
        }
        public void Get_Asset_By_Id()
        {
            var mockSet = BuildMock();

            var mockCtx = new Mock <LibraryContext>();

            mockCtx.Setup(c => c.LibraryAssets).Returns(mockSet.Object);

            var sut         = new LibraryAssetService(mockCtx.Object);
            var queryResult = sut.GetById(234);
            var expected    = new Video
            {
                Id       = 234,
                Title    = "The Matrix",
                Director = "WB"
            };

            queryResult.Should().BeEquivalentTo(expected);
        }
        public async Task EditAsset_ValidAsset_ShouldEditAsset()
        {
            using (var context = _factory.UseInMemory())
            {
                // Arrange
                var service = new LibraryAssetService(context, _logger);
                var asset   = GetAsset();
                context.Add(asset);
                context.SaveChanges();
                asset.Year = 2000;

                // Act
                await service.EditAsset(asset);

                var actual   = context.LibraryAssets.Single();
                var expected = asset;

                // Assert
                Assert.Equal(expected.Year, actual.Year);
            }
        }
        public async void GetAllAsync_PaginatedList_ReturnsPaginatedList()
        {
            using (var context = _factory.UseSqlite())
            {
                //Arrange
                ILogger <LibraryAssetService> logger = new NullLogger <LibraryAssetService>();

                context.AddRange(GetAllAssets());
                context.Add(GetAuthor());
                context.SaveChanges();

                //Act
                var service          = new LibraryAssetService(context, _logger);
                var paginationParams = new PaginationParams();
                var actual           = await service.GetAllAsync(paginationParams);

                var assets = GetAllAssets().ToList();

                //Assert
                Assert.Equal(actual.Count, assets.Count);
            }
        }
        public async Task AddAsset_ValidAsset_ShouldAddNewAsset()
        {
            using (var context = _factory.UseInMemory())
            {
                // Arrange
                var service = new LibraryAssetService(context, _logger);

                // Act
                await service.AddAsset(GetAsset());

                var actual   = context.LibraryAssets.Single();
                var expected = GetAsset();
                expected.StatusId = (int)EnumStatus.Available;

                // Assert
                Assert.NotNull(actual);
                Assert.Equal(expected.NumberOfCopies, actual.CopiesAvailable);
                Assert.Equal(expected.StatusId, actual.StatusId);
                Assert.Equal(expected.Id, actual.Id);
                Assert.Single(context.LibraryAssets.ToList());
            }
        }
        public void Get_Library_Card_By_Asset_Id()
        {
            var options = new DbContextOptionsBuilder <LibraryContext>()
                          .UseInMemoryDatabase("Gets_library_card_for_asset")
                          .Options;

            using (var context = new LibraryContext(options))
            {
                var card = new LibraryCard
                {
                    Id      = 16,
                    Created = new DateTime(1999, 1, 1),
                    Fees    = 0M
                };

                var checkout = new Checkout
                {
                    Id           = 87,
                    LibraryAsset = new Book {
                        Id = 300
                    },
                    LibraryCard = card
                };

                context.Checkouts.Add(checkout);
                context.SaveChanges();
            }

            using (var context = new LibraryContext(options))
            {
                var sut    = new LibraryAssetService(context);
                var result = sut.GetById(300);
                result.Should()
                .BeEquivalentTo(new LibraryCard {
                    Id = 16, Created = new DateTime(1999, 1, 1), Fees = 0M
                });
            }
        }
        public async void GetAssetById_ExistingAsset_ReturnAsset()
        {
            using (var context = _factory.UseSqlite())
            {
                //Arrange
                ILogger <LibraryAssetService> logger = new NullLogger <LibraryAssetService>();

                context.AddRange(GetAllAssets());
                context.Add(GetAuthor());
                context.SaveChanges();

                // Act
                var service = new LibraryAssetService(context, _logger);
                var actual  = await service.GetAsset(1);

                var expected = GetAllAssets().FirstOrDefault();

                //Assert
                Assert.Equal(expected.Id, actual.Id);
                Assert.Equal(GetAuthor().Id, actual.Author.Id);
                Assert.Equal(expected.Title, actual.Title);
            }
        }
        public async Task EditAsset_UnAvailableAsset_ShouldMakeAssetVailable()
        {
            using (var context = _factory.UseInMemory())
            {
                // Arrange
                var service = new LibraryAssetService(context, _logger);
                var asset   = GetAsset();
                asset.StatusId        = (int)EnumStatus.Unavailable;
                asset.CopiesAvailable = 0;
                context.Add(asset);
                context.SaveChanges();
                asset.CopiesAvailable = 10;

                // Act
                await service.EditAsset(asset);

                var actual   = context.LibraryAssets.Single();
                var expected = asset;

                // Assert
                Assert.Equal(expected.StatusId, actual.StatusId);
                Assert.Equal(asset.CopiesAvailable, actual.CopiesAvailable);
            }
        }
Example #24
0
        public void GetAllReturnsLibraryAssets()
        {
            // Arrange
            var options = new DbContextOptionsBuilder <ILSContext>()
                          .UseInMemoryDatabase(databaseName: "GetAllReturnsLibraryAssets")
                          .Options;

            using (var context = new ILSContext(options))
            {
                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Book",
                    Title          = "The Republic",
                    Author         = "Plato",
                    DeweyIndex     = "820.119",
                    ISBN           = "9780758320209",
                    Year           = -380,
                    Cost           = 11,
                    ImageUrl       = "/images/republic.png",
                    NumberOfCopies = 2,
                    Location       = new BranchDetails {
                        Name = "Branch A"
                    },
                    Status = new Status {
                        Name = "Available", Description = "Available"
                    },
                    LibraryCard = new LibraryCard {
                    }
                });

                context.LibraryAsset.Add(new LibraryAsset
                {
                    Discriminator  = "Book",
                    Title          = "Jane Eyre",
                    Author         = "Charlotte Brontë",
                    DeweyIndex     = "822.133",
                    ISBN           = "9781519133977",
                    Year           = 1847,
                    Cost           = 15,
                    ImageUrl       = "/images/janeeyre.png",
                    NumberOfCopies = 5,
                    LocationId     = 1,
                    StatusId       = 1
                });

                context.SaveChanges();
            }

            IEnumerable <LibraryAsset> result;
            int count;

            // Act
            using (var context = new ILSContext(options))
            {
                var libraryAssetService = new LibraryAssetService(context);
                result = libraryAssetService.GetAll();
                count  = result.Count();
            }

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(count, 2);
        }