public async Task ToRpc_Collection_Byte_With_Capabilities_Value()
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, RpcWorkerConstants.TypedDataCollection }
};
capabilities.UpdateCapabilities(addedCapabilities);
byte[][] arrBytes = new byte[2][];
arrBytes[0] = new byte[] { 22 };
arrBytes[1] = new byte[] { 11 };
TypedData returned_typedata = await arrBytes.ToRpc(logger, capabilities);
TypedData typedData = new TypedData();
CollectionBytes collectionBytes = new CollectionBytes();
foreach (byte[] element in arrBytes)
{
if (element != null)
{
collectionBytes.Bytes.Add(ByteString.CopyFrom(element));
}
}
typedData.CollectionBytes = collectionBytes;
Assert.Equal(typedData.CollectionBytes, returned_typedata.CollectionBytes);
Assert.Equal(typedData.CollectionBytes.Bytes[0], returned_typedata.CollectionBytes.Bytes[0]);
}
public async Task ToRpc_Collection_Long_With_Capabilities_Value()
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, RpcWorkerConstants.TypedDataCollection }
};
capabilities.UpdateCapabilities(addedCapabilities);
long[] arrLong = { 1L, 2L };
TypedData returned_typedata = await arrLong.ToRpc(logger, capabilities);
TypedData typedData = new TypedData();
CollectionSInt64 collectionLong = new CollectionSInt64();
foreach (long element in arrLong)
{
collectionLong.Sint64.Add(element);
}
typedData.CollectionSint64 = collectionLong;
Assert.Equal(typedData.CollectionSint64, returned_typedata.CollectionSint64);
Assert.Equal(typedData.CollectionSint64.Sint64[0], returned_typedata.CollectionSint64.Sint64[0]);
}
public async Task ToRpc_Collection_Double_With_Capabilities_Value()
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, RpcWorkerConstants.TypedDataCollection }
};
capabilities.UpdateCapabilities(addedCapabilities);
double[] arrDouble = { 1.1, 2.2 };
TypedData returned_typedata = await arrDouble.ToRpc(logger, capabilities);
TypedData typedData = new TypedData();
CollectionDouble collectionDouble = new CollectionDouble();
foreach (double element in arrDouble)
{
collectionDouble.Double.Add(element);
}
typedData.CollectionDouble = collectionDouble;
Assert.Equal(typedData.CollectionDouble, returned_typedata.CollectionDouble);
Assert.Equal(typedData.CollectionDouble.Double[0], returned_typedata.CollectionDouble.Double[0]);
}
public async Task ToRpc_Collection_String_With_Capabilities_Value()
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, RpcWorkerConstants.TypedDataCollection }
};
capabilities.UpdateCapabilities(addedCapabilities);
string[] arrString = { "element1", "element_2" };
TypedData returned_typedata = await arrString.ToRpc(logger, capabilities);
TypedData typedData = new TypedData();
CollectionString collectionString = new CollectionString();
foreach (string element in arrString)
{
if (!string.IsNullOrEmpty(element))
{
collectionString.String.Add(element);
}
}
typedData.CollectionString = collectionString;
Assert.Equal(typedData.CollectionString, returned_typedata.CollectionString);
Assert.Equal(typedData.CollectionString.String[0], returned_typedata.CollectionString.String[0]);
}
public async Task HttpObjects_Headers(bool ignoreEmptyValues, string[] headerKeys, string[] headerValues, string[] expectedKeys, string[] expectedValues)
{
var logger = MockNullLoggerFactory.CreateLogger();
// Capability must be enabled
var capabilities = new GrpcCapabilities(logger);
if (ignoreEmptyValues)
{
capabilities.UpdateCapabilities(new MapField <string, string>
{
{ RpcWorkerConstants.IgnoreEmptyValuedRpcHttpHeaders, "true" }
});
}
var headerDictionary = new HeaderDictionary();
for (int i = 0; i < headerValues.Length; i++)
{
headerDictionary.Add(headerKeys[i], headerValues[i]);
}
HttpRequest request = HttpTestHelpers.CreateHttpRequest("GET", $"http://localhost/api/httptrigger-scenarios", headerDictionary);
var rpcRequestObject = await request.ToRpc(logger, capabilities);
// Same key and value strings for each pair
for (int i = 0; i < expectedKeys.Length; i++)
{
Assert.True(rpcRequestObject.Http.Headers.ContainsKey(expectedKeys[i]));
Assert.Equal(expectedValues[i], rpcRequestObject.Http.Headers.GetValueOrDefault(expectedKeys[i]));
}
}
public void Capability_Handled_Correctly(string value)
{
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ testCapability2, value }
};
_capabilities.UpdateCapabilities(addedCapabilities);
Assert.Equal(value, _capabilities.GetCapabilityState(testCapability2));
var logs = _loggerProvider.GetAllLogMessages().Select(p => p.FormattedMessage).ToArray();
Assert.Collection(logs,
p => Assert.Equal($"Updating capabilities: {{ \"{testCapability2}\": \"{value}\" }}", p));
}
public void Setup()
{
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, "1" }
};
grpcCapabilities.UpdateCapabilities(addedCapabilities);
}
public async Task ToRpc_Bytes_With_Capabilities_Value()
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.TypedDataCollection, RpcWorkerConstants.TypedDataCollection }
};
capabilities.UpdateCapabilities(addedCapabilities);
byte[] arrByte = Encoding.Default.GetBytes("HellowWorld");
TypedData returned_typedata = await arrByte.ToRpc(logger, capabilities);
TypedData typedData = new TypedData();
typedData.Bytes = ByteString.CopyFrom(arrByte);
Assert.Equal(typedData.Bytes, returned_typedata.Bytes);
}
public async Task HttpObjects_RawBodyBytes_Image_Length(string contentType, string rawBytesEnabled)
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
if (!string.Equals(rawBytesEnabled, null))
{
capabilities.UpdateCapabilities(new MapField <string, string>
{
{ RpcWorkerConstants.RawHttpBodyBytes, rawBytesEnabled.ToString() }
});
}
FileStream image = new FileStream(TestImageLocation, FileMode.Open, FileAccess.Read);
byte[] imageBytes = FileStreamToBytes(image);
string imageString = Encoding.UTF8.GetString(imageBytes);
long imageBytesLength = imageBytes.Length;
long imageStringLength = imageString.Length;
var headers = new HeaderDictionary();
headers.Add("content-type", contentType);
HttpRequest request = HttpTestHelpers.CreateHttpRequest("GET", "http://localhost/api/httptrigger-scenarios", headers, imageBytes);
var rpcRequestObject = await request.ToRpc(logger, capabilities);
if (string.IsNullOrEmpty(rawBytesEnabled))
{
Assert.Empty(rpcRequestObject.Http.RawBody.Bytes);
Assert.Equal(imageStringLength, rpcRequestObject.Http.RawBody.String.Length);
}
else
{
Assert.Empty(rpcRequestObject.Http.RawBody.String);
Assert.Equal(imageBytesLength, rpcRequestObject.Http.RawBody.Bytes.ToByteArray().Length);
}
}
public async Task HttpTrigger_Post_ByteArray(string expectedContentType, bool rcpHttpBodyOnly)
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
if (rcpHttpBodyOnly)
{
capabilities.UpdateCapabilities(new MapField <string, string>
{
{ RpcWorkerConstants.RpcHttpBodyOnly, rcpHttpBodyOnly.ToString() }
});
}
var headers = new HeaderDictionary();
headers.Add("content-type", expectedContentType);
byte[] body = new byte[] { 1, 2, 3, 4, 5 };
HttpRequest request = HttpTestHelpers.CreateHttpRequest("POST", "http://localhost/api/httptrigger-scenarios", headers, body);
var rpcRequestObject = await request.ToRpc(logger, capabilities);
if (rcpHttpBodyOnly)
{
Assert.Equal(null, rpcRequestObject.Http.RawBody);
Assert.Equal(body, rpcRequestObject.Http.Body.Bytes);
}
else
{
Assert.Equal(body, rpcRequestObject.Http.Body.Bytes);
Assert.Equal(Encoding.UTF8.GetString(body), rpcRequestObject.Http.RawBody.String);
}
string contentType;
rpcRequestObject.Http.Headers.TryGetValue("content-type", out contentType);
Assert.Equal(expectedContentType, contentType);
}
public async Task HttpObjects_JsonBody(string expectedContentType, string body, bool rcpHttpBodyOnly)
{
var logger = MockNullLoggerFactory.CreateLogger();
var capabilities = new GrpcCapabilities(logger);
if (rcpHttpBodyOnly)
{
capabilities.UpdateCapabilities(new MapField <string, string>
{
{ RpcWorkerConstants.RpcHttpBodyOnly, rcpHttpBodyOnly.ToString() }
});
}
var headers = new HeaderDictionary();
headers.Add("content-type", expectedContentType);
HttpRequest request = HttpTestHelpers.CreateHttpRequest("GET", "http://localhost/api/httptrigger-scenarios", headers, body);
var rpcRequestObject = await request.ToRpc(logger, capabilities);
if (rcpHttpBodyOnly)
{
Assert.Equal(null, rpcRequestObject.Http.RawBody);
Assert.Equal(body.ToString(), rpcRequestObject.Http.Body.String);
}
else
{
Assert.Equal(body.ToString(), rpcRequestObject.Http.RawBody.String);
Assert.Equal(JsonConvert.DeserializeObject(body), JsonConvert.DeserializeObject(rpcRequestObject.Http.Body.Json));
}
string contentType;
rpcRequestObject.Http.Headers.TryGetValue("content-type", out contentType);
Assert.Equal(expectedContentType, contentType);
}
public async Task ToRpcInvocationRequest_Http_OmitsDuplicateBodyOfBindingData()
{
var logger = new TestLogger("test");
var httpContext = new DefaultHttpContext();
httpContext.Request.Host = new HostString("local");
httpContext.Request.Path = "/test";
httpContext.Request.Method = "Post";
var inputs = new List <(string name, DataType type, object val)>
{
("req", DataType.String, httpContext.Request)
};
var bindingData = new Dictionary <string, object>
{
{ "req", httpContext.Request },
{ "$request", httpContext.Request },
{ "headers", httpContext.Request.Headers.ToDictionary(p => p.Key, p => p.Value) },
{ "query", httpContext.Request.QueryString.ToString() },
{ "sys", new SystemBindingData() }
};
var invocationContext = new ScriptInvocationContext()
{
ExecutionContext = new ExecutionContext()
{
InvocationId = Guid.NewGuid(),
FunctionName = "Test",
},
BindingData = bindingData,
Inputs = inputs,
ResultSource = new TaskCompletionSource <ScriptInvocationResult>(),
Logger = logger,
AsyncExecutionContext = System.Threading.ExecutionContext.Capture()
};
var functionMetadata = new FunctionMetadata
{
Name = "Test"
};
var httpTriggerBinding = new BindingMetadata
{
Name = "req",
Type = "httpTrigger",
Direction = BindingDirection.In,
Raw = new JObject()
};
var httpOutputBinding = new BindingMetadata
{
Name = "res",
Type = "http",
Direction = BindingDirection.Out,
Raw = new JObject(),
DataType = DataType.String
};
functionMetadata.Bindings.Add(httpTriggerBinding);
functionMetadata.Bindings.Add(httpOutputBinding);
invocationContext.FunctionMetadata = functionMetadata;
GrpcCapabilities capabilities = new GrpcCapabilities(logger);
MapField <string, string> addedCapabilities = new MapField <string, string>
{
{ RpcWorkerConstants.RpcHttpTriggerMetadataRemoved, "1" },
{ RpcWorkerConstants.RpcHttpBodyOnly, "1" }
};
capabilities.UpdateCapabilities(addedCapabilities);
var result = await invocationContext.ToRpcInvocationRequest(logger, capabilities, isSharedMemoryDataTransferEnabled : false, _sharedMemoryManager);
Assert.Equal(1, result.InputData.Count);
Assert.Equal(2, result.TriggerMetadata.Count);
Assert.True(result.TriggerMetadata.ContainsKey("headers"));
Assert.True(result.TriggerMetadata.ContainsKey("query"));
}
