public void When_it_changes_an_entity_container_name_then_the_proxy_reflects_the_change()
{
var newEntityContainerName = Any.CSharpIdentifier();
var nameMap =
new Dictionary <string, IImmutableDictionary <string, string> >
{
{
_model.EntityContainer.Namespace, new Dictionary <string, string>
{
{ _model.EntityContainer.Name, newEntityContainerName }
}.ToImmutableDictionary()
}
}.ToImmutableDictionary();
var configMock = new Mock <IConfigurationProvider>(MockBehavior.Loose);
configMock
.Setup(c => c.OdcmClassNameToProxyClassName)
.Returns(() => nameMap);
var proxy = GetProxy(_model, configMock.Object);
proxy.GetClasses()
.Where(c => c.Namespace == _model.EntityContainer.Namespace)
.Select(c => c.Name)
.Should()
.Contain(newEntityContainerName)
.And
.NotContain(_model.EntityContainer.Name);
}
public Given_an_OdcmClass_Service_Navigation_Property_Collection()
{
base.Init(m =>
{
_navigationProperty = Any.OdcmProperty(p => p.Type = Class);
var @namespace = m.Namespaces[0];
_navTargetClass = Any.EntityOdcmClass(@namespace);
Model.AddType(_navTargetClass);
var @class = @namespace.Classes.First();
_navigationProperty = Any.OdcmProperty(p =>
{
p.Class = OdcmContainer;
p.Type = _navTargetClass;
p.Field = new OdcmField(Any.CSharpIdentifier())
{
Class = @class,
Type = _navTargetClass,
IsCollection = true
};
});
OdcmContainer.Properties.Add(_navigationProperty);
});
}
public void When_it_changes_an_entity_name_then_the_proxy_reflects_the_change()
{
var nameMap = _model.Namespaces
.ToImmutableDictionary(
n => n.Name,
n => (IImmutableDictionary <string, string>)n.Classes
.Where(c => c.Kind == OdcmClassKind.Entity)
.RandomSubset(2)
.ToImmutableDictionary(c => c.Name, c => Any.CSharpIdentifier()));
var configMock = new Mock <IConfigurationProvider>(MockBehavior.Loose);
configMock
.Setup(c => c.OdcmClassNameToProxyClassName)
.Returns(() => nameMap);
var proxy = GetProxy(_model, configMock.Object);
foreach (var targetNamespace in nameMap.Keys)
{
var @namespace = targetNamespace;
proxy.GetClasses()
.Where(c => c.Namespace == @namespace)
.Select(cl => cl.Name)
.Should()
.Contain(nameMap[targetNamespace].Values)
.And
.NotContain(nameMap[targetNamespace].Keys);
}
}
public Given_an_OdcmClass_Entity_Navigation_Property_Instance()
{
_navigationProperty = Any.OdcmProperty(p => p.Type = Class);
base.Init(m =>
{
var @namespace = m.Namespaces[0];
_navTargetClass = Any.EntityOdcmClass(@namespace);
@namespace.Types.Add(_navTargetClass);
var @class = @namespace.Classes.First();
_navigationProperty = Any.OdcmProperty(p =>
{
p.Class = @class;
p.Type = _navTargetClass;
p.Field = new OdcmField(Any.CSharpIdentifier())
{
Class = @class,
Type = _navTargetClass,
IsCollection = false
};
});
m.Namespaces[0].Classes.First().Properties.Add(_navigationProperty);
});
}
public void Init()
{
_model = new OdcmModel();
_namespace = Any.OdcmNamespace();
_model.Namespaces.Add(_namespace);
_class = new OdcmClass(Any.CSharpIdentifier(), _namespace.Name, OdcmClassKind.Entity);
}
public void When_proxied_then_the_proxy_class_has_a_Fetcher_interface()
{
_class = new OdcmClass(Any.CSharpIdentifier(), _namespace.Name, OdcmClassKind.Entity);
var interfaceName = _namespace.Name + ".I" + _class.Name + "Fetcher";
_model.AddType(_class);
var proxy = GetProxy(_model);
var classType = proxy.GetClass(_class.Namespace, _class.Name);
classType.GetInterface(interfaceName).Should().NotBeNull();
}
public void When_proxied_then_the_proxy_class_inherits_from_EntityBase()
{
_class = new OdcmClass(Any.CSharpIdentifier(), _namespace.Name, OdcmClassKind.Entity);
_model.AddType(_class);
var proxy = GetProxy(_model);
var classType = proxy.GetClass(_class.Namespace, _class.Name);
var complexTypeBaseType = proxy.GetClass(_class.Namespace + ".Extensions", "EntityBase");
classType.BaseType.Should().Be(complexTypeBaseType);
}
public void When_it_requests_a_namespace_prefix_then_the_proxy_reflects_the_prefix()
{
var prefix = Any.CSharpIdentifier();
var configMock = new Mock<IConfigurationProvider>(MockBehavior.Loose);
configMock
.Setup(c => c.NamespacePrefix)
.Returns(() => prefix);
var proxy = GetProxy(_model, configMock.Object);
proxy.GetNamespaces()
.Count(n => !n.StartsWith(prefix + "."))
.Should().Be(0, "Because all namespaces should be prefixed");
}
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_model_has_several_non_empty_namespaces_each_is_exposed_in_the_proxy()
{
var @namespace1 = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(@namespace1);
_model.AddType(new OdcmEnum(Any.CSharpIdentifier(1, 10), @namespace1));
var @namespace2 = Any.EmptyOdcmNamespace();
_model.Namespaces.Add(@namespace2);
_model.AddType(new OdcmEnum(Any.CSharpIdentifier(1, 10), @namespace2));
var proxy = GetProxy(_model);
proxy.GetNamespaces()
.Should().Contain(new[] { @namespace1.Name, @namespace2.Name });
}
public void When_it_changes_a_namespace_then_the_proxy_reflects_the_change()
{
var namespaceMap = _model.Namespaces
.RandomSubset(2)
.ToImmutableDictionary(n => n.Name, n => Any.CSharpIdentifier());
var configMock = new Mock <IConfigurationProvider>(MockBehavior.Loose);
configMock
.Setup(c => c.OdcmNamespaceToProxyNamespace)
.Returns(() => namespaceMap);
var proxy = GetProxy(_model, configMock.Object);
proxy.GetNamespaces()
.Should()
.Contain(namespaceMap.Values)
.And
.NotContain(namespaceMap.Keys);
}
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 static IEnumerable <Tuple <string, object> > GetSampleKeyArguments(this OdcmEntityClass entityClass)
{
return(entityClass.Key.Select(p => new Tuple <string, object>(p.Name, Any.CSharpIdentifier(1))));
}
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");
}
}
