public void SerializationTest()
{
// Arrange.
const string DisplayName = "Test Type";
const string Name = "TestType";
const string ElementTypeName = "ElementType";
const WebServiceTypeCode TypeCode = WebServiceTypeCode.String;
const string DerivedTypeName = "TestDerivedType";
const string FieldName = "TestField";
const string FieldType = "TestFieldType";
var service = new WebServiceClientDescription();
var type = new WebServiceTypeDescription(service)
{
DisplayName = DisplayName,
Name = Name,
ElementTypeName = ElementTypeName,
IsSimple = true,
IsArray = true,
IsAbstract = true,
IsEnum = true,
IsNullable = true,
TypeCode = TypeCode
};
type.AssignableTypes.Add(new WebServiceTypeReference { TypeName = DerivedTypeName });
type.Fields.Add(new WebServiceTypeFieldDescription(type) { Name = FieldName, TypeName = FieldType });
// Act.
var element = type.GetXElement();
var newType = WebServiceTypeDescription.CreateTypeDescription(service, element);
// Assert.
Assert.AreEqual(DisplayName, newType.DisplayName);
Assert.AreEqual(Name, newType.Name);
Assert.AreEqual(ElementTypeName, newType.ElementTypeName);
Assert.IsTrue(newType.IsSimple);
Assert.IsTrue(newType.IsArray);
Assert.IsTrue(newType.IsAbstract);
Assert.IsTrue(newType.IsEnum);
Assert.IsTrue(newType.IsNullable);
Assert.AreEqual(TypeCode, newType.TypeCode);
Assert.AreEqual(1, newType.AssignableTypes.Count);
Assert.AreEqual(DerivedTypeName, newType.AssignableTypes.ElementAt(0).TypeName);
Assert.AreEqual(1, newType.Fields.Count);
Assert.AreEqual(FieldName, newType.Fields.ElementAt(0).Name);
Assert.AreEqual(FieldType, newType.Fields.ElementAt(0).TypeName);
}
/// <summary>
/// Gets the service description.
/// </summary>
/// <param name="serviceContract">The service contract.</param>
/// <returns>WebServiceClientDescription.</returns>
/// <exception cref="System.InvalidOperationException">Service client type not found.</exception>
private WebServiceClientDescription GetServiceDescription(Type serviceContract)
{
var contractClient = _proxyAssembly.GetTypes().FirstOrDefault(t => !t.IsAbstract && serviceContract.IsAssignableFrom(t));
if (contractClient == null)
throw new InvalidOperationException("Service client type not found.");
var serviceDescription = new WebServiceClientDescription { ContractTypeName = serviceContract.GetAssemblyQualifiedName() };
serviceDescription.Methods.AddRange(GetWebMethdods(serviceContract).Select(m => GetMethodDescription(serviceDescription, m)));
var accessibleTypes = GetAccessibleTypes(serviceContract);
foreach (var type in accessibleTypes)
serviceDescription.TypeDescriptions.Add(GetTypeDescription(serviceDescription, type));
return serviceDescription;
}
public void IsAssignableFromTest()
{
// Arrange.
var service = new WebServiceClientDescription();
var type1 = new WebServiceTypeDescription(service) { Name = "Type1" };
var derived1 = new WebServiceTypeDescription(service) { Name = "Derived1" };
var derived2 = new WebServiceTypeDescription(service) { Name = "Derived2" };
var type2 = new WebServiceTypeDescription(service) { Name = "Type2" };
type1.AssignableTypes.Add(new WebServiceTypeReference { TypeName = derived1.Name });
type1.AssignableTypes.Add(new WebServiceTypeReference { TypeName = derived2.Name });
// Act / Assert.
Assert.IsTrue(type1.IsAssignableFrom(type1));
Assert.IsTrue(type1.IsAssignableFrom(derived1));
Assert.IsTrue(type1.IsAssignableFrom(derived2));
Assert.IsFalse(type1.IsAssignableFrom(type2));
}
public void SerializationTest()
{
// Arrange.
const string MethodName = "TestMethod";
const string ParameterName = "testParameter";
const string ParameterType = "TestType1";
var serviceDescription = new WebServiceClientDescription();
var method = new WebServiceMethodDescription(serviceDescription) { Name = MethodName };
method.InputParameters.Add(new WebServiceMethodParameterDescription(method) { Name = ParameterName, TypeName = ParameterType });
// Act.
var element = method.GetXElement();
var newMethod = WebServiceMethodDescription.CreateMethodDescription(serviceDescription, element);
// Assert.
Assert.AreEqual(MethodName, newMethod.Name);
Assert.AreEqual(1, newMethod.InputParameters.Count);
Assert.AreEqual(ParameterName, newMethod.InputParameters.ElementAt(0).Name);
Assert.AreEqual(ParameterType, newMethod.InputParameters.ElementAt(0).TypeName);
}
public void GetAssignableTypesForTypeTest()
{
// Arrange.
var serviceDescription = new WebServiceClientDescription();
var type1 = new WebServiceTypeDescription(serviceDescription) { Name = "Type1" };
var type2 = new WebServiceTypeDescription(serviceDescription) { Name = "Type2" };
var type3 = new WebServiceTypeDescription(serviceDescription) { Name = "Type3", IsAbstract = true };
type1.AssignableTypes.Add(new WebServiceTypeReference { TypeName = type2.Name });
type1.AssignableTypes.Add(new WebServiceTypeReference { TypeName = type3.Name });
serviceDescription.TypeDescriptions.Add(type1);
serviceDescription.TypeDescriptions.Add(type2);
serviceDescription.TypeDescriptions.Add(type3);
// Act.
var assignableTypes = serviceDescription.GetAssignableTypesForType(type1);
// Assert.
Assert.AreEqual(2, assignableTypes.Count);
Assert.IsTrue(assignableTypes.Contains(type1));
Assert.IsTrue(assignableTypes.Contains(type2));
}
public void SerializationTest()
{
// Arrange.
const int Id = 123;
const string ContractTypeName = "TestContract";
const string EndpointConfiguration = "Test Endpoint Configuration";
var serviceDescription = new WebServiceClientDescription
{
Id = Id,
ContractTypeName = ContractTypeName,
EndpointConfiguration = EndpointConfiguration
};
serviceDescription.Methods.Add(new WebServiceMethodDescription(serviceDescription) { Name = "Method1" });
serviceDescription.Methods.Add(new WebServiceMethodDescription(serviceDescription) { Name = "Method2" });
serviceDescription.TypeDescriptions.Add(new WebServiceTypeDescription(serviceDescription) { Name = "Type1", DisplayName = "Type 1" });
serviceDescription.TypeDescriptions.Add(new WebServiceTypeDescription(serviceDescription) { Name = "Type2", DisplayName = "Type 2" });
// Act.
var bytes = serviceDescription.Serialize();
var newServiceDescription = WebServiceClientDescription.Deserialize(bytes);
// Assert.
Assert.AreEqual(Id, newServiceDescription.Id);
Assert.AreEqual(ContractTypeName, newServiceDescription.ContractTypeName);
Assert.AreEqual(EndpointConfiguration, newServiceDescription.EndpointConfiguration);
Assert.AreEqual(2, newServiceDescription.Methods.Count);
Assert.AreEqual("Method1", newServiceDescription.Methods.ElementAt(0).Name);
Assert.AreEqual("Method2", newServiceDescription.Methods.ElementAt(1).Name);
Assert.AreEqual(2, newServiceDescription.TypeDescriptions.Count);
Assert.AreEqual("Type1", newServiceDescription.TypeDescriptions.ElementAt(0).Name);
Assert.AreEqual("Type2", newServiceDescription.TypeDescriptions.ElementAt(1).Name);
}
public void FindTypeByNameTest()
{
// Arrange.
var serviceDescription = new WebServiceClientDescription();
var type1 = new WebServiceTypeDescription(serviceDescription) { Name = "Type1" };
var type2 = new WebServiceTypeDescription(serviceDescription) { Name = "Type2" };
serviceDescription.TypeDescriptions.Add(type1);
serviceDescription.TypeDescriptions.Add(type2);
// Act / Assert.
Assert.AreSame(type1, serviceDescription.FindTypeByName("Type1"));
Assert.AreSame(type2, serviceDescription.FindTypeByName("Type2"));
Assert.IsNull(serviceDescription.FindTypeByName("Type3"));
}
/// <summary>
/// Gets the method description.
/// </summary>
/// <param name="declaringService">The declaring service.</param>
/// <param name="method">The method.</param>
/// <returns>WebServiceMethodDescription.</returns>
private WebServiceMethodDescription GetMethodDescription(WebServiceClientDescription declaringService, MethodInfo method)
{
var requestType = GetRequestType(method);
var methodDescription = new WebServiceMethodDescription(declaringService) { Name = method.Name };
var requestFields = requestType.GetFields(BindingFlags.Instance | BindingFlags.Public);
var resultFields = method.ReturnType.GetFields(BindingFlags.Instance | BindingFlags.Public);
methodDescription.InputParameters.AddRange(
requestFields.Where(IsMessageBodyMember).Select(p => GetMethodParameterDescription(methodDescription, p)));
methodDescription.InputParameters.AddRange(
requestFields.Where(IsMessageHeader).Select(h => GetMethodParameterDescription(methodDescription, h)));
methodDescription.OutputParameters.AddRange(
resultFields.Where(IsMessageBodyMember).Select(f => GetMethodParameterDescription(methodDescription, f)));
methodDescription.OutputParameters.AddRange(
resultFields.Where(IsMessageHeader).Select(f => GetMethodParameterDescription(methodDescription, f)));
return methodDescription;
}
/// <summary>
/// Gets the type description.
/// </summary>
/// <param name="declaringService">The declaring service.</param>
/// <param name="type">The type.</param>
/// <returns>WebServiceTypeDescription.</returns>
private WebServiceTypeDescription GetTypeDescription(WebServiceClientDescription declaringService, Type type)
{
var underlyingType = Nullable.GetUnderlyingType(type);
var typeDescription = new WebServiceTypeDescription(declaringService)
{
TypeCode = WebServiceTypeDescription.GetTypeCode(underlyingType ?? type),
Name = type.GetAssemblyQualifiedName(),
DisplayName = GetDisplayName(underlyingType ?? type),
IsAbstract = type.IsAbstract,
IsArray = type.IsArray,
IsEnum = (underlyingType ?? type).IsEnum,
IsSimple = IsSimpleType(underlyingType ?? type),
IsNullable = IsNullableType(type)
};
if (type.IsArray)
typeDescription.ElementTypeName = type.GetElementType().GetAssemblyQualifiedName();
if (type.Assembly == _proxyAssembly && !type.IsArray && !IsSimpleType(type))
typeDescription.Fields.AddRange(
type.GetFields(BindingFlags.Instance | BindingFlags.Public).Select(f => GetTypeFieldDescription(typeDescription, f)));
typeDescription.AssignableTypes.AddRange(GetIncludedTypes(type).Where(type.IsAssignableFrom).Select(GetTypeReference));
return typeDescription;
}
/// <summary>
/// Creates the type description.
/// </summary>
/// <param name="declaringService">The declaring service.</param>
/// <param name="element">The element.</param>
/// <returns>The <see cref="WebServiceTypeDescription"/>.</returns>
public static WebServiceTypeDescription CreateTypeDescription(WebServiceClientDescription declaringService, XElement element)
{
ParseHelper.CheckRequiredElement(element, CnType);
var type = new WebServiceTypeDescription(declaringService)
{
TypeCode =
(WebServiceTypeCode)
Enum.Parse(
typeof(WebServiceTypeCode),
ParseHelper.ReadRequiredAttribute(element, CnTypeCode),
true),
Name = ParseHelper.ReadRequiredAttribute(element, CnName),
DisplayName = ParseHelper.ReadRequiredAttribute(element, CnDisplayName),
IsSimple =
bool.Parse(ParseHelper.ReadOptionalAttribute(element, CnIsSimple, bool.FalseString)),
IsArray =
bool.Parse(ParseHelper.ReadOptionalAttribute(element, CnIsArray, bool.FalseString)),
IsAbstract =
bool.Parse(ParseHelper.ReadOptionalAttribute(element, CnIsAbstract, bool.FalseString)),
IsEnum = bool.Parse(ParseHelper.ReadOptionalAttribute(element, CnIsEnum, bool.FalseString)),
IsNullable =
bool.Parse(ParseHelper.ReadOptionalAttribute(element, CnIsNullable, bool.FalseString))
};
if (element.Attribute(CnElementTypeName) != null)
type.ElementTypeName = ParseHelper.ReadOptionalAttribute(element, CnElementTypeName);
var fieldsElement = element.Element(CnFields);
if (fieldsElement != null)
{
type.Fields.AddRange(
fieldsElement.Elements(WebServiceTypeFieldDescription.CnField).Select(f => WebServiceTypeFieldDescription.CreateFieldDescription(type, f)));
}
var includedTypesElement = element.Element(CnAssignableTypes);
if (includedTypesElement != null)
{
type.AssignableTypes.AddRange(includedTypesElement.Elements(WebServiceTypeReference.CN_TypeRef).Select(WebServiceTypeReference.CreateTypeReference));
}
return type;
}
/// <summary>
/// Creates a method description.
/// </summary>
/// <param name="declaringService">
/// The declaring service.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <returns>
/// The <see cref="WebServiceMethodDescription"/>.
/// </returns>
public static WebServiceMethodDescription CreateMethodDescription(WebServiceClientDescription declaringService, XElement element)
{
ParseHelper.CheckRequiredElement(element, CnMethod);
var method = new WebServiceMethodDescription(declaringService) { Name = ParseHelper.ReadRequiredAttribute(element, CnName) };
var parametersElement = element.Element(CnInputParameters);
if (parametersElement != null)
{
method.InputParameters.AddRange(
parametersElement.Elements(WebServiceMethodParameterDescription.CnParameter)
.Select(x => WebServiceMethodParameterDescription.CreateParameterDescription(method, x)));
}
var outputParametersElement = element.Element(CnOutputParameters);
if (outputParametersElement != null)
{
method.OutputParameters.AddRange(
outputParametersElement.Elements(WebServiceMethodParameterDescription.CnParameter)
.Select(x => WebServiceMethodParameterDescription.CreateParameterDescription(method, x)));
}
return method;
}
private static WebServiceClientDescription CreateServiceDescription(XElement element)
{
ParseHelper.CheckRequiredElement(element, ServiceElementName);
var service = new WebServiceClientDescription
{
Id = int.Parse(ParseHelper.ReadRequiredAttribute(element, IdAttributeName)),
ContractTypeName = ParseHelper.ReadRequiredAttribute(element, ContractTypeNameAttributeName)
};
var endpointConfigurationElement = element.Element(EndpointConfigurationElementName);
if (endpointConfigurationElement != null)
{
service.EndpointConfiguration = endpointConfigurationElement.Value;
}
var methodsElement = element.Element(MethodsElementName);
if (methodsElement != null)
{
service.Methods.AddRange(
methodsElement.Elements(WebServiceMethodDescription.CnMethod).Select(x => WebServiceMethodDescription.CreateMethodDescription(service, x)));
}
var typesElement = element.Element(TypesElementName);
if (typesElement != null)
{
service.TypeDescriptions.AddRange(
typesElement.Elements(WebServiceTypeDescription.CnType).Select(x => WebServiceTypeDescription.CreateTypeDescription(service, x)));
}
return service;
}