public void PagingOptions_Apply_Return_Requested_Page_With_Multiple_Sort()
        {
            var contacts = new List<Contact>();
            for (int i = 1; i <= 5; i++)
            {
                contacts.Add(new Contact { Name = "Test User " + (i % 2), ContactTypeId = i});
            }

            const int resultingPage = 2;
            const int pageSize = 2;

            var qo = new PagingOptions<Contact>(resultingPage, pageSize, "Name", isDescending: true);
            qo.ThenSortBy("ContactTypeId", isDescending: true);

            IQueryable<Contact> queryable = qo.Apply(contacts.AsQueryable());
            queryable.Count().ShouldEqual(2);

            var contact = queryable.First();
            contact.Name.ShouldEqual("Test User 1");
            contact.ContactTypeId.ShouldEqual(1);

            var qo2 = new PagingOptions<Contact, string>(resultingPage, pageSize, x => x.Name, isDescending: true);
            qo2.ThenSortBy(x => x.ContactTypeId, isDescending: true);

            queryable = qo2.Apply(contacts.AsQueryable());
            queryable.Count().ShouldEqual(2);

            contact = queryable.First();
            contact.Name.ShouldEqual("Test User 1");
            contact.ContactTypeId.ShouldEqual(1);
        }
        public override void SetUp()
        {
            base.SetUp();

            expectedGamingGroup = new GamingGroup
            {
                Id = gamingGroupId, 
                OwningUserId = CurrentUser.Id
            };

            filter = new GamingGroupFilter
            {
                GamingGroupId = gamingGroupId
            };

            AutoMocker.Get<IDataContext>().Expect(mock => mock.FindById<GamingGroup>(gamingGroupId))
                .Return(expectedGamingGroup);

            gameDefinitionSummaries = new List<GameDefinitionSummary>
            {
                new GameDefinitionSummary()
            };

            AutoMocker.Get<IGameDefinitionRetriever>().Expect(mock => mock.GetAllGameDefinitions(gamingGroupId, filter.DateRangeFilter))
                                       .Return(gameDefinitionSummaries);

            List<ApplicationUser> applicationUsers = new List<ApplicationUser>();
            applicationUsers.Add(CurrentUser);

            AutoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<ApplicationUser>())
                .Return(applicationUsers.AsQueryable());

            AutoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<ApplicationUser>())
                .Return(applicationUsers.AsQueryable());
        }
        public async void should_query_if_query_string_is_empty()
        {
            // Arrange
            const string key = "test";
            var userList = new List<User> { new User { Email = "*****@*****.**", FullName = "test" } };

            var userRepository = new Mock<IRepository<User>>();
            userRepository.Setup(x => x.FindAll(It.IsAny<Expression<Func<User, bool>>>()))
                          .Returns(userList.AsQueryable());

            userRepository.Setup(x => x.AsQueryable(userList.AsQueryable(), It.IsAny<Expression<Func<User, bool>>>()))
                          .Returns(userList.AsQueryable());

            // Act
            var sut = new SearchServiceBuilder().WithUserRespository(userRepository.Object)
                                                .Build();

            var nullTask = await sut.Query(string.Empty);
            var notNullResult = await sut.Query(key); 

            // Assert
            Assert.IsNull(nullTask);
            Assert.NotNull(notNullResult);
            Assert.IsInstanceOf(typeof(ISearchService), sut);
             
            userRepository.Verify(x => x.FindAll(It.IsAny<Expression<Func<User, bool>>>()), Times.AtLeastOnce);
        }
        public void Init()
        {
            AutoMapperConfiguration.Configure();
            var mockSiteRepository = new Mock<ISiteRepository>();
            var items = new List<Hatfield.EnviroData.Core.Site> { 
                            new Hatfield.EnviroData.Core.Site{
                                SiteTypeCV = "Stream",
                                Latitude = 49.2827,
                                Longitude = 123.1207,
                                SpatialReferenceID = 1
                            },
                            new Hatfield.EnviroData.Core.Site{
                                SiteTypeCV = "Stream",
                                Latitude = 49.2827,
                                Longitude = 123.1207,
                                SpatialReferenceID = 1
                            }};
            mockSiteRepository.Setup(x => x.GetAll())
                          .Returns(items.AsQueryable());

            var mockActionRepository = new Mock<IWQDataRepository>();
            var actions = new List<Hatfield.EnviroData.Core.Action> { 
             new Hatfield.EnviroData.Core.Action{
                                ActionID = 2,
                                BeginDateTime = new DateTime(2015, 2, 2)
                            },
                            new Hatfield.EnviroData.Core.Action{
                                ActionID = 3,
                                BeginDateTime = new DateTime(2015, 2, 3)
                            }               
            };
            mockSiteRepository.Setup(x => x.GetAll())
                          .Returns(items.AsQueryable());

            var mockVariableRepository = new Mock<IWQVariableRepository>();
            var variables = new List<Hatfield.EnviroData.Core.Variable> { 
                            new Hatfield.EnviroData.Core.Variable{
                                VariableTypeCV = "Chemistry",
                                VariableCode = "108-88-3",
                                VariableNameCV = "1,1,1-Trichloroethane",
                                VariableDefinition = "",
                                NoDataValue = -9999,
                            },
                            new Hatfield.EnviroData.Core.Variable{
                                VariableTypeCV = "Chemistry",
                                VariableCode = "528-78-3",
                                VariableNameCV = "1,1,1-Trichloroethane",
                                VariableDefinition = "",
                                NoDataValue = -9999,
                            }};
            mockVariableRepository.Setup(x => x.GetAllChemistryVariables())
                          .Returns(variables.AsQueryable());

            var mockDefaultValueProvider = new Mock<IWQDefaultValueProvider>();

            this.controller = new StationQueryAPIController(mockDefaultValueProvider.Object, mockSiteRepository.Object, mockVariableRepository.Object, mockActionRepository.Object);
        }
Esempio n. 5
0
        public void TheWidgetShouldBeReturned()
        {
            //Arrange
            List<DomainWidget> values = new List<DomainWidget>
            {
                new DomainWidget
                {
                    Name = "Test Widget",
                    Description = "A test widget",
                    Manufacturer = "Radix2"
                },
                new DomainWidget
                {
                    Name = "Second Widget",
                    Description = "A second widget",
                    Manufacturer = "Radix2"
                }

            };
            IQueryable<DomainWidget> valuesQueryable = values.AsQueryable();

            var mockRepository = new Mock<IRepository>();
            mockRepository
                .Setup(x => x.All<DomainWidget>(It.IsAny<String[]>()))
                .Returns(()=> valuesQueryable);

            var widgetService = new WidgetService(mockRepository.Object);

            //Act
            var widgets = widgetService.Get();

            //Assert
            Assert.IsInstanceOf<List<DomainWidget>>(widgets);
        }
        public void BuildsAListOfNameValueObjectsBasedOnOrigins()
        {
            var viewDataDictionary = new ViewDataDictionary();
            var order = new Order();
            
            var origins = new List<string>
            {
                "Test Origin 1",
                "Test Origin 2"
            };

            Mock.Arrange(() => _mockOriginRepository.GetAllOrigins()).Returns(origins.AsQueryable()).OccursOnce();
            Mock.Arrange(() => _mockDestinationRepository.GetAllDestinations()).Returns(new string[0].AsQueryable());

            var builder = new OrderViewDataBuilder(_mockOriginRepository, _mockDestinationRepository, _mockPackageTypeSelectListBuilder);

            builder.BuildViewData(viewDataDictionary, order);

            Mock.AssertAll(_mockOriginRepository);
            var result = viewDataDictionary["Origins"];
            Assert.IsNotNull(result);
            var resultList = ((IEnumerable<dynamic>) result).ToList();
            Assert.AreEqual(2, resultList.Count());

            Assert.AreEqual("Test Origin 1", resultList[0].Name);
            Assert.AreEqual("Test Origin 1", resultList[0].Value);
            
            Assert.AreEqual("Test Origin 2", resultList[1].Name);
            Assert.AreEqual("Test Origin 2", resultList[1].Value);
        }
		private IQueryable<User> MockedGetAll()
		{
			List<User> users = new List<User>();
			users.Add(new User(Guid.NewGuid(), "komil.patel", "*****@*****.**", "Komil", "Patel", false, true));
			users.Add(new User(Guid.NewGuid(), "nikki.patel", "*****@*****.**", "Nikki", "Patel", false, true));
			return users.AsQueryable();
		}
        public void Given_a_consultant_all_checklists_that_are_visited_by_consultant_are_returned()
        {
            //given
            var consultantToFind = "Mr H&S";
            var expectedIdOfFoundChecklist = Guid.NewGuid();
            var checklists = new List<Checklist>
                                 {
                                     new Checklist() {ClientId = 14145135, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                     , new Checklist() {Id= expectedIdOfFoundChecklist, ClientId = 14145135, VisitBy = consultantToFind, ChecklistCreatedBy = consultantToFind, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                     , new Checklist() {ClientId = 23452435, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                 };

           
            _queryableWrapper.Setup(x => x.Queryable())
                .Returns(() => checklists.AsQueryable());


            var target = new GetChecklistsQuery(_queryableWrapper.Object);

            //when
            var result = target.WithConsultantName(consultantToFind)
                .Execute();

            //then
            Assert.That(result.Count, Is.EqualTo(1));
            Assert.That(result.First().Id, Is.EqualTo(expectedIdOfFoundChecklist));
        }
        public void UnsuccessfulMatchReturnsNotFound()
        {
            // Arrange
            var validatorFactory = new Mock<IValidatorEngine>();
            var mappingEngine = new Mock<IMappingEngine>();
            var repository = new Mock<IRepository>();
            var searchCache = new Mock<ISearchCache>();
            var service = new PersonService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);

            var list = new List<PersonMapping>();
            repository.Setup(x => x.Queryable<PersonMapping>()).Returns(list.AsQueryable());

            var message = new GetRequest
            {
                EntityId = 0,
            };

            // Act
            var contract = service.Request(message);

            // Assert
            Assert.IsNotNull(contract, "Contract null");
            Assert.IsFalse(contract.IsValid, "Contract valid");
            Assert.AreEqual(ErrorType.NotFound, contract.Error.Type, "ErrorType difers");
        }
        public void Queryable_FirstOne_Should_Return_First_Item()
        {
            var list = new List<string> { "First", "Second", "Third" };
            var first = list.AsQueryable().FirstOne();

            Assert.AreEqual(first, "First");
        }
        public void ItReturnsOnlyGameDefinitionsInTheSpecifiedGamingGroup()
        {
            const int VALID_GAME_DEFINITION_ID = 1;
            var gameDefinitionList = new List<GameDefinition>
            {
                new GameDefinition
                {
                    Id = VALID_GAME_DEFINITION_ID,
                    Active = true,
                    GamingGroupId = currentUser.CurrentGamingGroupId
                },
                new GameDefinition
                {
                    Id = VALID_GAME_DEFINITION_ID + 1,
                    Active = true,
                    GamingGroupId = currentUser.CurrentGamingGroupId + 1
                }
            };

            autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionList.AsQueryable());

            var results = autoMocker.ClassUnderTest.GetAllGameDefinitionNames(this.currentUser.CurrentGamingGroupId);

            Assert.That(results.Count, Is.EqualTo(1));
            Assert.That(results[0].Id, Is.EqualTo(VALID_GAME_DEFINITION_ID));
        }
        public void PerfomancesCount_ContextHasPerfomances_ReturnsExpectedCount()
        {
            //Arrange
            var expectation = new List<Perfomance>
            {
                new Perfomance{Id = Guid.NewGuid(), Name = "Test"},
                new Perfomance{Id = Guid.NewGuid(), Name = "Test"},
                new Perfomance{Id = Guid.NewGuid(), Name = "Test"}
            };
            var perfomanceDbSet = PerfomanceStubs.CreateDbSet(expectation.AsQueryable());

            var contextMock = new Mock<DbContext>();
            contextMock
                .Setup(x => x.Set<Perfomance>())
                .Returns(perfomanceDbSet);
            mDbContextFactoryMock
                .Setup(x => x.CreateContext())
                .Returns(contextMock.Object);

            //Act
            var executionResult = mClassUnderTest.PerfomancesCount();

            //Assert
            executionResult.ShouldBeEquivalentTo(expectation.Count);
        }
Esempio n. 13
0
        public void TestAsFacade()
        {
            var l1 = new List<C0>();
            l1.Add(new C0 { X = 1 });
            l1.Add(new C1 { X = 1, Y = "hello", Z = "goodbye" });
            l1.Add(new C0 { X = 2 });
            l1.Add(new C0 { X = 0 });

            var l2 = new List<C1>();
            l2.Add(new C1 { X = 0, Y = "xyz", Z = "zzz" });
            l2.Add(new C1 { X = 2, Y = "mmm", Z = "nnn" });
            l2.Add(new C1 { X = 1, Y = null, Z = "qqq" });

            var l3 = new List<IHasZ>();
            l3.Add(new C1 { X = 2, Y = "000", Z = "abc" });
            l3.Add(new CX0 { Z = "yyy" });
            l3.Add(new CX0 { Z = "abc" });

            var l4 = new List<IHasZ>();

            IQueryable l1Q = l1.AsQueryable();
            IQueryable l2Q = l2.AsQueryable();
            var out0 = l1Q.AsFacade<C0>().Where(x => x.X == 1).ToList();
            Assert.AreEqual(out0.Count, 2);
            var out1 = l2Q.AsFacade<C0>().Where(x => x.X == 1).ToList();
            Assert.AreEqual(out1.Count, 1);

            IQueryable l3Q = l3.AsQueryable();
            var out3 = l3Q.AsFacade<IHasZ>().Where(x => x.Z == "abc").ToList();
            Assert.AreEqual(out3.Count, 2);
        }
        public void Index()
        {
            // Arrange
            var controller = GetHomeController();

            var stores = new List<Store>
                {
                    new Store()
                };

            storeRepositoryMock.Setup( s => s.GetAll() )
                .Returns( stores.AsQueryable() )
                .Verifiable();

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

            // Assert
            storeRepositoryMock.Verify();

            Assert.IsInstanceOf<ViewResult>( result );

            var view = (ViewResult)result;

            Assert.IsInstanceOf<List<Store>>( view.Model );
        }
        public void ItOnlyIncludesRecordsForTheGivenPlayer()
        {
            //--the player's minion was never their nemesis
            var expectedNemesisRecords = new List<Nemesis>
            {
                new Nemesis
                {
                    NemesisPlayerId = _playerId + 1,
                    MinionPlayerId = _playerId + 2,
                    DateCreated = DateTime.UtcNow,
                    NemesisPlayer = new Player
                    {
                        CurrentAndPriorNemeses = new List<Nemesis>
                        {
                            new Nemesis
                            {
                                NemesisPlayerId = _playerId + 2,
                                MinionPlayerId = _playerId + 1,
                                DateCreated = DateTime.UtcNow.AddDays(-1)
                            }
                        }
                    }
                }
            };
            _autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<Nemesis>()).Return(expectedNemesisRecords.AsQueryable());

            //--act
            var results = _autoMocker.ClassUnderTest.IsAwardedForThisPlayer(_playerId);

            //--assert
            Assert.That(results.LevelAwarded, Is.Null);
        }
		public void Setup()
		{
			products= new List<Product>();
			images = new List<Image>();
			validator = MockRepository.GenerateStub<IValidatingBinder>();
			repository = MockRepository.GenerateStub<IRepository<Product>>();
			repository.Expect(x => x.GetAll()).Return(products.AsQueryable());
			fileService = MockRepository.GenerateStub<IHttpFileService>();
			imageOrderableService = MockRepository.GenerateStub<IOrderableService<ProductImage>>();
			fileService.Expect(x => x.GetUploadedImages(null)).IgnoreArguments().Return(images);
			sizeService = MockRepository.GenerateStub<ISizeService>();
			
			var resolver = MockRepository.GenerateStub<IRepositoryResolver>();
			
			controllerContext = new ControllerContext()
			{
				HttpContext = MockRepository.GenerateStub<HttpContextBase>()
			};

			controllerContext.HttpContext.Stub(x => x.Request).Return(MockRepository.GenerateStub<HttpRequestBase>());
			sizeService.Expect(x => x.WithValues(controllerContext.HttpContext.Request.Form)).Return(sizeService);

			valueProvider = new FakeValueProvider();
			bindingContext = new ModelBindingContext() 
			{
				ModelState = new ModelStateDictionary(),
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Product)),
				ModelName = "product",
				ValueProvider = valueProvider
			};

			binder = new ProductBinder(validator, resolver, repository, fileService, imageOrderableService, sizeService);
		}
Esempio n. 17
0
        public async void Edit_GET_Valid_ViewById()
        {
            var game = new Game { Id = gameId };

            var games = new List<Game>
            {
               game
            };

            var esrbRating = new List<ESRBRating>
            {
                new ESRBRating { RatingId = "E", Description = "Everyone" }
            };


            Mock<IVeilDataAccess> dbStub = TestHelpers.GetVeilDataAccessFake();
            Mock<DbSet<Game>> gameDbSetStub = TestHelpers.GetFakeAsyncDbSet(games.AsQueryable());
            dbStub.Setup(db => db.Games).Returns(gameDbSetStub.Object);
            gameDbSetStub.Setup(gdb => gdb.FindAsync(game.Id)).ReturnsAsync(game);

            Mock<DbSet<ESRBRating>> esrbRatingDbSetStub = TestHelpers.GetFakeAsyncDbSet(esrbRating.AsQueryable());
            dbStub.Setup(db => db.ESRBRatings).Returns(esrbRatingDbSetStub.Object);

            GamesController controller = new GamesController(dbStub.Object, idGetter: null);

            var result = await controller.Edit(game.Id) as ViewResult;

            Assert.That(result != null);
            Assert.That(result.Model, Is.InstanceOf<Game>());
            Assert.That(result.Model, Is.EqualTo(game));
        }
Esempio n. 18
0
        public void TestSyncFiles()
        {
            var existingFiles = new List<File>
            {
                new File { Name = "a001z160105.xml", Content = "a001z160105.xml content" }, 
                new File { Name = "b001z160105.xml", Content = "b001z160105.xml content" }
            };

            var newFiles = new List<CurrencyRates.NbpCurrencyRates.Services.Entities.File>
            {
                new CurrencyRates.NbpCurrencyRates.Services.Entities.File { Name = "a002z160106.xml", Content = "a002z160106.xml content" }, 
                new CurrencyRates.NbpCurrencyRates.Services.Entities.File { Name = "b002z160106.xml", Content = "b002z160106.xml content" }
            };

            var context = new Mock<Context>();
            var fileFetcher = new Mock<IFileFetcher>();
            var fileDbSet = DbSetMockBuilder.Build(existingFiles.AsQueryable());

            context.Setup(c => c.Files).Returns(fileDbSet.Object);
            fileFetcher.Setup(ff => ff.FetchAllFilesExcept(new[] { existingFiles[0].Name, existingFiles[1].Name })).Returns(newFiles);

            var synchronizer = new Synchronizer(context.Object, fileFetcher.Object);
            synchronizer.SyncFiles();

            fileDbSet.Verify(fds => fds.Add(It.Is<File>(f => f.Name == newFiles[0].Name && f.Content == newFiles[0].Content)));
            fileDbSet.Verify(fds => fds.Add(It.Is<File>(f => f.Name == newFiles[1].Name && f.Content == newFiles[1].Content)));

            context.Verify(c => c.SaveChanges());
        }
Esempio n. 19
0
        public void GetAllPlansTest()
        {
            // Setup dependency
            var settingsMock = new Mock<ISettings>();
            var repositoryMock = new Mock<IRepository>();
            var uowMock = new Mock<IUnitOfWork>();
            var serviceLocatorMock = new Mock<IServiceLocator>();
            serviceLocatorMock.Setup(x => x.GetInstance<IRepository>())
                .Returns(repositoryMock.Object);
            ServiceLocator.SetLocatorProvider(() => serviceLocatorMock.Object);

            // Arrange
            decimal expectedResult = 10;
            List<Plan> plans = new List<Plan>();
            for (int i = 0; i < expectedResult; i++)
            {
                Plan plan = new Plan
                {
                    Id = Guid.NewGuid()
                };
                plans.Add(plan);
            }

            repositoryMock.Setup(r => r.Query<Plan>()).Returns(plans.AsQueryable());

            // Act
            PlanService bookingService = new PlanService(uowMock.Object, repositoryMock.Object, settingsMock.Object);
            List<PlanDto> currentResult = bookingService.GetAllPlans();

            // Assert
            repositoryMock.Verify(repo => repo.Query<Plan>());
            Assert.AreEqual(expectedResult, currentResult.Count());
        }
        public void Can_Remove_Product_From_Cart()
        {
            // Подготовка
            var mockProductsRepository = new Moq.Mock<IProductsRepository>();
            var products = new List<Product>()
            {
                new Product {ProductID=14, Name="Much Ado About Nothing" },
                new Product {ProductID=27, Name="The Comedy of Errors" }
            };
            mockProductsRepository.Setup(x => x.Products)
                                  .Returns(products.AsQueryable());
            var cart = new Cart();
            var controller = new CartController(mockProductsRepository.Object, null);
            controller.AddToCart(cart, 14, "someReturnUrl");
            controller.AddToCart(cart, 27, "someReturnUrl");
            Assert.AreEqual(2, cart.Lines.Count);
            // Действие
            RedirectToRouteResult result =
                controller.RemoveFromCart(cart, 14, "someReturnUrl");
            // Утверждение
            Assert.AreEqual(1, cart.Lines.Count);
            Assert.AreEqual(27, cart.Lines[0].Product.ProductID);

            Assert.AreEqual("Index", result.RouteValues["action"]);
            Assert.AreEqual("someReturnUrl", result.RouteValues["returnUrl"]);
        }
        public void SuccessMatch()
        {
            // Arrange
            var validatorFactory = new Mock<IValidatorEngine>();
            var mappingEngine = new Mock<IMappingEngine>();
            var repository = new Mock<IRepository>();
            var searchCache = new Mock<ISearchCache>();

            var service = new SourceSystemService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);

            // Domain details
            var start = new DateTime(1999, 12, 31);
            var finish = new DateTime(2020, 1, 1);
            var system = new SourceSystem { Name = "Endur" };
            var mapping = new SourceSystemMapping
            {
                System = system,
                MappingValue = "A"
            };
            var sourcesystem = new SourceSystem
            {
                Id = 1,
                Validity = new DateRange(start, finish)
            };
            //SourceSystem.AddDetails(details);
            sourcesystem.ProcessMapping(mapping);

            // Contract details
            var identifier = new EnergyTrading.Mdm.Contracts.MdmId
            {
                SystemName = "Endur",
                Identifier = "A"
            };
            var cDetails = new EnergyTrading.Mdm.Contracts.SourceSystemDetails();

            mappingEngine.Setup(x => x.Map<SourceSystemMapping, EnergyTrading.Mdm.Contracts.MdmId>(mapping)).Returns(identifier);
            mappingEngine.Setup(x => x.Map<SourceSystem, EnergyTrading.Mdm.Contracts.SourceSystemDetails>(sourcesystem)).Returns(cDetails);
            validatorFactory.Setup(x => x.IsValid(It.IsAny<MappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);

            var list = new List<SourceSystemMapping> { mapping };
            repository.Setup(x => x.Queryable<SourceSystemMapping>()).Returns(list.AsQueryable());

            var request = new MappingRequest { SystemName = "Endur", Identifier = "A", ValidAt = SystemTime.UtcNow(), Version = 1 };

            // Act
            var response = service.Map(request);
            var candidate = response.Contract;

            // Assert
            mappingEngine.Verify(x => x.Map<SourceSystemMapping, EnergyTrading.Mdm.Contracts.MdmId>(mapping));
            mappingEngine.Verify(x => x.Map<SourceSystem, EnergyTrading.Mdm.Contracts.SourceSystemDetails>(sourcesystem));
            repository.Verify(x => x.Queryable<SourceSystemMapping>());
            Assert.IsNotNull(candidate, "Contract null");
            Assert.AreEqual(2, candidate.Identifiers.Count, "Identifier count incorrect");
            // NB This is order dependent
            Assert.AreSame(identifier, candidate.Identifiers[1], "Different identifier assigned");
            Assert.AreSame(cDetails, candidate.Details, "Different details assigned");
            Assert.AreEqual(start, candidate.MdmSystemData.StartDate, "Start date differs");
            Assert.AreEqual(finish, candidate.MdmSystemData.EndDate, "End date differs");
        }
        public void CountsByLocationAndProviderOrgUnit()
        {
            var location = CreateOrgUnit(1);

            var providerList = new List<ProviderCacheView>();

            var provider1 = CreateProvider(1);
            providerList.AddRange(provider1.AddOrgUnit(location).AddInsurance(_insurance1).AddInsurance(_insurance2));

            var builder = new InsuranceFilterBuilder();

            var filter = builder.CreateFilters(providerList.AsQueryable()).FirstOrDefault();

            Assert.IsNotNull(filter);
            Assert.AreEqual(2, filter.FilterValues.Count());

            var filterValue0 = filter.FilterValues.ElementAt(0);
            Assert.AreEqual(1, filterValue0.Count);
            Assert.AreEqual(_insurance1.Name, filterValue0.DisplayName);
            Assert.AreEqual(_insurance1.Id.ToString(CultureInfo.InvariantCulture), filterValue0.QueryStringParameterValue);

            var filterValue1 = filter.FilterValues.ElementAt(1);
            Assert.AreEqual(1, filterValue1.Count);
            Assert.AreEqual(_insurance2.Name, filterValue1.DisplayName);
            Assert.AreEqual(_insurance2.Id.ToString(CultureInfo.InvariantCulture), filterValue1.QueryStringParameterValue);
        }
        public void GetCompliancesVerificationDetail_AnyUserId()
        {
            // Setup dependency
            var settingsMock = new Mock<ISettings>();
            var repositoryMock = new Mock<IRepository>();
            var uowMock = new Mock<IUnitOfWork>();
            var serviceLocatorMock = new Mock<IServiceLocator>();
            serviceLocatorMock.Setup(x => x.GetInstance<IRepository>())
                .Returns(repositoryMock.Object);
            ServiceLocator.SetLocatorProvider(() => serviceLocatorMock.Object);

            // Arrange
            List<User> users = new List<User>();
            Guid id = Guid.NewGuid();

            User user = new User
            {
                Id = id,
                FirstName = id.ToString(),
                Role = Role.Specialist
            };
            users.Add(user);

            repositoryMock.Setup(r => r.Query<User>()).Returns(users.AsQueryable());

            // Act
            ManagementService managementService = new ManagementService(uowMock.Object, repositoryMock.Object, settingsMock.Object);
            var currentResult = managementService
                .GetCompliancesVerificationDetail(id);

            // Assert
            repositoryMock.Verify(r => r.Query<User>());
            Assert.AreEqual(null, currentResult);
        }
        public void Index_ViewBagContainsUserEmail()
        {
            // arrange
            var tasksRepository = new Mock<ITasksRepository>();
            var usersRepository = new Mock<IUsersRepository>();
            var pathHelper = new Mock<IPathHelper>();
            var hashService = new HashService();
            var shareService = new ShareService(pathHelper.Object, hashService);
            var controller = new ShareController(shareService, tasksRepository.Object, usersRepository.Object);

            var tasks = new List<Task> 
            {
                new Task { Id = 0, UserId = 11,  Description = "Task 0" },
                new Task { Id = 1, UserId = 11, Description = "Task 1" },
                new Task { Id = 2, UserId = 11, Description = "Task 2" }
            };
            tasksRepository.Setup(r => r.Tasks).Returns(tasks.AsQueryable());

            var users = new List<User> 
            {
                new User { Email = "*****@*****.**", Id = 11 }
            };
            usersRepository.Setup(u => u.Users).Returns(users.AsQueryable());

            // act
            var email = "*****@*****.**";
            var correctHash = hashService.CreateMD5Hash(email + "shared_tasks");
            var result = controller.Index(email, correctHash) as ViewResult;

            // assert
            var emailResult = result.ViewBag.Email as string;
            emailResult.Should().Be(email);

        }
        public void Given_a_clientId_all_checklists_that_are_linked_to_client_are_returned()
        {
            //given
            var clientIdForTEST002 = 14145135;
            var checklists = new List<Checklist>
                                 {
                                     new Checklist() {ClientId = 5257647, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                     ,
                                     new Checklist() {ClientId = clientIdForTEST002, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                     ,
                                     new Checklist() {ClientId = 23452435, QaAdvisor = new QaAdvisor{Id = Guid.NewGuid(), Forename = "Test", Surname = "Test"}}
                                 };

            _queryableWrapper.Setup(x => x.Queryable())
                .Returns(() => checklists.AsQueryable());


            var target = new GetChecklistsQuery(_queryableWrapper.Object);
            
            //when
            var result = target
                .WithClientId(clientIdForTEST002)
                .Execute();

            //then
            Assert.That(result.Count,Is.EqualTo(1));
            Assert.That(result.First().ClientId, Is.EqualTo(clientIdForTEST002));

        }
        public void NoOverlappingIndentifierShouldPass()
        {
            // Assert
            var start = new DateTime(1999, 1, 1);
            var finish = new DateTime(2020, 12, 31);
            var validity = new DateRange(start, finish);
            var system = new SourceSystem { Name = "Test" };
            var expectedPartyRole = new PartyRole() { PartyRoleType = "PartyRole" };
            var expected = new PartyRoleMapping { System = system, MappingValue = "1", Validity = validity, PartyRole = expectedPartyRole };
            var list = new List<PartyRoleMapping> { expected };
            var repository = new Mock<IRepository>();
            repository.Setup(x => x.Queryable<PartyRoleMapping>()).Returns(list.AsQueryable());
            repository.Setup(x => x.FindOne<PartyRole>(It.IsAny<int>())).Returns(expectedPartyRole);

            var identifier = new EnergyTrading.Mdm.Contracts.MdmId
            {
                SystemName = "Test",
                Identifier = "1",
                StartDate = start.AddHours(-10),
                EndDate = start.AddHours(-5)
            };

            var request = new CreateMappingRequest() { EntityId = 1, Mapping = identifier };
            var rule = new PartyRoleCreateMappingdNoOverlappingRule<PartyRole, PartyRoleMapping>(repository.Object);

            // Act
            var result = rule.IsValid(request);

            // Assert
            repository.Verify(x => x.FindOne<PartyRole>(It.IsAny<int>()));
            Assert.IsTrue(result, "Rule failed");
        }
        public override void SetUp()
        {
            base.SetUp();

            gamingGroupList = new List<GamingGroup>
            {
                new GamingGroup
                {
                    Id = gamingGroupId1,
                    UserGamingGroups = new List<UserGamingGroup>
                    {
                        new UserGamingGroup
                        {
                            ApplicationUserId = CurrentUser.Id
                        }
                    }
                },
                new GamingGroup
                {
                    Id = gamingGroupId2,
                    UserGamingGroups = new List<UserGamingGroup>
                    {
                        new UserGamingGroup
                        {
                            ApplicationUserId = "some other application id"
                        }
                    }
                }
            };

            AutoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GamingGroup>())
                           .Return(gamingGroupList.AsQueryable());
        }
        public void TestCreateFilter()
        {
            //setup
            var source = new List<ProviderCacheView>
                             {
                                 new ProviderCacheView { Id=1, Gender = "male", GenderId = 1},
                                 new ProviderCacheView { Id=2, Gender = "male", GenderId = 1},
                                 new ProviderCacheView { Id=3, Gender = "female", GenderId = 2},
                                 new ProviderCacheView { Id=4, Gender = null}
                             };

            var builder = new GenderFilterBuilder();

            //act
            var filter = builder.CreateFilters(source.AsQueryable()).FirstOrDefault();

            //assert
            Assert.IsNotNull(filter);
            Assert.AreEqual(QueryStringKeys.GenderIdKey, filter.QueryStringParameterName);
            Assert.AreEqual("Gender", filter.Name);
            Assert.IsNotNull(filter.FilterValues);
            Assert.AreEqual(2, filter.FilterValues.Count());

            var value = filter.FilterValues.ElementAt(0);
            Assert.AreEqual("female", value.DisplayName);
            Assert.AreEqual(1, value.Count);
            Assert.AreEqual("2", value.QueryStringParameterValue);

            value = filter.FilterValues.ElementAt(1);
            Assert.AreEqual("male", value.DisplayName);
            Assert.AreEqual(2, value.Count);
            Assert.AreEqual("1", value.QueryStringParameterValue);
        }
        public void Index_WhenCalls_SetsUpViewModelWithAllPlatformsAndSelectedList()
        {
            List<Platform> selectedPlatforms = new List<Platform>();
            List<Platform> allPlatforms = new List<Platform>
            {
                new Platform(),
                new Platform()
            };

            Mock<IVeilDataAccess> dbStub = TestHelpers.GetVeilDataAccessFake();
            Mock<DbSet<Platform>> platformDbSetStub = TestHelpers.GetFakeAsyncDbSet(allPlatforms.AsQueryable());

            dbStub.
                Setup(db => db.Platforms).
                Returns(platformDbSetStub.Object);

            PlatformsController controller = new PlatformsController(dbStub.Object);

            var result = controller.Index(selectedPlatforms);

            Assert.That(result != null);
            Assert.That(result.Model, Is.InstanceOf<PlatformViewModel>());

            var model = (PlatformViewModel) result.Model;

            Assert.That(model.Selected, Is.SameAs(selectedPlatforms));
            Assert.That(model.AllPlatforms.Count(), Is.EqualTo(allPlatforms.Count));
            Assert.That(model.AllPlatforms, Has.Member(allPlatforms.First()).And.Member(allPlatforms.Last()));
        }
        public void Index_WhenCalls_SetsUpViewModelWithAllContentDescriptorsAndSelectedList()
        {
            List<ESRBContentDescriptor> selectedContentDescriptors = new List<ESRBContentDescriptor>();
            List<ESRBContentDescriptor> allContentDescriptors = new List<ESRBContentDescriptor>
            {
                new ESRBContentDescriptor(),
                new ESRBContentDescriptor()
            };

            Mock<IVeilDataAccess> dbStub = TestHelpers.GetVeilDataAccessFake();
            Mock<DbSet<ESRBContentDescriptor>> contentDescriptorsDbSetStub = TestHelpers.GetFakeAsyncDbSet(allContentDescriptors.AsQueryable());

            dbStub.
                Setup(db => db.ESRBContentDescriptors).
                Returns(contentDescriptorsDbSetStub.Object);

            ESRBDescriptionController controller = new ESRBDescriptionController(dbStub.Object);

            var result = controller.Index(selectedContentDescriptors);

            Assert.That(result != null);
            Assert.That(result.Model, Is.InstanceOf<ESRBDescriptionViewModel>());

            var model = (ESRBDescriptionViewModel)result.Model;

            Assert.That(model.Selected, Is.SameAs(selectedContentDescriptors));
            Assert.That(model.All.Count(), Is.EqualTo(allContentDescriptors.Count));
            Assert.That(model.All, Has.Member(allContentDescriptors.First()).And.Member(allContentDescriptors.Last()));
        }