public OdcmClass(string name, OdcmNamespace @namespace, OdcmClassKind kind)
: base(name, @namespace)
{
Kind = kind;
Properties = new List<OdcmProperty>();
Methods = new List<OdcmMethod>();
Derived = new List<OdcmClass>();
}
public Given_an_OdcmEnum()
{
_model = new OdcmModel(Any.ServiceMetadata());
_namespace = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(_namespace);
}
public static OdcmNamespace EmptyOdcmNamespace(Action<OdcmNamespace> config = null)
{
var retVal = new OdcmNamespace(Any.CSharpIdentifier());
if (config != null) config(retVal);
return retVal;
}
public OdcmClass(string name, OdcmNamespace @namespace, OdcmClassKind kind)
: base(name, @namespace)
{
Kind = kind;
Properties = new List <OdcmProperty>();
Methods = new List <OdcmMethod>();
Derived = new List <OdcmClass>();
}
public Namespace(OdcmNamespace @namespace, OdcmModel model)
{
Name = NamesService.GetNamespaceName(@namespace);
//Features = @namespace.Enums.SelectMany(global::Vipr.Writer.CSharp.Features.ForOdcmEnum)
// .Concat(@namespace.Classes.SelectMany(global::Vipr.Writer.CSharp.Features.ForOdcmClass))
// .Concat(@namespace.Classes.SelectMany(c => global::Vipr.Writer.CSharp.Features.ForEntityContainer(c, model)));
Features = @namespace.Enums.SelectMany(global::Vipr.Writer.CSharp.Features.ForOdcmEnum)
.Concat(@namespace.Classes.OfType<OdcmComplexClass>().SelectMany(global::Vipr.Writer.CSharp.Features.ForOdcmClass))
.Concat(@namespace.Classes.OfType<OdcmEntityClass>().SelectMany(global::Vipr.Writer.CSharp.Features.ForOdcmClass))
.Concat(@namespace.Classes.OfType<OdcmServiceClass>().SelectMany(c => global::Vipr.Writer.CSharp.Features.ForEntityContainer(c, model)));
}
public void When_the_model_has_a_namespace_called_Edm_it_is_ignored()
{
var @namespace = new OdcmNamespace("EDM");
_model.Namespaces.Add(@namespace);
_model.AddType(Any.OdcmEnum(e => e.Namespace = OdcmNamespace.Edm));
var proxy = GetProxy(_model);
proxy.GetNamespaces()
.Should().BeEquivalentTo(new object[] { });
}
public void Init(Action<OdcmModel> config = null, bool generateMocks = false)
{
Model = new OdcmModel(Any.ServiceMetadata());
Namespace = Any.EmptyOdcmNamespace();
Model.Namespaces.Add(Namespace);
Class = Any.OdcmEntityClass(Namespace);
Model.AddType(Class);
OdcmContainer = Any.ServiceOdcmClass(Namespace);
Model.AddType(OdcmContainer);
if (config != null) config(Model);
Model.ServiceMetadata["$metadata"] = Model.ToEdmx(true);
Proxy = GetProxy(Model, ConfigurationProvider, generateMocks ? new[] { "DynamicProxyGenAssembly2" } : null);
ConcreteType = Proxy.GetClass(Class.Namespace, Class.Name);
ConcreteInterface = Proxy.GetInterface(Class.Namespace, "I" + Class.Name);
FetcherType = Proxy.GetClass(Class.Namespace, Class.Name + "Fetcher");
FetcherInterface = Proxy.GetInterface(Class.Namespace, "I" + Class.Name + "Fetcher");
CollectionType = Proxy.GetClass(Class.Namespace, Class.Name + "Collection");
CollectionInterface = Proxy.GetInterface(Class.Namespace, "I" + Class.Name + "Collection");
EntityContainerType = Proxy.GetClass(Model.EntityContainer.Namespace, Model.EntityContainer.Name);
EntityContainerInterface = Proxy.GetInterface(Model.EntityContainer.Namespace, "I" + Model.EntityContainer.Name);
TargetEntity = new EntityArtifacts()
{
Class = Class,
ConcreteType = ConcreteType,
ConcreteInterface = ConcreteInterface,
FetcherType = FetcherType,
FetcherInterface = FetcherInterface,
CollectionType = CollectionType,
CollectionInterface = CollectionInterface
};
}
public bool TryResolveNamespace(string @namespace, out OdcmNamespace odcmNamespace)
{
foreach (OdcmNamespace candidate in Namespaces)
{
if (candidate.CanonicalName().Equals(@namespace, StringComparison.InvariantCulture))
{
odcmNamespace = candidate;
return(true);
}
}
odcmNamespace = null;
return(false);
}
public void AddType(OdcmType type)
{
string @namespace = type.Namespace.Name;
OdcmNamespace odcmNamespace = Namespaces.FirstOrDefault(x => x.Name == @namespace);
if (odcmNamespace == null)
{
odcmNamespace = new OdcmNamespace(@namespace);
Namespaces.Add(odcmNamespace);
}
_Types.Add(type);
odcmNamespace.Types.Add(type);
}
public Given_an_OdcmClass_Complex()
{
_model = new OdcmModel(Any.ServiceMetadata());
_namespace = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(_namespace);
_class = Any.OdcmComplexClass(e => e.Namespace = _namespace);
_model.AddType(_class);
_proxy = GetProxy(_model);
_classType = _proxy.GetClass(_class.Namespace, _class.Name);
}
protected OdcmType(string name, OdcmNamespace @namespace)
: base(name)
{
Namespace = @namespace;
DefaultProjection = new OdcmProjection()
{
Type = this,
Capabilities = OdcmCapability.DefaultOdcmCapabilities
};
Projection = new OdcmProjection()
{
Capabilities = new List <OdcmCapability>()
};
AddProjection(OdcmCapability.DefaultOdcmCapabilities);
}
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";
}
public void When_it_changes_a_namespace_then_requests_OdataType_is_set_to_the_old_namespace()
{
var oldNamespace = _model.EntityContainer.Namespace;
var namespacePrefix = Any.CSharpIdentifier();
var namespaceRename = Any.CSharpIdentifier();
var newNamespace = new OdcmNamespace(namespacePrefix + "." + namespaceRename);
var namespaceMap = new Dictionary<string, string> { { oldNamespace.Name, namespaceRename } };
var proxy = GetProxyWithChangedNamespaces(namespacePrefix, namespaceMap);
var @class = oldNamespace.Classes.OfType<OdcmEntityClass>().First();
var entityArtifacts = GetEntityArtifactsFromNewNamespace(@class, newNamespace, proxy, oldNamespace);
using (var mockService = new MockService()
)
{
mockService
.OnRequest(c => c.Request.Method == "POST" &&
c.Request.Path.Value == @class.GetDefaultEntitySetPath() &&
IsNamespaceReplaced(c.Request, oldNamespace.Name, newNamespace.Name))
.RespondWith(
(c, b) =>
{
c.Response.StatusCode = 201;
c.Response.WithDefaultODataHeaders();
c.Response.WithODataEntityResponseBody(b,
@class.GetDefaultEntitySetName(), null);
});
var collection = mockService
.CreateContainer(proxy.GetClass(newNamespace.Name, _model.EntityContainer.Name))
.GetPropertyValue<ReadOnlyQueryableSetBase>(entityArtifacts.Class.GetDefaultEntitySetName());
var instance = entityArtifacts.ConcreteType.Initialize(@class.GetSampleKeyArguments().ToArray());
var task = collection.InvokeMethod<Task>("Add" + @class.Name + "Async", args: new[] { instance, false });
task.Wait();
}
public void When_the_model_has_a_namespace_and_class_with_the_same_name_then_compilation_succeeds()
{
var name = Any.CSharpIdentifier();
var @namespace = new OdcmNamespace(name);
_model.Namespaces.Add(@namespace);
var @class = Any.OdcmEntityClass(@namespace, name);
@class.Properties.Add(new OdcmProperty(Any.CSharpIdentifier()) {Class = @class, Type = @class});
_model.AddType(@class);
var proxy = GetProxy(_model);
proxy.GetClass(name, name)
.Should().NotBeNull();
}
public Given_a_nullable_Primitive_OdcmProperty()
{
_model = new OdcmModel(Any.ServiceMetadata());
_namespace = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(_namespace);
_class = Any.OdcmEntityClass(_namespace);
_property = Any.PrimitiveOdcmProperty(p =>
{
p.IsNullable = true;
p.Class = _class;
});
_class.Properties.Add(_property);
_model.AddType(_class);
}
public static OdcmNamespace OdcmNamespace(Action<OdcmNamespace> config = null)
{
var retVal = new OdcmNamespace(Any.CSharpIdentifier());
retVal.Types.AddRange(Any.Sequence(s => Any.OdcmEnum()));
retVal.Types.AddRange(Any.Sequence(s => Any.ComplexOdcmClass(retVal)));
var classes = Any.Sequence(s => Any.OdcmEntityClass(retVal))
.Concat(Any.Sequence(s => Any.MediaOdcmClass(retVal), count: 2)).ToArray();
foreach (var @class in (from @class in retVal.Types where @class is OdcmEntityClass select @class as OdcmEntityClass))
{
@class.Properties.AddRange(Any.Sequence(i => Any.OdcmProperty(p =>
{
p.Class = @class;
p.Type = classes.RandomElement();
})));
}
foreach (var @class in classes)
{
@class.Properties.AddRange(Any.Sequence(i => Any.OdcmProperty(p =>
{
p.Class = @class;
p.Type = classes.RandomElement();
})));
}
classes[0].Base = classes[1];
if (!classes[1].Derived.Contains(classes[0]))
{
classes[1].Derived.Add(classes[0]);
}
retVal.Types.AddRange(classes);
if (config != null) config(retVal);
return retVal;
}
public void AddType(OdcmType type)
{
string @namespace = type.Namespace;
OdcmNamespace odcmNamespace = null;
foreach (OdcmNamespace candidate in Namespaces)
{
if (string.Equals(candidate.Name, @namespace))
{
odcmNamespace = candidate;
break;
}
}
if (odcmNamespace == null)
{
odcmNamespace = new OdcmNamespace(@namespace);
Namespaces.Add(odcmNamespace);
}
_Types.Add(type);
odcmNamespace.Types.Add(type);
}
public static OdcmEntityClass OdcmEntityClass(OdcmNamespace odcmNamespace, Action<OdcmEntityClass> config = null)
{
return Any.OdcmEntityClass(odcmNamespace, Any.CSharpIdentifier(), config);
}
[Fact(Skip = "https://github.com/Microsoft/Vipr/issues/43")]
public void When_it_changes_a_namespace_then_responses_odata_type_is_translated_to_new_namespace()
{
var oldNamespace = _model.EntityContainer.Namespace;
var namespacePrefix = Any.CSharpIdentifier();
var namespaceRename = Any.CSharpIdentifier();
var newNamespace = new OdcmNamespace(namespacePrefix + "." + namespaceRename);
var namespaceMap = new Dictionary<string, string> { { oldNamespace.Name, namespaceRename } };
var entityClasses = oldNamespace.Classes.OfType<OdcmEntityClass>().ToList();
var baseClass = entityClasses.Where(c => c.Base == null).RandomElement();
entityClasses.Remove(baseClass);
baseClass.IsAbstract = true;
var derivedClass = entityClasses.RandomElement();
entityClasses.Remove(derivedClass);
derivedClass.Base = baseClass;
entityClasses.RandomElement().Base = baseClass;
var proxy = GetProxyWithChangedNamespaces(namespacePrefix, namespaceMap);
var entityArtifacts = GetEntityArtifactsFromNewNamespace(derivedClass, newNamespace, proxy, oldNamespace);
var responseObject = entityArtifacts.Class.GetSampleJObject(derivedClass.GetSampleKeyArguments().Concat(baseClass.GetSampleKeyArguments()).ToArray());
var responseOdataType = String.Format("#{0}.{1}", oldNamespace.Name, derivedClass.Name);
var singletonPath = baseClass.GetDefaultSingletonPath();
using (var mockService = new MockService(true)
)
{
mockService
.OnRequest(c => c.Request.Method == "GET" && c.Request.Path.Value == singletonPath)
.RespondWith(
(c, b) =>
{
c.Response.StatusCode = 200;
c.Response.WithDefaultODataHeaders();
c.Response.WithODataEntityResponseBody(mockService.GetBaseAddress(),
baseClass.GetDefaultEntitySetName(), responseObject, new JProperty("@odata.type", new JValue(responseOdataType)));
});
var fetcher = mockService
.CreateContainer(proxy.GetClass(newNamespace.Name, _model.EntityContainer.Name))
.GetPropertyValue<RestShallowObjectFetcher>(baseClass.GetDefaultSingletonName());
var task = fetcher.ExecuteAsync();
var result = task.GetPropertyValue<EntityBase>("Result");
protected OdcmEntityClass(string name, OdcmNamespace @namespace, OdcmClassKind kind) :
base(name, @namespace, kind)
{
Key = new List <OdcmProperty>();
}
protected OdcmEntityClass(string name, OdcmNamespace @namespace, OdcmClassKind kind) :
base(name, @namespace, kind)
{
Key = new List<OdcmProperty>();
}
public bool TryResolveNamespace(string @namespace, out OdcmNamespace odcmNamespace)
{
odcmNamespace = Namespaces.FirstOrDefault(x => x.CanonicalName().Equals(@namespace, StringComparison.InvariantCulture));
return(odcmNamespace != null);
}
public static OdcmServiceClass ServiceOdcmClass(OdcmNamespace odcmNamespace, Action<OdcmServiceClass> config = null)
{
var retVal = new OdcmServiceClass(Any.CSharpIdentifier(), odcmNamespace);
var entities = odcmNamespace.Classes
.Where(c => c.Kind == OdcmClassKind.Entity);
foreach (var entity in entities)
{
retVal.Properties.Add(new OdcmProperty(entity.Name) { Class = retVal, Type = entity });
retVal.Properties.Add(new OdcmProperty(entity.Name + "s")
{
Class = retVal,
Type = entity,
IsCollection = true
});
}
retVal.Methods.AddRange(Any.Sequence(s => Any.OdcmMethod()));
if (config != null) config(retVal);
return retVal;
}
public static EnumType GetEnum(this Assembly asm, OdcmNamespace odcmNamespace, string name)
{
return asm.GetEnum(odcmNamespace.Name, name);
}
public OdcmEnum(string name, OdcmNamespace @namespace)
: base(name, @namespace)
{
Members = new List <OdcmEnumMember>();
}
public OdcmEnum(string name, OdcmNamespace @namespace)
: base(name, @namespace)
{
Members = new List<OdcmEnumMember>();
}
public OdcmTypeDefinition(string name, OdcmNamespace @namespace)
: base(name, @namespace)
{
}
public static string GetNamespaceName(OdcmNamespace @namespace)
{
return ResolveNamespace(@namespace.Name);
}
}
private static EntityArtifacts GetEntityArtifactsFromNewNamespace(OdcmEntityClass @class, OdcmNamespace newNamespace,
Assembly proxy, OdcmNamespace oldNamespace)
{
@class.Namespace = newNamespace;
var entityArtifacts = @class.GetArtifactsFrom(proxy);
@class.Namespace = oldNamespace;
public static OdcmEntityClass OdcmEntityClass(OdcmNamespace odcmNamespace, string name, Action<OdcmEntityClass> config = null)
{
var retVal = new OdcmEntityClass(name, odcmNamespace);
EntityOrMediaOdcmClass(odcmNamespace, config, retVal);
return retVal;
}
private static void EntityOrMediaOdcmClass(OdcmNamespace odcmNamespace, Action<OdcmEntityClass> config, OdcmEntityClass retVal)
{
retVal.Properties.AddRange(Any.Sequence(i => Any.PrimitiveOdcmProperty(p => p.Class = retVal)));
retVal.Key.AddRange(retVal.Properties.RandomSubset(2));
if (odcmNamespace.Classes.Any(c => c.Kind == OdcmClassKind.Complex))
retVal.Properties.AddRange(Any.Sequence(i => Any.OdcmProperty(p =>
{
p.Class = retVal;
p.Type = odcmNamespace.Classes.Where(c => c.Kind == OdcmClassKind.Complex).RandomElement();
})));
retVal.Properties.AddRange(Any.Sequence(i => Any.OdcmEntityProperty(retVal, p => { p.Class = retVal; })));
retVal.Properties.AddRange(Any.Sequence(i => Any.OdcmEntityProperty(retVal, p =>
{
p.Class = retVal;
p.IsCollection = true;
})));
if (config != null) config(retVal);
retVal.Methods.AddRange(Any.Sequence(s => Any.OdcmMethod()));
}
public OdcmMethod(string name, OdcmNamespace @namespace)
: base(name, @namespace)
{
Parameters = new List <OdcmParameter>();
}
public OdcmEntityClass(string name, OdcmNamespace @namespace) :
this(name, @namespace, OdcmClassKind.Entity)
{
}
public static OdcmComplexClass ComplexOdcmClass(OdcmNamespace odcmNamespace, Action<OdcmClass> config = null)
{
var retVal = new OdcmComplexClass(Any.CSharpIdentifier(), odcmNamespace);
retVal.Properties.AddRange(Any.Sequence(i => Any.PrimitiveOdcmProperty(p => p.Class = retVal)));
if (config != null) config(retVal);
return retVal;
}
public static string MakeCanonicalName(string name, OdcmNamespace @namespace)
{
return(string.Format("{1}.{0}", name, @namespace.CanonicalName()));
}
public static OdcmProperty EntityOdcmProperty(OdcmNamespace odcmNamespace, Action<OdcmProperty> config = null)
{
return OdcmEntityProperty(Any.OdcmEntityClass(odcmNamespace), config);
}
public static Type GetInterface(this Assembly asm, OdcmNamespace @namespace, string name)
{
return asm.GetInterface(@namespace.Name, name);
}
public static OdcmProperty ComplexOdcmProperty(OdcmNamespace odcmNamespace, Action<OdcmProperty> config = null)
{
var retVal = new OdcmProperty(Any.CSharpIdentifier()) { Type = Any.ComplexOdcmClass(odcmNamespace) };
if (config != null) config(retVal);
return retVal;
}
public OdcmEntityClass(string name, OdcmNamespace @namespace) :
this(name, @namespace, OdcmClassKind.Entity)
{
}
public static OdcmMediaClass MediaOdcmClass(OdcmNamespace odcmNamespace, Action<OdcmEntityClass> config = null)
{
var retVal = new OdcmMediaClass(Any.CSharpIdentifier(), odcmNamespace);
EntityOrMediaOdcmClass(odcmNamespace, config, retVal);
return retVal;
}
public static string MakeCanonicalName(string name, OdcmNamespace @namespace)
{
return string.Format("{1}.{0}", name, @namespace.CanonicalName());
}
public OdcmTypeDefinition(string name, OdcmNamespace @namespace)
: base(name, @namespace)
{
}
