public async Task InvokeMethodAsync_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var metadata = new Dictionary <string, string>();
metadata.Add("key1", "value1");
metadata.Add("key2", "value2");
var task = daprClient.InvokeMethodAsync <InvokedResponse>("test", "test", metadata);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
envelope.Metadata.Count.Should().Be(2);
envelope.Metadata.Keys.Contains("key1").Should().BeTrue();
envelope.Metadata.Keys.Contains("key2").Should().BeTrue();
envelope.Metadata["key1"].Should().Be("value1");
envelope.Metadata["key2"].Should().Be("value2");
}
public async Task InvokeBindingAsync_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var metadata = new Dictionary <string, string>();
metadata.Add("key1", "value1");
metadata.Add("key2", "value2");
var invokeRequest = new InvokeRequest()
{
RequestParameter = "Hello "
};
var task = daprClient.InvokeBindingAsync <InvokeRequest>("test", invokeRequest, metadata);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeBindingEnvelope>(entry.Request);
envelope.Name.Should().Be("test");
envelope.Metadata.Count.Should().Be(2);
envelope.Metadata.Keys.Contains("key1").Should().BeTrue();
envelope.Metadata.Keys.Contains("key2").Should().BeTrue();
envelope.Metadata["key1"].Should().Be("value1");
envelope.Metadata["key2"].Should().Be("value2");
var json = envelope.Data.Value.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json);
typeFromRequest.RequestParameter.Should().Be("Hello ");
}
public async Task InvokeMethodAsync_CanInvokeMethodWithNoReturnTypeAndData_ThrowsErrorNonSuccess()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.InvokeMethodAsync <InvokeRequest>("test", "test", new InvokeRequest()
{
RequestParameter = "Hello "
});
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
var json = envelope.Data.Value.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json);
typeFromRequest.RequestParameter.Should().Be("Hello ");
// Create Response & Respond
var response = GrpcUtils.CreateResponse(HttpStatusCode.NotAcceptable);
entry.Completion.SetResult(response);
//validate response
await FluentActions.Awaiting(async() => await task).Should().ThrowAsync <RpcException>();
}
public async Task InvokeMethodAsync_CanInvokeMethodWithReturnTypeNoData_ThrowsExceptionNonSuccess()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.InvokeMethodAsync <InvokedResponse>("test", "test");
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
// Create Response & Respond
var response = GrpcUtils.CreateResponse(HttpStatusCode.NotAcceptable);
entry.Completion.SetResult(response);
//validate response
await FluentActions.Awaiting(async() => await task).Should().ThrowAsync <RpcException>();
}
public async Task InvokeMethodAsync_WithNoReturnTypeAndData_UsesConfiguredJsonSerializerOptions()
{
// Configure Client
var httpClient = new TestHttpClient();
var jsonOptions = new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.UseJsonSerializationOptions(jsonOptions)
.Build();
var invokeRequest = new InvokeRequest()
{
RequestParameter = "Hello"
};
var task = daprClient.InvokeMethodAsync <InvokeRequest, InvokedResponse>("test", "test", invokeRequest);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
var json = envelope.Data.Value.ToStringUtf8();
json.Should().Be(JsonSerializer.Serialize(invokeRequest, jsonOptions));
}
public async Task SaveStateAsync_CanSaveState()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var widget = new Widget()
{
Size = "small", Color = "yellow",
};
var task = daprClient.SaveStateAsync("testStore", "test", widget);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.SaveStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Requests.Count.Should().Be(1);
var request = envelope.Requests[0];
request.Key.Should().Be("test");
var stateJson = request.Value.Value.ToStringUtf8();
var stateFromRequest = JsonSerializer.Deserialize <Widget>(stateJson);
stateFromRequest.Size.Should().Be(widget.Size);
stateFromRequest.Color.Should().Be(widget.Color);
}
public async Task InvokeMethodAsync_CanInvokeMethodWithReturnTypeAndData()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.InvokeMethodAsync <InvokedResponse>("test", "test");
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
// Create Response & Respond
var data = new InvokedResponse()
{
Name = "Look, I was invoked!"
};
SendResponse(data, entry);
// Validate Response
var invokedResponse = await task;
invokedResponse.Name.Should().Be("Look, I was invoked!");
}
public async Task GetStateAsync_ValidateRequest(ConsistencyMode consistencyMode, string expectedConsistencyMode)
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.GetStateAsync <Widget>("testStore", "test", consistencyMode);
// Get Request & Validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.GetStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test");
envelope.Consistency.Should().Be(expectedConsistencyMode);
// Create Response & Respond
SendResponseWithState <Widget>(null, entry);
// Get response and validate
var state = await task;
state.Should().BeNull();
}
public async Task GetSecretAsync_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var metadata = new Dictionary <string, string>();
metadata.Add("key1", "value1");
metadata.Add("key2", "value2");
var task = daprClient.GetSecretAsync("testStore", "test_key", metadata);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.GetSecretEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test_key");
envelope.Metadata.Count.Should().Be(2);
envelope.Metadata.Keys.Contains("key1").Should().BeTrue();
envelope.Metadata.Keys.Contains("key2").Should().BeTrue();
envelope.Metadata["key1"].Should().Be("value1");
envelope.Metadata["key2"].Should().Be("value2");
}
public async Task InvokeMethodAsync_CanInvokeMethodWithReturnTypeAndData_EmptyResponseReturnsNull()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.InvokeMethodAsync <InvokeRequest, InvokedResponse>("test", "test", new InvokeRequest()
{
RequestParameter = "Hello "
});
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceEnvelope>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Method.Should().Be("test");
var json = envelope.Data.Value.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json);
typeFromRequest.RequestParameter.Should().Be("Hello ");
// Create Response & Respond
SendResponse <InvokedResponse>(null, entry);
// Validate Response.
var invokedResponse = await task;
invokedResponse.Should().BeNull();
}
public async Task InvokeMethodAsync_WithReturnTypeAndData_WithNonDefaultVerb_WithQueryString_UsesConfiguredJsonSerializerOptions()
{
// Configure Client
var httpClient = new TestHttpClient();
var jsonOptions = new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.UseJsonSerializationOptions(jsonOptions)
.Build();
var invokeRequest = new InvokeRequest()
{
RequestParameter = "Hello "
};
var invokedResponse = new InvokedResponse {
Name = "Look, I was invoked!"
};
Dictionary <string, string> queryString = new Dictionary <string, string>();
queryString.Add("key1", "value1");
var httpExtension = new Http.HTTPExtension()
{
Verb = HTTPVerb.Put,
QueryString = queryString
};
var task = daprClient.InvokeMethodAsync <InvokeRequest, InvokedResponse>("test", "test", invokeRequest, httpExtension);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceRequest>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Message.Method.Should().Be("test");
envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationJson);
envelope.Message.HttpExtension.Verb.Should().Be(Autogen.Grpc.v1.HTTPExtension.Types.Verb.Put);
envelope.Message.HttpExtension.Querystring.Count.Should().Be(1);
envelope.Message.HttpExtension.Querystring.ContainsKey("key1").Should().BeTrue();
envelope.Message.HttpExtension.Querystring["key1"].Should().Be("value1");
var json = envelope.Message.Data.Value.ToStringUtf8();
json.Should().Be(JsonSerializer.Serialize(invokeRequest, jsonOptions));
SendResponse(invokedResponse, entry, jsonOptions);
var response = await task;
response.Name.Should().Be(invokedResponse.Name);
}
public async Task GetStateEntryAsync_CanSaveState()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.GetStateEntryAsync <Widget>("testStore", "test");
// Create Response & Respond
var data = new Widget()
{
Size = "small", Color = "yellow",
};
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
SendResponseWithState(data, entry);
var state = await task;
state.Key.Should().Be("test");
state.Value.Size.Should().Be("small");
state.Value.Color.Should().Be("yellow");
// Modify the state and save it
state.Value.Color = "green";
var task2 = state.SaveAsync();
// Get Request and validate
httpClient.Requests.TryDequeue(out entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.SaveStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Requests.Count.Should().Be(1);
var request = envelope.Requests[0];
request.Key.Should().Be("test");
var stateJson = request.Value.Value.ToStringUtf8();
var stateFromRequest = JsonSerializer.Deserialize <Widget>(stateJson);
stateFromRequest.Size.Should().Be("small");
stateFromRequest.Color.Should().Be("green");
}
public async Task DeleteStateAsync_CanDeleteState()
{
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.DeleteStateAsync("testStore", "test");
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.DeleteStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test");
}
public async Task GetSecretAsync_ReturnMultipleSecrets()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var metadata = new Dictionary <string, string>();
metadata.Add("key1", "value1");
metadata.Add("key2", "value2");
var task = daprClient.GetSecretAsync("testStore", "test_key", metadata);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.GetSecretEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test_key");
envelope.Metadata.Count.Should().Be(2);
envelope.Metadata.Keys.Contains("key1").Should().BeTrue();
envelope.Metadata.Keys.Contains("key2").Should().BeTrue();
envelope.Metadata["key1"].Should().Be("value1");
envelope.Metadata["key2"].Should().Be("value2");
// Create Response & Respond
var secrets = new Dictionary <string, string>();
secrets.Add("redis_secret", "Guess_Redis");
secrets.Add("kafka_secret", "Guess_Kafka");
await SendResponseWithSecrets(secrets, entry);
// Get response and validate
var secretsResponse = await task;
secretsResponse.Count.Should().Be(2);
secretsResponse.ContainsKey("redis_secret").Should().BeTrue();
secretsResponse["redis_secret"].Should().Be("Guess_Redis");
secretsResponse.ContainsKey("kafka_secret").Should().BeTrue();
secretsResponse["kafka_secret"].Should().Be("Guess_Kafka");
}
public async Task TryDeleteStateAsync_ValidateOptions(
ConsistencyMode consistencyMode,
ConcurrencyMode concurrencyMode,
RetryMode retryMode,
string expectedConsistency,
string expectedConcurrency,
string expectedRetryMode)
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var stateOptions = new StateOptions
{
Concurrency = concurrencyMode,
Consistency = consistencyMode,
RetryOptions = new RetryOptions
{
RetryInterval = TimeSpan.FromSeconds(5),
RetryMode = retryMode,
RetryThreshold = 10
}
};
var task = daprClient.TryDeleteStateAsync("testStore", "test", "Test_Etag", stateOptions);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.DeleteStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test");
envelope.Etag.Should().Be("Test_Etag");
envelope.Options.Concurrency.Should().Be(expectedConcurrency);
envelope.Options.Consistency.Should().Be(expectedConsistency);
envelope.Options.RetryPolicy.Pattern.Should().Be(expectedRetryMode);
envelope.Options.RetryPolicy.Threshold.Should().Be(10);
envelope.Options.RetryPolicy.Interval.Seconds.Should().Be(5);
}
public async Task PublishEventAsync_CanPublishTopicWithNoContent()
{
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.PublishEventAsync("test");
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <PublishEventEnvelope>(entry.Request);
var jsonFromRequest = envelope.Data.Value.ToStringUtf8();
envelope.Topic.Should().Be("test");
jsonFromRequest.Should().Be("\"\"");
}
public async Task InvokeMethodAsync_CanInvokeMethodWithNoReturnTypeAndData()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
InvokeRequest invokeRequest = new InvokeRequest()
{
RequestParameter = "Hello "
};
var task = daprClient.InvokeMethodAsync <InvokeRequest>("test", "test", invokeRequest);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceRequest>(entry.Request);
envelope.Id.Should().Be("test");
envelope.Message.Method.Should().Be("test");
envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationJson);
var json = envelope.Message.Data.Value.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json);
typeFromRequest.RequestParameter.Should().Be("Hello ");
// Create Response & Respond
var response = new InvokedResponse()
{
Name = "Look, I was invoked!"
};
SendResponse(response, entry);
FluentActions.Awaiting(async() => await task).Should().NotThrow();
}
public async Task PublishEventAsync_CanPublishTopicWithContent()
{
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var publishContent = new PublishContent()
{
PublishObjectParameter = "testparam"
};
var task = daprClient.PublishEventAsync <PublishContent>("test", publishContent);
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <PublishEventEnvelope>(entry.Request);
var jsonFromRequest = envelope.Data.Value.ToStringUtf8();
envelope.Topic.Should().Be("test");
jsonFromRequest.Should().Be(JsonSerializer.Serialize(publishContent));
}
public async Task GetStateEntryAsync_CanDeleteState()
{
// Configure client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.GetStateEntryAsync <Widget>("testStore", "test");
// Create Response & Respond
var data = new Widget()
{
Size = "small", Color = "yellow",
};
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
SendResponseWithState(data, entry);
var state = await task;
state.Key.Should().Be("test");
state.Value.Size.Should().Be("small");
state.Value.Color.Should().Be("yellow");
state.Value.Color = "green";
var task2 = state.DeleteAsync();
// Get Request and validate
httpClient.Requests.TryDequeue(out entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.DeleteStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Key.Should().Be("test");
}
public async Task InvokeMethodAsync_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var queryString = new Dictionary <string, string>();
queryString.Add("key1", "value1");
queryString.Add("key2", "value2");
var httpExtension = new Http.HTTPExtension()
{
Verb = HTTPVerb.Post,
QueryString = queryString
};
var task = daprClient.InvokeMethodAsync <InvokedResponse>("app1", "mymethod", httpExtension);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceRequest>(entry.Request);
envelope.Id.Should().Be("app1");
envelope.Message.Method.Should().Be("mymethod");
envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationJson);
envelope.Message.HttpExtension.Verb.Should().Be(Autogen.Grpc.v1.HTTPExtension.Types.Verb.Post);
envelope.Message.HttpExtension.Querystring.Count.Should().Be(2);
envelope.Message.HttpExtension.Querystring.ContainsKey("key1").Should().BeTrue();
envelope.Message.HttpExtension.Querystring.ContainsKey("key2").Should().BeTrue();
envelope.Message.HttpExtension.Querystring["key1"].Should().Be("value1");
envelope.Message.HttpExtension.Querystring["key2"].Should().Be("value2");
}
public async Task SaveStateAsync_CanClearState()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var task = daprClient.SaveStateAsync <object>("testStore", "test", null);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.SaveStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Requests.Count.Should().Be(1);
var request = envelope.Requests[0];
request.Key.Should().Be("test");
request.Value.Should().BeNull();
}
public async Task InvokeMethodAsync_NoVerbSpecifiedByUser_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
// httpExtension not specified
var task = daprClient.InvokeMethodAsync <InvokedResponse>("app1", "mymethod");
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <InvokeServiceRequest>(entry.Request);
envelope.Id.Should().Be("app1");
envelope.Message.Method.Should().Be("mymethod");
envelope.Message.ContentType.Should().Be(Constants.ContentTypeApplicationJson);
envelope.Message.HttpExtension.Verb.Should().Be(Autogen.Grpc.v1.HTTPExtension.Types.Verb.Post);
envelope.Message.HttpExtension.Querystring.Count.Should().Be(0);
}
public async Task TrySaveStateAsync_ValidateOptions(
ConsistencyMode consistencyMode,
ConcurrencyMode concurrencyMode,
RetryMode retryMode,
string expectedConsistency,
string expectedConcurrency,
string expectedRetryMode)
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var widget = new Widget()
{
Size = "small", Color = "yellow",
};
var stateOptions = new StateOptions
{
Concurrency = concurrencyMode,
Consistency = consistencyMode,
RetryOptions = new RetryOptions
{
RetryInterval = TimeSpan.FromSeconds(5),
RetryMode = retryMode,
RetryThreshold = 10
}
};
var metadata = new Dictionary <string, string>();
metadata.Add("key1", "value1");
metadata.Add("key2", "value2");
var task = daprClient.TrySaveStateAsync("testStore", "test", widget, "Test_Etag", stateOptions, metadata);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var envelope = await GrpcUtils.GetEnvelopeFromRequestMessageAsync <Autogenerated.SaveStateEnvelope>(entry.Request);
envelope.StoreName.Should().Be("testStore");
envelope.Requests.Count.Should().Be(1);
var request = envelope.Requests[0];
request.Key.Should().Be("test");
request.Etag.Should().Be("Test_Etag");
request.Metadata.Count.Should().Be(2);
request.Metadata.Keys.Contains("key1").Should().BeTrue();
request.Metadata.Keys.Contains("key2").Should().BeTrue();
request.Metadata["key1"].Should().Be("value1");
request.Metadata["key2"].Should().Be("value2");
request.Options.Concurrency.Should().Be(expectedConcurrency);
request.Options.Consistency.Should().Be(expectedConsistency);
request.Options.RetryPolicy.Pattern.Should().Be(expectedRetryMode);
request.Options.RetryPolicy.Threshold.Should().Be(10);
request.Options.RetryPolicy.Interval.Seconds.Should().Be(5);
var stateJson = request.Value.Value.ToStringUtf8();
var stateFromRequest = JsonSerializer.Deserialize <Widget>(stateJson);
stateFromRequest.Size.Should().Be(widget.Size);
stateFromRequest.Color.Should().Be(widget.Color);
}