Example #1
0
        public async Task get_async_should_return_bucket()
        {
            //Arrange
            var name   = "test";
            var bucket = new Bucket(Guid.NewGuid(), name);
            var dto    = new BucketDTO
            {
                Name = bucket.Name
            };
            var repositoryMock = new Mock <IBucketRepository>();
            var mapperMock     = new Mock <IMapper>();

            repositoryMock.Setup(x => x.GetAsync(name))
            .Returns(Task.FromResult(bucket));
            mapperMock.Setup(x => x.Map <BucketDTO>(bucket))
            .Returns(dto);

            var service = new BucketService(repositoryMock.Object, mapperMock.Object);

            //Act
            var bucketDto = await service.GetAsync(name);

            repositoryMock.Verify(x => x.GetAsync(name), Times.Once());
            mapperMock.Verify(x => x.Map <BucketDTO>(bucket), Times.Once());
        }
Example #2
0
        public async Task GetAsync_ReturnBucket()
        {
            Bucket    bucket    = new Bucket(BucketName);
            BucketDTO bucketDto = new BucketDTO();
            Mock <IBucketRepository> bucketRepository = new Mock <IBucketRepository>();
            Mock <IMapper>           mapper           = new Mock <IMapper>();

            bucketRepository
            .Setup((it) => it.GetAsync(BucketName))
            .ReturnsAsync(bucket);

            mapper
            .Setup((it) => it.Map <BucketDTO>(bucket))
            .Returns(bucketDto);

            IBucketService bucketService = new BucketService(
                bucketRepository.Object, mapper.Object
                );

            await bucketService.GetAsync(BucketName);

            bucketRepository.Verify(
                (it) => it.GetAsync(BucketName),
                Times.Once
                );
            mapper.Verify(
                (it) => it.Map <BucketDTO>(bucket),
                Times.Once
                );
        }
Example #3
0
        public async Task AddAsync_CreateNewBucket()
        {
            IBucketService bucketService = new BucketService(
                new InMemoryBucketRepository(), AutoMapperConfig.InitializeMapper()
                );

            await bucketService.AddAsync(BucketName);

            BucketDTO bucketDto = await bucketService.GetAsync(BucketName);

            Assert.Equal(BucketName, bucketDto.Name);
        }
Example #4
0
        public async Task get_async_should_return_bucket_dto()
        {
            var name      = "test-bucket";
            var bucket    = new Bucket(Guid.NewGuid(), name);
            var bucketDto = new BucketDTO {
                Name = name
            };
            var repositoryMock = new Mock <IBucketRepository>();
            var mapperMock     = new Mock <IMapper>();
            var service        = new BucketService(repositoryMock.Object, mapperMock.Object);

            repositoryMock.Setup(x => x.GetAsync(name))
            .ReturnsAsync(bucket);
            mapperMock.Setup(x => x.Map <BucketDTO>(bucket))
            .Returns(bucketDto);

            var result = await service.GetAsync(name);

            result.Should().BeEquivalentTo(bucketDto);
        }