public async Task PutObjectAsync_should_create_object_with_metadata()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);
            var dummyModel = new DummyModel()
            {
                Age         = 1,
                CreatedDate = DateTime.Now,
                FullName    = "Fizz Buzz",
                Id          = Guid.NewGuid()
            };
            var contentBody = _jsonSerializationService.SerializeObject(dummyModel);

            var putObjectRequest = new PutObjectRequestBuilder(BucketName, FileNameWithMetadata, contentBody);

            putObjectRequest.WithMetadata("biz", "bat");
            putObjectRequest.WithMetadata("fizz", "buzz");

            // Act
            var response = await classUnderTest
                           .PutObjectAsync(putObjectRequest.Create());

            // Assert
            Assert.IsTrue(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
        }
        public async Task DeleteObjectAsync_should_delete_the_object()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);

            // Act
            var actual = await classUnderTest.DeleteObjectAsync(BucketName, FileName);

            // Assert
            Assert.AreEqual(actual.DeleteMarker, null);
        }
        public async Task ListObjectsAsync_()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);

            // Act
            var response = await classUnderTest.ListObjectsAsync(BucketName);

            var actual = response.S3Objects.Count();

            // Assert
            Assert.IsTrue(actual > 0);
        }
        public async Task GetObjectTaggingAsync_should_get_tags()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);

            // Act
            var response = await classUnderTest.GetObjectTaggingAsync(BucketName, FileNameWithTag);

            var actual = response.Tagging.Count();

            // Assert
            Assert.IsTrue(actual > 0);
        }
        public async Task GetObjectMetadataAsync_should_get_metadata()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);

            // Act
            var response = await classUnderTest.GetObjectMetadataAsync(BucketName, FileNameWithMetadata);

            var actual = response.Metadata.Keys.Any(x => x.Equals("x-amz-meta-foo"));

            // Assert
            Assert.IsTrue(actual);
        }
        public void GetPreSignedURL_should_get_url()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);
            var expireInHours = 1;

            // Act
            var actual = classUnderTest.GetPreSignedURL(BucketName, FileNameBinaryPdf, expireInHours);

            // Assert
            StringAssert.Contains(BucketName, actual);
            StringAssert.Contains(FileName, actual);
        }
        public async Task PutTextObjectAsync_puts_text_file_in_bucket()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);
            var dummyModel = new DummyModel()
            {
                Age         = 42,
                CreatedDate = DateTime.Now,
                FullName    = "Foo Bar",
                Id          = Guid.NewGuid()
            };
            var contentBody = _jsonSerializationService.SerializeObject(dummyModel);

            // Act
            var response = await classUnderTest
                           .PutTextObjectAsync(BucketName, FileName, contentBody);

            // Assert
            Assert.IsTrue(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
        }
        public async Task GetObjectAsync_should_get_object()
        {
            // Arrange
            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);

            // Act
            var response = await classUnderTest.GetObjectAsync(BucketName, FileNameWithTag);

            using (var reader = new StreamReader(response.ResponseStream))
            {
                // Not really needed for this test, I just thought it was cool
                var fileContent = await reader.ReadToEndAsync();

                var file = _jsonSerializationService.DeserializeObject <DummyModel>(fileContent);
            }

            // Assert
            Assert.IsTrue(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
            Assert.AreEqual(FileNameWithTag, response.Key);
        }
        public async Task PutObjectAsync_should_create_object()
        {
            // TODO - use the builder, I think take `contentBody` out of the ctr

            var uploadFile = FileNameBinaryPdf;
            var filePath   = @"C:\Dev\AwsAdministrator\files\" + uploadFile;

            IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);
            var content = File.ReadAllBytes(filePath);

            var request = new PutObjectRequest
            {
                BucketName  = BucketName,
                Key         = uploadFile,
                ContentType = filePath.GetContentType(),
                InputStream = new MemoryStream(content),
            };

            var response = await classUnderTest
                           .PutObjectAsync(request);

            // Assert
            Assert.IsTrue(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
        }