public void Wether_CorrectBehave_Paging_UsingTestData1()
        {
            using (var db = new CoreTaskManagerContext(Utilities.TestDbContextOptions()))
            {
                // Arrage
                db.Progresses.AddRange(GetSeedingProgressesTestData1());
                db.SaveChanges();
                var progresses = db.Progresses.AsQueryable();

                // Act
                var result = progresses.Paging(1, 1);

                // Assert
                Assert.IsAssignableFrom <IQueryable <Progress> >(result);

                Assert.Equal(6, progresses.Paging(1, 6).Count());
                Assert.Equal(4, progresses.Paging(1, 4).Count());
                Assert.Equal(1, progresses.Paging(1, 1).Count());

                Assert.ThrowsAny <ArgumentException>(() =>
                {
                    return(progresses.Paging(-1, 1));
                });
                Assert.ThrowsAny <ArgumentException>(() =>
                {
                    return(progresses.Paging(0, -1));
                });
                Assert.ThrowsAny <ArgumentException>(() =>
                {
                    return(progresses.Paging(1, -1));
                });
            }
        }
        public void Wether_CorrectBehave_GenerateGenre_UsingNoData()
        {
            using (var db = new CoreTaskManagerContext(Utilities.TestDbContextOptions()))
            {
                // Act
                var genre = db.GenerateGenreList();

                // Assert
                Assert.Equal(0, genre.Count());
            }
        }
        public void Wether_CorrectBehave_Filtering_WhenInputSearchQuery_UsingTestData1()
        {
            using (var db = new CoreTaskManagerContext(Utilities.TestDbContextOptions()))
            {
                // Arrange
                db.Progresses.AddRange(GetSeedingProgressesTestData1());
                db.SaveChanges();
                var expectedProgresses  = db.Progresses.Where(d => d.Title == "a");
                var expectedProgresses2 = db.Progresses.Where(d => d.Title == "あ");
                var expectedProgresses3 = db.Progresses.Where(d => d.Title == "い");
                var expectedProgresses4 = db.Progresses.Where(d => d.Title == "テスト");
                var expectedProgresses5 = db.Progresses.Where(d => d.Genre == "ソフトウェア");
                var expectedProgresses6 = db.Progresses.Where(d => d.Genre == "ソフトウェア").Where(d => d.Title == "Web開発");

                // Assert
                var actualProgresses = db.FilterUsingSearchStrings("", "a");
                Assert.Equal(
                    expectedProgresses2.OrderBy(x => x.Id),
                    actualProgresses.OrderBy(x => x.Id)
                    );
                var actualProgresses2 = db.FilterUsingSearchStrings("", "あ");
                Assert.Equal(
                    expectedProgresses2.OrderBy(x => x.Id),
                    actualProgresses2.OrderBy(x => x.Id)
                    );
                var actualProgresses3 = db.FilterUsingSearchStrings("", "い");
                Assert.Equal(
                    expectedProgresses3.OrderBy(x => x.Id),
                    actualProgresses3.OrderBy(x => x.Id)
                    );
                var actualProgresses4 = db.FilterUsingSearchStrings("", "テスト");
                Assert.Equal(
                    expectedProgresses4.OrderBy(x => x.Id),
                    actualProgresses4.OrderBy(x => x.Id)
                    );
                var actualProgresses5 = db.FilterUsingSearchStrings("ソフトウェア", "");
                Assert.Equal(
                    expectedProgresses5.OrderBy(x => x.Id),
                    actualProgresses5.OrderBy(x => x.Id)
                    );
                var actualProgresses6 = db.FilterUsingSearchStrings("ソフトウェア", "Web開発");
                Assert.Equal(
                    expectedProgresses6.OrderBy(x => x.Id),
                    actualProgresses6.OrderBy(x => x.Id)
                    );
            }
        }
        public void Wether_CorrectBehave_GenerateGenre_UsingTestData1()
        {
            using (var db = new CoreTaskManagerContext(Utilities.TestDbContextOptions()))
            {
                // Arrage
                db.Progresses.AddRange(GetSeedingProgressesTestData1());
                db.SaveChanges();

                // Act
                var genre = db.GenerateGenreList();

                // Assert
                Assert.Equal(2, genre.Count());
                Assert.Equal(1, genre.Where(g => g == "ソフトウェア").Count());
                Assert.Equal(1, genre.Where(g => g == "松村").Count());
            }
        }
        public async Task Wether_ReturnCorrectActionResult_NextPage_Test()
        {
            // Arrange
            var optionsBuilderCtmc = new DbContextOptionsBuilder <CoreTaskManagerContext>()
                                     .UseInMemoryDatabase("InMemoryDb1");
            var optionsBuilderADC = new DbContextOptionsBuilder <ApplicationDbContext>()
                                    .UseInMemoryDatabase("InMemoryDb2");
            var mockCtmc           = new Mock <CoreTaskManagerContext>(optionsBuilderCtmc.Options);
            var mockAdc            = new Mock <ApplicationDbContext>(optionsBuilderADC.Options);
            var expectedProgresses = CoreTaskManagerContext.GetSeedingProgresses();
            var expectedIdentities = ApplicationDbContext.GetSeedingUserIdentities();

            mockCtmc.Setup(db => db.GetProgressAsync()).Returns(Task.FromResult(expectedProgresses));
            mockAdc.Setup(db => db.GetIdentityAsync()).Returns(Task.FromResult(expectedIdentities));
            var pageModel = new IndexModel(mockCtmc.Object, mockAdc.Object);


            //Assert.Equal(1, 1);
            // Assert
            // When Session(pageNumber.etc) is Null
            //var redirectActionResult = Assert.IsType<RedirectResult>(result);
            //Assert.Equal("Progresses?progressesGenre=&searchString=&currentPageString=1", redirectActionResult.Url);
        }