internal StringContent CreateContent(KSqlDbStatement ksqlDbStatement) { var json = JsonSerializer.Serialize(ksqlDbStatement); var data = new StringContent(json, ksqlDbStatement.ContentEncoding, MediaType); return(data); }
public void StatementText_WasSet() { //Arrange var ksqlDbStatement = new KSqlDbStatement(Statement); //Act var statementText = ksqlDbStatement.Sql; //Assert statementText.Should().Be(Statement); }
public void ContentEncoding_DefaultIsUTF8() { //Arrange var ksqlDbStatement = new KSqlDbStatement(Statement); //Act var defaultEncoding = ksqlDbStatement.ContentEncoding; //Assert defaultEncoding.Should().Be(Encoding.UTF8); }
public void GetEndpoint_DefaultIs_KSql() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var endpoint = KSqlDbRestApiClient.GetEndpoint(ksqlDbStatement); //Assert endpoint.Should().Be("/ksql"); }
public void EndpointType_DefaultIsKSql() { //Arrange var ksqlDbStatement = new KSqlDbStatement(Statement); //Act var endpointType = ksqlDbStatement.EndpointType; //Assert endpointType.Should().Be(EndpointType.KSql); }
public void CreateContent_MediaTypeAndCharsetWereApplied() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var stringContent = ClassUnderTest.CreateContent(ksqlDbStatement); //Assert stringContent.Headers.ContentType.MediaType.Should().Be(KSqlDbRestApiClient.MediaType); stringContent.Headers.ContentType.CharSet.Should().Be(Encoding.UTF8.WebName); }
internal static string GetEndpoint(KSqlDbStatement ksqlDbStatement) { var endpoint = ksqlDbStatement.EndpointType switch { EndpointType.KSql => "/ksql", EndpointType.Query => "/query", _ => throw new ArgumentOutOfRangeException() }; return(endpoint); } }
public async Task CreateContent_KSqlContentWasSet() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var stringContent = ClassUnderTest.CreateContent(ksqlDbStatement); //Assert var content = await GetContent(stringContent); content.Should().Be(@$ "{{" "ksql" ":" "{createOrReplaceTableStatement}" "," "streamsProperties" ":{{}}}}"); }
internal HttpRequestMessage CreateHttpRequestMessage(KSqlDbStatement ksqlDbStatement) { var data = CreateContent(ksqlDbStatement); var endpoint = GetEndpoint(ksqlDbStatement); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpoint) { Content = data }; return(httpRequestMessage); }
public async Task ExecuteStatementAsync_HttpClientWasCalled_OkResult() { //Arrange var ksqlDbStatement = new KSqlDbStatement(statement); //Act var httpResponseMessage = await ClassUnderTest.ExecuteStatementAsync(ksqlDbStatement); //Assert httpResponseMessage.Should().NotBeNull(); Mock.Get(HttpClientFactory).Verify(c => c.CreateClient(), Times.Once); }
public void CreateHttpRequestMessage_HttpRequestMessage_WasConfigured() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var httpRequestMessage = ClassUnderTest.CreateHttpRequestMessage(ksqlDbStatement); //Assert httpRequestMessage.Method.Should().Be(HttpMethod.Post); httpRequestMessage.RequestUri.Should().Be("/ksql"); httpRequestMessage.Content.Headers.ContentType.MediaType.Should().Be(KSqlDbRestApiClient.MediaType); }
private Task <HttpResponseMessage> ExecuteStatementAsync(KSqlDbStatement ksqlDbStatement, CancellationToken cancellationToken = default) { var httpClient = new HttpClient() { BaseAddress = ksqlDbUrl }; var httpClientFactory = new HttpClientFactory(httpClient); var restApiClient = new KSqlDbRestApiClient(httpClientFactory); return(restApiClient.ExecuteStatementAsync(ksqlDbStatement, cancellationToken)); }
public async Task CreateHttpRequestMessage_HttpRequestMessage_ContentWasSet() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var httpRequestMessage = ClassUnderTest.CreateHttpRequestMessage(ksqlDbStatement); //Assert var content = await httpRequestMessage.Content.ReadAsStringAsync(); content.Should().Be(@$ "{{" "ksql" ":" "{createOrReplaceTableStatement}" "," "streamsProperties" ":{{}}}}"); }
public async Task <HttpResponseMessage> ExecuteStatementAsync(KSqlDbStatement ksqlDbStatement, CancellationToken cancellationToken = default) { using var httpClient = httpClientFactory.CreateClient(); var httpRequestMessage = CreateHttpRequestMessage(ksqlDbStatement); httpClient.DefaultRequestHeaders.Accept.Add( new MediaTypeWithQualityHeaderValue(MediaType)); var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage, cancellationToken) .ConfigureAwait(false); return(httpResponseMessage); }
public void GetEndpoint_OverridenToQueryEndpoint() { //Arrange var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement) { EndpointType = EndpointType.Query }; //Act var endpoint = KSqlDbRestApiClient.GetEndpoint(ksqlDbStatement); //Assert endpoint.Should().Be("/query"); }
public async Task CreateOrReplaceStreamStatement_ToStatementString_ComplexQueryWasGenerated() { //Arrange var restApiClient = KSqlDbRestApiProvider.Create(); var statement = new KSqlDbStatement(StatementTemplates.DropStream(StreamName)); var response = await restApiClient.ExecuteStatementAsync(statement); EntityCreationMetadata metadata = new() { EntityName = StreamEntityName, KafkaTopic = nameof(Movie) + "Test2", Partitions = 1, Replicas = 1 }; var httpResponseMessage = await restApiClient.CreateStreamAsync <Movie>(metadata, ifNotExists : false); var creationMetadata = new CreationMetadata { KafkaTopic = "moviesByTitle", KeyFormat = SerializationFormats.Json, ValueFormat = SerializationFormats.Json, Replicas = 1, Partitions = 1 }; var createStatement = Context.CreateOrReplaceStreamStatement(StreamName) .With(creationMetadata) .As <Movie>(StreamEntityName) .Where(c => c.Id < 3) .Select(c => new { c.Id, c.Title, ReleaseYear = c.Release_Year }) .PartitionBy(c => c.Id); //Act var ksql = createStatement.ToStatementString(); httpResponseMessage = await createStatement.ExecuteStatementAsync(); //Assert ksql.Should().BeEquivalentTo(@$ "CREATE OR REPLACE STREAM {StreamName} WITH ( KAFKA_TOPIC='moviesByTitle', KEY_FORMAT='Json', VALUE_FORMAT='Json', PARTITIONS='1', REPLICAS='1' ) AS SELECT Id, Title, Release_Year AS ReleaseYear FROM {StreamEntityName} WHERE Id < 3 PARTITION BY Id EMIT CHANGES;"); var responses = await httpResponseMessage.ToStatementResponsesAsync(); responses[0].CommandStatus.Status.Should().BeOneOf("SUCCESS", "EXECUTING"); }
public Task <HttpResponseMessage> ExecuteStatementAsync(CancellationToken cancellationToken = default) { serviceScope = serviceScopeFactory.CreateScope(); cancellationToken.Register(() => serviceScope?.Dispose()); var restApiClient = serviceScope.ServiceProvider.GetService <IKSqlDbRestApiClient>(); serviceScope.Dispose(); var ksqlQuery = BuildKsql(); var dBStatement = new KSqlDbStatement(ksqlQuery); return(restApiClient?.ExecuteStatementAsync(dBStatement, cancellationToken)); }
public void CreateContent_Encoding_OverridenCharsetWasApplied() { //Arrange var encoding = Encoding.Unicode; var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement) { ContentEncoding = encoding }; //Act var stringContent = ClassUnderTest.CreateContent(ksqlDbStatement); //Assert stringContent.Headers.ContentType.CharSet.Should().Be(encoding.WebName); }
public async Task ExecuteStatementAsync_LogInformation() { //Arrange CreateHttpMocks(StatementResponse); var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement); //Act var httpResponseMessage = await ClassUnderTest.ExecuteStatementAsync(ksqlDbStatement); //Assert httpResponseMessage.Should().NotBeNull(); LoggerMock.VerifyLog(LogLevel.Debug, Times.Once); LoggerMock.VerifyLog(LogLevel.Information, Times.Once); }
public async Task CreateContent_CommandSequenceNumber() { //Arrange long commandSequenceNumber = 1000; var ksqlDbStatement = new KSqlDbStatement(createOrReplaceTableStatement) { CommandSequenceNumber = commandSequenceNumber }; //Act var stringContent = ClassUnderTest.CreateContent(ksqlDbStatement); //Assert var content = await GetContent(stringContent); content.Should().Be(@$ "{{" "commandSequenceNumber" ":{commandSequenceNumber}," "ksql" ":" "{createOrReplaceTableStatement}" "," "streamsProperties" ":{{}}}}"); }
public async Task ExecuteStatementAsync_HttpClientWasCalled_OkResult() { //Arrange var ksqlDbStatement = new KSqlDbStatement(statement); var restApiClient = new KSqlDbRestApiClient(HttpClientFactory); var httpResponseMessage = await restApiClient.ExecuteStatementAsync(ksqlDbStatement); //Act var responses = httpResponseMessage.ToStatementResponses(); //Assert responses[0].CommandStatus.Message.Should().Be("Table created"); responses[0].CommandStatus.Status.Should().Be("SUCCESS"); responses[0].CommandId.Should().Be("table/`MOVIES`/create"); responses[0].CommandSequenceNumber.Should().Be(328); }
public async Task CreateOrReplaceTableStatement_ExecuteStatementAsync_ResponseWasReceived() { //Arrange var restApiClient = KSqlDbRestApiProvider.Create(); await restApiClient.CreateStreamAsync <Movie>(new EntityCreationMetadata(EntityName, 1) { EntityName = EntityName, ShouldPluralizeEntityName = false }); var statement = new KSqlDbStatement(StatementTemplates.DropTable(TableName)); var response = await restApiClient.ExecuteStatementAsync(statement); int retryCount = 0; while ((await KSqlDbRestApiProvider.Create().GetTablesAsync()).SelectMany(c => c.Tables).Any(c => c.Name == TableName.ToUpper())) { if (retryCount++ > 5) { return; } await Task.Delay(TimeSpan.FromSeconds(1)); } var createStatement = Context.CreateTableStatement(TableName) .As <Movie>(EntityName) .GroupBy(c => c.Title) .Select(c => new { Title = c.Key, Count = c.Count() }); //Act var httpResponseMessage = await createStatement.ExecuteStatementAsync(); //Assert string responseContent = await httpResponseMessage.Content.ReadAsStringAsync(); responseContent.Should().NotBeNull(); var responses = await httpResponseMessage.ToStatementResponsesAsync(); responses[0].CommandStatus.Status.Should().Be("SUCCESS"); }
public async Task <bool> CreateTablesAsync() { var createMoviesTable = $@"CREATE OR REPLACE TABLE {MoviesTableName} ( title VARCHAR PRIMARY KEY, id INT, release_year INT ) WITH ( KAFKA_TOPIC='{MoviesTableName}', PARTITIONS=1, VALUE_FORMAT = 'JSON' );"; KSqlDbStatement ksqlDbStatement = new(createMoviesTable); var result = await restApiProvider.ExecuteStatementAsync(ksqlDbStatement); var isSuccess = result.IsSuccess(); isSuccess.Should().BeTrue(); var createActorsTable = $@"CREATE OR REPLACE TABLE {ActorsTableName} ( title VARCHAR PRIMARY KEY, actor_name VARCHAR ) WITH ( KAFKA_TOPIC='{ActorsTableName}', PARTITIONS=1, VALUE_FORMAT='JSON' );"; ksqlDbStatement = new KSqlDbStatement(createActorsTable); result = await restApiProvider.ExecuteStatementAsync(ksqlDbStatement); isSuccess = result.IsSuccess(); isSuccess.Should().BeTrue(); return(true); }
public static async Task ClassInitialize(TestContext context) { RestApiProvider = KSqlDbRestApiProvider.Create(); var statement = new KSqlDbStatement( @"CREATE STREAM stream2 (id INT, lambda_arr ARRAY<INTEGER>) WITH (kafka_topic = 'stream2', partitions = 1, value_format = 'json');"); var response = await RestApiProvider.ExecuteStatementAsync(statement); var statement2 = new KSqlDbStatement( @"CREATE OR REPLACE STREAM stream4 (id INT, lambda_map MAP<STRING,ARRAY<INTEGER>>) WITH (kafka_topic = 'stream4', partitions = 1, value_format = 'json');"); response = await RestApiProvider.ExecuteStatementAsync(statement2); string insertIntoStream3 = "insert into stream4 (id, lambda_map) values (1, MAP('hello':= ARRAY [1,2,3], 'goodbye':= ARRAY [-1,-2,-3]) );"; response = await RestApiProvider.ExecuteStatementAsync( new KSqlDbStatement("insert into stream2 (id, lambda_arr) values (1, ARRAY [1,2,3]);")); response = await RestApiProvider.ExecuteStatementAsync( new KSqlDbStatement(insertIntoStream3)); }
internal HttpRequestMessage CreateHttpRequestMessage(KSqlDbStatement ksqlDbStatement) { return(CreateHttpRequestMessage(ksqlDbStatement, ksqlDbStatement.EndpointType, ksqlDbStatement.ContentEncoding)); }
internal static string GetEndpoint(KSqlDbStatement ksqlDbStatement) { return(GetEndpoint(ksqlDbStatement.EndpointType)); }
private Task <HttpResponseMessage> ExecuteAsync <T>(string ksql, CancellationToken cancellationToken = default) { var ksqlStatement = new KSqlDbStatement(ksql); return(ExecuteStatementAsync(ksqlStatement, cancellationToken)); }
/// <summary> /// Run a sequence of SQL statements. /// </summary> /// <param name="ksqlDbStatement">The text of the SQL statements.</param> /// <param name="cancellationToken">Optional cancellation token to cancel the operation</param> /// <returns></returns> public Task <HttpResponseMessage> ExecuteStatementAsync(KSqlDbStatement ksqlDbStatement, CancellationToken cancellationToken = default) { logger?.LogInformation($"Executing command: {ksqlDbStatement.Sql}"); return(ExecuteStatementAsync(ksqlDbStatement, ksqlDbStatement.EndpointType, ksqlDbStatement.ContentEncoding, cancellationToken)); }
internal StringContent CreateContent(KSqlDbStatement ksqlDbStatement) { return(CreateContent(ksqlDbStatement, ksqlDbStatement.ContentEncoding)); }