public void When_the_verb_is_POST_the_Concrete_passes_parameters_on_the_URI_and_in_the_body()
{
Init(m =>
{
Method = Any.OdcmMethodPost();
Method.Class = Class;
Method.ReturnType = null;
Method.IsCollection = false;
Class.Methods.Add(Method);
});
var entityKeyValues = Class.GetSampleKeyArguments().ToArray();
var instancePath = Class.GetDefaultEntityPath(entityKeyValues);
using (var mockService = new MockService(true)
.SetupPostEntity(TargetEntity, entityKeyValues)
)
{
var concrete = mockService
.GetDefaultContext(Model)
.CreateConcrete(ConcreteType);
mockService.ValidateParameterPassing("POST", concrete, instancePath, Method,
ServerMethodNameGenerator(), null);
}
}
public void Write(OdcmMethod odcmMethod)
{
var returnType = NamesService.GetPublicTypeName(odcmMethod.ReturnType);
var parameters = string.Join(", ",
(from i in odcmMethod.Parameters select NamesService.GetPublicTypeName(i.Type, i.IsCollection) + " " + i.Name));
}
public void When_the_verb_is_POST_the_Fetcher_passes_parameters_on_the_URI_and_in_the_body()
{
Init(m =>
{
Method = Any.OdcmMethodPost();
Method.Class = Class;
Method.ReturnType = null;
Method.IsCollection = false;
Class.Methods.Add(Method);
});
var entityKeyValues = Class.GetSampleKeyArguments().ToArray();
var fetcherPath = Class.GetDefaultEntityPath(entityKeyValues);
using (var mockService = new MockService()
)
{
var fetcher = mockService
.GetDefaultContext(Model)
.CreateFetcher(FetcherType, fetcherPath);
mockService.ValidateParameterPassing("POST", fetcher, fetcherPath, Method,
ServerMethodNameGenerator(), null);
}
}
public void When_the_return_type_is_primitive_it_is_mapped_to_an_IEnumerable_of_DotNet_Primitives()
{
Init(model => model.Namespaces[0].Classes.First()
.Methods.Add(Method = Any.OdcmMethod(m =>
{
m.ReturnType = new OdcmPrimitiveType("Stream", OdcmNamespace.Edm);
m.IsCollection = IsCollection;
})));
_expectedReturnType = ReturnTypeGenerator(typeof(Microsoft.OData.Client.DataServiceStreamLink));
_expectedMethodName = Method.Name + "Async";
var methodInfos = new[]
{
FetcherInterface.GetMethod(_expectedMethodName),
FetcherType.GetMethod(_expectedMethodName)
};
foreach (var methodInfo in methodInfos)
{
methodInfo.ReturnType
.Should().Be(_expectedReturnType);
}
}
public void When_the_verb_is_GET_the_Fetcher_passes_parameters_on_the_URI()
{
base.Init(m =>
{
Method = Any.OdcmMethodGet();
Method.Class = Class;
Method.ReturnType = Class;
Method.IsCollection = IsCollection;
Class.Methods.Add(Method);
});
var entityKeyValues = Class.GetSampleKeyArguments().ToArray();
var fetcherPath = Class.GetDefaultEntityPath(entityKeyValues);
using (var mockService = new MockService()
)
{
var fetcher = mockService
.GetDefaultContext(Model)
.CreateFetcher(FetcherType, fetcherPath);
mockService.ValidateParameterPassing("GET", fetcher, fetcherPath, Method,
TargetEntity);
}
}
private OdcmMethod WriteMethod(OdcmClass odcmClass, IEdmOperation operation)
{
var parameters = operation.IsBound
? (from parameter in operation.Parameters
where parameter != operation.Parameters.First()
select parameter)
: (operation.Parameters);
var isBoundToCollection = operation.IsBound && operation.Parameters.First().Type.IsCollection();
var odcmMethod = new OdcmMethod(operation.Name, odcmClass.Namespace)
{
IsComposable = operation.IsFunction() && ((IEdmFunction)operation).IsComposable,
IsFunction = operation.IsFunction(),
IsBoundToCollection = isBoundToCollection,
Verbs = operation.IsAction() ? OdcmAllowedVerbs.Post : OdcmAllowedVerbs.Any,
Class = odcmClass
};
AddVocabularyAnnotations(odcmMethod, operation);
if (!odcmMethod.IsDeprecated && odcmClass.IsDeprecated)
{
odcmMethod.Deprecation = odcmClass.Deprecation;
}
if (operation.ReturnType != null)
{
odcmMethod.ReturnType = ResolveType(operation.ReturnType);
odcmMethod.IsCollection = operation.ReturnType.IsCollection();
if (!odcmMethod.IsDeprecated && odcmMethod.ReturnType.IsDeprecated)
{
odcmMethod.Deprecation = odcmMethod.ReturnType.Deprecation;
}
}
var callingConvention =
operation.IsAction()
? OdcmCallingConvention.InHttpMessageBody
: OdcmCallingConvention.InHttpRequestUri;
foreach (var parameter in parameters)
{
var odcmParameter = new OdcmParameter(parameter.Name)
{
CallingConvention = callingConvention,
Type = ResolveType(parameter.Type),
IsCollection = parameter.Type.IsCollection(),
IsNullable = parameter.Type.IsNullable
};
AddVocabularyAnnotations(odcmParameter, parameter);
odcmMethod.Parameters.Add(odcmParameter);
}
return(odcmMethod);
}
public string GetMethodHeader(OdcmMethod action)
{
var returnString = action.ReturnType == null ? "int returnValue"
: this.GetTypeForAction(action) + action.ReturnType.Name.ToLowerFirstChar();
return(string.Format("- (void){0}{1}:(void (^)({2}, MSOrcError *error))callback",
action.Name.ToLowerFirstChar(), this.GetParamsString(action.Parameters), returnString));
}
public static Method ForEntityType(OdcmMethod odcmMethod)
{
return(odcmMethod.ReturnType == null
? (Method) new EntityVoidMethod(odcmMethod)
: odcmMethod.IsCollection
? (Method) new EntityCollectionFunctionMethod(odcmMethod)
: (Method) new EntityInstanceFunctionMethod(odcmMethod));
}
/// Returns a List containing the supplied method plus its overloads
public static List <OdcmMethod> WithOverloads(this OdcmMethod odcmMethod)
{
var methods = new List <OdcmMethod>();
methods.Add(odcmMethod);
methods.AddRange(odcmMethod.Overloads);
return(methods);
}
public Given_an_OdcmClass_Entity_Bound_Action()
{
_method = Any.OdcmMethod();
_expectedMethodName = _method.Name + "Async";
Init(m => m.Namespaces[0].Classes.First().Methods.Add(_method));
}
public Given_an_OdcmClass_Service_Bound_VoidMethod()
{
_method = Any.OdcmMethod();
_expectedMethodName = _method.Name + "Async";
Init(m => m.EntityContainer.Methods.Add(_method));
}
public EntityVoidMethod(OdcmMethod odcmMethod)
{
IsAsync = true;
ModelName = odcmMethod.Name;
Name = odcmMethod.Name + "Async";
Parameters = odcmMethod.Parameters.Select(Parameter.FromOdcmParameter);
ReturnType = new Type(new Identifier("System.Threading.Tasks", "Task"));
}
public Given_an_OdcmClass_Entity_Bound_Function()
{
Init(model => model.Namespaces[0].Classes.First()
.Methods.Add(_method = Any.OdcmMethod(m => m.ReturnType = model.Namespaces[0].Classes.First())));
_expectedReturnType = typeof(Task <>).MakeGenericType(ConcreteInterface);
_expectedMethodName = _method.Name + "Async";
}
public EntityFunctionMethod(OdcmMethod odcmMethod)
{
InstanceName = NamesService.GetConcreteTypeName(odcmMethod.ReturnType);
IsAsync = true;
ModelName = odcmMethod.Name;
Name = odcmMethod.Name + "Async";
Parameters = odcmMethod.Parameters.Select(Parameter.FromOdcmParameter);
ReturnType = new Type(new Identifier("System.Threading.Tasks", "Task"), new Type(NamesService.GetPublicTypeName(odcmMethod.ReturnType)));
}
public Given_an_OdcmClass_Entity_Bound_VoidMethod()
{
Method = Any.OdcmMethod();
_expectedMethodName = Method.Name + "Async";
Init(m => m.Namespaces[0].Classes.First().Methods.Add(Method));
ServerMethodNameGenerator = () => Method.FullName;
}
public Given_an_OdcmClass_Entity_Collection_Bound_Action()
{
_method = Any.OdcmMethod(m => m.IsBoundToCollection = true);
_expectedMethodName = _method.Name + "Async";
_expectedMethodParameters = _method.Parameters.Select(p => Proxy.GetClass(p.Type.Namespace, p.Type.Name));
Init(m => m.Namespaces[0].Classes.First().Methods.Add(_method));
}
public Given_an_OdcmClass_Entity_Collection_Bound_VoidMethod()
{
Method = Any.OdcmMethod(m => m.IsBoundToCollection = true);
_expectedMethodName = Method.Name + "Async";
_expectedMethodParameters = Method.Parameters.Select(p => Proxy.GetClass(p.Type.Namespace, p.Type.Name));
Init(m => m.Namespaces[0].Classes.First().Methods.Add(Method));
ServerMethodNameGenerator = () => Method.FullName;
}
/// <summary>
/// Use this method to get a collection of methods on the return type
/// of a composable function. This will include the methods and overloads.
/// </summary>
/// <param name="odcmMethod">The OdcmMethod to target.</param>
/// <returns>An ordered (by name) list of methods bound to the return
/// type. Can be an empty list.</returns>
public static List <OdcmMethod> GetComposableFunctionReturnTypeMethods(this OdcmMethod odcmMethod)
{
if (!odcmMethod.IsComposable)
{
throw new InvalidOperationException("This extension method is intended " +
"to only be called on a composable function.");
}
return(odcmMethod.ReturnType.AsOdcmClass().MethodsAndOverloads()
.OrderBy(m => m.Name)
.ToList());
}
public string GetTypeForAction(OdcmMethod action)
{
if (action.ReturnType.IsComplex())
{
if (action.IsCollection)
{
return("NSArray *");
}
return(action.ReturnType.IsSystem() ? action.ReturnType.GetTypeString() : action.ReturnType.GetTypeString() + " *");
}
return(action.ReturnType.GetTypeString());
}
/// <summary>
/// Deduplicates the parameter list for an overloaded method.
/// </summary>
/// <param name="odcmMethod">Method with potential overloads and duplicate parameters across overloads.</param>
/// <returns>A deduplicated list of OdcmParameter.</returns>
public static List <OdcmParameter> WithDistinctParameters(this OdcmMethod odcmMethod)
{
var distinctMethods = odcmMethod.WithDistinctOverloads();
var parameters = new List <OdcmParameter>();
foreach (var method in distinctMethods)
{
parameters.AddRange(method.Parameters);
}
return(parameters.Distinct(paramComparer).ToList());
}
/// <summary>
/// Use this method to get a collection of navigation properties on the return type
/// of a composable function.
/// </summary>
/// <param name="odcmMethod">The OdcmMethod to target.</param>
/// <returns>An ordered (by name) list of navigation properties bound
/// to the return type. Can be an empty list.</returns>
public static List <OdcmProperty> GetComposableFunctionReturnTypeNavigations(this OdcmMethod odcmMethod)
{
if (!odcmMethod.IsComposable)
{
throw new InvalidOperationException("This extension method is intended " +
"to only be called on a composable function.");
}
return((odcmMethod.ReturnType as OdcmClass).Properties
.Where(p => p.IsLink)
.OrderBy(p => p.Name)
.ToList());
}
public Given_an_OdcmClass_Service_Bound_Function()
{
Init(
model =>
{
model.AddType(_expectedReturnClass = Any.OdcmClass());
model.EntityContainer.Methods.Add(
_method = Any.OdcmMethod(m => m.ReturnType = _expectedReturnClass));
});
_expectedReturnType =
typeof(Task <>).MakeGenericType(Proxy.GetClass(_expectedReturnClass.Namespace, _expectedReturnClass.Name));
_expectedMethodName = _method.Name + "Async";
}
public Given_an_OdcmClass_Entity_Collection_Bound_Function()
{
Init(model => model.Namespaces[0].Classes.First()
.Methods.Add(_method = Any.OdcmMethod(m =>
{
m.ReturnType = model.Namespaces[0].Classes.First();
m.IsBoundToCollection = true;
})));
_expectedReturnType = typeof(Task <>).MakeGenericType(ConcreteInterface);
_expectedMethodName = _method.Name + "Async";
_expectedMethodParameters = _method.Parameters.Select(p => Proxy.GetClass(p.Type.Namespace, p.Type.Name));
}
protected ServerMethod(OdcmMethod odcmMethod)
{
BodyParameters = odcmMethod.Parameters
.Where(p => p.CallingConvention == OdcmCallingConvention.InHttpMessageBody)
.Select(Parameter.FromOdcmParameter);
UriParameters = odcmMethod.Parameters
.Where(p => p.CallingConvention == OdcmCallingConvention.InHttpRequestUri)
.Select(Parameter.FromOdcmParameter);
switch (odcmMethod.Verbs)
{
case OdcmAllowedVerbs.Any:
HttpMethod = "GET";
break;
case OdcmAllowedVerbs.Delete:
HttpMethod = "DELETE";
break;
case OdcmAllowedVerbs.Get:
HttpMethod = "GET";
break;
case OdcmAllowedVerbs.Patch:
HttpMethod = "PATCH";
break;
case OdcmAllowedVerbs.Post:
HttpMethod = "POST";
break;
case OdcmAllowedVerbs.Put:
HttpMethod = "PUT";
break;
default:
throw new ArgumentOutOfRangeException();
}
IsAsync = true;
ModelName = ConfigurationService.Settings.OmitMethodNamespaceInUriPaths
? odcmMethod.Name
: odcmMethod.FullName;
Description = odcmMethod.Description;
Name = odcmMethod.Name + "Async";
Parameters = odcmMethod.Parameters.Select(Parameter.FromOdcmParameter);
}
public static OdcmMethod OdcmMethod(Action <OdcmMethod> config = null)
{
var retVal = new OdcmMethod(Any.CSharpIdentifier());
retVal.Parameters.AddRange(
Any.Sequence(s => new OdcmParameter(Any.CSharpIdentifier())
{
Type = Any.PrimitiveOdcmType()
}, Any.Int(0, 3)));
if (config != null)
{
config(retVal);
}
return(retVal);
}
protected void Init(Action <OdcmMethod> config = null)
{
Init(model => model.Namespaces[0].Classes.First()
.Methods.Add(Method = Any.OdcmMethod(m =>
{
m.ReturnType = model.Namespaces[0].Classes.First();
m.IsCollection = IsCollection;
if (config != null)
{
config(m);
}
})));
_expectedReturnType = ReturnTypeGenerator(ConcreteInterface);
_expectedMethodName = Method.Name + "Async";
}
public Given_an_OdcmParameter()
{
_model = new OdcmModel(Any.ServiceMetadata());
_namespace = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(_namespace);
_class = Any.OdcmEntityClass(_namespace);
_model.AddType(_class);
_method = Any.OdcmMethod(m => m.Parameters.Clear());
_class.Methods.Add(_method);
_param = Any.OdcmParameter();
_method.Parameters.Add(_param);
_expectedMethodName = _method.Name + "Async";
}
private void WriteMethod(OdcmClass odcmClass, IEdmFunctionImport operation)
{
IEnumerable <IEdmFunctionParameter> parameters = operation.IsBindable
? (from parameter in operation.Parameters
where parameter != operation.Parameters.First()
select parameter)
: (operation.Parameters);
bool isBoundToCollection = operation.IsBindable && operation.Parameters.First().Type.IsCollection();
var odcmMethod = new OdcmMethod(operation.Name)
{
Verbs = operation.IsSideEffecting ? OdcmAllowedVerbs.Post : OdcmAllowedVerbs.Any,
IsBoundToCollection = isBoundToCollection,
IsComposable = operation.IsComposable,
Class = odcmClass
};
odcmClass.Methods.Add(odcmMethod);
if (operation.ReturnType != null)
{
odcmMethod.ReturnType = ResolveType(operation.ReturnType);
odcmMethod.IsCollection = operation.ReturnType.IsCollection();
}
var callingConvention =
operation.IsSideEffecting
? OdcmCallingConvention.InHttpMessageBody
: OdcmCallingConvention.InHttpRequestUri;
foreach (var parameter in parameters)
{
odcmMethod.Parameters.Add(new OdcmParameter(parameter.Name)
{
CallingConvention = callingConvention,
Type = ResolveType(parameter.Type),
IsCollection = parameter.Type.IsCollection(),
IsNullable = parameter.Type.IsNullable
});
}
}
public void When_the_verb_is_GET_the_Collection_passes_parameters_on_the_URI()
{
Init(model =>
{
Method = Any.OdcmMethodGet();
Method.Class = model.EntityContainer;
Method.ReturnType = Class;
Method.IsCollection = false;
Method.IsBoundToCollection = false;
model.EntityContainer.Methods.Add(Method);
});
using (var mockService = new MockService())
{
var service = mockService
.CreateContainer(EntityContainerType);
mockService.ValidateParameterPassing("GET", service, "", Method,
TargetEntity);
}
}
public void Init(Action <OdcmMethod> config = null)
{
Init(model => model.Namespaces[0].Classes.First()
.Methods.Add(Method = Any.OdcmMethod(m =>
{
m.ReturnType = model.Namespaces[0].Classes.First();
m.IsCollection = IsCollection;
m.IsBoundToCollection = true;
if (config != null)
{
config(m);
}
})));
_expectedReturnType = ReturnTypeGenerator(ConcreteInterface);
_expectedMethodName = Method.Name + "Async";
_expectedMethodParameters = Method.Parameters.Select(p => Proxy.GetClass(p.Type.Namespace, p.Type.Name));
}