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)); }