コード例 #1
1
        // This is used as a 'common' test method for ActionFilterAttribute and Controller
        public static async Task ActionFilter_SettingResult_ShortCircuits(Mock mock)
        {
            // Arrange
            mock.As<IAsyncActionFilter>()
                .Setup(f => f.OnActionExecutionAsync(
                    It.IsAny<ActionExecutingContext>(),
                    It.IsAny<ActionExecutionDelegate>()))
                .CallBase();

            mock.As<IActionFilter>()
                .Setup(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()))
                .Callback<ActionExecutingContext>(c =>
                {
                    mock.ToString();
                    c.Result = new NoOpResult();
                });

            mock.As<IActionFilter>()
                .Setup(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()))
                .Verifiable();

            var context = CreateActionExecutingContext(mock.As<IFilter>().Object);
            var next = new ActionExecutionDelegate(() => { throw null; }); // This won't run

            // Act
            await mock.As<IAsyncActionFilter>().Object.OnActionExecutionAsync(context, next);

            // Assert
            Assert.IsType<NoOpResult>(context.Result);

            mock.As<IActionFilter>()
                .Verify(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()), Times.Never());
        }
コード例 #2
1
        public void GetAllShouldReturnTodos()
        {
            var data = new List<Todo>
            {
                new Todo {Id = 1},
                new Todo {Id = 2},
                new Todo {Id = 3},
            }.AsQueryable();

            var mockSet = new Mock<DbSet<Todo>>();
            mockSet.As<IQueryable<Todo>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Todo>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Todo>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Todo>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<ApplicationDbContext>();
            mockContext.Setup(c => c.Todos).Returns(mockSet.Object);

            var service = new TodoRepository(mockContext.Object);
            var todos = service.GetAll().ToList();

            Assert.AreEqual(3, todos.Count);
            Assert.AreEqual(1, todos[0].Id);
            Assert.AreEqual(2, todos[1].Id);
            Assert.AreEqual(3, todos[2].Id);
        }
コード例 #3
0
ファイル: UnitTest1.cs プロジェクト: Dronetech/legion_network
        private legion_service_api generateSensorDataSet()
        {
            Random rnd = new Random();

            IQueryable<sensor_data> data = new List<sensor_data>
            {
                new sensor_data { Id = 1, userGuid = "teste.teste.teste", sensor_name = "sensor1", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 3, userGuid = "teste.teste.teste", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 4, userGuid = "teste.teste.teste", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 5, userGuid = "teste.teste.teste", sensor_name = "sensor3", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 6, userGuid = "teste.teste.teste2", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 7, userGuid = "teste.teste.teste2", sensor_name = "sensor2", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))},
                new sensor_data { Id = 2, userGuid = "teste.teste.teste2", sensor_name = "sensor1", timestamp = DateTime.Now.AddMilliseconds(rnd.Next(1000, 10000))}

            }.AsQueryable();
            var mockset = new Mock<DbSet<sensor_data>>();
            mockset.As<IQueryable<sensor_data>>().Setup(m => m.Provider).Returns(data.Provider);
            mockset.As<IQueryable<sensor_data>>().Setup(m => m.Expression).Returns(data.Expression);
            mockset.As<IQueryable<sensor_data>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockset.As<IQueryable<sensor_data>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<legion_serviceContext>();
            mockContext.Setup(s => s.sensor_data).Returns(mockset.Object);

               return new legion_service_api(mockContext.Object);
        }
コード例 #4
0
        public void Animal_needs_an_enclosure()
        {
            var mockContext = new Mock<IZooDbContext>();

            var animals = new List<Animal>
            {
                new Animal
                {
                    Id = 1,
                    Name = "Pumba",
                    Enclosure = new Enclosure
                    {
                        Id = 1, Name = "Kenya Room",
                        Location = "Center",
                        Environment = "Africa"
                    }
                }
            }.AsQueryable();

            var mockSet = new Mock<DbSet<Animal>>();
            mockSet.As<IQueryable<Animal>>().Setup(m => m.Provider).Returns(animals.Provider);
            mockSet.As<IQueryable<Animal>>().Setup(m => m.Expression).Returns(animals.Expression);
            mockSet.As<IQueryable<Animal>>().Setup(m => m.ElementType).Returns(animals.ElementType);
            mockSet.As<IQueryable<Animal>>().Setup(m => m.GetEnumerator()).Returns(animals.GetEnumerator());

            mockContext.Setup(x => x.Animals)
                .Returns(mockSet.Object);

            var db = mockContext.Object;
            var controller = new HomeController() { Database = db };

            var result = controller.Index();

            Assert.IsType<ViewResult>(result);
        }
コード例 #5
0
        /// <summary>
        /// Tests patient and appointment lists.
        /// </summary>
        /// <param name="appts">List of appointments to substitute in our mockup.</param>
        /// <param name="patients">List of patients to substitute in our mockup.</param>
        /// <param name="compare_date">The date to compare in our mockup.</param>
        /// <returns></returns>
        private static IEnumerable<Transaction> TestPatientsAndAppointments(
            List<appointment_data> appts, 
            List<patient_data> patients, 
            DateTime compare_date)
        {
            var mock_appts = new Mock<DbSet<appointment_data>>();
            mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.Provider)
                .Returns(appts.AsQueryable<appointment_data>().Provider);
            mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.Expression)
                .Returns(appts.AsQueryable<appointment_data>().Expression);
            mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.ElementType)
                .Returns(appts.AsQueryable<appointment_data>().ElementType);
            mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.GetEnumerator())
                .Returns(appts.AsQueryable<appointment_data>().GetEnumerator());

            var mock_patients = new Mock<DbSet<patient_data>>();
            mock_patients.As<IQueryable<patient_data>>().Setup(m => m.Provider)
                .Returns(patients.AsQueryable<patient_data>().Provider);
            mock_patients.As<IQueryable<patient_data>>().Setup(m => m.Expression)
                .Returns(patients.AsQueryable<patient_data>().Expression);
            mock_patients.As<IQueryable<patient_data>>().Setup(m => m.ElementType)
                .Returns(patients.AsQueryable<patient_data>().ElementType);
            mock_patients.As<IQueryable<patient_data>>().Setup(m => m.GetEnumerator())
                .Returns(patients.AsQueryable<patient_data>().GetEnumerator());


            var fake_entities = new Mock<broadlyEntities>();
            fake_entities.Setup(c => c.appointment_data).Returns(mock_appts.Object);
            fake_entities.Setup(c => c.patient_data).Returns(mock_patients.Object);

            IEnumerable<Transaction> transactions = DataSource.GetTransactions(compare_date, fake_entities.Object);

            Assert.IsNotNull(transactions);
            Assert.IsTrue(transactions is IQueryable);
            Assert.IsTrue(transactions is IQueryable<Transaction>);

            foreach (Transaction transaction in transactions)
            {
                // There is an email
                Assert.IsTrue(!string.IsNullOrEmpty(transaction.PatientEmail));
                // The appoinment time matches
                Assert.IsTrue(transaction.AppointmentTime == compare_date);
                // There is a transaction with this Id
                appointment_data appt = appts.Find(x => x.appointment_id == transaction.AppointmentId);
                Assert.IsNotNull(appt);
                // There is a patient with the appt's Id
                patient_data patient = patients.Find(x => x.patient_id == appt.patient_id);
                Assert.IsNotNull(patient);
                // Check content
                Assert.IsTrue(transaction.AppointmentId == appt.appointment_id);
                Assert.IsTrue(transaction.AppointmentTime == appt.scheduled);
                Assert.IsTrue(appt.status == "completed");
                Assert.IsTrue(transaction.PatientFirstName == patient.first_name);
                Assert.IsTrue(transaction.PatientLastName == patient.last_name);
                Assert.IsTrue(transaction.PatientId == patient.patient_id);
                Assert.IsTrue(transaction.PatientPhone == patient.phone);
            }

            return transactions;
        }
コード例 #6
0
        public void GetAllTasks_Order_By_Username()
        {
            var taskData = new List<TaskModel>
            {
                Build_Task_For_Testing("B's Task", new DateTime(2015, 7, 3, 5, 5, 5), "B's Test Task", "B"),
                Build_Task_For_Testing("C's Task", new DateTime(2015, 7, 5, 5, 5, 5), "C's Test Task", "C"),
                Build_Task_For_Testing("D's Task", new DateTime(2015, 7, 6, 5, 5, 5), "D's Test Task", "D")
            }.AsQueryable();

            var taskData2 = new List<TaskModel> { }.AsQueryable();

            var mockSet = new Mock<DbSet<TaskModel>>();
            mockSet.As<IQueryable<TaskModel>>().Setup(m => m.Provider).Returns(taskData.Provider);
            mockSet.As<IQueryable<TaskModel>>().Setup(m => m.Expression).Returns(taskData.Expression);
            mockSet.As<IQueryable<TaskModel>>().Setup(m => m.ElementType).Returns(taskData.ElementType);
            mockSet.As<IQueryable<TaskModel>>().Setup(m => m.GetEnumerator()).Returns(taskData.GetEnumerator());

            var mockDbContext = new Mock<TaskDBContext>();
            mockDbContext.Setup(t => t.Tasks).Returns(mockSet.Object);

            var testClass = new TestClass(mockDbContext.Object);
            var allTasks = testClass.GetAllTasks();

            Assert.AreEqual(3, allTasks.Count);
            Assert.AreEqual("B", allTasks[0].Username);
            Assert.AreEqual("C", allTasks[1].Username);
            Assert.AreEqual("D", allTasks[2].Username);
        }
コード例 #7
0
        public void testIndesReturnsAViewForTheRelevantProductID()
        {
            var Products = new List<Product>
            {
                new Product{ID = 1,Title = "FirstProduct",Description = "First Product In Database"}
            }.AsQueryable();

            Mock<IHypermartContext> mockDBContext = new Mock<IHypermartContext>();

            var mockSet = new Mock<DbSet<Product>>();
            mockSet.As<IQueryable<Product>>().Setup(m => m.Provider).Returns(Products.Provider);
            mockSet.As<IQueryable<Product>>().Setup(m => m.Expression).Returns(Products.Expression);
            mockSet.As<IQueryable<Product>>().Setup(m => m.ElementType).Returns(Products.ElementType);
            mockSet.As<IQueryable<Product>>().Setup(m => m.GetEnumerator()).Returns(Products.GetEnumerator());

            mockDBContext.Setup(x => x.Products).Returns(mockSet.Object);

            var xy = mockDBContext.Object.Products.ToList();

            ProductsController SUT = new ProductsController(mockDBContext.Object);
            ActionResult  ViewResults =SUT.Index();
            ViewResult vResult = ViewResults as ViewResult;
            if (vResult != null)
            {
                Assert.AreEqual(string.Empty, vResult.ViewName);
                //Assert.IsInstanceOfType(typeof(Product),vResult.Model.GetType() );
                //Product model = vResult.Model as Product;
                //if (model != null)
                //{
                //    //...
                //}
            }
        }
コード例 #8
0
        public void AssemblyStatusService_GetAsync_ReturnsAssemblyStatussByIds()
        {
            //Arrange
            var mockDbContextScopeFac = new Mock<IDbContextScopeFactory>();
            var mockDbContextScope = new Mock<IDbContextReadOnlyScope>();
            var mockEfDbContext = new Mock<EFDbContext>();
            mockDbContextScopeFac.Setup(x => x.CreateReadOnly(DbContextScopeOption.JoinExisting)).Returns(mockDbContextScope.Object);
            mockDbContextScope.Setup(x => x.DbContexts.Get<EFDbContext>()).Returns(mockEfDbContext.Object);

            var dbEntry1 = new AssemblyStatus { Id = "dummyEntryId1", AssyStatusName = "Name1", AssyStatusAltName = "NameAlt1", IsActive_bl = false };
            var dbEntry2 = new AssemblyStatus { Id = "dummyEntryId2", AssyStatusName = "Name2", AssyStatusAltName = "NameAlt2", IsActive_bl = true };
            var dbEntry3 = new AssemblyStatus { Id = "dummyEntryId3", AssyStatusName = "Name3", AssyStatusAltName = "NameAlt3", IsActive_bl = true };
            var dbEntries = (new List<AssemblyStatus> { dbEntry1, dbEntry2, dbEntry3 }).AsQueryable();

            var mockDbSet = new Mock<DbSet<AssemblyStatus>>();
            mockDbSet.As<IDbAsyncEnumerable<AssemblyStatus>>().Setup(m => m.GetAsyncEnumerator()).Returns(new MockDbAsyncEnumerator<AssemblyStatus>(dbEntries.GetEnumerator()));
            mockDbSet.As<IQueryable<AssemblyStatus>>().Setup(m => m.Provider).Returns(new MockDbAsyncQueryProvider<AssemblyStatus>(dbEntries.Provider));
            mockDbSet.As<IQueryable<AssemblyStatus>>().Setup(m => m.Expression).Returns(dbEntries.Expression);
            mockDbSet.As<IQueryable<AssemblyStatus>>().Setup(m => m.ElementType).Returns(dbEntries.ElementType);
            mockDbSet.As<IQueryable<AssemblyStatus>>().Setup(m => m.GetEnumerator()).Returns(dbEntries.GetEnumerator());
            mockDbSet.Setup(x => x.Include(It.IsAny<string>())).Returns(mockDbSet.Object);

            mockEfDbContext.Setup(x => x.AssemblyStatuss).Returns(mockDbSet.Object);

            var assyStatusService = new AssemblyStatusService(mockDbContextScopeFac.Object, "dummyUserId");

            //Act
            var serviceResult = assyStatusService.GetAsync(new string[] { "dummyEntryId3" }).Result;

            //Assert
            Assert.IsTrue(serviceResult.Count == 1);
            Assert.IsTrue(serviceResult[0].AssyStatusAltName.Contains("NameAlt3"));

        }
コード例 #9
0
        public void ClassInit()
        {
            // Installing mock DbSet.
            var data = new List<MockCatalog>
            {
                new MockCatalog(false) { Name = "BBB" },
                new MockCatalog(false) { Name = "ZZZ" },
                new MockCatalog(false) { Name = "AAA" },
            }.AsQueryable();

            var mockDbSet = new Mock<DbSet<MockCatalog>>();
            mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.Provider).Returns(data.Provider);
            mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.Expression).Returns(data.Expression);
            mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockDbSet.As<IQueryable<MockCatalog>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            // Installing mock Context.
            var mockContext = new Mock<MetadataEFContext>();
            mockContext.Setup(m => m.Set<MockCatalog>()).Returns(mockDbSet.Object);

            // Installing repository.
            var catalogRepository = new EFCatalogRepository<MockCatalog>(mockContext.Object);

            // Installing shared tests.
            SharedTests = new SharedTests<MockCatalog>(mockDbSet, mockContext, catalogRepository, CreateCatalogItem);
        }
コード例 #10
0
ファイル: TestMOQ.cs プロジェクト: diegoares02/UniversityMOCK
        public void DeberiActualizar()
        {
            var mockSet = new Mock<DbSet<Student>>();
            var mockContext = new Mock<UniversityContext>();
            mockContext.Setup(m => m.Students).Returns(mockSet.Object);
            var existing = new Student { StudentId = 1, Nombre = "Carlos", Paterno = "Estrada", Materno = "Copa", Telefono = 2269587 };
            var data = new Student
            {
                StudentId = 1,
                Nombre = "Carlos",
                Paterno = "Estrada",
                Materno = "Copa",
                Telefono = 2269587,
            };
            var queryable = new List<Student> { data }.AsQueryable();
            mockSet.As<IQueryable<Student>>().Setup(m => m.Provider).Returns(queryable.Provider);
            mockSet.As<IQueryable<Student>>().Setup(m => m.Expression).Returns(queryable.Expression);
            mockSet.As<IQueryable<Student>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
            mockSet.As<IQueryable<Student>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
            mockContext.Setup(m => m.SaveChanges()).Verifiable();

            var service = new UniversityContextService(mockContext.Object);
            service.UpdateStudent(data);
            var mostrar = service.Show();

            mockContext.Verify();
            Assert.AreEqual(1, mostrar.Count);
            Assert.AreEqual("Carlos", mostrar[0].Nombre);
            Assert.AreEqual(2269587, mostrar[0].Telefono);
        }
コード例 #11
0
        public void Handler_ReturnsFalse_WhenUserExists_ButHasDifferentPassword()
        {
            string nameOrVerifiedEmail = FakeData.Email();
            string password = FakeData.String();
            var user = new User { Name = nameOrVerifiedEmail, };
            var queries = new Mock<IProcessQueries>(MockBehavior.Strict);
            Expression<Func<UserByNameOrVerifiedEmail, bool>> expectedQuery =
                x => x.NameOrEmail == nameOrVerifiedEmail;
            queries.Setup(x => x.Execute(It.Is(expectedQuery)))
                .Returns(Task.FromResult(user));
            var userStore = new Mock<IUserStore<User, int>>(MockBehavior.Strict);
            userStore.Setup(x => x.FindByNameAsync(nameOrVerifiedEmail)).Returns(Task.FromResult(user));
            var passwordHasher = new PasswordHasher();
            Expression<Func<User, bool>> expectedUser = x => x.Name == nameOrVerifiedEmail;
            userStore.As<IUserPasswordStore<User, int>>().Setup(x => x.GetPasswordHashAsync(It.Is(expectedUser)))
                .Returns(Task.FromResult(passwordHasher.HashPassword(FakeData.String())));
            var userManager = new UserManager<User, int>(userStore.Object);
            var handler = new HandleIsPasswordVerifiedQuery(queries.Object, userManager);
            var query = new IsPasswordVerified
            {
                UserNameOrVerifiedEmail = nameOrVerifiedEmail,
                Password = password,
            };

            bool result = handler.Handle(query).Result;

            result.ShouldBeFalse();
            queries.Verify(x => x.Execute(It.Is(expectedQuery)), Times.Once());
            userStore.Verify(x => x.FindByNameAsync(nameOrVerifiedEmail), Times.Once);
            userStore.As<IUserPasswordStore<User, int>>().Verify(
                x => x.GetPasswordHashAsync(It.Is(expectedUser)), Times.Once);
        }
コード例 #12
0
            public void ReturnsPostsThatHavePublishedSetToTrue_AndPostedDateDesc()
            {
                var posts = new List<Post>
                {
                    new Post {Id = 1, PostedOn = DateTime.Now.AddDays(-2), Published = true},
                    new Post {Id = 2, PostedOn = DateTime.Now.AddDays(-1), Published = false},
                    new Post {Id = 3, PostedOn = DateTime.Now, Published = true},
                }.AsQueryable();

                var mockPosts = new Mock<DbSet<Post>>();
                mockPosts.As<IQueryable<Post>>().Setup(m => m.Provider).Returns(posts.Provider);
                mockPosts.As<IQueryable<Post>>().Setup(m => m.Expression).Returns(posts.Expression);
                mockPosts.As<IQueryable<Post>>().Setup(m => m.ElementType).Returns(posts.ElementType);
                mockPosts.As<IQueryable<Post>>().Setup(m => m.GetEnumerator()).Returns(posts.GetEnumerator());

                var expected = mockPosts.Object.Where(x => x.Published).OrderByDescending(x => x.PostedOn).ToList();

                _slapdashContext
                    .Setup(x => x.Posts)
                    .Returns(mockPosts.Object);

                var actual = _classUnderTest.Posts(1, 1);

                Assert.Equal(expected, actual);
            }
コード例 #13
0
        public void ComponentStatusService_GetAsync_ReturnsComponentStatuss()
        {
            //Arrange
            var mockDbContextScopeFac = new Mock<IDbContextScopeFactory>();
            var mockDbContextScope = new Mock<IDbContextReadOnlyScope>();
            var mockEfDbContext = new Mock<EFDbContext>();
            mockDbContextScopeFac.Setup(x => x.CreateReadOnly(DbContextScopeOption.JoinExisting)).Returns(mockDbContextScope.Object);
            mockDbContextScope.Setup(x => x.DbContexts.Get<EFDbContext>()).Returns(mockEfDbContext.Object);

            var dbEntry1 = new ComponentStatus { Id = "dummyEntryId1", CompStatusName = "Name1", CompStatusAltName = "NameAlt1", IsActive_bl = false, Comments = "DummyComments1" };
            var dbEntry2 = new ComponentStatus { Id = "dummyEntryId2", CompStatusName = "Name2", CompStatusAltName = "NameAlt2", IsActive_bl = true, Comments = "DummyComments2" };
            var dbEntries = (new List<ComponentStatus> { dbEntry1, dbEntry2 }).AsQueryable();

            var mockDbSet = new Mock<DbSet<ComponentStatus>>();
            mockDbSet.As<IDbAsyncEnumerable<ComponentStatus>>().Setup(m => m.GetAsyncEnumerator()).Returns(new MockDbAsyncEnumerator<ComponentStatus>(dbEntries.GetEnumerator())); 
            mockDbSet.As<IQueryable<ComponentStatus>>().Setup(m => m.Provider).Returns(new MockDbAsyncQueryProvider<ComponentStatus>(dbEntries.Provider));
            mockDbSet.As<IQueryable<ComponentStatus>>().Setup(m => m.Expression).Returns(dbEntries.Expression);
            mockDbSet.As<IQueryable<ComponentStatus>>().Setup(m => m.ElementType).Returns(dbEntries.ElementType);
            mockDbSet.As<IQueryable<ComponentStatus>>().Setup(m => m.GetEnumerator()).Returns(dbEntries.GetEnumerator());
            mockDbSet.Setup(x => x.Include(It.IsAny<string>())).Returns(mockDbSet.Object);
            
            mockEfDbContext.Setup(x => x.ComponentStatuss).Returns(mockDbSet.Object);

            var compStatusService = new ComponentStatusService(mockDbContextScopeFac.Object,"DummyUserId");

            //Act
            var resultComponentStatuss = compStatusService.GetAsync().Result;
            
            //Assert
            Assert.IsTrue(resultComponentStatuss.Count == 1);
            Assert.IsTrue(resultComponentStatuss[0].CompStatusAltName.Contains("NameAlt2"));
        }
コード例 #14
0
ファイル: Tests_ProjectService.cs プロジェクト: naishan/SDDB
        public void ProjectService_GetAsync_ReturnsProjects()
        {
            //Arrange
            var mockDbContextScopeFac = new Mock<IDbContextScopeFactory>();
            var mockDbContextScope = new Mock<IDbContextReadOnlyScope>();
            var mockEfDbContext = new Mock<EFDbContext>();
            mockDbContextScopeFac.Setup(x => x.CreateReadOnly(DbContextScopeOption.JoinExisting)).Returns(mockDbContextScope.Object);
            mockDbContextScope.Setup(x => x.DbContexts.Get<EFDbContext>()).Returns(mockEfDbContext.Object);

            

            var dbEntry1 = new Project { Id = "dummyEntryId1", ProjectName = "Project1", ProjectAltName = "ProjectAlt1", IsActive_bl = false, ProjectCode = "CODE1" };
            var dbEntry2 = new Project { Id = "dummyEntryId2", ProjectName = "Project2", ProjectAltName = "ProjectAlt2", IsActive_bl = true, ProjectCode = "CODE2" };
            var dbEntries = (new List<Project> { dbEntry1, dbEntry2 }).AsQueryable();

            var mockDbSet = new Mock<DbSet<Project>>();
            mockDbSet.As<IDbAsyncEnumerable<Project>>().Setup(m => m.GetAsyncEnumerator()).Returns(new MockDbAsyncEnumerator<Project>(dbEntries.GetEnumerator())); 
            mockDbSet.As<IQueryable<Project>>().Setup(m => m.Provider).Returns(new MockDbAsyncQueryProvider<Project>(dbEntries.Provider));
            mockDbSet.As<IQueryable<Project>>().Setup(m => m.Expression).Returns(dbEntries.Expression);
            mockDbSet.As<IQueryable<Project>>().Setup(m => m.ElementType).Returns(dbEntries.ElementType);
            mockDbSet.As<IQueryable<Project>>().Setup(m => m.GetEnumerator()).Returns(dbEntries.GetEnumerator());
            mockDbSet.Setup(x => x.Include(It.IsAny<string>())).Returns(mockDbSet.Object);
            
            mockEfDbContext.Setup(x => x.Projects).Returns(mockDbSet.Object);

            var projectService = new ProjectService(mockDbContextScopeFac.Object, "dummyUserId");

            //Act
            var resultProjects = projectService.GetAsync().Result;
            
            //Assert
            Assert.IsTrue(resultProjects.Count == 1);
            Assert.IsTrue(resultProjects[0].ProjectAltName.Contains("ProjectAlt2"));
        }
        private ODM2Entities MockDbContext()
        {
            var queryable = (new List<ProcessingLevel> 
            { 
                new ProcessingLevel
                {
                    ProcessingLevelCode = "Draft"
                },
                new ProcessingLevel
                {
                    ProcessingLevelCode = "Provisional"
                },
                new ProcessingLevel
                {
                    ProcessingLevelCode = "Finalized"
                }
            }).AsQueryable();
            var dbSet = new Mock<DbSet<ProcessingLevel>>();
            dbSet.As<IQueryable<ProcessingLevel>>().Setup(m => m.Provider).Returns(queryable.Provider);
            dbSet.As<IQueryable<ProcessingLevel>>().Setup(m => m.Expression).Returns(queryable.Expression);
            dbSet.As<IQueryable<ProcessingLevel>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
            dbSet.As<IQueryable<ProcessingLevel>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());

            var mockContext = new Mock<ODM2Entities>();
            mockContext.Setup(x => x.ProcessingLevels).Returns(dbSet.Object);

            return mockContext.Object;
        
        }
        public void RepositoryGetArtistById()
        {
            const int expectedId = 3;
            var expected = new Artist { Id = expectedId, Name = "WWWW", Country = "WEE", Identifier = "dfr" };

            var data = new List<Artist>{
                expected,
                new Artist{Id = 1, Name = "Ronald", Country = "ZW", Identifier = "abc", Eliases = new List<Elias>{new Elias {Id = 1, EliasName = "Ron", ArtistId = 1}}},
                new Artist{Id = 2, Name = "Zebra", Country = "SA", Identifier = "bvf", Eliases = new List<Elias>{new Elias {Id = 2, EliasName = "Zeb", ArtistId = 2}}}
            }.AsQueryable();

            var mockSet = new Mock<DbSet<Artist>>();
            mockSet.As<IQueryable<Artist>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Artist>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Artist>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Artist>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<BEContext>();
            mockContext.Setup(m => m.Artists).Returns(mockSet.Object);
            mockContext.Setup(m => m.Set<Artist>()).Returns(mockSet.Object);

            var repo = new Repository<Artist>(mockContext.Object);

            var list = repo.GetArtistById(expectedId);

            Assert.AreEqual(1, list.Id);
        }
コード例 #17
0
ファイル: RepositoryTests.cs プロジェクト: Naa2e/Sign-In-CP
        public void EnsureICanDeleteLessonTest()
        {
            //Arrange
            List<Lesson> my_list = new List<Lesson>();
            Mock<CContext> mock_context = new Mock<CContext>();
            Mock<DbSet<Teacher>> mock_teacher = new Mock<DbSet<Teacher>>();
            Mock<DbSet<Student>> mock_student = new Mock<DbSet<Student>>();
            Mock<DbSet<Payment>> mock_payment = new Mock<DbSet<Payment>>();
            Mock<DbSet<Lesson>> mock_lesson = new Mock<DbSet<Lesson>>();

            var data = my_list.AsQueryable();

            mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.Provider).Returns(data.Provider);
            mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.Expression).Returns(data.Expression);

            mock_lesson.Setup(m => m.Add(It.IsAny<Lesson>())).Callback((Lesson b) => my_list.Add(b));
            mock_lesson.Setup(m => m.Remove(It.IsAny<Lesson>())).Callback((Lesson b) => my_list.Remove(b));

            mock_context.Setup(m => m.Lessons).Returns(mock_lesson.Object);

            Repository Repo = new Repository(mock_context.Object);
            my_list.Add(new Lesson { LessonId = 1, Title = "Private" });

            //Act
            bool Success = Repo.DeleteLesson(1);

            //Assert
            Assert.AreEqual(0, Repo.Context.Lessons.Count());
        }
コード例 #18
0
        public void GetFirstUnsentAddress_ShouldReturnNull_IfNoUserWithNotSentStatusExistsInDatabase()
        {
            // Arrange
            var stubContext = new Mock<Context>();

            var stubRecipients = new List<Recipient>
            {
                new Recipient("*****@*****.**"),
                new Recipient("*****@*****.**"),
                new Recipient("*****@*****.**"),
            }.AsQueryable();
            stubRecipients.ElementAt(0).MarkAsSent(DateTime.Now);
            stubRecipients.ElementAt(1).MarkAsSent(DateTime.Now);
            stubRecipients.ElementAt(2).MarkAsFailed("sending failed", DateTime.Now);

            var stubDbSet = new Mock<DbSet<Recipient>>();
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Provider).Returns(stubRecipients.Provider);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Expression).Returns(stubRecipients.Expression);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.ElementType).Returns(stubRecipients.ElementType);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.GetEnumerator()).Returns(stubRecipients.GetEnumerator());

            stubContext.Setup(c => c.Recipients).Returns(stubDbSet.Object);

            // Act
            var repository = new Repository(stubContext.Object);
            var recipient = repository.GetFirstUnsentAddress();

            // Assert
            Assert.IsNull(recipient);
        }
コード例 #19
0
            public void InitializeContext()
            {
                var elementInfo1 = Mocks.Of<IElementInfo>().First(i => i.Name == "FooElementName" && i.DisplayName == "FooElementNameDisplayName");
                var element1 = new Mock<IElement>();
                element1.SetupGet(e => e.Info).Returns(elementInfo1);
                element1.As<IAbstractElement>().SetupGet(e => e.Info).Returns(elementInfo1);
                element1.As<IProductElement>().SetupGet(e => e.Info).Returns(elementInfo1);

                var elementInfo2 = Mocks.Of<IElementInfo>().First(i => i.Name == "BarElementName" && i.DisplayName == "BarElementNameDisplayName");
                var element2 = new Mock<IElement>();
                element2.Setup(e => e.InstanceName).Returns("FooElement2NameDisplayName");
                element2.SetupGet(e => e.Info).Returns(elementInfo2);
                element2.As<IAbstractElement>().SetupGet(e => e.Info).Returns(elementInfo2);
                element2.As<IProductElement>().SetupGet(e => e.Info).Returns(elementInfo2);

                var viewInfo = new Mock<IViewInfo>();
                viewInfo.SetupGet(v => v.Elements).Returns(new[] { elementInfo1, elementInfo2 });
                var view = new Mock<IView>();
                view.SetupGet(v => v.Info).Returns(viewInfo.Object);
                view.SetupGet(v => v.Elements).Returns(new[] { element1.Object, element2.Object });

                var productInfo = new Mock<IPatternInfo>();
                productInfo.SetupGet(pi => pi.Name).Returns("FooProductName");
                productInfo.SetupGet(pi => pi.Views).Returns(new[] { viewInfo.Object });

                var product = new Mock<IProduct>();
                product.Setup(p => p.InstanceName).Returns("TestProduct");
                product.As<IProduct>().SetupGet(p => p.Info).Returns(productInfo.Object);
                product.As<IProductElement>().SetupGet(p => p.Info).Returns(productInfo.Object);
                product.SetupGet(p => p.Views).Returns(new[] { view.Object });

                this.rule = new CardinalityValidationRule();
                this.rule.CurrentElement = product.Object;
            }
コード例 #20
0
        public void GetFirstUnsentAddress_ShouldReturnFirstRecipientWithNotSentStatus_IfItExistsInDatabase()
        {
            // Arrange
            var stubContext = new Mock<Context>();

            var stubRecipients = new List<Recipient>
            {
                new Recipient("*****@*****.**"),
                new Recipient("*****@*****.**"),
                new Recipient("*****@*****.**"),
            }.AsQueryable();
            stubRecipients.First().MarkAsSent(DateTime.Now);

            var stubDbSet = new Mock<DbSet<Recipient>>();
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Provider).Returns(stubRecipients.Provider);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.Expression).Returns(stubRecipients.Expression);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.ElementType).Returns(stubRecipients.ElementType);
            stubDbSet.As<IQueryable<Recipient>>().Setup(m => m.GetEnumerator()).Returns(stubRecipients.GetEnumerator());

            stubContext.Setup(c => c.Recipients).Returns(stubDbSet.Object);

            // Act
            var repository = new Repository(stubContext.Object);
            var recipient = repository.GetFirstUnsentAddress();

            // Assert
            Assert.AreEqual("*****@*****.**", recipient.Email);
        }
コード例 #21
0
ファイル: MockUnitTests.cs プロジェクト: hobe/entityframework
            public async Task GetAllBlogsAsync_orders_by_name()
            {

                var data = new List<Blog>
                {
                    new Blog { Name = "BBB" },
                    new Blog { Name = "ZZZ" },
                    new Blog { Name = "AAA" },
                }.AsQueryable();

                var mockSet = new Mock<DbSet<Blog>>();
                mockSet.As<IDbAsyncEnumerable<Blog>>()
                    .Setup(m => m.GetAsyncEnumerator())
                    .Returns(new TestDbAsyncEnumerator<Blog>(data.GetEnumerator()));

                mockSet.As<IQueryable<Blog>>()
                    .Setup(m => m.Provider)
                    .Returns(new TestDbAsyncQueryProvider<Blog>(data.Provider));

                mockSet.As<IQueryable<Blog>>().Setup(m => m.Expression).Returns(data.Expression);
                mockSet.As<IQueryable<Blog>>().Setup(m => m.ElementType).Returns(data.ElementType);
                mockSet.As<IQueryable<Blog>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

                var mockContext = new Mock<BloggingContext>();
                mockContext.Setup(c => c.Blogs).Returns(mockSet.Object);

                var service = new BlogService(mockContext.Object);
                var blogs = await service.GetAllBlogsAsync();

                Assert.AreEqual(3, blogs.Count);
                Assert.AreEqual("AAA", blogs[0].Name);
                Assert.AreEqual("BBB", blogs[1].Name);
                Assert.AreEqual("ZZZ", blogs[2].Name);
            }
コード例 #22
0
        public void TestCacheableGetAllProductsSync()
        {
            var data = new List<Product>
            {
                new Product { ProductName = "BBB"},
                new Product { ProductName = "ZZZ" },
                new Product { ProductName = "AAA" }
            }.AsQueryable();

            var mockSet = new Mock<DbSet<Product>>();
            mockSet.As<IQueryable<Product>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Product>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Product>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Product>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<SampleContext>();
            mockContext.Setup(c => c.Products).Returns(mockSet.Object);

            // public List<Product> GetAllProductsOrderedByName()
            var products = mockContext.Object.Products
                                             .OrderBy(product => product.ProductName)
                                             .Cacheable()
                                             .ToList();

            Assert.AreEqual(3, products.Count);
            Assert.AreEqual("AAA", products[0].ProductName);
            Assert.AreEqual("BBB", products[1].ProductName);
            Assert.AreEqual("ZZZ", products[2].ProductName);
        }
コード例 #23
0
        private void SetupForGetMessages()
        {
            var list1 = new List<Message>()
            {
                new Message()
                {
                    Body = "B1"
                },
                new Message()
                {
                    Body = "B2"
                }
            }.AsQueryable();

            var mockMessages = new Mock<DbSet<Message>>();
            mockMessages.As<IQueryable<Message>>().Setup(m => m.Provider).Returns(list1.Provider);
            mockMessages.As<IQueryable<Message>>().Setup(m => m.Expression).Returns(list1.Expression);
            mockMessages.As<IQueryable<Message>>().Setup(m => m.ElementType).Returns(list1.ElementType);
            mockMessages.As<IQueryable<Message>>().Setup(m => m.GetEnumerator()).Returns(list1.GetEnumerator());

            var mockContext = new Mock<AppDbContext>();
            mockContext.Setup(c => c.Messages).Returns(mockMessages.Object);

            _dbContext = mockContext.Object;
        }
コード例 #24
0
        private Mock<ApplicationDbContext> GetApplicationDbContextMock()
        {
            // single user
            var appUser = new ApplicationUser();
            appUser.Id = "1";

            var data = new List<ToDo>  {
                    new ToDo { Id = 0, Title = "Todo 1", Completed = false, User = appUser },
                    new ToDo { Id = 1, Title = "Todo 2", Completed = true, User = appUser },
                  }.AsQueryable();

            var mockSet = new Mock<DbSet<ToDo>>();

            mockSet.As<IDbAsyncEnumerable<ToDo>>()
               .Setup(m => m.GetAsyncEnumerator())
               .Returns(new TestDbAsyncEnumerator<ToDo>(data.GetEnumerator()));

            mockSet.As<IQueryable<ToDo>>()
                .Setup(m => m.Provider)
                .Returns(new TestDbAsyncQueryProvider<ToDo>(data.Provider));

            mockSet.As<IQueryable<ToDo>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<ToDo>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<ToDo>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var applicationDbContext = new Mock<ApplicationDbContext>();
            applicationDbContext.Setup(c => c.ToDos).Returns(mockSet.Object);

            return applicationDbContext;
        }
コード例 #25
0
        public void GetUserStocks_must_return_all_stocks_of_user_from_context()
        {
            var data = new List<UserStock>
            {
                new UserStock {ID = 0, Name = "DAX", User = Thread.CurrentPrincipal.Identity.GetUserName()},
                new UserStock {ID = 1, Name = "NYSE", User = "******"},
                new UserStock {ID = 1, Name = "NASDAQ", User = Thread.CurrentPrincipal.Identity.GetUserName()},
            }.AsQueryable();

            var mockSet = new Mock<DbSet<UserStock>>();

            mockSet.As<IQueryable<UserStock>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<UserStock>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<UserStock>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<UserStock>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<IStockExchangeDbContext>();
            mockContext.Setup(c => c.UserStocks).Returns(mockSet.Object);

            var service = new UserStocksController(mockContext.Object);
            var result = service.GetUserStocks();

            Assert.AreEqual(2, result.Count());
            Assert.AreEqual("DAX", result.Single(us => us.ID == 0).Name);
            Assert.AreEqual("NASDAQ", result.Single(us => us.ID == 1).Name);
        }
コード例 #26
0
ファイル: KraniumTests.cs プロジェクト: TheGapFillers/Auluxa
		public async Task GetKraniumAsyncTest()
		{
			var kraniumsMockedList = new List<KraniumEntity>
			{
				new KraniumEntity { Name = "TheKranium", IPAddress = "192.168.0.50" },
				//new Kranium { Name = "TheBackupKranium", IPAddress = "192.168.0.51" },
			}.AsQueryable();

			var mockSet = new Mock<DbSet<KraniumEntity>>();
			mockSet.As<IDbAsyncEnumerable<KraniumEntity>>()
				.Setup(m => m.GetAsyncEnumerator())
				.Returns(new TestDbAsyncEnumerator<KraniumEntity>(kraniumsMockedList.GetEnumerator()));

			mockSet.As<IQueryable<KraniumEntity>>()
				.Setup(m => m.Provider)
				.Returns(new TestDbAsyncQueryProvider<KraniumEntity>(kraniumsMockedList.Provider));

			mockSet.As<IQueryable<KraniumEntity>>().Setup(m => m.Expression).Returns(kraniumsMockedList.Expression);
			mockSet.As<IQueryable<KraniumEntity>>().Setup(m => m.ElementType).Returns(kraniumsMockedList.ElementType);
			mockSet.As<IQueryable<KraniumEntity>>().Setup(m => m.GetEnumerator()).Returns(kraniumsMockedList.GetEnumerator());

			var mockContext = new Mock<IKraniumDbContext>();
			mockContext.Setup(c => c.Kranium).Returns(mockSet.Object);

			var repository = new EfKraniumRepository { Context = mockContext.Object };
			var kranium = await repository.GetKraniumAsync();

			Assert.IsNotNull(kranium);
			Assert.AreEqual("TheKranium", kranium.Name);
			Assert.AreEqual("192.168.0.50", kranium.IPAddress);
		}
コード例 #27
0
ファイル: Tests_PersonService.cs プロジェクト: naishan/SDDB
        public void PersonService_GetAsync_ReturnsPersons()
        {
            //Arrange
            var mockDbContextScopeFac = new Mock<IDbContextScopeFactory>();
            var mockDbContextScope = new Mock<IDbContextReadOnlyScope>();
            var mockEfDbContext = new Mock<EFDbContext>();
            mockDbContextScopeFac.Setup(x => x.CreateReadOnly(DbContextScopeOption.JoinExisting)).Returns(mockDbContextScope.Object);
            mockDbContextScope.Setup(x => x.DbContexts.Get<EFDbContext>()).Returns(mockEfDbContext.Object);

            var mockAppUserManager = new Mock<IAppUserManager>();
            var mockDbUserService = new Mock<DBUserService>(new object[] {mockDbContextScopeFac.Object, mockAppUserManager.Object,  true });

            var dbEntry1 = new Person { Id = "dummyEntryId1", FirstName = "First1", LastName = "Last1", IsActive_bl = false, Initials = "FLA1" };
            var dbEntry2 = new Person { Id = "dummyEntryId2", FirstName = "First2", LastName = "Last2", IsActive_bl = true, Initials = "FLA2" };
            var dbEntries = (new List<Person> { dbEntry1, dbEntry2 }).AsQueryable();

            var mockDbSet = new Mock<DbSet<Person>>();
            mockDbSet.As<IDbAsyncEnumerable<Person>>().Setup(m => m.GetAsyncEnumerator()).Returns(new MockDbAsyncEnumerator<Person>(dbEntries.GetEnumerator())); 
            mockDbSet.As<IQueryable<Person>>().Setup(m => m.Provider).Returns(new MockDbAsyncQueryProvider<Person>(dbEntries.Provider));

            mockDbSet.As<IQueryable<Person>>().Setup(m => m.Expression).Returns(dbEntries.Expression);
            mockDbSet.As<IQueryable<Person>>().Setup(m => m.ElementType).Returns(dbEntries.ElementType);
            mockDbSet.As<IQueryable<Person>>().Setup(m => m.GetEnumerator()).Returns(dbEntries.GetEnumerator());
            
            mockEfDbContext.Setup(x => x.Persons).Returns(mockDbSet.Object);

            var personService = new PersonService(mockDbContextScopeFac.Object, "DummyUserId");

            //Act
            var resultPersons = personService.GetAllAsync().Result;
            
            //Assert
            Assert.IsTrue(resultPersons.Count == 1);
            Assert.IsTrue(resultPersons[0].LastName.Contains("Last2"));
        }
コード例 #28
0
        public async Task Delete()
        {
            var data = new List<Department>
            {
                new Department {DepartmentID = 1, Name = "Test1", Budget = 1001, StartDate = DateTime.Today.AddDays(1)},
                new Department {DepartmentID = 2, Name = "Test2", Budget = 1002, StartDate = DateTime.Today.AddDays(2)},
                new Department {DepartmentID = 3, Name = "Test3", Budget = 1003, StartDate = DateTime.Today.AddDays(3)},
                new Department {DepartmentID = 4, Name = "Test4", Budget = 1004, StartDate = DateTime.Today.AddDays(4)}
            }.AsQueryable();

            var mockSet = new Mock<DbSet<Department>>();
            mockSet.As<IQueryable<Department>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Department>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Department>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Department>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<SchoolContext>();
            mockContext.Setup(m => m.Departments).Returns(mockSet.Object);

            var controller = new DepartmentController(mockContext.Object);

            Department departmentToDelete = controller.GetAllDepartments().First();
            await controller.Delete(departmentToDelete);

            mockContext.Verify(m => m.SaveChangesAsync(), Times.Once());

            //Assert.AreEqual(3, controller.GetAllDepartments().Count);

        }
コード例 #29
0
        public void Index()
        {
            // DBのモックを用意する
            var mockset = new Mock<DbSet<BoardEntity>>();
            var mockcontext = new Mock<BoardDbContext>();

            var originalData = new List<BoardEntity> {
                new BoardEntity { Id = 1, Title = "A", Text = "a" },
                new BoardEntity { Id = 2, Title = "B", Text = "b" },
                new BoardEntity { Id = 3, Title = "C", Text = "c" },
            };
            var data = originalData.AsQueryable();

            // 各メソッドの返り値をモックに差し替える
            mockset.As<IQueryable<BoardEntity>>().Setup( m => m.Provider ).Returns( data.Provider );
            mockset.As<IQueryable<BoardEntity>>().Setup( m => m.Expression ).Returns( data.Expression );
            mockset.As<IQueryable<BoardEntity>>().Setup( m => m.ElementType ).Returns( data.ElementType );
            mockset.As<IQueryable<BoardEntity>>().Setup( m => m.GetEnumerator() ).Returns( data.GetEnumerator() );

            mockcontext.Setup( m => m.Boards ).Returns( mockset.Object );

            var controller = new BoardController( mockcontext.Object );
            ViewResult result = controller.Index() as ViewResult;

            //  モデルのデータがちゃんとDBのデータを取得出来ているか検証
            var model = result.Model as BoardListModel;
            Assert.AreSame( originalData[0], model.Boards[0] );
            Assert.AreSame( originalData[1], model.Boards[1] );
            Assert.AreSame( originalData[2], model.Boards[2] );

            Assert.IsNotNull( result );
        }
コード例 #30
0
        public void CreateShouldReturnCorrectComment()
        {
            AutoMapperConfig.RegisterMappings(Assembly.Load("ForumSystem.Api"));
            var data = comments.AsQueryable();
            var mockSet = new Mock<DbSet<Comment>>();
            mockSet.As<IQueryable<Comment>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Comment>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Comment>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Comment>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock<IForumDbContext>();
            mockContext.Setup(c => c.Comments).Returns(mockSet.Object);

            var controller = new CommentsController(mockContext.Object);

            var okResponse = controller.Create(1, new CommentDataModel
            {
                Id = 1,
                Content = "Content"
            });

            var okResult = okResponse as OkNegotiatedContentResult<CommentDataModel>;

            Assert.IsNotNull(okResponse);
            Assert.AreEqual(1, okResult.Content.Id);
            Assert.AreEqual("Content", okResult.Content.Content);
        }
コード例 #31
0
        private Mock <DbSet <Payment> > GetPayments(bool dataAllowed = true)
        {
            IQueryable <Payment> data;

            if (dataAllowed)
            {
                data = new List <Payment>()
                {
                    new Payment
                    {
                        Id               = 1,
                        Booking_id       = 1,
                        Customer_id      = 1,
                        PaymentMethod_id = 2,
                        Amount           = Convert.ToDecimal(6.7800),
                        Deleted          = false
                    }
                }.AsQueryable();
            }
            else
            {
                data = Enumerable.Empty <Payment>().AsQueryable();
            }

            Mock <DbSet <Payment> > dataSet = new Mock <DbSet <Payment> >();

            dataSet.As <IDbAsyncEnumerable <Payment> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <Payment>(data.GetEnumerator()));
            dataSet.As <IQueryable <Payment> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <Payment>(data.Provider));
            dataSet.As <IQueryable>().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <Payment>(data.Provider));
            dataSet.As <IQueryable <Payment> >().Setup(m => m.Expression).Returns(data.Expression);
            dataSet.As <IQueryable <Payment> >().Setup(m => m.ElementType).Returns(data.ElementType);
            dataSet.As <IQueryable <Payment> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            dataSet.Setup(m => m.Add(It.IsAny <Payment>())).Returns((Payment r) => r);

            return(dataSet);
        }
コード例 #32
0
        private Mock <DbSet <MenuItemType> > GetMenuItemTypes(bool dataAllowed = true)
        {
            IQueryable <MenuItemType> data;

            if (dataAllowed)
            {
                data = new List <MenuItemType>()
                {
                    new MenuItemType {
                        Id = 1, MenuItem_id = 1, Type_id = 1, Deleted = false
                    },
                    new MenuItemType {
                        Id = 2, MenuItem_id = 2, Type_id = 2, Deleted = false
                    },
                    new MenuItemType {
                        Id = 3, MenuItem_id = 3, Type_id = 3, Deleted = false
                    }
                }.AsQueryable();
            }
            else
            {
                data = Enumerable.Empty <MenuItemType>().AsQueryable();
            }

            Mock <DbSet <MenuItemType> > dataSet = new Mock <DbSet <MenuItemType> >();

            dataSet.As <IDbAsyncEnumerable <MenuItemType> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <MenuItemType>(data.GetEnumerator()));
            dataSet.As <IQueryable <MenuItemType> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <MenuItemType>(data.Provider));
            dataSet.As <IQueryable>().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <MenuItemType>(data.Provider));
            dataSet.As <IQueryable <MenuItemType> >().Setup(m => m.Expression).Returns(data.Expression);
            dataSet.As <IQueryable <MenuItemType> >().Setup(m => m.ElementType).Returns(data.ElementType);
            dataSet.As <IQueryable <MenuItemType> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            dataSet.Setup(m => m.Add(It.IsAny <MenuItemType>())).Returns((MenuItemType r) => r);

            return(dataSet);
        }
コード例 #33
0
        private Mock <DbSet <DietInfo> > GetDietInfo(bool dataAllowed = true)
        {
            IQueryable <DietInfo> data;

            if (dataAllowed)
            {
                data = new List <DietInfo>()
                {
                    new DietInfo {
                        Id = 1, Name = "Vegetarian", Deleted = false
                    },
                    new DietInfo {
                        Id = 2, Name = "Vegan", Deleted = false
                    },
                    new DietInfo {
                        Id = 3, Name = "Contains Nuts", Deleted = false
                    }
                }.AsQueryable();
            }
            else
            {
                data = Enumerable.Empty <DietInfo>().AsQueryable();
            }

            Mock <DbSet <DietInfo> > dataSet = new Mock <DbSet <DietInfo> >();

            dataSet.As <IDbAsyncEnumerable <DietInfo> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <DietInfo>(data.GetEnumerator()));
            dataSet.As <IQueryable <DietInfo> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <DietInfo>(data.Provider));
            dataSet.As <IQueryable>().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <DietInfo>(data.Provider));
            dataSet.As <IQueryable <DietInfo> >().Setup(m => m.Expression).Returns(data.Expression);
            dataSet.As <IQueryable <DietInfo> >().Setup(m => m.ElementType).Returns(data.ElementType);
            dataSet.As <IQueryable <DietInfo> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            dataSet.Setup(m => m.Add(It.IsAny <DietInfo>())).Returns((DietInfo r) => r);

            return(dataSet);
        }
コード例 #34
0
        private Mock <DbSet <BookingMenuItem> > GetBookingMenuItems(bool dataAllowed = true)
        {
            IQueryable <BookingMenuItem> data;

            if (dataAllowed)
            {
                data = new List <BookingMenuItem>()
                {
                    new BookingMenuItem
                    {
                        Id          = 1,
                        Booking_id  = 1,
                        MenuItem_id = 2,
                        Quantity    = 1,
                        Total       = Convert.ToDecimal(6.7800),
                        Deleted     = false
                    }
                }.AsQueryable();
            }
            else
            {
                data = Enumerable.Empty <BookingMenuItem>().AsQueryable();
            }

            Mock <DbSet <BookingMenuItem> > dataSet = new Mock <DbSet <BookingMenuItem> >();

            dataSet.As <IDbAsyncEnumerable <BookingMenuItem> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <BookingMenuItem>(data.GetEnumerator()));
            dataSet.As <IQueryable <BookingMenuItem> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <BookingMenuItem>(data.Provider));
            dataSet.As <IQueryable>().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <BookingMenuItem>(data.Provider));
            dataSet.As <IQueryable <BookingMenuItem> >().Setup(m => m.Expression).Returns(data.Expression);
            dataSet.As <IQueryable <BookingMenuItem> >().Setup(m => m.ElementType).Returns(data.ElementType);
            dataSet.As <IQueryable <BookingMenuItem> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            dataSet.Setup(m => m.Add(It.IsAny <BookingMenuItem>())).Returns((BookingMenuItem r) => r);

            return(dataSet);
        }
コード例 #35
0
        private Mock <DbSet <DatabaseContext.Data.Type> > GetTypes(bool dataAllowed = true)
        {
            IQueryable <DatabaseContext.Data.Type> data;

            if (dataAllowed)
            {
                data = new List <DatabaseContext.Data.Type>()
                {
                    new DatabaseContext.Data.Type {
                        Id = 1, Name = "Starter", Deleted = false
                    },
                    new DatabaseContext.Data.Type {
                        Id = 2, Name = "Main", Deleted = false
                    },
                    new DatabaseContext.Data.Type {
                        Id = 3, Name = "Dessert", Deleted = false
                    }
                }.AsQueryable();
            }
            else
            {
                data = Enumerable.Empty <DatabaseContext.Data.Type>().AsQueryable();
            }

            Mock <DbSet <DatabaseContext.Data.Type> > dataSet = new Mock <DbSet <DatabaseContext.Data.Type> >();

            dataSet.As <IDbAsyncEnumerable <DatabaseContext.Data.Type> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <DatabaseContext.Data.Type>(data.GetEnumerator()));
            dataSet.As <IQueryable <DatabaseContext.Data.Type> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <DatabaseContext.Data.Type>(data.Provider));
            dataSet.As <IQueryable>().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <DatabaseContext.Data.Type>(data.Provider));
            dataSet.As <IQueryable <DatabaseContext.Data.Type> >().Setup(m => m.Expression).Returns(data.Expression);
            dataSet.As <IQueryable <DatabaseContext.Data.Type> >().Setup(m => m.ElementType).Returns(data.ElementType);
            dataSet.As <IQueryable <DatabaseContext.Data.Type> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
            dataSet.Setup(m => m.Add(It.IsAny <DatabaseContext.Data.Type>())).Returns((DatabaseContext.Data.Type r) => r);

            return(dataSet);
        }
コード例 #36
0
        public static IVsHierarchy Create()
        {
            var mock = new Mock <IVsProject4>();

            return(mock.As <IVsHierarchy>().Object);
        }
コード例 #37
0
        public void GetAllProjectTest()
        {
            var pdata = new List <Project>()
            {
                new Project {
                    Project_ID = 1, ProjectName = "TestProject1", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, ManagerID = 1, IsSuspended = true, noofTasks = 1, noofCompletedTasks = 1, managerDetails = "Manager1"
                },
                new Project {
                    Project_ID = 2, ProjectName = "TestProject2", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 11, ManagerID = 2, IsSuspended = false, noofTasks = 1, noofCompletedTasks = 1, managerDetails = "Manager1"
                }
            }.AsQueryable();

            var mock = new Mock <DbSet <Project> >();

            mock.As <IQueryable <Project> >().Setup(x => x.Provider).Returns(pdata.Provider);
            mock.As <IQueryable <Project> >().Setup(x => x.Expression).Returns(pdata.Expression);
            mock.As <IQueryable <Project> >().Setup(x => x.ElementType).Returns(pdata.ElementType);
            mock.As <IQueryable <Project> >().Setup(x => x.GetEnumerator()).Returns(pdata.GetEnumerator());


            var udata = new List <User>()
            {
                new User {
                    User_ID = 1, Employee_ID = "1", FirstName = "FirstName1", LastName = "LastName1"
                },
                new User {
                    User_ID = 2, Employee_ID = "2", FirstName = "FirstName2", LastName = "LastName2"
                }
            }.AsQueryable();

            var umock = new Mock <DbSet <User> >();

            umock.As <IQueryable <User> >().Setup(x => x.Provider).Returns(udata.Provider);
            umock.As <IQueryable <User> >().Setup(x => x.Expression).Returns(udata.Expression);
            umock.As <IQueryable <User> >().Setup(x => x.ElementType).Returns(udata.ElementType);
            umock.As <IQueryable <User> >().Setup(x => x.GetEnumerator()).Returns(udata.GetEnumerator());


            var tdata = new List <Task>()
            {
                new Task {
                    Task_ID = 1, Parent_ID = 1, Project_ID = 1, TaskName = "TestTask1", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, User_ID = 1, IsParentTask = true, ParentTaskName = "ParentTask1", UserName = "******", ProjectName = "TestProject1"
                },
                new Task {
                    Task_ID = 2, Parent_ID = 1, Project_ID = 1, TaskName = "TestTask2", StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Priority = 10, User_ID = 1, IsParentTask = true, ParentTaskName = "ParentTask1", UserName = "******", ProjectName = "TestProject1"
                }
            }.AsQueryable();

            var tmock = new Mock <DbSet <Task> >();

            tmock.As <IQueryable <Task> >().Setup(x => x.Provider).Returns(tdata.Provider);
            tmock.As <IQueryable <Task> >().Setup(x => x.Expression).Returns(tdata.Expression);
            tmock.As <IQueryable <Task> >().Setup(x => x.ElementType).Returns(tdata.ElementType);
            tmock.As <IQueryable <Task> >().Setup(x => x.GetEnumerator()).Returns(tdata.GetEnumerator());


            var context = new Mock <ProjectManagerContext>();

            context.Setup(x => x.projects).Returns(mock.Object);
            context.Setup(x => x.users).Returns(umock.Object);
            context.Setup(x => x.tasks).Returns(tmock.Object);

            var            service = new ProjectRepository(context.Object);
            List <Project> users   = service.GetAllProjects();

            Assert.That(users.Count == 2);
        }
コード例 #38
0
        public static DTE2 Create()
        {
            var mock = new Mock <DTE>();

            return(mock.As <DTE2>().Object);
        }
コード例 #39
0
        public static void ClassInitialize(TestContext context)
        {
            mockContext   = new Mock <RegionCityContext>();
            mockRegionSet = new Mock <DbSet <Region> >();
            mockCitySet   = new Mock <DbSet <City> >();

            // Arrange data providers
            citiesProvider = new List <City>()
            {
                new City {
                    CityName = "Berlin", Region = new Region {
                        RegionName = "Berlin"
                    }
                },
                new City {
                    CityName = "Hamburg", Region = new Region {
                        RegionName = "Hamburg"
                    }
                },
                new City {
                    CityName = "Munich", Region = new Region {
                        RegionName = "Bavaria"
                    }
                },
                new City {
                    CityName = "Cologne", Region = new Region {
                        RegionName = "North Rhine-Westphalia"
                    }
                },
                new City {
                    CityName = "Frankfurt am Main", Region = new Region {
                        RegionName = "Hesse"
                    }
                }
            };
            regionsProvider = new List <Region>()
            {
                new Region {
                    RegionName = "Berlin"
                },
                new Region {
                    RegionName = "Hamburg"
                },
                new Region {
                    RegionName = "Bavaria"
                },
                new Region {
                    RegionName = "North Rhine-Westphalia"
                },
                new Region {
                    RegionName = "Hesse"
                }
            };


            // mockCitySet setup
            mockCitySet.As <IQueryable <City> >().Setup(m => m.Provider).Returns(citiesProvider.AsQueryable().Provider);
            mockCitySet.As <IQueryable <City> >().Setup(m => m.Expression).Returns(citiesProvider.AsQueryable().Expression);
            mockCitySet.As <IQueryable <City> >().Setup(m => m.ElementType).Returns(citiesProvider.AsQueryable().ElementType);
            mockCitySet.As <IQueryable <City> >().Setup(m => m.GetEnumerator()).Returns(citiesProvider.AsQueryable().GetEnumerator());

            // mockRegionSet setup
            mockRegionSet.As <IQueryable <Region> >().Setup(m => m.Provider).Returns(regionsProvider.AsQueryable().Provider);
            mockRegionSet.As <IQueryable <Region> >().Setup(m => m.Expression).Returns(regionsProvider.AsQueryable().Expression);
            mockRegionSet.As <IQueryable <Region> >().Setup(m => m.ElementType).Returns(regionsProvider.AsQueryable().ElementType);
            mockRegionSet.As <IQueryable <Region> >().Setup(m => m.GetEnumerator()).Returns(regionsProvider.AsQueryable().GetEnumerator());

            // mockContext setup
            mockContext.Setup(c => c.Regions).Returns(mockRegionSet.Object);
            mockContext.Setup(c => c.Set <Region>()).Returns(mockRegionSet.Object);
            mockContext.Setup(c => c.Cities).Returns(mockCitySet.Object);
            mockContext.Setup(c => c.Set <City>()).Returns(mockCitySet.Object);
        }
コード例 #40
0
        public async Task TestPostAudioJob()
        {
            //init
            var mockJobs         = new Mock <DbSet <Job> >();
            var mockServiceUsers = new Mock <DbSet <ServiceUser> >();
            var mockContext      = new Mock <RoboBrailleDataContext>();
            var mockAuSender     = new Mock <IAudioJobSender>();

            // arrange
            var users = new List <ServiceUser> {
                new ServiceUser
                {
                    EmailAddress = "*****@*****.**",
                    UserId       = Guid.Parse("d2b97532-e8c5-e411-8270-f0def103cfd0"),
                    ApiKey       = Encoding.UTF8.GetBytes("7b76ae41-def3-e411-8030-0c8bfd2336cd"),
                    FromDate     = new DateTime(2015, 1, 1),
                    ToDate       = new DateTime(2020, 1, 1),
                    UserName     = "******",
                    Jobs         = null
                }
            }.AsQueryable();

            AudioJob auj = new AudioJob()
            {
                Id              = Guid.NewGuid(),
                FileContent     = new byte[512],
                UserId          = Guid.Parse("d2b97532-e8c5-e411-8270-f0def103cfd0"),
                FileExtension   = ".pdf",
                FileName        = "test",
                MimeType        = "application/pdf",
                Status          = JobStatus.Started,
                SubmitTime      = DateTime.Now,
                DownloadCounter = 0,
                InputFileHash   = new byte[64],
                AudioLanguage   = Language.daDK,
                FormatOptions   = AudioFormat.Mp3,
                SpeedOptions    = AudioSpeed.Normal,
                VoicePropriety  = new VoicePropriety[] { VoicePropriety.Anne }
            };
            AudioJob auj2 = new AudioJob()
            {
                Id              = Guid.NewGuid(),
                FileContent     = new byte[256],
                UserId          = Guid.Parse("d2b87532-e8c5-e411-8270-f0def103cfd0"),
                FileExtension   = ".txt",
                FileName        = "test2",
                MimeType        = "text/plain",
                Status          = JobStatus.Done,
                SubmitTime      = DateTime.Now,
                DownloadCounter = 2,
                InputFileHash   = new byte[2]
            };
            var jobs = new List <AudioJob> {
                auj2
            }.AsQueryable();

            mockJobs.As <IDbAsyncEnumerable <Job> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <Job>(jobs.GetEnumerator()));
            mockJobs.As <IQueryable <Job> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <Job>(jobs.Provider));

            mockJobs.As <IQueryable <Job> >().Setup(m => m.Expression).Returns(jobs.Expression);
            mockJobs.As <IQueryable <Job> >().Setup(m => m.ElementType).Returns(jobs.ElementType);
            mockJobs.As <IQueryable <Job> >().Setup(m => m.GetEnumerator()).Returns(jobs.GetEnumerator());

            mockServiceUsers.As <IDbAsyncEnumerable <ServiceUser> >().Setup(m => m.GetAsyncEnumerator()).Returns(new TestDbAsyncEnumerator <ServiceUser>(users.GetEnumerator()));
            mockServiceUsers.As <IQueryable <ServiceUser> >().Setup(m => m.Provider).Returns(new TestDbAsyncQueryProvider <ServiceUser>(users.Provider));
            mockServiceUsers.As <IQueryable <ServiceUser> >().Setup(m => m.Expression).Returns(users.Expression);
            mockServiceUsers.As <IQueryable <ServiceUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
            mockServiceUsers.As <IQueryable <ServiceUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

            mockContext.Setup(m => m.Jobs).Returns(mockJobs.Object);
            mockContext.Setup(m => m.ServiceUsers).Returns(mockServiceUsers.Object);
            mockAuSender.Setup(m => m.SendAudioJobToQueue(auj)).Returns(Encoding.UTF8.GetBytes(testFileResult));

            var repo = new AudioRepository(mockContext.Object, mockAuSender.Object);

            var request = new HttpRequestMessage();

            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Authorization", "Hawk id=\"d2b97532-e8c5-e411-8270-f0def103cfd0\", ts=\"1470657024\", nonce=\"VkcMGB\", mac=\"hXW+BLRoqwlUaQZQtpPToOWnVAh5KbAXGGT5f8dLMVk=\"");
            var serviceController = new AudioController(repo)
            {
                Request = request
            };
            //call
            await serviceController.Post(auj);

            //test
            mockJobs.Verify(m => m.Add(It.IsAny <Job>()), Times.Once());

            mockContext.Verify(m => m.SaveChanges(), Times.Exactly(1));
            //twice if it is synced
            //mockContext.Verify(m => m.SaveChanges(), Times.Exactly(2));

            mockAuSender.Verify(m => m.SendAudioJobToQueue(It.IsAny <AudioJob>()), Times.Once());
            Assert.IsFalse(File.Exists(testFileResult));
        }
コード例 #41
0
        public override TDbContext Create()
        {
            var dbContextMock = new Mock <TDbContext>(ConstructorParameters.ToArray());

            dbContextMock.DefaultValueProvider = new NoSetUpDefaultValueProvider <TDbContext>(DbContext);

            dbContextMock.Setup(m => m.Add(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Add(providedEntity));
            dbContextMock.Setup(m => m.AddAsync(It.IsAny <object>(), It.IsAny <CancellationToken>()))
            .Returns((object providedEntity, CancellationToken providedCancellationToken) => DbContext.AddAsync(providedEntity, providedCancellationToken));
            dbContextMock.Setup(m => m.AddRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.AddRange(providedEntities));
            dbContextMock.Setup(m => m.AddRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.AddRange(providedEntities));
            dbContextMock.Setup(m => m.AddRangeAsync(It.IsAny <object[]>(), It.IsAny <CancellationToken>()))
            .Returns((object[] providedEntities, CancellationToken providedCancellationToken) => DbContext.AddRangeAsync(providedEntities, providedCancellationToken));
            dbContextMock.Setup(m => m.AddRangeAsync(It.IsAny <IEnumerable <object> >(), It.IsAny <CancellationToken>()))
            .Returns((IEnumerable <object> providedEntities, CancellationToken providedCancellationToken) =>
                     DbContext.AddRangeAsync(providedEntities, providedCancellationToken));

            dbContextMock.Setup(m => m.Attach(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Attach(providedEntity));
            dbContextMock.Setup(m => m.AttachRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.AttachRange(providedEntities));
            dbContextMock.Setup(m => m.AttachRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.AttachRange(providedEntities));

            dbContextMock.As <IDbContextDependencies>().Setup(m => m.ChangeDetector).Returns(((IDbContextDependencies)DbContext).ChangeDetector);
            dbContextMock.Setup(m => m.ChangeTracker).Returns(() => DbContext.ChangeTracker);
            dbContextMock.Setup(m => m.ContextId).Returns(() => DbContext.ContextId);
            dbContextMock.Setup(m => m.Database).Returns(() => DbContext.Database);
            dbContextMock.Setup(m => m.Dispose()).Callback(() => DbContext.Dispose());
            dbContextMock.Setup(m => m.DisposeAsync()).Callback(() => DbContext.DisposeAsync());
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.EntityFinderFactory).Returns(((IDbContextDependencies)DbContext).EntityFinderFactory);
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.EntityGraphAttacher).Returns(((IDbContextDependencies)DbContext).EntityGraphAttacher);
            dbContextMock.Setup(m => m.Entry(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Entry(providedEntity));

            dbContextMock.Setup(m => m.Find(It.IsAny <Type>(), It.IsAny <object[]>()))
            .Returns((Type providedEntityType, object[] providedKeyValues) => DbContext.Find(providedEntityType, providedKeyValues));
            dbContextMock.Setup(m => m.FindAsync(It.IsAny <Type>(), It.IsAny <object[]>()))
            .Returns((Type providedEntityType, object[] providedKeyValues) => DbContext.FindAsync(providedEntityType, providedKeyValues));
            dbContextMock.Setup(m => m.FindAsync(It.IsAny <Type>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>()))
            .Returns((Type providedEntityType, object[] providedKeyValues, CancellationToken providedCancellationToken) =>
                     DbContext.FindAsync(providedEntityType, providedKeyValues, providedCancellationToken));

            dbContextMock.As <IDbSetCache>()
            .Setup(m => m.GetOrAddSet(It.IsAny <IDbSetSource>(), It.IsAny <Type>()))
            .Returns((IDbSetSource providedSource, Type providedType) => ((IDbSetCache)DbContext).GetOrAddSet(providedSource, providedType));
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.InfrastructureLogger).Returns(((IDbContextDependencies)DbContext).InfrastructureLogger);
            dbContextMock.As <IInfrastructure <IServiceProvider> >().Setup(m => m.Instance).Returns(((IInfrastructure <IServiceProvider>)DbContext).Instance);
            //dbContextMock.As<IDbContextDependencies>().Setup(m => m.Model).Returns(((IDbContextDependencies) DbContext).Model);
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.QueryProvider).Returns(((IDbContextDependencies)DbContext).QueryProvider);

            dbContextMock.Setup(m => m.Remove(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Remove(providedEntity));
            dbContextMock.Setup(m => m.RemoveRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.RemoveRange(providedEntities));
            dbContextMock.Setup(m => m.RemoveRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.RemoveRange(providedEntities));

            dbContextMock.As <IDbContextPoolable>().Setup(m => m.ResetState()).Callback(((IDbContextPoolable)DbContext).ResetState);
            dbContextMock.As <IDbContextPoolable>()
            .Setup(m => m.ResetStateAsync(It.IsAny <CancellationToken>()))
            .Callback((CancellationToken providedCancellationToken) => ((IDbContextPoolable)DbContext).ResetStateAsync(providedCancellationToken));
            // dbContextMock.As<IDbContextPoolable>()
            //     .Setup(m => m.Resurrect(It.IsAny<DbContextPoolConfigurationSnapshot>()))
            //     .Callback((DbContextPoolConfigurationSnapshot providedConfigurationSnapshot) => ((IDbContextPoolable) DbContext).Resurrect(providedConfigurationSnapshot));

            dbContextMock.Setup(m => m.SaveChanges()).Returns(() => DbContext.SaveChanges());
            dbContextMock.Setup(m => m.SaveChanges(It.IsAny <bool>())).Returns((bool providedAcceptAllChangesOnSuccess) => DbContext.SaveChanges(providedAcceptAllChangesOnSuccess));
            dbContextMock.Setup(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()))
            .Returns((CancellationToken providedCancellationToken) => DbContext.SaveChangesAsync(providedCancellationToken));
            dbContextMock.Setup(m => m.SaveChangesAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
            .Returns((bool providedAcceptAllChangesOnSuccess, CancellationToken providedCancellationToken) =>
                     DbContext.SaveChangesAsync(providedAcceptAllChangesOnSuccess, providedCancellationToken));

            // dbContextMock.As<IDbContextPoolable>()
            //     .Setup(m => m.SetPool(It.IsAny<IDbContextPool>()))
            //     .Callback((IDbContextPool providedContextPool) => ((IDbContextPoolable) DbContext).SetPool(providedContextPool));
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.SetSource).Returns(((IDbContextDependencies)DbContext).SetSource);
            // dbContextMock.As<IDbContextPoolable>().Setup(m => m.SnapshotConfiguration()).Returns(((IDbContextPoolable) DbContext).SnapshotConfiguration());
            dbContextMock.As <IDbContextDependencies>().Setup(m => m.StateManager).Returns(((IDbContextDependencies)DbContext).StateManager);

            dbContextMock.Setup(m => m.Update(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Update(providedEntity));

            dbContextMock.As <IDbContextDependencies>().Setup(m => m.UpdateLogger).Returns(((IDbContextDependencies)DbContext).UpdateLogger);

            dbContextMock.Setup(m => m.UpdateRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.UpdateRange(providedEntities));
            dbContextMock.Setup(m => m.UpdateRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.UpdateRange(providedEntities));

            //Relational set up
            var rawSqlCommandBuilderMock = new Mock <IRawSqlCommandBuilder>();

            rawSqlCommandBuilderMock.Setup(m => m.Build(It.IsAny <string>(), It.IsAny <IEnumerable <object> >()))
            .Callback((string providedSql, IEnumerable <object> providedParameters) => Logger.LogDebug("Catch all exception invoked"))
            .Throws <InvalidOperationException>();
            var rawSqlCommandBuilder = rawSqlCommandBuilderMock.Object;

            // var concurrencyDetectorMock = new Mock<IConcurrencyDetector>();
            // concurrencyDetectorMock.Setup(x => x.EnterCriticalSection()).Returns(() => new ConcurrencyDetectorCriticalSectionDisposer(Mock.Of<IConcurrencyDetector>()));
            // var concurrencyDetector = concurrencyDetectorMock.Object;

            var relationalConnectionMock = new Mock <IRelationalConnection>();

            relationalConnectionMock.Setup(x => x.CommandTimeout).Returns(() => 0);
            var relationalConnection = relationalConnectionMock.Object;

            var dependenciesMock = new Mock <IRelationalDatabaseFacadeDependencies>();

            //dependenciesMock.Setup(m => m.ConcurrencyDetector).Returns(() => concurrencyDetector);
            dependenciesMock.Setup(m => m.CommandLogger).Returns(() => Mock.Of <IRelationalCommandDiagnosticsLogger>());
            dependenciesMock.Setup(m => m.RawSqlCommandBuilder).Returns(() => rawSqlCommandBuilder);
            dependenciesMock.Setup(m => m.RelationalConnection).Returns(() => relationalConnection);
            //dependenciesMock.Setup(m => m.CoreOptions.IsConcurrencyDetectionEnabled).Returns(() => true);
            dependenciesMock.Setup(m => m.CoreOptions.AreThreadSafetyChecksEnabled).Returns(() => false);
            var dependencies = dependenciesMock.Object;

            var serviceProviderMock = new Mock <IServiceProvider>();

            serviceProviderMock.Setup(m => m.GetService(It.Is <Type>(t => t == typeof(IDatabaseFacadeDependencies)))).Returns((Type providedType) => dependencies);
            var serviceProvider = serviceProviderMock.Object;

            dbContextMock.As <IInfrastructure <IServiceProvider> >().Setup(m => m.Instance).Returns(() => serviceProvider);

            var mockedDbContext = dbContextMock.Object;

            var databaseFacadeMock = new Mock <DatabaseFacade>(mockedDbContext);

            databaseFacadeMock.As <IDatabaseFacadeDependenciesAccessor>().Setup(x => x.Dependencies).Returns(() => dependencies);
            databaseFacadeMock.Setup(x => x.BeginTransaction()).Returns(() => Mock.Of <IDbContextTransaction>());
            var databaseFacade = databaseFacadeMock.Object;

            dbContextMock.Setup(m => m.Database).Returns(() => databaseFacade);

            return(mockedDbContext);
        }
コード例 #42
0
        private static PatientsController GetPatientsControllerForGetPatientsMethod(
            IEnumerable <User> dbUsers               = null,
            IEnumerable <Doctor> dbDoctors           = null,
            IEnumerable <Patient> dbPatients         = null,
            IEnumerable <Appointment> dbAppointments = null,
            string identityRole = ""
            )
        {
            var mockContext = new Mock <AlphaMedicContext>();

            if (dbUsers != null)
            {
                var mockSet = new Mock <DbSet <User> >();
                mockSet.As <IQueryable <User> >().Setup(m => m.Provider).Returns(dbUsers.AsQueryable().Provider);
                mockSet.As <IQueryable <User> >().Setup(m => m.Expression).Returns(dbUsers.AsQueryable().Expression);
                mockSet.As <IQueryable <User> >().Setup(m => m.ElementType).Returns(dbUsers.AsQueryable().ElementType);
                mockSet.As <IQueryable <User> >().Setup(m => m.GetEnumerator()).Returns(() => dbUsers.AsQueryable().GetEnumerator());
                mockContext.Setup(c => c.Users).Returns(mockSet.Object);
            }

            if (dbPatients != null)
            {
                var mockSet = new Mock <DbSet <Patient> >();
                mockSet.As <IQueryable <Patient> >().Setup(m => m.Provider).Returns(dbPatients.AsQueryable().Provider);
                mockSet.As <IQueryable <Patient> >().Setup(m => m.Expression).Returns(dbPatients.AsQueryable().Expression);
                mockSet.As <IQueryable <Patient> >().Setup(m => m.ElementType).Returns(dbPatients.AsQueryable().ElementType);
                mockSet.As <IQueryable <Patient> >().Setup(m => m.GetEnumerator()).Returns(() => dbPatients.AsQueryable().GetEnumerator());
                mockSet.Setup(m => m.Include("Appointments")).Returns(mockSet.Object);
                mockContext.Setup(c => c.Patients).Returns(mockSet.Object);
            }

            if (dbDoctors != null)
            {
                var mockSet = new Mock <DbSet <Doctor> >();
                mockSet.As <IQueryable <Doctor> >().Setup(m => m.Provider).Returns(dbDoctors.AsQueryable().Provider);
                mockSet.As <IQueryable <Doctor> >().Setup(m => m.Expression).Returns(dbDoctors.AsQueryable().Expression);
                mockSet.As <IQueryable <Doctor> >().Setup(m => m.ElementType).Returns(dbDoctors.AsQueryable().ElementType);
                mockSet.As <IQueryable <Doctor> >().Setup(m => m.GetEnumerator()).Returns(() => dbDoctors.AsQueryable().GetEnumerator());
                mockContext.Setup(c => c.Doctors).Returns(mockSet.Object);
            }

            if (dbAppointments != null)
            {
                var mockSet = new Mock <DbSet <Appointment> >();
                mockSet.As <IQueryable <Appointment> >().Setup(m => m.Provider).Returns(dbAppointments.AsQueryable().Provider);
                mockSet.As <IQueryable <Appointment> >().Setup(m => m.Expression).Returns(dbAppointments.AsQueryable().Expression);
                mockSet.As <IQueryable <Appointment> >().Setup(m => m.ElementType).Returns(dbAppointments.AsQueryable().ElementType);
                mockSet.As <IQueryable <Appointment> >().Setup(m => m.GetEnumerator()).Returns(() => dbAppointments.AsQueryable().GetEnumerator());


                //mockContext.Setup(m => m.Include("Appointments")).Returns(mockPersonSet.Object);
            }
            var service = new PatientsController(mockContext.Object);

            service.User = new GenericPrincipal(
                new GenericIdentity(
                    "*****@*****.**",
                    "Passport"), new[] { identityRole });

            return(service);
        }
コード例 #43
0
 public void BeforeEach()
 {
     _webElementMock         = new Mock <IWebElement>();
     _javaScriptExecutorMock = _webElementMock.As <IJavaScriptExecutor>();
 }
コード例 #44
0
        public static XafApplication NewApplication <TModule>(this Platform platform, bool transmitMessage = true, bool handleExceptions = true, bool usePersistentStorage = false)
            where TModule : ModuleBase
        {
            XafApplication application;

            ApplicationModulesManager.UseStaticCache = false;
            string applicationTypeName;

            if (platform == Platform.Web)
            {
                applicationTypeName = "Xpand.TestsLib.TestWebApplication";
                application         = (XafApplication)AppDomain.CurrentDomain.CreateTypeInstance(applicationTypeName, typeof(TModule), transmitMessage);
            }
            else if (platform == Platform.Win)
            {
                applicationTypeName = "Xpand.TestsLib.TestWinApplication";
                application         = (XafApplication)AppDomain.CurrentDomain.CreateTypeInstance(applicationTypeName, typeof(TModule), transmitMessage, handleExceptions);
            }
            else if (platform == Platform.Blazor)
            {
                application = (XafApplication)ApplicationType.CreateInstance(typeof(TModule), transmitMessage, handleExceptions);
            }
            else
            {
                throw new NotSupportedException(
                          "if implemented make sure all tests pass with TestExplorer and live testing");
            }


            application.Title            = TestContext.CurrentContext.Test.FullName;
            application.ConnectionString = usePersistentStorage?
                                           @$ "Integrated Security=SSPI;Pooling=false;Data Source=(localdb)\mssqllocaldb;Initial Catalog={typeof(TModule).Name}":InMemoryDataStoreProvider.ConnectionString;
            application.DatabaseUpdateMode     = DatabaseUpdateMode.UpdateDatabaseAlways;
            application.CheckCompatibilityType = CheckCompatibilityType.DatabaseSchema;
            application.ConfigureModel <TModule>(transmitMessage).SubscribeReplay();
            application.MockEditorsFactory();

            if (platform == Platform.Web)
            {
                var frameTemplateFactoryMock = new Mock <IFrameTemplateFactory>();
                var frameTemplateMock        = new Mock <IFrameTemplate>()
                {
                    CallBase = true
                };
                frameTemplateMock.Setup(template => template.GetContainers()).Returns(new ActionContainerCollection());
                frameTemplateFactoryMock.Setup(factory => factory.CreateTemplate(It.IsAny <TemplateContext>())).Returns(
                    (TemplateContext context) => {
                    if (context == TemplateContext.NestedFrame)
                    {
                        return((IFrameTemplate)frameTemplateMock.As <ISupportActionsToolbarVisibility>().Object);
                    }

                    return(frameTemplateMock.Object);
                });
                application.SetPropertyValue("FrameTemplateFactory", frameTemplateFactoryMock.Object);
            }
            else if (platform == Platform.Win)
            {
                application.SetPropertyValue("UseLightStyle", true);
            }

            return(application);
        }
コード例 #45
0
ファイル: MockTemplate.cs プロジェクト: sami119/Brainzzler
        public void MockTemplateContext()
        {
            //initialize
            Answer answer = new Answer {
                Id = 1, AnswerText = "Отговор 1", Correct = 1, WrongText = ""
            };
            Answer answer2 = new Answer {
                Id = 2, AnswerText = "Отговор 2", Correct = 0, WrongText = ""
            };
            Answer answer3 = new Answer {
                Id = 3, AnswerText = "Отговор 3", Correct = 0, WrongText = ""
            };
            List <Answer> answers = new List <Answer> {
                answer, answer2, answer3
            };
            var data1 = new List <Answer> {
                answer, answer2, answer3
            }.AsQueryable();
            var mockAnswer = new Mock <DbSet <Answer> >();

            mockAnswer.As <IQueryable <Answer> >().Setup(m => m.Provider).Returns(data1.Provider);
            mockAnswer.As <IQueryable <Answer> >().Setup(m => m.Expression).Returns(data1.Expression);
            mockAnswer.As <IQueryable <Answer> >().Setup(m => m.ElementType).Returns(data1.ElementType);
            mockAnswer.As <IQueryable <Answer> >().Setup(m => m.GetEnumerator()).Returns(data1.GetEnumerator());


            Question question = new Question {
                Answers = answers, Id = 1, QuestionText = "Въпрос", Score = 2, WrongText = ""
            };
            List <Question> questions = new List <Question> {
                question
            };
            var data2 = new List <Question> {
                question
            }.AsQueryable();
            var mockQuestion = new Mock <DbSet <Question> >();

            mockQuestion.As <IQueryable <Question> >().Setup(m => m.Provider).Returns(data2.Provider);
            mockQuestion.As <IQueryable <Question> >().Setup(m => m.Expression).Returns(data2.Expression);
            mockQuestion.As <IQueryable <Question> >().Setup(m => m.ElementType).Returns(data2.ElementType);
            mockQuestion.As <IQueryable <Question> >().Setup(m => m.GetEnumerator()).Returns(data2.GetEnumerator());


            var questionResponse = new QuestionResponse {
                Id = 1, Question = question, SelectedAnswers = new List <Answer> {
                    answer
                }, TextAnswer = ""
            };
            List <QuestionResponse> questionResponses = new List <QuestionResponse> {
                questionResponse
            };
            var data3 = new List <QuestionResponse> {
                questionResponse
            }.AsQueryable();
            var mockQuestionR = new Mock <DbSet <QuestionResponse> >();

            mockQuestionR.As <IQueryable <QuestionResponse> >().Setup(m => m.Provider).Returns(data3.Provider);
            mockQuestionR.As <IQueryable <QuestionResponse> >().Setup(m => m.Expression).Returns(data3.Expression);
            mockQuestionR.As <IQueryable <QuestionResponse> >().Setup(m => m.ElementType).Returns(data3.ElementType);
            mockQuestionR.As <IQueryable <QuestionResponse> >().Setup(m => m.GetEnumerator()).Returns(data3.GetEnumerator());

            Score score = new Score {
                Id = 1, CurrentScore = 2, MaxScore = 2, Note = ""
            };
            var data4 = new List <Score> {
                score
            }.AsQueryable();
            var mockScore = new Mock <DbSet <Score> >();

            mockScore.As <IQueryable <Score> >().Setup(m => m.Provider).Returns(data4.Provider);
            mockScore.As <IQueryable <Score> >().Setup(m => m.Expression).Returns(data4.Expression);
            mockScore.As <IQueryable <Score> >().Setup(m => m.ElementType).Returns(data4.ElementType);
            mockScore.As <IQueryable <Score> >().Setup(m => m.GetEnumerator()).Returns(data4.GetEnumerator());

            Test test = new Test {
                Id = 1, Test_Name = "Начално ниво", Questions = questions
            };
            var data5 = new List <Test> {
                test
            }.AsQueryable();
            var mockTest = new Mock <DbSet <Test> >();

            mockTest.As <IQueryable <Test> >().Setup(m => m.Provider).Returns(data5.Provider);
            mockTest.As <IQueryable <Test> >().Setup(m => m.Expression).Returns(data5.Expression);
            mockTest.As <IQueryable <Test> >().Setup(m => m.ElementType).Returns(data5.ElementType);
            mockTest.As <IQueryable <Test> >().Setup(m => m.GetEnumerator()).Returns(data5.GetEnumerator());

            var answerSheet = new AnswerSheet {
                Id = 1, QuestionResponses = questionResponses, Score = score, Test = test, UserId = "1", UserName = "******"
            };
            var data = new List <AnswerSheet> {
                answerSheet
            }.AsQueryable();
            var mockSet = new Mock <DbSet <AnswerSheet> >();

            mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var user = new AspNetUsers {
                Id = "1", UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", EmailConfirmed = false, PasswordHash = "AQAAAAEAACcQAAAAEDRMWdzHFXGRE3SgwHOq8nNPbPlucCQjPRkfK54J9YXxCjg7p2fk6Q1S83UnNINPFw==", SecurityStamp = "M6KU2AJELWWYDCKBRZOJS6TZ4S2O3J3U", ConcurrencyStamp = "93de2d96-9c3f-4c51-8676-4ca10ab68656", PhoneNumber = "NULL", PhoneNumberConfirmed = false, TwoFactorEnabled = false, LockoutEnd = null, LockoutEnabled = true, AccessFailedCount = 0
            };
            var data6 = new List <AspNetUsers> {
                user
            }.AsQueryable();
            var mockUser = new Mock <DbSet <AspNetUsers> >();

            mockSet.As <IQueryable <AspNetUsers> >().Setup(m => m.Provider).Returns(data6.Provider);
            mockSet.As <IQueryable <AspNetUsers> >().Setup(m => m.Expression).Returns(data6.Expression);
            mockSet.As <IQueryable <AspNetUsers> >().Setup(m => m.ElementType).Returns(data6.ElementType);
            mockSet.As <IQueryable <AspNetUsers> >().Setup(m => m.GetEnumerator()).Returns(data6.GetEnumerator());

            var mockContext = new Mock <Brainzzler_DBContext>();

            mockContext.Setup(set => set.AnswerSheet).Returns(mockSet.Object);
            mockContext.Setup(set => set.Answers).Returns(mockAnswer.Object);
            mockContext.Setup(set => set.Questions).Returns(mockQuestion.Object);
            mockContext.Setup(set => set.QuestionResponse).Returns(mockQuestionR.Object);
            mockContext.Setup(set => set.Score).Returns(mockScore.Object);
            mockContext.Setup(set => set.Tests).Returns(mockTest.Object);
            mockContext.Setup(set => set.AspNetUsers).Returns(mockUser.Object);
        }
コード例 #46
0
        public void GetFollowingMessages()
        {
            //Create a "result set" of messages
            var messagesData = new List <Message>
            {
                new Message {
                    Id = 1, UserName = "******", Text = "Message from user 1", TimeStamp = DateTime.Now
                },
                new Message {
                    Id = 2, UserName = "******", Text = "Message from user 2", TimeStamp = DateTime.Now
                },
                new Message {
                    Id = 3, UserName = "******", Text = "Message from user 2", TimeStamp = DateTime.Now
                },
                new Message {
                    Id = 4, UserName = "******", Text = "Message from user 3", TimeStamp = DateTime.Now
                }
            }.AsQueryable();

            //Create a "result set" of users
            var followingUserData = new List <FollowUser>
            {
                new FollowUser {
                    Id = 1, User = "******", UserToFollow = "user 2"
                },
                new FollowUser {
                    Id = 2, User = "******", UserToFollow = "user 3"
                },
                new FollowUser {
                    Id = 3, User = "******", UserToFollow = "user 4"
                },
                new FollowUser {
                    Id = 4, User = "******", UserToFollow = "user 1"
                },
            }.AsQueryable();

            //Using empty constructor for mocking purpose
            var usersDbContextMock = new Mock <UsersDbContext>();

            //Mock the DbSet to interact with
            var mockSetOfMessages   = new Mock <DbSet <Message> >();
            var mockSetOfFollowUser = new Mock <DbSet <FollowUser> >();

            //Mock all methods we are using
            //First follow users
            mockSetOfFollowUser.As <IQueryable <FollowUser> >().Setup(m => m.Provider).Returns(followingUserData.Provider);
            mockSetOfFollowUser.As <IQueryable <FollowUser> >().Setup(m => m.Expression).Returns(followingUserData.Expression);
            //Second messages
            mockSetOfMessages.As <IQueryable <Message> >().Setup(m => m.Provider).Returns(messagesData.Provider);
            mockSetOfMessages.As <IQueryable <Message> >().Setup(m => m.Expression).Returns(messagesData.Expression);

            //Specify when to return it
            usersDbContextMock.Setup(m => m.Messages).Returns(mockSetOfMessages.Object);
            usersDbContextMock.Setup(m => m.Users).Returns(mockSetOfFollowUser.Object);

            //Using empty constructor for mocking purpose
            var applicationDbContextMock = new Mock <ApplicationDbContext>();

            //Mock the logger
            var      logger   = new Mock <ILogger <Messages> >();
            Messages messages = new Messages(
                usersDbContextMock.Object,
                logger.Object);

            //Assert that it was successful
            Assert.True(messages.GetFollowingMessages("user 1").Count() == 2);

            //Verify that we have saved the change
            usersDbContextMock.Verify(m => m.Messages, Times.Once());
            usersDbContextMock.Verify(m => m.Users, Times.Once());
        }
コード例 #47
0
        public ExpedienteBLLTests()
        {
            var lista = new List <Expediente>
            {
                new Expediente()
                {
                    ExpedienteId             = 1,
                    Cuantia                  = 525000,
                    Descripcion              = "Esto es una descripcion",
                    DireccionEjecutado       = "Esto es una direccion",
                    DireccionTituloEjecutivo = "Esto es una direcciond e titulo ejecutivo",
                    EntidadEncargada         = "Entidad encargada es maira",
                    FechaRadicacion          = new DateTime(2017, 03, 19),
                    Identificacion           = "1065824563",
                    NaturalezaObligacion     = "Naturaleza es algo",
                    Nombre = "Maira mindiola",
                    UbicacionExpediente = "Esta en el lote tal",
                },
                new Expediente()
                {
                    ExpedienteId             = 2,
                    Cuantia                  = 525000,
                    Descripcion              = "Esto es una descripcion",
                    DireccionEjecutado       = "Esto es una direccion",
                    DireccionTituloEjecutivo = "Esto es una direcciond e titulo ejecutivo",
                    EntidadEncargada         = "Entidad encargada es maira",
                    FechaRadicacion          = new DateTime(2017, 03, 19),
                    Identificacion           = "1065824563",
                    NaturalezaObligacion     = "Naturaleza es algo",
                    Nombre = "Maira mindiola",
                    UbicacionExpediente = "Esta en el lote tal",
                },
                new Expediente()
                {
                    ExpedienteId             = 3,
                    Cuantia                  = 555000,
                    Descripcion              = "Esto es una descripcion",
                    DireccionEjecutado       = "Esto es una direccion",
                    DireccionTituloEjecutivo = "Esto es una direcciond e titulo ejecutivo",
                    EntidadEncargada         = "Entidad encargada es maira",
                    FechaRadicacion          = new DateTime(2017, 03, 19),
                    Identificacion           = "1065824563",
                    NaturalezaObligacion     = "Naturaleza es algo",
                    Nombre = "Maira mindiola",
                    UbicacionExpediente = "Esta en el lote tal",
                }
            };
            var dbContext = new Mock <ApplicationDbContext>();
            var data      = lista.AsQueryable();

            var mockSet = new Mock <DbSet <Expediente> >();

            mockSet.As <IQueryable <Expediente> >().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As <IQueryable <Expediente> >().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As <IQueryable <Expediente> >().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As <IQueryable <Expediente> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var mockContext = new Mock <ApplicationDbContext>();

            mockContext.Setup(c => c.Expedientes).Returns(mockSet.Object);

            servicio = new ExpedienteBLL(mockContext.Object);
        }
コード例 #48
0
        public void CounterStatusCheck()
        {
            //Für den ServiceProviderMock
            //Muss enthalten sein, damit der Mock nicht überschrieben wird
            IServiceProvider unused = ServiceManager.ServiceProvider;

            //Feld Infos holen
            System.Reflection.FieldInfo instance = typeof(ServiceManager).GetField("_serviceProvider", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);

            //Mocksaufsetzen
            //ServiceProvider
            Mock <IServiceProvider>        mockSingleton        = new Mock <IServiceProvider>();
            Mock <IActivityManager>        activityManagerMock  = new Mock <IActivityManager>();
            Mock <IServiceProvider>        activityProviderMock = new Mock <IServiceProvider>();
            Mock <AbstractStepActivity>    stepActivityMock     = new Mock <AbstractStepActivity>();
            Mock <AbstractRunningActivity> runningActivityMock  = new Mock <AbstractRunningActivity>();
            Mock <IEarablesConnection>     connectionMock       = new Mock <IEarablesConnection>();
            Mock <IPopUpService>           popUpMock            = new Mock <IPopUpService>();

            //ActivityManager
            activityManagerMock.Setup(x => x.ActitvityProvider).Returns(activityProviderMock.Object);
            activityProviderMock.Setup(x => x.GetService(typeof(AbstractRunningActivity))).Returns(runningActivityMock.Object);
            activityProviderMock.Setup(x => x.GetService(typeof(AbstractStepActivity))).Returns(stepActivityMock.Object);

            //IDataBaseConnection
            Mock <IDataBaseConnection> mockDataBase = new Mock <IDataBaseConnection>();
            List <DBEntry>             entries      = new List <DBEntry>();

            mockDataBase.As <IDataBaseConnection>().Setup(x => x.GetMostRecentEntries(1)).Returns(entries);

            DateTime _dt       = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
            DBEntry  _entryNew = new DBEntry(_dt, 10, 0, 0);

            mockDataBase.As <IDataBaseConnection>().Setup(x => x.SaveDBEntry(_entryNew)).Returns(1);

            //ServiceManager
            mockSingleton.Setup(x => x.GetService(typeof(IDataBaseConnection))).Returns(mockDataBase.Object);
            mockSingleton.Setup(x => x.GetService(typeof(IActivityManager))).Returns(activityManagerMock.Object);
            mockSingleton.Setup(x => x.GetService(typeof(IEarablesConnection))).Returns(connectionMock.Object);
            mockSingleton.Setup(x => x.GetService(typeof(IPopUpService))).Returns(popUpMock.Object);

            //Connection
            ScanningPopUpViewModel.IsConnected = true;
            connectionMock.As <IEarablesConnection>().Setup(x => x.StartSampling());

            //ServiceProvider anlegen
            instance.SetValue(null, mockSingleton.Object);

            //Test
            StepModeViewModel viewModel = new StepModeViewModel();

            viewModel.StartActivity();
            Assert.Equal("--:--", viewModel.StepFrequency);
            viewModel.OnActivityDone(this, null);
            viewModel.OnActivityDone(this, null);
            viewModel.OnActivityDone(this, null);
            viewModel.OnRunningDone(this, new RunningEventArgs(true));
            Assert.Equal(3, viewModel.StepCounter);
            Assert.True(viewModel.IsRunning);
            Assert.NotNull(viewModel.StepFrequency);
            Assert.Equal("Du läufst!", viewModel.StatusDisplay);
            viewModel.OnRunningDone(this, new RunningEventArgs(false));
            Assert.False(viewModel.IsRunning);

            viewModel.StopActivity();
            Assert.Equal(3, viewModel.StepCounter);
            viewModel.StartActivity();
            Assert.Equal(0, viewModel.StepCounter);
            Assert.False(viewModel.IsRunning);
        }
コード例 #49
0
        public void UceniciController_Sacuvaj()
        {
            var grad = new List <Grad>()
            {
                new Grad {
                    Id = 1, Naziv = "Beograd"
                },
                new Grad {
                    Id = 2, Naziv = "Novi Sad"
                }
            }.AsQueryable();

            var smer = new List <Smer>()
            {
                new Smer {
                    SmerID = 1, NazivSmera = "Mesar", Trajanje = 3
                },
                new Smer {
                    SmerID = 2, NazivSmera = "Tehnicar", Trajanje = 6
                }
            }.AsQueryable();

            Ucenik uce = new Ucenik()
            {
                Adresa = "Adresa1",
                BrojTelefonaRoditelja = "064111222",
                DatumRodjenja         = DateTime.Now,
                Ime               = "Firas",
                Prezime           = "Aburas",
                ImeMajke          = "Mama",
                PrezimeMajke      = "PrezimeMame",
                ImeOca            = "Tata",
                PrezimeOca        = "PrezimeTate",
                JedinstveniBroj   = "1",
                JMBG              = "1234567891012",
                MestoPrebivalista = "Beograd",
                MestoRodjenja     = new Grad(),
                MestoRodjenjaId   = 1,
                Odeljenje         = new Odeljenje(),
                OdeljenjeId       = 1,
                Razred            = 1,
                Smer              = new Smer(),
                SmerID            = 1,
                UcenikID          = 1,
                Vanredan          = false
            };


            var ucenik = new UcenikViewModel()
            {
                Ucenik  = uce,
                Gradovi = grad,
                Smerovi = smer
            };

            var mockSetGradovi = new Mock <DbSet <Grad> >();

            mockSetGradovi.As <IQueryable <Grad> >().Setup(m => m.Provider).Returns(grad.Provider);
            mockSetGradovi.As <IQueryable <Grad> >().Setup(m => m.Expression).Returns(grad.Expression);
            mockSetGradovi.As <IQueryable <Grad> >().Setup(m => m.ElementType).Returns(grad.ElementType);
            mockSetGradovi.As <IQueryable <Grad> >().Setup(m => m.GetEnumerator()).Returns(grad.GetEnumerator());

            var mockSetSmerovi = new Mock <DbSet <Smer> >();

            mockSetSmerovi.As <IQueryable <Smer> >().Setup(m => m.Provider).Returns(smer.Provider);
            mockSetSmerovi.As <IQueryable <Smer> >().Setup(m => m.Expression).Returns(smer.Expression);
            mockSetSmerovi.As <IQueryable <Smer> >().Setup(m => m.ElementType).Returns(smer.ElementType);
            mockSetSmerovi.As <IQueryable <Smer> >().Setup(m => m.GetEnumerator()).Returns(smer.GetEnumerator());



            var mockSet     = new Mock <DbSet <Ucenik> >();
            var mockContext = new Mock <ApplicationDbContext>();

            mockContext.Setup(p => p.Ucenici).Returns(mockSet.Object);

            var services = new UceniciController(mockContext.Object);

            //services.Sacuvaj(ucenik);

            mockSet.Verify(p => p.Add(It.IsAny <Ucenik>()), Times.Once());
            mockContext.Verify(p => p.SaveChanges(), Times.Once());
        }
コード例 #50
0
 public void BeforeEach()
 {
     _webElementMock   = new Mock <IWebElement>();
     _findsByXPathMock = _webElementMock.As <IFindsByXPath>();
 }
コード例 #51
0
    public async Task TestBlockedOperationCancel()
    {
        var copyOperation = new Mock <IInternalOperation>();

        copyOperation
        .SetupGet(m => m.State)
        .Returns(OperationState.Blocked);
        var blockedOperation = copyOperation.As <ISelfBlockingOperation>();

        blockedOperation
        .Setup(m => m.CurrentBlockedFile)
        .Returns((SourceName, DestinationName));
        copyOperation
        .Setup(m => m.RunAsync(It.IsAny <CancellationToken>()))
        .Callback(() =>
        {
            copyOperation.Raise(m => m.StateChanged += null,
                                new OperationStateChangedEventArgs(OperationState.Blocked));
        });
        IReadOnlyList <OperationGroup> operationGroups = new List <OperationGroup>
        {
            new OperationGroup(
                new[] { copyOperation.Object })
        };

        _autoMocker.Use(operationGroups);
        var settings = new BinaryFileSystemOperationSettings(
            new string[] { },
            new[] { SourceName },
            new string[] { },
            new[] { DestinationName },
            new Dictionary <string, string> {
            [SourceName] = DestinationName
        },
            new string[] { }
            );

        _autoMocker.Use(new OperationInfo(OperationType.Copy, settings));

        var operation            = _autoMocker.CreateInstance <CompositeOperation>();
        var taskCompletionSource = new TaskCompletionSource <bool>();

        operation.Blocked += async(sender, args) =>
        {
            if (operation.CurrentBlockedFile == (SourceName, DestinationName))
            {
                await operation.CancelAsync();

                taskCompletionSource.SetResult(true);
            }
        };

        await operation.RunAsync();

        var task = await Task.WhenAny(Task.Delay(500), taskCompletionSource.Task);

        if (task != taskCompletionSource.Task)
        {
            taskCompletionSource.SetResult(false);
        }

        var result = await taskCompletionSource.Task;

        Assert.True(result);
    }
}
コード例 #52
0
        public void Setup()
        {
            _dbContextFacade = new Mock <IDBContextFacade>(MockBehavior.Loose);
            _dataConverter   = new Mock <IDataConverter>(MockBehavior.Strict);
            _postFactory     = new Mock <IPostFactory>(MockBehavior.Strict);

            _databaseImitation = new Mock <ApplicationDbContext>(MockBehavior.Loose);
            _dbsetMockPost     = new Mock <DbSet <Post> >(MockBehavior.Strict);
            _dbsetMockUser     = new Mock <DbSet <ApplicationUser> >(MockBehavior.Strict);
            _dbsetMockComment  = new Mock <DbSet <Comment> >(MockBehavior.Strict);
            _dbsetMockLike     = new Mock <DbSet <Like> >(MockBehavior.Strict);
            _dbsetMockReport   = new Mock <DbSet <Report> >(MockBehavior.Strict);

            User = new ApplicationUser()
            {
                Id        = "randomId",
                UserPosts = new List <Post>()
            };

            post1 = new Post()
            {
                Id       = 0,
                Author   = "Shrekko",
                AuthorId = "randomId",
                Title    = "MockPost",
                Content  = "RandomContent",
                SubTitle = "Shrej",
                User     = User,
                Likes    = new List <Like>()
            };

            post2 = new Post()
            {
                Id       = 1,
                Author   = "Shrekkoko",
                AuthorId = "randomId2",
                Title    = "MockPost2",
                Content  = "RandomContent2",
                SubTitle = "rORKA",
                User     = User,
                Likes    = new List <Like>()
            };

            postList = new List <Post>();
            postList.Add(post1);
            postList.Add(post2);

            comment1 = new Comment()
            {
                Id       = 1,
                Author   = "Shrekko",
                AuthorId = "randomId1",
                Content  = "RandomContent1",
                User     = User,
                Post     = post1,
                Reports  = new List <Report>()
            };

            comment2 = new Comment()
            {
                Id       = 2,
                Author   = "Shrekkoko",
                AuthorId = "randomId2",
                Content  = "RandomContent2",
                User     = User,
                Post     = post2,
                Reports  = new List <Report>()
            };

            positiveLike = new Like()
            {
                Id         = 1,
                RatingType = RatingType.Positive,
                User       = User,
                UserID     = User.Id
            };
            negativeLike = new Like()
            {
                Id         = 2,
                RatingType = RatingType.Negative,
                User       = User,
                UserID     = User.Id
            };

            likeList = new List <Like>();
            likeList.Add(positiveLike);
            likeList.Add(negativeLike);

            report1 = new Report()
            {
                Id         = 1,
                Comment    = comment1,
                ReportText = "UMMAYAD",
                SenderName = User.UserName,
                CommentId  = comment1.Id
            };

            report2 = new Report()
            {
                Id         = 2,
                Comment    = comment2,
                ReportText = "BAD comment, indeed aga",
                SenderName = User.UserName,
                CommentId  = comment2.Id
            };

            reportList = new List <Report>();
            reportList.Add(report1);
            reportList.Add(report2);

            userList = new List <ApplicationUser>();
            userList.Add(User);

            commentList = new List <Comment>();
            commentList.Add(comment1);
            commentList.Add(comment2);

            User.UserPosts = postList;
            _dbContextFacade.Setup(x => x.GetDBContext()).Returns(_databaseImitation.Object);
            _databaseImitation.Setup(x => x.Set <Post>()).Returns(_dbsetMockPost.Object);

            _dbsetMockPost.As <IQueryable <Post> >().Setup(m => m.Provider).Returns(postList.AsQueryable().Provider);
            _dbsetMockPost.As <IQueryable <Post> >().Setup(m => m.Expression).Returns(postList.AsQueryable().Expression);
            _dbsetMockPost.As <IQueryable <Post> >().Setup(m => m.ElementType).Returns(postList.AsQueryable().ElementType);
            _dbsetMockPost.As <IQueryable <Post> >().Setup(m => m.GetEnumerator()).Returns(postList.AsQueryable().GetEnumerator());
            _dbsetMockPost.As <IEnumerable <Post> >().Setup(m => m.GetEnumerator()).Returns(postList.AsQueryable().GetEnumerator());

            _dbsetMockComment.As <IQueryable <Comment> >().Setup(m => m.Provider).Returns(commentList.AsQueryable().Provider);
            _dbsetMockComment.As <IQueryable <Comment> >().Setup(m => m.Expression).Returns(commentList.AsQueryable().Expression);
            _dbsetMockComment.As <IQueryable <Comment> >().Setup(m => m.ElementType).Returns(commentList.AsQueryable().ElementType);
            _dbsetMockComment.As <IQueryable <Comment> >().Setup(m => m.GetEnumerator()).Returns(commentList.AsQueryable().GetEnumerator());
            _dbsetMockComment.As <IEnumerable <Comment> >().Setup(m => m.GetEnumerator()).Returns(commentList.AsQueryable().GetEnumerator());

            _dbsetMockReport.As <IQueryable <Report> >().Setup(m => m.Provider).Returns(reportList.AsQueryable().Provider);
            _dbsetMockReport.As <IQueryable <Report> >().Setup(m => m.Expression).Returns(reportList.AsQueryable().Expression);
            _dbsetMockReport.As <IQueryable <Report> >().Setup(m => m.ElementType).Returns(reportList.AsQueryable().ElementType);
            _dbsetMockReport.As <IQueryable <Report> >().Setup(m => m.GetEnumerator()).Returns(reportList.AsQueryable().GetEnumerator());
            _dbsetMockReport.As <IEnumerable <Report> >().Setup(m => m.GetEnumerator()).Returns(reportList.AsQueryable().GetEnumerator());

            _dbsetMockLike.As <IQueryable <Like> >().Setup(m => m.Provider).Returns(likeList.AsQueryable().Provider);
            _dbsetMockLike.As <IQueryable <Like> >().Setup(m => m.Expression).Returns(likeList.AsQueryable().Expression);
            _dbsetMockLike.As <IQueryable <Like> >().Setup(m => m.ElementType).Returns(likeList.AsQueryable().ElementType);
            _dbsetMockLike.As <IQueryable <Like> >().Setup(m => m.GetEnumerator()).Returns(likeList.AsQueryable().GetEnumerator());
            _dbsetMockLike.As <IEnumerable <Like> >().Setup(m => m.GetEnumerator()).Returns(likeList.AsQueryable().GetEnumerator());

            _dbsetMockUser.As <IQueryable <ApplicationUser> >().Setup(m => m.Provider).Returns(userList.AsQueryable().Provider);
            _dbsetMockUser.As <IQueryable <ApplicationUser> >().Setup(m => m.Expression).Returns(userList.AsQueryable().Expression);
            _dbsetMockUser.As <IQueryable <ApplicationUser> >().Setup(m => m.ElementType).Returns(userList.AsQueryable().ElementType);
            _dbsetMockUser.As <IQueryable <ApplicationUser> >().Setup(m => m.GetEnumerator()).Returns(userList.AsQueryable().GetEnumerator());
            _dbsetMockUser.As <IEnumerable <ApplicationUser> >().Setup(m => m.GetEnumerator()).Returns(userList.AsQueryable().GetEnumerator());

            _dbsetMockPost.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => postList.AsQueryable().FirstOrDefault(d => d.Id == (int)ids[0]));
            _dbsetMockComment.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => commentList.AsQueryable().FirstOrDefault(d => d.Id == (int)ids[0]));
            _dbsetMockReport.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => reportList.AsQueryable().FirstOrDefault(d => d.Id == (int)ids[0]));

            _dbsetMockLike.Setup(x => x.Remove(negativeLike)).Callback <Like>((entity) => likeList.Remove(entity));
            _dbsetMockLike.Setup(x => x.Remove(positiveLike)).Callback <Like>((entity) => likeList.Remove(entity));

            _dbsetMockPost.Setup(m => m.Remove(It.IsAny <Post>())).Callback <Post>((entity) => postList.Remove(entity));

            _databaseImitation.Setup(x => x.Posts.Remove(It.IsAny <Post>())).Callback <Post>((entity) => postList.Remove(entity));

            _databaseImitation.Setup(x => x.Posts).Returns(_dbsetMockPost.Object);
            _databaseImitation.Setup(x => x.Users).Returns(_dbsetMockUser.Object);
            _databaseImitation.Setup(x => x.Comments).Returns(_dbsetMockComment.Object);
            _databaseImitation.Setup(x => x.PostLikes).Returns(_dbsetMockLike.Object);
            _databaseImitation.Setup(x => x.Reports).Returns(_dbsetMockReport.Object);

            _postFactory.Setup(x => x.CreateLike(It.IsAny <int>(), It.IsAny <string>(), RatingType.Positive)).Returns(positiveLike);
            _postFactory.Setup(x => x.CreateLike(It.IsAny <int>(), It.IsAny <string>(), RatingType.Negative))
            .Returns(negativeLike);

            _databaseImitation.Setup(x => x.PostLikes.Remove(negativeLike)).Callback <Like>((entity) => likeList.Remove(entity));
            _databaseImitation.Setup(x => x.PostLikes.Remove(positiveLike)).Callback <Like>((entity) => likeList.Remove(entity));

            _databaseImitation.Setup(x => x.SaveChanges());
            _blogRepository = new BlogRepository(_dbContextFacade.Object, _dataConverter.Object, _postFactory.Object);
        }
コード例 #53
0
        public void GetAllTasks_MockDbSetTasksAndContext_AndGetAllUserTask()
        {
            //assign
            MiniAutoFixture miniAutoFixture = new MiniAutoFixture();

            miniAutoFixture.Initialize();

            User        userSpecified   = DbSetTools.CreateUser(1, miniAutoFixture);
            User        user2           = DbSetTools.CreateUser(2, miniAutoFixture);
            User        user3           = DbSetTools.CreateUser(3, miniAutoFixture);
            List <Task> tasksCollection = DbSetTools.CreateTaskList(1, userSpecified, 20, miniAutoFixture)
                                          .Concat(DbSetTools.CreateTaskList(21, user2, 10, miniAutoFixture))
                                          .Concat(DbSetTools.CreateTaskList(31, user3, 10, miniAutoFixture))
                                          .ToList();

            IQueryable <Task> tasks = tasksCollection.AsQueryable();
            List <User>       userCollection = new User[] { userSpecified, user2, user3 }.ToList();
            IQueryable <User> users = userCollection.AsQueryable();

            var mockDbSetUser = new Mock <DbSet <User> >();
            var mockDbSetTask = new Mock <DbSet <Task> >();

            mockDbSetUser.As <IQueryable <User> >().Setup(m => m.Provider).Returns(users.Provider);
            mockDbSetUser.As <IQueryable <User> >().Setup(m => m.Expression).Returns(users.Expression);
            mockDbSetUser.As <IQueryable <User> >().Setup(m => m.ElementType).Returns(users.ElementType);
            mockDbSetUser.As <IQueryable <User> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

            mockDbSetTask.As <IQueryable <Task> >().Setup(m => m.Provider).Returns(tasks.Provider);
            mockDbSetTask.As <IQueryable <Task> >().Setup(m => m.Expression).Returns(tasks.Expression);
            mockDbSetTask.As <IQueryable <Task> >().Setup(m => m.ElementType).Returns(tasks.ElementType);
            mockDbSetTask.As <IQueryable <Task> >().Setup(m => m.GetEnumerator()).Returns(tasks.GetEnumerator());

            var mockContext = new Mock <OrganizerContext>();

            mockContext.Setup(c => c.User).Returns(mockDbSetUser.Object);
            mockContext.Setup(c => c.Tasks).Returns(mockDbSetTask.Object);
            var            logger         = new Mock <ILogger <ViewRepository> >();
            ViewRepository viewRepository = new ViewRepository(mockContext.Object, logger.Object);

            //action
            IEnumerable <TaskView> taskList = viewRepository.GetAllUserTask(userSpecified.Id);

            //assign
            IEnumerable <Task> tasksUser = tasks.Where(a => a.User.Id == userSpecified.Id);

            Assert.Equal(tasksUser.Count(), taskList.Count());
            tasksUser.ToList().ForEach(task =>
            {
                Assert.Equal
                (
                    taskList.Count
                    (
                        taskView =>
                        taskView.Id == task.Id &&
                        taskView.Text == task.Text &&
                        taskView.Date == task.Date &&
                        taskView.Deleted == task.Deleted &&
                        taskView.Done == task.Done
                    ),
                    1
                );
            }
                                       );
        }
コード例 #54
0
        public void Ctor_Object_String_IBindingList(string dataMember)
        {
            PropertyDescriptor sortProperty = TypeDescriptor.GetProperties(typeof(DataClass))[0];
            var syncRoot = new object();
            var mockList = new Mock <IBindingList>(MockBehavior.Strict);

            mockList
            .Setup(p => p.Count)
            .Returns(0);
            mockList
            .Setup(p => p.AllowEdit)
            .Returns(false);
            mockList
            .Setup(p => p.AllowNew)
            .Returns(false);
            mockList
            .Setup(p => p.AllowRemove)
            .Returns(false);
            mockList
            .Setup(p => p.GetEnumerator())
            .Returns(new List <int>().GetEnumerator());
            mockList
            .Setup(p => p.IsFixedSize)
            .Returns(false);
            mockList
            .Setup(p => p.IsReadOnly)
            .Returns(false);
            mockList
            .Setup(p => p.IsSynchronized)
            .Returns(false);
            mockList
            .Setup(p => p.IsSorted)
            .Returns(true);
            mockList
            .Setup(p => p.SortDirection)
            .Returns(ListSortDirection.Descending);
            mockList
            .Setup(p => p.SortProperty)
            .Returns(sortProperty);
            mockList
            .Setup(p => p.SupportsChangeNotification)
            .Returns(false);
            mockList
            .Setup(p => p.SupportsSearching)
            .Returns(true);
            mockList
            .Setup(p => p.SupportsSorting)
            .Returns(true);
            mockList
            .Setup(p => p.SyncRoot)
            .Returns(syncRoot);

            var sortDescriptions = new ListSortDescriptionCollection();
            var mockListView     = mockList.As <IBindingListView>();

            mockListView
            .Setup(p => p.SortDescriptions)
            .Returns(sortDescriptions);
            mockListView
            .Setup(p => p.SupportsAdvancedSorting)
            .Returns(true);
            mockListView
            .Setup(p => p.SupportsFiltering)
            .Returns(true);

            var source = new SubBindingSource(mockList.Object, dataMember);

            Assert.False(source.AllowEdit);
            Assert.False(source.AllowNew);
            Assert.False(source.AllowRemove);
            Assert.True(source.CanRaiseEvents);
            Assert.Null(source.Container);
            Assert.Empty(source);
            Assert.Equal(0, source.CurrencyManager.Count);
            Assert.Empty(source.CurrencyManager.Bindings);
            Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
            Assert.Throws <IndexOutOfRangeException>(() => source.CurrencyManager.Current);
            Assert.True(source.CurrencyManager.IsBindingSuspended);
            Assert.Same(source, source.CurrencyManager.List);
            Assert.Equal(-1, source.CurrencyManager.Position);
            Assert.Same(source.CurrencyManager, source.CurrencyManager);
            Assert.Null(source.Current);
            Assert.Same(dataMember, source.DataMember);
            Assert.Same(mockList.Object, source.DataSource);
            Assert.False(source.DesignMode);
            Assert.NotNull(source.Events);
            Assert.Same(source.Events, source.Events);
            Assert.Null(source.Filter);
            Assert.True(source.IsBindingSuspended);
            Assert.False(source.IsFixedSize);
            Assert.False(source.IsReadOnly);
            Assert.True(source.IsSorted);
            Assert.False(source.IsSynchronized);
            Assert.Same(mockList.Object, source.List);
            Assert.True(source.RaiseListChangedEvents);
            Assert.Null(source.Site);
            Assert.Null(source.Sort);
            Assert.Same(sortDescriptions, source.SortDescriptions);
            Assert.Equal(ListSortDirection.Descending, source.SortDirection);
            Assert.Same(sortProperty, source.SortProperty);
            Assert.True(source.SupportsAdvancedSorting);
            Assert.True(source.SupportsChangeNotification);
            Assert.True(source.SupportsFiltering);
            Assert.True(source.SupportsSearching);
            Assert.True(source.SupportsSorting);
            Assert.Same(syncRoot, source.SyncRoot);
        }
コード例 #55
0
        private static Mock <DbSet <T> > CreateDbSetMock <T>(IQueryable <T> items) where T : class
        {
            var dbSetMock = new Mock <DbSet <T> >();

            dbSetMock.As <IAsyncEnumerable <T> >()
            .Setup(x => x.GetAsyncEnumerator(default))
コード例 #56
0
ファイル: EmployeeServiceTest.cs プロジェクト: zainzia/OCAS
        public void TestGetEmployee_ValidInput()
        {
            //Setup the required properties
            var rand       = new Random();
            var employeeId = rand.Next(1000);

            var firstName    = "Test E";
            var lastName     = "Test E2";
            var emailAddress = "*****@*****.**";

            var employeeDTO = Mock.Of <EmployeeDTO>(e => e.EmailAddress == emailAddress &&
                                                    e.FirstName == firstName &&
                                                    e.LastName == lastName &&
                                                    e.Id == employeeId);

            var employees = new List <Employee>
            {
                new Employee {
                    FirstName = "Test A", LastName = "Test A2", EmailAddress = "*****@*****.**", Id = rand.Next(1000)
                },
                new Employee {
                    FirstName = "Test B", LastName = "Test B2", EmailAddress = "*****@*****.**", Id = rand.Next(1000)
                },
                new Employee {
                    FirstName = "Test C", LastName = "Test C2", EmailAddress = "*****@*****.**", Id = rand.Next(1000)
                },
                new Employee {
                    FirstName = "Test D", LastName = "Test D2", EmailAddress = "*****@*****.**", Id = rand.Next(1000)
                },
                new Employee {
                    FirstName = firstName, LastName = lastName, EmailAddress = emailAddress, Id = employeeId
                }
            }.AsQueryable();

            //Setup the Mock DbSet and its properties
            var employeeDbSetMock = new Mock <DbSet <Employee> >();

            employeeDbSetMock.As <IQueryable <Employee> >().Setup(m => m.Provider).Returns(employees.Provider);
            employeeDbSetMock.As <IQueryable <Employee> >().Setup(m => m.Expression).Returns(employees.Expression);
            employeeDbSetMock.As <IQueryable <Employee> >().Setup(m => m.ElementType).Returns(employees.ElementType);
            employeeDbSetMock.As <IQueryable <Employee> >().Setup(m => m.GetEnumerator()).Returns(employees.GetEnumerator());

            //Setup the Employees field for the _dbContextMock
            _dbContextMock.Setup(m => m.Employees).Returns(employeeDbSetMock.Object);

            //Setup the Mock for the
            _autoMapperMock.Setup(m => m.Map <EmployeeDTO>(It.IsNotNull <Employee>())).Returns(employeeDTO);

            //Call the method to test => GetEmployee()
            var employee = _employeeService.GetEmployee(employeeId);

            //Verify _dbContextMock method calls
            _dbContextMock.Verify(x => x.Employees, Times.Once);

            //Verify _autoMapperMock method calls
            _autoMapperMock.Verify(x => x.Map <EmployeeDTO>(It.IsAny <Employee>()), Times.Once);

            //Test the Returned Object
            Assert.IsNotNull(employee);
            Assert.AreEqual(employeeId, employee.Id);
            Assert.AreEqual(firstName, employee.FirstName);
            Assert.AreEqual(lastName, employee.LastName);
            Assert.AreEqual(emailAddress, employee.EmailAddress);
        }
コード例 #57
0
        public static Solution Create()
        {
            var mock = new Mock <Solution2>();

            return(mock.As <Solution>().Object);
        }
コード例 #58
0
        private void TestBadAsForNonAbstractClass()
        {
            var mock = new Mock <BaseSampleClass>();

            mock.As <OtherClass>();
        }
コード例 #59
0
        public void SearchFollowersNoUserFoundTest()
        {
            var appSettingsClass = new AppSettings()
            {
                Secret = "1xNQ0brDZ6TwznGi9p58WRI2gfLJXcvq"
            };

            IOptions <AppSettings> appSettings = Options.Create(appSettingsClass);

            var data = new List <UserModel>
            {
                new UserModel()
                {
                    Id = 1, Token = "aa", Username = "******", Password = "******", Email = "@gmail"
                }.HashPassword(),
                new UserModel()
                {
                    Id = 2, Token = "aaa", Username = "******", Password = "******", Email = "2@gmail"
                }.HashPassword()
            }.AsQueryable();

            var mockSet = new Mock <DbSet <UserModel> >();

            mockSet.As <IQueryable <UserModel> >().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As <IQueryable <UserModel> >().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As <IQueryable <UserModel> >().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As <IQueryable <UserModel> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

            var followerData = new List <FollowerModel>
            {
                new FollowerModel()
                {
                    FollowedId = 2, FollowerId = 1, Id = 1
                }
            }.AsQueryable();

            var followerMockSet = new Mock <DbSet <FollowerModel> >();

            followerMockSet.As <IQueryable <FollowerModel> >().Setup(m => m.Provider).Returns(followerData.Provider);
            followerMockSet.As <IQueryable <FollowerModel> >().Setup(m => m.Expression).Returns(followerData.Expression);
            followerMockSet.As <IQueryable <FollowerModel> >().Setup(m => m.ElementType).Returns(followerData.ElementType);
            followerMockSet.As <IQueryable <FollowerModel> >().Setup(m => m.GetEnumerator()).Returns(followerData.GetEnumerator());

            var options = new DbContextOptionsBuilder <MyDbContext>()
                          .Options;

            var mockContext = new Mock <MyDbContext>(options);

            mockContext.Setup(x => x.Users).Returns(mockSet.Object);
            mockContext.Setup(x => x.Followers).Returns(followerMockSet.Object);

            mockContext.SetupProperty(x => x.Trips);
            mockContext.SetupProperty(x => x.PinPoints);

            var userService = new UserService(appSettings, mockContext.Object);

            var service = new AccountController(mockContext.Object, userService);

            var result = service.SearchFollowers("BB");

            Assert.AreEqual(result.Result.Value, null);
        }
コード例 #60
0
        private void TestOkAsForInterface()
        {
            var mock = new Mock <BaseSampleClass>();

            mock.As <ISampleInterface>();
        }