public void Should_SetInactivePeriod_When_AgentIsInactive()
        {
            // Arrange
            var expectedResult = TimeSpan.FromMilliseconds(MonitoringSettings.AgentActivePeriod + 1000);

            var createDate = Now - expectedResult;

            var agentStateCreateDates = new[]
            {
                new AgentStateCreateDate {
                    CreateDate = createDate
                },
            };

            var unitOfWork = new Mock <IUnitOfWork>();

            unitOfWork.Setup(x => x.AgentStateRepository.GetLastAgentStateCreateDates(Now))
            .Returns(agentStateCreateDates);

            var options = new Mock <IOptions <MonitoringSettings> >();

            options.Setup(x => x.Value).Returns(MonitoringSettings);

            var service = new AggregationService(unitOfWork.Object, options.Object);


            // Act
            var actualResult = service.Aggregate(Now).Single().InactivePeriod;

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }
        public void NoPets_NotIncludedInResults_Test()
        {
            var service = new AggregationService();

            var result = service.Aggregate(mockPeople,
                                           p => p.Name,
                                           p => p.Name != null,
                                           p => p.Type
                                           );

            Assert.False(result.ContainsKey("Ann"));
        }
        public void GroupByPersonName_FilterByPetName_ProjectType_Test()
        {
            var service = new AggregationService();

            var result = service.Aggregate(mockPeople,
                                           p => p.Name,
                                           p => p.Name == "Snappy",
                                           p => p.Type
                                           );

            Assert.NotEmpty(result);
            Assert.Equal(PetType.Dog, result["John"].First());
        }
        public void GroupByGender_FilterByPetType_ProjectName_Test()
        {
            var service = new AggregationService();

            var result = service.Aggregate(mockPeople,
                                           p => p.Gender,
                                           p => p.Type == PetType.Fish,
                                           p => p.Name
                                           );

            Assert.NotEmpty(result);
            Assert.Equal("Talky", result[Gender.Female].First());
        }
        public void Should_SetAgentId_When_AgentStateExists()
        {
            // Arrange
            const int expectedResult = 1;

            var agentStateCreateDates = new[]
            {
                new AgentStateCreateDate {
                    AgentId = expectedResult
                },
            };

            _unitOfWork.Setup(x => x.AgentStateRepository.GetLastAgentStateCreateDates(Now))
            .Returns(agentStateCreateDates);

            // Act
            var actualResult = _aggregationService.Aggregate(Now).Single().AgentId;

            // Assert
            Assert.AreEqual(expectedResult, actualResult);
        }