public void HttpOperationDescription_Insert_OutputParameters_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescriptionCollection mpdColl = od.Messages[1].Body.Parts;
Assert.AreEqual(1, mpdColl.Count, "Test assumes we start with 1 output param");
// Get a synchronized HOD and HODCollection
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
// Get an HPD for the newly created MPD
MessagePartDescription mpdNew = new MessagePartDescription("NewMPD", "NewMPDNS")
{
Type = typeof(byte)
};
HttpParameterDescription hpd = mpdNew.ToHttpParameterDescription();
// Add it to the output parameters
hpdColl.Add(hpd);
// Verify it appears in the MPD coll
Assert.AreEqual(2, mpdColl.Count, "Adding new MPD to HPD collection should have updated MPD collection");
Assert.AreEqual(2, od.Messages[1].Body.Parts.Count, "Adding new MPD should have updated Parts");
Assert.AreEqual(typeof(byte), od.Messages[1].Body.Parts[1].Type, "Adding new MPD failed due to type");
}
public void HttpOperationDescription_Update_ReturnValue_From_Incomplete_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
MessagePartDescription mpd = od.Messages[1].Body.ReturnValue;
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescription hpd = hod.ReturnValue;
// Clear out all of Messages[]
od.Messages.Clear();
Assert.IsNull(hod.ReturnValue, "ReturnValue should be null with no backing Messages[1]");
// Attempting to set a mock HPD should throw
ExceptionAssert.ThrowsInvalidOperation(
"Setting unsynchronized HPD to ReturnValue should throw",
() => hod.ReturnValue = new HttpParameterDescription()
{
ParameterType = typeof(string)
}
);
// Setting a valid ReturnValue should auto-create Messages[1]
hod.ReturnValue = hpd;
Assert.IsNotNull(hod.ReturnValue, "ReturnValue was not set");
Assert.AreSame(hpd.MessagePartDescription, hod.ReturnValue.MessagePartDescription, "ReturnValue not as expected");
Assert.AreEqual(2, od.Messages.Count, "Setting ReturnValue should have created Messages[1]");
}
public void HttpOperationDescription_Update_ReturnValue_From_OperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
HttpParameterDescription returnParameter = hod.ReturnValue;
Assert.IsNotNull(returnParameter, "Return parameter was null");
Assert.AreEqual(typeof(string), returnParameter.ParameterType, "Return parameter type should have been string");
// Update return MPD in-place
MessagePartDescription mpd = od.Messages[1].Body.ReturnValue;
mpd.Type = typeof(float);
Assert.AreEqual(typeof(float), hod.ReturnValue.ParameterType, "Updating OD ReturnValue in place should reflect in HOD");
// Insert a new MPD
mpd = new MessagePartDescription("NewName", "NewNamespace");
mpd.Type = typeof(double);
od.Messages[1].Body.ReturnValue = mpd;
Assert.AreEqual(typeof(double), hod.ReturnValue.ParameterType, "Inserting new OD ReturnValue should reflect in HOD");
// Remove the MPD
od.Messages.RemoveAt(1);
Assert.IsNull(hod.ReturnValue, "Removing return value message part should yield null ReturnValue");
}
public void HttpParameterDescription_Type_Property_Updated_From_MessagePartDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
MessagePartDescription mpd = od.Messages[0].Body.Parts[0];
HttpParameterDescription hpd = new HttpParameterDescription(mpd);
mpd.Type = typeof(float);
Assert.AreEqual(typeof(float), hpd.ParameterType, "Setting type on messagePartDescription should update http parameter description");
}
public void HttpParameterDescription_Default_Ctor()
{
HttpParameterDescription hpd = new HttpParameterDescription();
Assert.IsNull(hpd.ParameterType, "ProcessorType should have been null");
Assert.IsNull(hpd.Name, "Name should have been null");
Assert.IsNull(hpd.Namespace, "Namespace should have been null");
Assert.AreEqual(0, hpd.Index, "Index should have been zero");
Assert.IsNull(hpd.MessagePartDescription, "Internal messagePartDescription should be null");
}
public void HttpParameterDescription_Index_Property_Updates_MessagePartDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
MessagePartDescription mpd = od.Messages[0].Body.Parts[0];
HttpParameterDescription hpd = new HttpParameterDescription(mpd);
hpd.Index = 5;
Assert.AreEqual(5, mpd.Index, "Setting index on http parameter description should update messagePartDescription");
Assert.AreEqual(5, hpd.Index, "Setting index did not retain value");
}
public void HttpParameterDescription_ExtensionMethod_Creates_From_MessagePartDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescription mpd = od.Messages[1].Body.ReturnValue;
HttpParameterDescription hpd = mpd.ToHttpParameterDescription();
Assert.AreEqual("SampleMethodResult", hpd.Name, "Name was not set correctly");
Assert.AreEqual(typeof(string), hpd.ParameterType, "ProcessorType was not set correctly");
Assert.AreEqual(0, hpd.Index, "Index was not set correctly");
Assert.AreSame(mpd, hpd.MessagePartDescription, "Internal messagePartDescription should be what we passed to ctor");
}
public void HttpParameterDescription_Namespace_Immutable_From_MessagePartDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpParameterDescription hpd = new HttpParameterDescription(od.Messages[0].Body.Parts[0]);
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting namespace property should throw",
() => { hpd.Namespace = "newName"; }
);
}
public void HttpOperationDescription_Return_Parameter_Matches_Void_Method()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "NoParametersReturnsVoid");
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
HttpParameterDescription returnParameter = hod.ReturnValue;
Assert.IsNotNull(returnParameter, "Return parameter was null");
Assert.AreEqual(typeof(void), returnParameter.ParameterType, "Return parameter type should have been void");
}
public void HttpOperationDescription_Can_Be_Created_From_Simple_Types()
{
HttpOperationDescription hod = new HttpOperationDescription();
hod.ReturnValue = new HttpParameterDescription()
{
Name = "Return",
Namespace = "ReturnNS",
ParameterType = typeof(string),
Index = 0
};
hod.InputParameters.Add(new HttpParameterDescription()
{
Name = "InParameter",
Namespace = "InParameterNS",
ParameterType = typeof(int),
Index = 0
});
hod.OutputParameters.Add(new HttpParameterDescription()
{
Name = "OutParameter",
Namespace = "OutParameterNS",
ParameterType = typeof(string),
Index = 1
});
HttpParameterDescription parmDesc = hod.ReturnValue;
Assert.AreEqual("Return", parmDesc.Name, "ReturnValue.Name incorrect");
Assert.AreEqual("ReturnNS", parmDesc.Namespace, "ReturnValue.Namespace incorrect");
Assert.AreEqual(typeof(string), parmDesc.ParameterType, "ReturnValue.ParameterType incorrect");
Assert.AreEqual(0, parmDesc.Index, "ReturnValue.Index incorrect");
HttpParameterDescriptionCollection coll = hod.InputParameters;
Assert.AreEqual(1, coll.Count, "Input parameter collection should have 1 element");
parmDesc = coll[0];
Assert.AreEqual("InParameter", parmDesc.Name, "InputParameter.Name incorrect");
Assert.AreEqual("InParameterNS", parmDesc.Namespace, "InputParameter.Namespace incorrect");
Assert.AreEqual(typeof(int), parmDesc.ParameterType, "InputParameter.ParameterType incorrect");
Assert.AreEqual(0, parmDesc.Index, "InputParameter.Index incorrect");
coll = hod.OutputParameters;
Assert.AreEqual(1, coll.Count, "Output parameter collection should have 1 element");
parmDesc = coll[0];
Assert.AreEqual("OutParameter", parmDesc.Name, "OutParameter.Name incorrect");
Assert.AreEqual("OutParameterNS", parmDesc.Namespace, "OutParameter.Namespace incorrect");
Assert.AreEqual(typeof(string), parmDesc.ParameterType, "OutParameter.ParameterType incorrect");
Assert.AreEqual(1, parmDesc.Index, "OutParameter.Index incorrect");
}
public JsonValueProcessor(HttpParameterDescription parameter, MediaTypeProcessorMode mode)
: base(parameter, mode)
{
if (parameter != null)
{
parameterType = parameter.ParameterType;
isJsonValueParameter = typeof(JsonValue).IsAssignableFrom(parameterType);
if (!isJsonValueParameter)
{
serializer = new DataContractJsonSerializer(parameterType);
}
}
}
// Verifies that a HttpOperationDescription built from an OperationDescription
// matches the given MethodInfo for return type, parameters, and attributes
private void AssertHttpOperationDescriptionMatchesMethod(HttpOperationDescription hod, MethodInfo method)
{
Assert.IsNotNull(hod, "HttpOperationDescription was null");
Assert.AreEqual(hod.Name, method.Name, "Name mismatch");
HttpParameterDescription returnParameter = hod.ReturnValue;
Assert.AreEqual(returnParameter.ParameterType, method.ReturnType, "Return type mismatch");
IList <HttpParameterDescription> inputParameters = hod.InputParameters;
ParameterInfo[] parameters = method.GetParameters().Where(p => !p.IsOut).ToArray();
Assert.AreEqual(parameters.Length, inputParameters.Count, "Input parameter count mismatch");
for (int i = 0; i < parameters.Length; ++i)
{
Assert.AreEqual(parameters[i].Name, inputParameters[i].Name, "Input parameter name mismatch");
Assert.AreEqual(parameters[i].ParameterType, inputParameters[i].ParameterType, "Input parameter type mismatch");
}
IList <HttpParameterDescription> outputParameters = hod.OutputParameters;
parameters = method.GetParameters().Where(p => p.IsOut).ToArray();
Assert.AreEqual(parameters.Length, outputParameters.Count, "Output parameter count mismatch");
for (int i = 0; i < parameters.Length; ++i)
{
Assert.AreEqual(parameters[i].Name, outputParameters[i].Name, "Output parameter name mismatch");
// ServiceModel removes the ByRef part
Type t = parameters[i].ParameterType;
if (t.HasElementType && t.IsByRef)
{
t = t.GetElementType();
}
Assert.AreEqual(t, outputParameters[i].ParameterType, "Output parameter type mismatch");
}
IEnumerable <Attribute> hodAttributes = hod.Attributes;
IEnumerable <Attribute> methodAttributes = method.GetCustomAttributes(false).Cast <Attribute>().ToArray();
foreach (Attribute a in methodAttributes)
{
if (!hodAttributes.Contains(a))
{
Assert.Fail("Did not find attribute " + a.GetType().Name + " on method " + method.Name);
}
}
}
public void HttpParameterDescription_Construct_From_Simple_Properties()
{
HttpParameterDescription hpd = new HttpParameterDescription()
{
Name = "Sample",
Namespace = "SampleNS",
ParameterType = typeof(string),
Index = 1
};
Assert.AreEqual("Sample", hpd.Name, "Name was not set correctly");
Assert.AreEqual("SampleNS", hpd.Namespace, "Namespace was not set correctly");
Assert.AreEqual(typeof(string), hpd.ParameterType, "ProcessorType was not set correctly");
Assert.AreEqual(1, hpd.Index, "Index was not set correctly");
}
public void HttpOperationDescription_Return_Parameter_Matches_Method()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
HttpParameterDescription returnParameter = hod.ReturnValue;
Assert.IsNotNull(returnParameter, "Return parameter was null");
Assert.AreEqual(typeof(string), returnParameter.ParameterType, "Return parameter type should have been string");
Assert.AreEqual("GetAStringFromIntResult", returnParameter.Name, "Return parameter name match operation + Result");
Assert.AreEqual(TestNamespace, returnParameter.Namespace, "Return parameter namespace should match namespace");
Assert.AreEqual(0, returnParameter.Index, "Return parameter index should be zero");
}
public void HttpOperationDescription_Unsynchronized_ReturnValue_Setter()
{
HttpOperationDescription hod = new HttpOperationDescription();
HttpParameterDescription returnValue = new HttpParameterDescription()
{
Name = "TheReturn",
ParameterType = typeof(string)
};
hod.ReturnValue = returnValue;
Assert.AreSame(returnValue, hod.ReturnValue, "Failed to set return value");
hod.ReturnValue = null;
Assert.IsNull(hod.ReturnValue, "Failed to reset return value");
}
public void HttpOperationDescription_Update_OutputParameters_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescription mpd = od.Messages[1].Body.Parts[0]; // output parameter 1 in the MPD
Assert.AreEqual(typeof(double), mpd.Type, "MPD out parameter 1 has wrong type");
// Get a synchronized HOD.
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Get a synchronized HPDCollection and from it a synchronized HPD
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
HttpParameterDescription hpd = hpdColl[0];
Assert.IsNotNull(hpd, "Input parameter was null");
Assert.AreEqual(typeof(double), hpd.ParameterType, "HPD out parameter 1 has wrong type");
// Negative test -- Name and Namespace are immutable when synchronized
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
// Update return value directly in HOD's parameter description
hpd.ParameterType = typeof(int);
hpd.Index = 5;
// This should have directly updated it in the MPD as well
Assert.AreEqual(typeof(int), mpd.Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, mpd.Index, "HPD failed to update Index in MPD");
// Final test -- and that should have updated it in the OD.
// This is technically the same test as above, but this proves it.
Assert.AreEqual(typeof(int), od.Messages[1].Body.Parts[0].Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, od.Messages[1].Body.Parts[0].Index, "HPD failed to update Index in MPD");
}
public void HttpOperationDescription_Update_ReturnValue_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
MessagePartDescription mpd = od.Messages[1].Body.ReturnValue;
// Get a synchronized HOD.
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Get a synchronized HPD
HttpParameterDescription hpd = hod.ReturnValue;
Assert.IsNotNull(hpd, "Return parameter was null");
Assert.AreEqual(typeof(string), hpd.ParameterType, "Return parameter type should have been string");
// Negative test -- Name and Namespace are immutable when synchronized
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
// Update return value directly in HOD's parameter description
hpd.ParameterType = typeof(double);
hpd.Index = 5;
// This should have directly updated it in the MPD as well
Assert.AreEqual(typeof(double), mpd.Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, mpd.Index, "HPD failed to update Index in MPD");
// Final test -- and that should have updated it in the OD.
// This is technically the same test as above, but this proves it.
Assert.AreEqual(typeof(double), od.Messages[1].Body.ReturnValue.Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, od.Messages[1].Body.ReturnValue.Index, "HPD failed to update Index in MPD");
}
public void HttpOperationDescription_Update_OutputParameters_From_Incomplete_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescription mpd = od.Messages[1].Body.Parts[0]; // output parameter 1 in the MPD
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
HttpParameterDescription hpd = hpdColl[0];
// Zap the Messages[]
od.Messages.Clear();
// Zapping the backing Messages should have rendered the input collection empty
Assert.AreEqual(0, hpdColl.Count, "Resetting Messages did not reset count");
Assert.AreEqual(0, hod.InputParameters.Count, "Resetting Messages did not reset count in HOD");
// Mutating the OutputParameter collection should auto-create the both in and out Messages
hpdColl.Add(hpd);
Assert.AreEqual(2, od.Messages.Count, "Messages[1] was not autocreated");
Assert.AreEqual(1, hpdColl.Count, "Creating Messages did not set count");
Assert.AreEqual(1, hod.OutputParameters.Count, "Creating Messages did not set count in HOD");
}
public void HttpOperationDescription_Update_ReturnValue_Throws_From_Unsynchronized()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
MessagePartDescription mpd = od.Messages[1].Body.ReturnValue;
// Get a synchronized HOD.
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Get an unsynchronized HPD
HttpParameterDescription unsynchedHpd = new HttpParameterDescription()
{
Name = "TheReturn",
ParameterType = typeof(int)
};
ExceptionAssert.ThrowsInvalidOperation(
"Expect InvalidOperation to throw when trying to set unsynchronized return",
() => hod.ReturnValue = unsynchedHpd
);
// Get a synchronized HPD
HttpParameterDescription hpd = hod.ReturnValue;
Assert.IsNotNull(hpd, "Return parameter was null");
Assert.AreEqual(typeof(string), hpd.ParameterType, "Return parameter type should have been string");
// Null set should succeed
hod.ReturnValue = null;
Assert.IsNull(hod.ReturnValue, "Could not set to null");
// Null should propagate
Assert.IsNull(od.Messages[1].Body.ReturnValue, "Null did not propagate");
// Set back to valid value and see if propagates
hod.ReturnValue = hpd;
Assert.AreEqual(mpd, od.Messages[1].Body.ReturnValue, "Did not reset to synced value");
}
public void HttpOperationDescription_Default_Ctor()
{
HttpOperationDescription hod = new HttpOperationDescription();
HttpParameterDescription returnValue = hod.ReturnValue;
Assert.IsNull(returnValue, "ReturnValue should initialize to null");
Collection <Attribute> attributes = hod.Attributes;
Assert.IsNotNull(attributes, "Attributes should initialize to non-null");
Assert.AreEqual(0, attributes.Count, "Attributes should initialize to empty collection");
HttpParameterDescriptionCollection inputs = hod.InputParameters;
Assert.IsNotNull(inputs, "InputParameters should initialize to non-null");
Assert.AreEqual(0, inputs.Count, "InputParameters should initialize to empty collection");
HttpParameterDescriptionCollection outputs = hod.OutputParameters;
Assert.IsNotNull(outputs, "OutputParameters should initialize to non-null");
Assert.AreEqual(0, outputs.Count, "OutputParameters should initialize to empty collection");
KeyedByTypeCollection <IOperationBehavior> behaviors = hod.Behaviors;
Assert.IsNotNull(behaviors, "Behaviors should initialize to non-null");
Assert.AreEqual(0, behaviors.Count, "Behaviors should initialize to empty");
Collection <Type> knownTypes = hod.KnownTypes;
Assert.IsNotNull(knownTypes, "knownTypes should initialize to non-null");
Assert.AreEqual(0, knownTypes.Count, "knownTypes should initialize to empty");
Assert.IsNull(hod.BeginMethod, "BeginMethod should initialize to null");
Assert.IsNull(hod.EndMethod, "EndMethod should initialize to null");
Assert.IsNull(hod.SyncMethod, "SyncMethod should initialize to null");
Assert.IsNull(hod.DeclaringContract, "DeclaringContract should initialize to null");
}
public PngFormatter(HttpParameterDescription parameter, MediaTypeProcessorMode mode)
: base(parameter, mode)
{
}