Esempio n. 1
0
 public DomainStatProjectDeletion StatProjectDeletionToDomain(StatProjectDeletionV2Entity entity)
 {
     return new DomainStatProjectDeletion
     {
         DateTime = entity.DateTime,
         Tick = entity.Tick,
         UserId = entity.UserId,
         EventId = entity.EventId,
         ProductName = entity.ProductName,
         ProjectId = entity.ProjectId
     };
 }
        public async Task AddProjectDeletionTest()
        {
            var projectDeletionEntity = new StatProjectDeletionV2Entity();
            var projectDeletionRepository = new Mock<IRepository<StatProjectDeletionV2Entity>>();
            var projectStateRepository = new Mock<IRepository<StatProjectStateV3Entity>>();
           
            _repositoryFactory.Setup(m => m.Create<StatProjectDeletionV2Entity>(Tables.StatProjectDeletionV2)).Returns(projectDeletionRepository.Object);
            _repositoryFactory.Setup(m => m.Create<StatProjectStateV3Entity>(Tables.StatProjectStateV3)).Returns(projectStateRepository.Object);
            
            _statEntityFactory.Setup(m => m.CreateProjectDeletionEntity(EventId, _dateTime, _domain, ProjectId)).Returns(projectDeletionEntity);
            projectDeletionRepository.Setup(m => m.AddAsync(projectDeletionEntity, It.IsAny<CancellationToken>())).Returns(async () => projectDeletionEntity);

            var projectDeletionService = new StatProjectDeletionService(_repositoryFactory.Object, _statEntityFactory.Object, _guidWrapper.Object, _dateTimeWrapper.Object);

            //Act & Assert
            await projectDeletionService.AddProjectDeletion(_domain, ProjectId);
        }
Esempio n. 3
0
        public void DomainStatProjectDeletionTest()
        {
            //Arrange
            var deletionEntity = new StatProjectDeletionV2Entity()
            {
                Tick = "tick",
                DateTime = new DateTime(23456345344),
                UserId = "userId",
                EventId = "eventId",
                ProductName = "productName",
                ProjectId = "projectId"
            };

            var statMapper = new StatMapper();

            //Act
            var domain = statMapper.StatProjectDeletionToDomain(deletionEntity);

            //Assert
            Assert.AreEqual(deletionEntity.Tick, domain.Tick);
            Assert.AreEqual(deletionEntity.DateTime, domain.DateTime);
            Assert.AreEqual(deletionEntity.EventId, domain.EventId);
            Assert.AreEqual(deletionEntity.UserId, domain.UserId);
            Assert.AreEqual(deletionEntity.ProductName, domain.ProductName);
            Assert.AreEqual(deletionEntity.ProjectId, domain.ProjectId);
        }
        public void GetProjectDeletionsTest()
        {
            //Arrange
            var domain1 = new DomainStatProjectDeletion();
            var domain2 = new DomainStatProjectDeletion();

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

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

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

            repositoryFactory.Setup(m => m.Create<StatProjectDeletionV2Entity>(Tables.StatProjectDeletionV2)).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.StatProjectDeletionToDomain(entity1)).Returns(domain1);
            statMapper.Setup(m => m.StatProjectDeletionToDomain(entity2)).Returns(domain2);

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

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

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