public static object ShouldBeConstantParameterWithValueType <TValue>(this OperationSegmentParameter parameter, string name, TValue value)
{
Assert.Equal(name, parameter.Name);
ConstantNode constantNode = Assert.IsType <ConstantNode>(parameter.Value);
if (value == null)
{
Assert.Null(constantNode.Value);
}
else
{
if (typeof(TValue).IsPrimitive() || typeof(TValue) == typeof(decimal))
{
// for int value --> long TValue
TValue tmp = (TValue)Convert.ChangeType(constantNode.Value, typeof(TValue));
Assert.NotNull(tmp);
Assert.Equal(value, tmp);
}
else if (typeof(TValue) == typeof(UriTemplateExpression))
{
UriTemplateExpression actual = Assert.IsType <UriTemplateExpression>(constantNode.Value);
UriTemplateExpression expect = Assert.IsType <UriTemplateExpression>(value);
Assert.Equal(expect.LiteralText, actual.LiteralText);
Assert.Equal(expect.ExpectedType.FullName(), expect.ExpectedType.FullName());
}
else
{
constantNode.Value.GetType().IsAssignableFrom(typeof(TValue));
Assert.Equal(value, constantNode.Value);
}
}
return(constantNode.Value);
}
private static object GetParameterValue(OperationSegment segment, string paramName)
{
if (segment == null)
{
throw Error.ArgumentNull("segment");
}
if (string.IsNullOrEmpty(paramName))
{
throw Error.ArgumentNullOrEmpty("parameterName");
}
if (!segment.Operations.Any() || !segment.Operations.First().IsFunction())
{
throw Error.Argument("segment");
}
OperationSegmentParameter parameter = segment.Parameters.FirstOrDefault(p => p.Name == paramName);
Assert.NotNull(parameter);
ConstantNode node = parameter.Value as ConstantNode;
if (node != null)
{
return(node.Value);
}
return(TranslateNode(parameter.Value));
}
public void BuildPath_AliasInFunctionImport_enum()
{
Uri fullUri = new Uri("http://gobbledygook/GetPetCount(colorPattern=@p1)?@p1=Fully.Qualified.Namespace.ColorPattern'BlueYellowStriped'");
ODataUriParser odataUriParser = new ODataUriParser(HardCodedTestModel.TestModel, serviceRoot, fullUri);
SetODataUriParserSettingsTo(this.settings, odataUriParser.Settings);
odataUriParser.UrlKeyDelimiter = ODataUrlKeyDelimiter.Parentheses;
ODataUri odataUri = odataUriParser.ParseUri();
IDictionary <string, SingleValueNode> aliasNodes = odataUri.ParameterAliasNodes;
OperationSegmentParameter p = odataUri.Path.LastSegment.ShouldBeOperationImportSegment(HardCodedTestModel.GetFunctionImportForGetPetCount()).And.Parameters.First();
p.Name.Should().Be("colorPattern");
p.Value.As <ParameterAliasNode>().Alias.Should().Be("@p1");
p.Value.As <ParameterAliasNode>().TypeReference.IsEnum().Should().Be(true);
p.Value.As <ParameterAliasNode>().TypeReference.Definition.FullTypeName().ShouldBeEquivalentTo("Fully.Qualified.Namespace.ColorPattern");
aliasNodes["@p1"].As <ConstantNode>().Value.As <ODataEnumValue>().TypeName.Should().Be("Fully.Qualified.Namespace.ColorPattern");
aliasNodes["@p1"].As <ConstantNode>().Value.As <ODataEnumValue>().Value.Should().Be("22");
aliasNodes["@p1"].TypeReference.IsEnum().Should().Be(true);
Uri actualUri = odataUri.BuildUri(ODataUrlKeyDelimiter.Parentheses);
Assert.Equal(fullUri, actualUri);
actualUri = odataUri.BuildUri(ODataUrlKeyDelimiter.Slash);
Assert.Equal(fullUri, actualUri);
}
public static AndConstraint <T> ShouldBeConstantParameterWithValueType <T>(this OperationSegmentParameter parameter, string name)
{
parameter.Name.Should().Be(name);
object val = parameter.Value.As <ConstantNode>().Value;
val.Should().BeAssignableTo <T>();
return(new AndConstraint <T>((T)val));
}
public static AndConstraint <OperationSegment> ShouldHaveSegmentOfParameterAliasNode(this OperationSegment segment, string name, string alias, IEdmTypeReference typeReference = null)
{
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == name);
parameter.Should().NotBeNull();
parameter.ShouldHaveParameterAliasNode(name, alias, typeReference);
return(new AndConstraint <OperationSegment>(segment));
}
public static T ShouldBeConstantParameterWithValueType <T>(this OperationSegmentParameter parameter, string name)
{
Assert.Equal(name, parameter.Name);
object val = Assert.IsType <ConstantNode>(parameter.Value).Value;
Assert.IsType <T>(val);
return((T)val);
}
private string Translate(OperationSegmentParameter parameter)
{
string val = parameter.Value is ConstantNode
? ((ConstantNode)parameter.Value).ToLogString()
: parameter.Value.ToString();
return(string.Format("{0}={1}", parameter.Name, val));
}
public static AndConstraint <OperationImportSegment> ShouldHaveConstantParameter <TValue>(this OperationImportSegment segment, string name, TValue value)
{
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == name);
parameter.Should().NotBeNull();
parameter.ShouldBeConstantParameterWithValueType(name, value);
return(new AndConstraint <OperationImportSegment>(segment));
}
public static OperationSegment ShouldHaveSegmentOfParameterAliasNode(this OperationSegment segment, string name, string alias, IEdmTypeReference typeReference = null)
{
Assert.NotNull(segment);
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == name);
Assert.NotNull(parameter);
parameter.ShouldHaveParameterAliasNode(name, alias, typeReference);
return(segment);
}
public static OperationImportSegment ShouldHaveConstantParameter <TValue>(this OperationImportSegment segment, string name, TValue value)
{
Assert.NotNull(segment);
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == name);
Assert.NotNull(parameter);
parameter.ShouldBeConstantParameterWithValueType(name, value);
return(segment);
}
internal static List <OperationSegmentParameter> BindSegmentParameters(ODataUriParserConfiguration configuration, IEdmOperation functionOrOpertion, ICollection <FunctionParameterToken> segmentParameterTokens)
{
// TODO: HandleComplexOrCollectionParameterValueIfExists is temp work around for single copmlex or colleciton type, it can't handle nested complex or collection value.
ICollection <FunctionParameterToken> parametersParsed = FunctionCallBinder.HandleComplexOrCollectionParameterValueIfExists(configuration.Model, functionOrOpertion, segmentParameterTokens, configuration.Resolver.EnableCaseInsensitive, configuration.EnableUriTemplateParsing);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = null;
state.RangeVariables.Clear();
MetadataBinder binder = new MetadataBinder(state);
List <OperationSegmentParameter> boundParameters = new List <OperationSegmentParameter>();
IDictionary <string, SingleValueNode> input = new Dictionary <string, SingleValueNode>(StringComparer.Ordinal);
foreach (var paraToken in parametersParsed)
{
// TODO: considering another better exception
if (paraToken.ValueToken is EndPathToken)
{
throw new ODataException(Strings.MetadataBinder_ParameterNotInScope(
string.Format(CultureInfo.InvariantCulture, "{0}={1}", paraToken.ParameterName, (paraToken.ValueToken as EndPathToken).Identifier)));
}
SingleValueNode boundNode = (SingleValueNode)binder.Bind(paraToken.ValueToken);
if (!input.ContainsKey(paraToken.ParameterName))
{
input.Add(paraToken.ParameterName, boundNode);
}
}
IDictionary <IEdmOperationParameter, SingleValueNode> result = configuration.Resolver.ResolveOperationParameters(functionOrOpertion, input);
foreach (var item in result)
{
SingleValueNode boundNode = item.Value;
// ensure node type is compatible with parameter type.
var sourceTypeReference = boundNode.GetEdmTypeReference();
bool sourceIsNullOrOpenType = (sourceTypeReference == null);
if (!sourceIsNullOrOpenType)
{
// if the node has been rewritten, no further conversion is needed.
if (!TryRewriteIntegralConstantNode(ref boundNode, item.Key.Type))
{
boundNode = MetadataBindingUtils.ConvertToTypeIfNeeded(boundNode, item.Key.Type);
}
}
OperationSegmentParameter boundParamer = new OperationSegmentParameter(item.Key.Name, boundNode);
boundParameters.Add(boundParamer);
}
return(boundParameters);
}
public void ActionWithTemplateShouldWork()
{
IEdmFunction operation = HardCodedTestModel.GetHasDogOverloadForPeopleWithTwoParameters();
IList <ODataPathSegment> path = this.templateParser.ParsePath(new[] { "Boss", "Fully.Qualified.Namespace.HasDog(inOffice={fido})" });
OperationSegmentParameter parameter = path[1].ShouldBeOperationSegment(operation).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("inOffice", new UriTemplateExpression {
LiteralText = "{fido}", ExpectedType = operation.Parameters.Last().Type
});
}
public void FunctionImportWithTemplateShouldWork()
{
IEdmOperationImport operationImport = HardCodedTestModel.GetFunctionImportForFindMyOwner();
IList <ODataPathSegment> path = this.templateParser.ParsePath(new[] { "FindMyOwner(dogsName={fido})" });
OperationSegmentParameter parameter = path[0].ShouldBeOperationImportSegment(operationImport).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("dogsName", new UriTemplateExpression {
LiteralText = "{fido}", ExpectedType = operationImport.Operation.Parameters.Single().Type
});
}
public void ParseParameterTemplateWithTemplateParser()
{
var uriParser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("http://host"), new Uri("http://host/People(1)/Fully.Qualified.Namespace.HasHat(onCat={why555})"))
{
EnableUriTemplateParsing = true
};
IEdmFunction function = HardCodedTestModel.TestModel.FindOperations("Fully.Qualified.Namespace.HasHat").Single(f => f.Parameters.Count() == 2).As <IEdmFunction>();
var path = uriParser.ParsePath();
OperationSegmentParameter parameter = path.LastSegment.ShouldBeOperationSegment(function).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("onCat", new UriTemplateExpression {
LiteralText = "{why555}", ExpectedType = function.Parameters.Last().Type
});
}
public void ParseParameterTemplateOfEnumTypeWithTemplateParser()
{
var uriParser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("GetPetCount(colorPattern={COLOR})", UriKind.Relative))
{
EnableUriTemplateParsing = true
};
IEdmOperationImport operationImport = HardCodedTestModel.TestModel.EntityContainer.FindOperationImports("GetPetCount").Single();
var path = uriParser.ParsePath();
OperationSegmentParameter parameter = path.LastSegment.ShouldBeOperationImportSegment(operationImport).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("colorPattern", new UriTemplateExpression {
LiteralText = "{COLOR}", ExpectedType = operationImport.Operation.Parameters.Single().Type
});
}
public void ParseParameterTemplateForFunctionImportWithTemplateParser()
{
var uriParser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("IsAddressGood(address={ADDR})", UriKind.Relative))
{
EnableUriTemplateParsing = true
};
IEdmFunctionImport functionImport = HardCodedTestModel.TestModel.EntityContainer.FindOperationImports("IsAddressGood").Single().As <IEdmFunctionImport>();
var path = uriParser.ParsePath();
OperationSegmentParameter parameter = path.LastSegment.ShouldBeOperationImportSegment(functionImport).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("address", new UriTemplateExpression {
LiteralText = "{ADDR}", ExpectedType = functionImport.Function.Parameters.Single().Type
});
}
public void ParsePath_AliasInFunctionImport_enum()
{
ParseUriAndVerify(
new Uri("http://gobbledygook/GetPetCount(colorPattern=@p1)?@p1=Fully.Qualified.Namespace.ColorPattern'BlueYellowStriped'"),
(oDataPath, filterClause, orderByClause, selectExpandClause, aliasNodes) =>
{
OperationSegmentParameter p = oDataPath.LastSegment.ShouldBeOperationImportSegment(HardCodedTestModel.GetFunctionImportForGetPetCount()).And.Parameters.First();
p.Name.Should().Be("colorPattern");
p.Value.As <ParameterAliasNode>().Alias.Should().Be("@p1");
p.Value.As <ParameterAliasNode>().TypeReference.IsEnum().Should().Be(true);
p.Value.As <ParameterAliasNode>().TypeReference.Definition.FullTypeName().ShouldBeEquivalentTo("Fully.Qualified.Namespace.ColorPattern");
aliasNodes["@p1"].As <ConstantNode>().Value.As <ODataEnumValue>().TypeName.Should().Be("Fully.Qualified.Namespace.ColorPattern");
aliasNodes["@p1"].As <ConstantNode>().Value.As <ODataEnumValue>().Value.Should().Be("22");
aliasNodes["@p1"].TypeReference.IsEnum().Should().Be(true);
});
}
public static AndConstraint <ConvertNode> ShouldHaveConvertNode(this OperationSegmentParameter parameter,
string name, IEdmTypeReference typeReference = null)
{
parameter.Name.Should().Be(name);
var node = parameter.Value.As <ConvertNode>();
if (typeReference == null)
{
node.TypeReference.Should().BeNull();
}
else
{
node.TypeReference.FullName().Should().Be(typeReference.FullName());
}
return(new AndConstraint <ConvertNode>(node));
}
public static ConvertNode ShouldHaveConvertNode(this OperationSegmentParameter parameter,
string name, IEdmTypeReference typeReference = null)
{
Assert.Equal(name, parameter.Name);
var node = Assert.IsType <ConvertNode>(parameter.Value);
if (typeReference == null)
{
Assert.Null(node.TypeReference);
}
else
{
Assert.Equal(node.TypeReference.FullName(), typeReference.FullName());
}
return(node);
}
/// <summary>
/// Gets the value of an operation from the URL segments when available
/// </summary>
/// <param name="parameter">Parameter to look for</param>
/// <returns>Value provided by the HTTP snippet</returns>
private static string GetParameterValueFromOperationUrlSegement(OperationSegmentParameter parameter, bool returnEnumTypeIfEnum)
{
switch (parameter.Value)
{
case ConvertNode convertNode when convertNode.Source is ConstantNode cNode:
return($"\"{cNode.Value}\"");
case ConstantNode constantNode when constantNode.TypeReference.Definition.TypeKind == EdmTypeKind.Enum && returnEnumTypeIfEnum:
return($"{constantNode.TypeReference.Definition.FullTypeName()}{constantNode.LiteralText}");
case ConstantNode constantNode:
return(constantNode.LiteralText);
default:
return(null);
}
}
internal static List <OperationSegmentParameter> BindSegmentParameters(ODataUriParserConfiguration configuration, IEdmOperation functionOrOpertion, ICollection <FunctionParameterToken> segmentParameterTokens)
{
// TODO: HandleComplexOrCollectionParameterValueIfExists is temp work around for single copmlex or colleciton type, it can't handle nested complex or collection value.
ICollection <FunctionParameterToken> parametersParsed = FunctionCallBinder.HandleComplexOrCollectionParameterValueIfExists(configuration.Model, functionOrOpertion, segmentParameterTokens, configuration.EnableUriTemplateParsing);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = null;
state.RangeVariables.Clear();
MetadataBinder binder = new MetadataBinder(state);
List <OperationSegmentParameter> boundParameters = new List <OperationSegmentParameter>();
foreach (var paraToken in parametersParsed)
{
// TODO: considering another better exception
if (paraToken.ValueToken is EndPathToken)
{
throw new ODataException(Strings.MetadataBinder_ParameterNotInScope(
string.Format(CultureInfo.InvariantCulture, "{0}={1}", paraToken.ParameterName, (paraToken.ValueToken as EndPathToken).Identifier)));
}
SingleValueNode boundNode = (SingleValueNode)binder.Bind(paraToken.ValueToken);
// ensure parameter name existis
var functionParameter = functionOrOpertion.FindParameter(paraToken.ParameterName);
if (functionParameter == null)
{
throw new ODataException(Strings.ODataParameterWriterCore_ParameterNameNotFoundInOperation(paraToken.ParameterName, functionOrOpertion.Name));
}
// ensure node type is compatible with parameter type.
var sourceTypeReference = boundNode.GetEdmTypeReference();
bool sourceIsNullOrOpenType = (sourceTypeReference == null);
if (!sourceIsNullOrOpenType)
{
boundNode = MetadataBindingUtils.ConvertToTypeIfNeeded(boundNode, functionParameter.Type);
}
OperationSegmentParameter boundParamer = new OperationSegmentParameter(paraToken.ParameterName, boundNode);
boundParameters.Add(boundParamer);
}
return(boundParameters);
}
public void ValidTemplateInputShouldWork()
{
var inputs = new[]
{
"{}", "{_12}", "{12}", "{j}", "{count}",
"{temp1}", "{top_of_p}", "{skip12}", "{LastNum}", "{_1V!@$%^&*}",
"{(}", "{)}", "{)(*&^%$@!}", "{___}", "{_v1V)_}",
"{變量}", "{嵐山}", "{춘향전}", "{的1_vé@_@}", "{{}and{}}",
};
// Validate template for parameters
IEdmFunction function = HardCodedTestModel.TestModel.FindOperations("Fully.Qualified.Namespace.HasHat").Single(f => f.Parameters.Count() == 2).As <IEdmFunction>();
foreach (var input in inputs)
{
var uriParser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("People(1)/Fully.Qualified.Namespace.HasHat(onCat=" + input + ")", UriKind.Relative))
{
EnableUriTemplateParsing = true
};
var path = uriParser.ParsePath();
OperationSegmentParameter parameter = path.LastSegment.ShouldBeOperationSegment(function).And.Parameters.Single();
parameter.ShouldBeConstantParameterWithValueType("onCat", new UriTemplateExpression {
LiteralText = input, ExpectedType = function.Parameters.Last().Type
});
}
// Validate template for keys
foreach (var input in inputs)
{
var uriParser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("http://host"), new Uri("http://host/People(" + input + ")"))
{
EnableUriTemplateParsing = true
};
var path = uriParser.ParsePath();
var keySegment = path.LastSegment.As <KeySegment>();
KeyValuePair <string, object> keypair = keySegment.Keys.Single();
keypair.Key.Should().Be("ID");
keypair.Value.As <UriTemplateExpression>().ShouldBeEquivalentTo(new UriTemplateExpression()
{
LiteralText = input, ExpectedType = keySegment.EdmType.As <IEdmEntityType>().DeclaredKey.Single().Type
});
}
}
public void BuildPathWithFunctionImport()
{
ODataUri odataUri = new ODataUri();
odataUri.ServiceRoot = new Uri("http://gobbledygook/");
IEdmOperationImport functionImport = HardCodedTestModel.TestModel.EntityContainer.FindOperationImports("GetPet1").Single();
IEdmEntitySetReferenceExpression reference = functionImport.EntitySet as IEdmEntitySetReferenceExpression;
OperationSegmentParameter[] parameters = new OperationSegmentParameter[] { new OperationSegmentParameter("id", new ConstantNode(1, "1")) };
odataUri.Path = new ODataPath(new OperationImportSegment(
new IEdmOperationImport[] { functionImport },
reference.ReferencedEntitySet,
parameters));
ODataUriBuilder odataUriBuilder = new ODataUriBuilder(ODataUrlConventions.Default, odataUri);
Uri actual = odataUriBuilder.BuildUri();
Assert.Equal(new Uri("http://gobbledygook/GetPet1(id=1)"), actual);
}
public void MatchForFunction_ReturnsBuiltEnumParameters(string enumValue)
{
// Arrange
EdmModel model = new EdmModel();
EdmEnumType enumType = new EdmEnumType("NS", "Color");
enumType.AddMember("Red", new EdmEnumMemberValue(1));
enumType.AddMember("Green", new EdmEnumMemberValue(2));
model.AddElement(enumType);
var intType = EdmCoreModel.Instance.GetInt32(false);
EdmFunction function = new EdmFunction("NS", "MyFunction", intType);
function.AddParameter("favoriateColor", new EdmEnumTypeReference(enumType, false));
model.AddElement(function);
RouteValueDictionary routeValues = new RouteValueDictionary()
{
{ "favoriateColorValue", $"{enumValue}" }
};
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValues,
Model = model
};
IDictionary <string, string> parameterMappings = new Dictionary <string, string>
{
{ "favoriateColor", "favoriateColorValue" }
};
// Act
IList <OperationSegmentParameter> parameters = SegmentTemplateHelpers.Match(context, function, parameterMappings);
// Assert
OperationSegmentParameter operationParameter = Assert.Single(parameters);
Assert.Equal("favoriateColor", operationParameter.Name);
ODataEnumValue oDataEnumValue = Assert.IsType <ODataEnumValue>(operationParameter.Value);
Assert.Equal("2", oDataEnumValue.Value);
}
public void ParametersSetCorrectly()
{
OperationImportSegment segment = new OperationImportSegment(new List <IEdmOperationImport>()
{
HardCodedTestModel.GetFunctionImportForGetCoolestPerson()
},
HardCodedTestModel.GetPeopleSet(),
new[] { new OperationSegmentParameter("stuff", new ConstantNode(new ODataPrimitiveValue(true))), });
OperationSegmentParameter parameter = segment.Parameters.SingleOrDefault(p => p.Name == "stuff");
Assert.NotNull(parameter);
ConstantNode constantNode = Assert.IsType <ConstantNode>(parameter.Value);
var actual = Assert.IsType <ODataPrimitiveValue>(constantNode.Value);
Assert.Equal(true, actual.Value);
}
/// <summary>
/// Gets the parameter value.
/// </summary>
/// <param name="segment">The function segment</param>
/// <param name="parameterName">The parameter name</param>
/// <returns>The parameter value</returns>
public static object GetParameterValue(this OperationSegment segment, string parameterName)
{
if (segment == null)
{
throw Error.ArgumentNull("segment");
}
if (String.IsNullOrEmpty(parameterName))
{
throw Error.ArgumentNullOrEmpty("parameterName");
}
if (!segment.Operations.Any() || !segment.Operations.First().IsFunction())
{
throw Error.Argument("segment", SRResources.OperationSegmentMustBeFunction);
}
OperationSegmentParameter parameter = segment.Parameters.FirstOrDefault(p => p.Name == parameterName);
if (parameter == null)
{
throw Error.Argument("parameterName", SRResources.FunctionParameterNotFound, parameterName);
}
object value = TranslateNode(parameter.Value);
if (value == null || value is ODataNullValue)
{
IEdmOperation operation = segment.Operations.First();
IEdmOperationParameter operationParameter = operation.Parameters.First(p => p.Name == parameterName);
Contract.Assert(operationParameter != null);
if (!operationParameter.Type.IsNullable)
{
throw new ODataException(String.Format(CultureInfo.InvariantCulture,
SRResources.NullOnNonNullableFunctionParameter, operationParameter.Type.FullName()));
}
}
return(value);
}
public void MatchForFunction_ReturnsBuiltParameters_ParameterAlias()
{
// Arrange
var strType = EdmCoreModel.Instance.GetString(false);
EdmModel model = new EdmModel();
EdmFunction function = new EdmFunction("NS", "MyFunction", strType, true, null, false);
function.AddParameter("name", strType);
model.AddElement(function);
RouteValueDictionary routeValues = new RouteValueDictionary()
{
{ "nameValue", "@p" }
};
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.QueryString = new QueryString("?@p='abc'");
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
HttpContext = httpContext,
RouteValues = routeValues,
Model = model
};
IDictionary <string, string> parameterMappings = new Dictionary <string, string>
{
{ "name", "nameValue" }
};
// Act
IList <OperationSegmentParameter> parameters = SegmentTemplateHelpers.Match(context, function, parameterMappings);
// Assert
OperationSegmentParameter functionParameter = Assert.Single(parameters);
Assert.Equal("name", functionParameter.Name);
Assert.Equal("abc", functionParameter.Value);
}
public static bool TryGetParameterValue(this OperationSegment segment, string parameterName, out object parameterValue)
{
if (segment == null)
{
throw Error.ArgumentNull("segment");
}
if (String.IsNullOrEmpty(parameterName))
{
throw Error.ArgumentNullOrEmpty("parameterName");
}
parameterValue = null;
OperationSegmentParameter parameter = segment.Parameters.FirstOrDefault(p => p.Name == parameterName);
if (parameter == null)
{
return(false);
}
parameterValue = TranslateNode(parameter.Value);
return(true);
}
public static AndConstraint <T> ShouldHaveValueType <T>(this OperationSegmentParameter parameter, string name)
{
parameter.Name.Should().Be(name);
parameter.Value.Should().BeAssignableTo <T>();
return(new AndConstraint <T>((T)parameter.Value));
}
public static AndConstraint <object> ShouldBeConstantParameterWithValueType <TValue>(this OperationSegmentParameter parameter, string name, TValue value)
{
parameter.Name.Should().Be(name);
ConstantNode constantNode = parameter.Value.As <ConstantNode>();
if (value == null)
{
constantNode.Value.Should().BeNull();
}
else
{
if (typeof(TValue).IsPrimitive() || typeof(TValue) == typeof(decimal))
{
// for int value --> long TValue
TValue tmp = (TValue)Convert.ChangeType(constantNode.Value, typeof(TValue));
tmp.Should().NotBeNull();
tmp.ShouldBeEquivalentTo(value);
}
else
{
constantNode.Value.Should().BeAssignableTo <TValue>();
constantNode.Value.As <TValue>().ShouldBeEquivalentTo(value);
}
}
return(new AndConstraint <object>(constantNode.Value));
}
