Exemplo n.º 1
0
        public void StatWatchingEntityToDomainTest()
        {
            //Arrange
            var watchingEntity = new StatWatchingV2Entity()
            {
                AnonymousId     = "AnonymousId",
                DateTime        = new DateTime(23456345344),
                ProjectId       = "projectId",
                UrlReferrer     = "urlReferrer",
                UserId          = "userId",
                IsAuthenticated = true,
                Tick            = "tick",
                EventId         = "eventId"
            };

            var statMapper = new StatMapper();

            //Act
            var domain = statMapper.StatWatchingToDomain(watchingEntity);

            //Assert
            Assert.AreEqual(watchingEntity.Tick, domain.Tick);
            Assert.AreEqual(watchingEntity.AnonymousId, domain.AnonymousId);
            Assert.AreEqual(watchingEntity.DateTime, domain.DateTime);
            Assert.AreEqual(watchingEntity.EventId, domain.EventId);
            Assert.AreEqual(watchingEntity.IsAuthenticated, domain.IsAuthenticated);
            Assert.AreEqual(watchingEntity.ProjectId, domain.ProjectId);
            Assert.AreEqual(watchingEntity.UrlReferrer, domain.UrlReferrer);
            Assert.AreEqual(watchingEntity.UserId, domain.UserId);
        }
        public async Task AddWatchingTest()
        {
            const string eventId   = "eventId";
            const string projectId = "projectId";
            var          dateTime  = new DateTime(2013, 2, 13);

            var domain            = new DomainActionData();
            var httpMessageEntity = new StatHttpMessageV2Entity();
            var watchingEntity    = new StatWatchingV2Entity();

            var guidWrapper           = new Mock <IGuidWrapper>();
            var dateTimeWrapper       = new Mock <IDateTimeWrapper>();
            var httpMessageRepository = new Mock <IRepository <StatHttpMessageV2Entity> >();
            var watchingRepository    = new Mock <IRepository <StatWatchingV2Entity> >();
            var repositoryFactory     = new Mock <IRepositoryFactory>();
            var statEntityFactory     = new Mock <IStatEntityFactory>();

            guidWrapper.Setup(m => m.Generate()).Returns(eventId);
            dateTimeWrapper.Setup(m => m.CurrentDateTime()).Returns(dateTime);

            repositoryFactory.Setup(m => m.Create <StatHttpMessageV2Entity>(Tables.StatHttpMessageV2)).Returns(httpMessageRepository.Object);
            repositoryFactory.Setup(m => m.Create <StatWatchingV2Entity>(Tables.StatWatchingV2)).Returns(watchingRepository.Object);

            statEntityFactory.Setup(m => m.CreateHttpMessageEntity(eventId, dateTime, domain)).Returns(httpMessageEntity);
            statEntityFactory.Setup(m => m.CreateWatchingEntity(eventId, dateTime, domain, projectId)).Returns(watchingEntity);
            httpMessageRepository.Setup(m => m.AddAsync(httpMessageEntity, It.IsAny <CancellationToken>())).Returns(async() => httpMessageEntity);
            watchingRepository.Setup(m => m.AddAsync(watchingEntity, It.IsAny <CancellationToken>())).Returns(async() => watchingEntity);

            var watchingService = new StatWatchingService(repositoryFactory.Object, statEntityFactory.Object, guidWrapper.Object, dateTimeWrapper.Object);

            //Act & Assert
            await watchingService.AddWatching(domain, projectId);
        }
Exemplo n.º 3
0
        public Task AddWatching(DomainActionData domain, string projectId)
        {
            string   eventId     = GuidWraper.Generate();
            DateTime curDateTime = DateTimeWrapper.CurrentDateTime();

            StatWatchingV2Entity watchingEntity = StatEntityFactory.CreateWatchingEntity(eventId, curDateTime, domain, projectId);
            ITableRepository <StatWatchingV2Entity> watchingRepository = RepositoryFactory.Create <StatWatchingV2Entity>();

            return(watchingRepository.AddAsync(watchingEntity));
        }
Exemplo n.º 4
0
 public DomainStatWatching StatWatchingToDomain(StatWatchingV2Entity entity)
 {
     return(new DomainStatWatching
     {
         AnonymousId = entity.AnonymousId,
         DateTime = entity.DateTime,
         ProjectId = entity.ProjectId,
         Tick = entity.Tick,
         UrlReferrer = entity.UrlReferrer,
         UserId = entity.UserId,
         IsAuthenticated = entity.IsAuthenticated,
         EventId = entity.EventId,
         UserAgent = entity.UserAgent
     });
 }
        public void GetWatchingsTest()
        {
            //Arrange
            var domain1 = new DomainStatWatching();
            var domain2 = new DomainStatWatching();

            var entity1 = new StatWatchingV2Entity()
            {
                Tick = Tick1
            };
            var entity2 = new StatWatchingV2Entity()
            {
                Tick = Tick2
            };
            var entities = new List <StatWatchingV2Entity>()
            {
                entity1, entity2
            };

            var repository = new Mock <IRepository <StatWatchingV2Entity> >();

            var repositoryFactory   = new Mock <IRepositoryFactory>();
            var tableValueConverter = new Mock <ITableValueConverter>();
            var statMapper          = new Mock <IStatMapper>();

            repositoryFactory.Setup(m => m.Create <StatWatchingV2Entity>(Tables.StatWatchingV2)).Returns(repository.Object);
            repository.Setup(m => m.GetStatEntities(It.Is <StatQueryObject>(p => p.StartInterval == Tick2 &&
                                                                            p.EndInterval == Tick1 &&
                                                                            p.IsStartInclude == false &&
                                                                            p.IsEndInclude == false)))
            .Returns(entities);

            tableValueConverter.Setup(m => m.DateTimeToComparerTick(_startDate)).Returns(Tick2);
            tableValueConverter.Setup(m => m.DateTimeToComparerTick(_finishDate)).Returns(Tick1);
            statMapper.Setup(m => m.StatWatchingToDomain(entity1)).Returns(domain1);
            statMapper.Setup(m => m.StatWatchingToDomain(entity2)).Returns(domain2);

            var statisticsService = new StatisticsService(repositoryFactory.Object, tableValueConverter.Object, statMapper.Object);

            //Act
            var result = statisticsService.GetWatchings(_interval).ToList();

            //Assert
            Assert.AreEqual(2, result.Count);
            CollectionAssert.Contains(result, domain1);
            CollectionAssert.Contains(result, domain2);
        }