public void ShouldReturnOrderedSearchResultsFromCache()
        {
            // Given
            var mockValidationEngine = new Mock <IValidatorEngine>();
            var mockMappingEngine    = new Mock <IMappingEngine>();
            var mockRepository       = new Mock <IRepository>();
            var mockSearchCache      = new Mock <ISearchCache>();
            var abcService           = new AbcEntityTestService(mockValidationEngine.Object, mockMappingEngine.Object, mockRepository.Object, mockSearchCache.Object);

            // When

            // ids are stored in a specific order
            var ids = new List <int> {
                1, 100, 50
            };
            var cacheSearchResultsPage = new CacheSearchResultPage(ids, DateTime.Now, 2, "abc");

            mockSearchCache.Setup(x => x.Get("abc", 1)).Returns(cacheSearchResultsPage);

            // entities are returned in a different order
            var entities = new List <AbcEntity>
            {
                new AbcEntity {
                    Id = 100, Validity = new DateRange()
                },
                new AbcEntity {
                    Id = 50, Validity = new DateRange()
                },
                new AbcEntity {
                    Id = 1, Validity = new DateRange()
                }
            };

            var details = new AbcEntityDetails {
                Validity = new DateRange()
            };

            foreach (var abcEntity in entities)
            {
                abcEntity.AddDetails(details);
            }

            mockRepository.Setup(x => x.Queryable <AbcEntity>()).Returns(entities.AsQueryable());

            var searchResultsPage = abcService.GetSearchResults("abc", 1);

            Assert.AreEqual("abc", searchResultsPage.SearchResultsKey);
            Assert.AreEqual(2, searchResultsPage.NextPage);
            Assert.AreEqual(3, searchResultsPage.Contracts.Count);
            Assert.AreEqual(1, searchResultsPage.Contracts[0].ToMdmKey());
            Assert.AreEqual(100, searchResultsPage.Contracts[1].ToMdmKey());
            Assert.AreEqual(50, searchResultsPage.Contracts[2].ToMdmKey());
        }
        public void ShouldGetEntityByIdWhenGetRequestRequested()
        {
            // Given
            var mockValidationEngine = new Mock <IValidatorEngine>();
            var mockMappingEngine    = new Mock <IMappingEngine>();
            var mockRepository       = new Mock <IRepository>();
            var mockSearchCache      = new Mock <ISearchCache>();
            var abcService           = new AbcEntityTestService(mockValidationEngine.Object, mockMappingEngine.Object, mockRepository.Object, mockSearchCache.Object);

            // When
            var getRequest = new GetRequest()
            {
                EntityId = 3, ValidAt = DateTime.Now
            };

            abcService.Request(getRequest);

            // Then
            mockRepository.Verify(x => x.FindOne <AbcEntity>(getRequest.EntityId));
        }
        public void ShouldReturnNotFoundWhenMapRequestedWithInvalidNexusIdentifier()
        {
            // Given
            var mockValidationEngine = new Mock <IValidatorEngine>();
            var mockMappingEngine    = new Mock <IMappingEngine>();
            var mockRepository       = new Mock <IRepository>();
            var mockSearchCache      = new Mock <ISearchCache>();
            var abcService           = new AbcEntityTestService(mockValidationEngine.Object, mockMappingEngine.Object, mockRepository.Object, mockSearchCache.Object);

            // When
            var mappingRequest = new MappingRequest()
            {
                Identifier = "Three",
                SystemName = "Nexus",
                ValidAt    = DateTime.Now
            };

            var response = abcService.Map(mappingRequest);

            Assert.AreEqual(ErrorType.NotFound, response.Error.Type);
        }
        public void ShouldGetEntityByIdWhenMapRequestedForNexusSystem()
        {
            // Given
            var mockValidationEngine = new Mock <IValidatorEngine>();
            var mockMappingEngine    = new Mock <IMappingEngine>();
            var mockRepository       = new Mock <IRepository>();
            var mockSearchCache      = new Mock <ISearchCache>();
            var abcService           = new AbcEntityTestService(mockValidationEngine.Object, mockMappingEngine.Object, mockRepository.Object, mockSearchCache.Object);

            // When
            var mappingRequest = new MappingRequest()
            {
                Identifier = "3",
                SystemName = "Nexus",
                ValidAt    = DateTime.Now
            };

            abcService.Map(mappingRequest);

            // Then
            mockRepository.Verify(x => x.FindOne <AbcEntity>(int.Parse(mappingRequest.Identifier)));
        }
        public void ShouldFindMappingWhenMapRequestedForNonNexusSystems()
        {
            // Given
            var mockValidationEngine = new Mock <IValidatorEngine>();
            var mockMappingEngine    = new Mock <IMappingEngine>();
            var mockRepository       = new Mock <IRepository>();
            var mockSearchCache      = new Mock <ISearchCache>();
            IQueryable <AbcEntityMapping> abcEntityMappingQueryObject =
                (new List <AbcEntityMapping>
            {
                new AbcEntityMapping()
                {
                    System = new SourceSystem()
                    {
                        Name = "Endur"
                    },
                    MappingValue = "EndurId-3",
                    Validity = new DateRange(DateTime.Now.AddDays(-1), DateTime.Now.AddDays(1))
                }
            }).AsQueryable();
            var abcService = new AbcEntityTestService(
                mockValidationEngine.Object, mockMappingEngine.Object, mockRepository.Object, mockSearchCache.Object);

            // When
            var mappingRequest = new MappingRequest()
            {
                Identifier = "EndurId-3",
                SystemName = "Endur",
                ValidAt    = DateTime.Now
            };

            mockValidationEngine.Setup(x => x.IsValid <MappingRequest>(mappingRequest, It.IsAny <IList <IRule> >())).Returns(true);
            mockRepository.Setup(x => x.Queryable <AbcEntityMapping>()).Returns(abcEntityMappingQueryObject);

            abcService.Map(mappingRequest);

            // Then
            mockRepository.Verify(x => x.Queryable <AbcEntityMapping>());
        }