public void Given_Default_When_Instantiated_Then_It_Should_Return_Value()
        {
            var instance = new BlobStorageSchemaSink();

            instance.BaseLocation.Should().BeEmpty();
            instance.Container.Should().Be("schemas");
        }
        public void Given_Null_Path_When_GetSchemaAsync_Invoked_Then_It_Should_Throw_Exception()
        {
            var instance = new BlobStorageSchemaSink();

            Func <Task> func = async() => await instance.GetSchemaAsync(null).ConfigureAwait(false);

            func.Should().Throw <ArgumentNullException>();
        }
        public void Given_Null_Container_When_WithContainer_Invoked_Then_It_Should_Throw_Exception()
        {
            var instance = new BlobStorageSchemaSink();

            Action action = () => instance.WithContainer(null);

            action.Should().Throw <ArgumentNullException>();
        }
        public void Given_Container_When_WithContainer_Invoked_Then_It_Should_Return_Value(string container)
        {
            var instance = new BlobStorageSchemaSink();

            instance.WithContainer(container);

            instance.Container.Should().Be(container);
        }
        public void Given_Uri_When_WithBaseLocation_Invoked_Then_It_Should_Return_Result(string uri)
        {
            var instance = new BlobStorageSchemaSink();

            var result = instance.WithBaseLocation(new Uri(uri));

            result.BaseLocation.Trim('/').Should().BeEquivalentTo(uri.Trim('/'));
        }
        public void Given_Null_Uri_When_WithBaseLocation_Invoked_Then_It_Should_Throw_Exception()
        {
            var instance = new BlobStorageSchemaSink();

            Action action = () => instance.WithBaseLocation((Uri)null);

            action.Should().Throw <ArgumentNullException>();
        }
        public void Given_Location_When_Instantiated_Then_It_Should_Return_Result(string location)
        {
            var instance = default(BlobStorageSchemaSink);

            instance = new BlobStorageSchemaSink(location);
            instance.BaseLocation.Should().Be(location);

            instance = new BlobStorageSchemaSink(new Uri(location));
            instance.BaseLocation.Trim('/').Should().Be(location.Trim('/'));
        }
        public void Given_Location_With_BlobClient_When_Instantiated_Then_It_Should_Return_Result(string location, string blobUri)
        {
            var instance   = default(BlobStorageSchemaSink);
            var blobClient = new CloudBlobClient(new Uri(blobUri));

            instance = new BlobStorageSchemaSink(location, blobClient);
            instance.BaseLocation.Trim('/').Should().Be(blobUri.Trim('/'));

            instance = new BlobStorageSchemaSink(new Uri(location), blobClient);
            instance.BaseLocation.Trim('/').Should().Be(blobUri.Trim('/'));
        }
        private static ISchemaSink GetBlobSchemaSink(Options options)
        {
            var blobClient = CloudStorageAccount.Parse(options.BlobConnectionString)
                             .CreateCloudBlobClient();

            var sink = new BlobStorageSchemaSink(blobClient)
                       .WithBaseLocation(options.BlobBaseUri)
                       .WithContainer(options.Container);

            return(sink);
        }
Exemple #10
0
        private void ConfigureSchemaValidation(IServiceCollection services)
        {
            var blobConnectionString = Environment.GetEnvironmentVariable(StorageConnectionStringKey);
            var blobClient           = CloudStorageAccount.Parse(blobConnectionString)
                                       .CreateCloudBlobClient();
            var sink = new BlobStorageSchemaSink(blobClient);

            services.AddSingleton <ISchemaSink, BlobStorageSchemaSink>(_ => sink);
            services.AddSingleton <ISchemaConsumer, SchemaConsumer>();
            services.AddSingleton <ISchemaValidator, SchemaValidator>();
        }
        public void Given_HttpClient_When_WithContainer_Invoked_Then_It_Should_Return_Result()
        {
            var sink      = new BlobStorageSchemaSink();
            var uri       = new Uri("https://localhost");
            var container = "lorem-ipsum";

            var result = SchemaSinkExtensions.WithContainer(sink, container);

            result
            .Should().NotBeNull()
            .And.BeAssignableTo <ISchemaSink>();
        }
        public void Given_HttpClient_When_WithHttpClient_Invoked_Then_It_Should_Return_Result()
        {
            var sink       = new BlobStorageSchemaSink();
            var uri        = new Uri("https://localhost");
            var blobClient = new CloudBlobClient(uri);

            var result = SchemaSinkExtensions.WithBlobClient(sink, blobClient);

            result
            .Should().NotBeNull()
            .And.BeAssignableTo <ISchemaSink>();
        }
        public void Given_BlobClient_When_WithBlobClient_Invoked_Then_It_Should_Return_Result(string blobUri)
        {
            var blobClient = new CloudBlobClient(new Uri(blobUri));
            var instance   = new BlobStorageSchemaSink();

            var result = instance.WithBlobClient(blobClient);

            result.BaseLocation.Trim('/').Should().Be(blobUri.Trim('/'));

            var field = typeof(BlobStorageSchemaSink).GetField("_blobClient", BindingFlags.NonPublic | BindingFlags.Instance);

            field.GetValue(instance).Should().Be(blobClient);
        }
        public void Given_Null_Parameters_When_SetSchemaAsync_Invoked_Then_It_Should_Throw_Exception()
        {
            var schema   = "{ \"lorem\": \"ipsum\" }";
            var instance = new BlobStorageSchemaSink();

            var func = default(Func <Task>);

            func = async() => await instance.SetSchemaAsync(null, null).ConfigureAwait(false);

            func.Should().Throw <ArgumentNullException>();

            func = async() => await instance.SetSchemaAsync(schema, null).ConfigureAwait(false);

            func.Should().Throw <ArgumentNullException>();
        }
        public async Task Given_Invalid_Container_When_GetSchemaAsync_Invoked_Then_It_Should_Throw_Exception(string container, string path)
        {
            var account    = CloudStorageAccount.DevelopmentStorageAccount;
            var blobClient = account.CreateCloudBlobClient();
            await blobClient.GetContainerReference(container)
            .DeleteIfExistsAsync()
            .ConfigureAwait(false);

            var instance = new BlobStorageSchemaSink(blobClient)
                           .WithContainer(container);

            Func <Task> func = async() => await instance.GetSchemaAsync(path).ConfigureAwait(false);

            func.Should().Throw <BlobContainerNotFoundException>();
        }
        public async Task Given_Blob_When_SetSchemaAsync_Invoked_Then_It_Should_Return_Result(string container, string path, string schema)
        {
            var account       = CloudStorageAccount.DevelopmentStorageAccount;
            var blobClient    = account.CreateCloudBlobClient();
            var blobContainer = blobClient.GetContainerReference(container);
            await blobContainer.CreateIfNotExistsAsync().ConfigureAwait(false);

            var blob = blobContainer.GetBlockBlobReference(path);
            await blob.UploadTextAsync(schema).ConfigureAwait(false);

            var instance = new BlobStorageSchemaSink(blobClient)
                           .WithContainer(container);

            var result = await instance.SetSchemaAsync(schema, path).ConfigureAwait(false);

            result.Should().BeTrue();

            await blob.DeleteIfExistsAsync().ConfigureAwait(false);

            await blobClient.GetContainerReference(container)
            .DeleteIfExistsAsync()
            .ConfigureAwait(false);
        }