private DataContractCollection CreateDataContractCollection()
{
DataContractCollection dataContractCol = Store.ElementFactory.CreateElement(DataContractCollection.DomainClassId) as DataContractCollection;
dataContractCol.Name = "fooDataContractCollection";
return(dataContractCol);
}
private DataContractCollection CreateDataContractCollection(string name)
{
DataContractCollection dataContract = new DataContractCollection(DataContractStore);
dataContract.Name = name;
return(dataContract);
}
public void ReturnSuccessForEmtpyDataContract()
{
DataContractCollection dc = CreateDataContractCollection();
TestNonRecursiveDataContractValidator validator = new TestNonRecursiveDataContractValidator();
ValidationResults validationResults = new ValidationResults();
validator.TestDoValidate(dc.DataContract, dc, "DataContract", validationResults);
Assert.IsTrue(validationResults.IsValid);
}
public void ReturnFailureForEmptyDataContract()
{
DataContractCollection dc = CreateDataContractCollection();
TestNonEmptyDataContractValidator validator = new TestNonEmptyDataContractValidator();
ValidationResults validationResults = new ValidationResults();
validator.TestDoValidate(dc.DataContract, dc, "DataContract", validationResults);
Assert.IsFalse(validationResults.IsValid);
}
public void ShouldReturnAsmxDataContractCollectionArtifactLink()
{
DataContractCollection dcCollection = new DataContractCollection(Store);
dcCollection.DataContractModel = new DataContractModel(Store);
AsmxDataContractCollection asmxDCCollection = new AsmxDataContractCollection();
asmxDCCollection.ModelElement = dcCollection;
Assert.IsInstanceOfType(asmxDCCollection.ArtifactLink, typeof(AsmxDataContractCollectionLink));
}
private bool HasRecursiveGraph(string name, DataContractBase dataContract)
{
DataContractCollection collection = dataContract as DataContractCollection;
if (collection != null &&
collection.DataContract != null)
{
return(name == collection.DataContract.Name ||
HasRecursiveGraph(name, collection.DataContract));
}
return(false);
}
public void ReturnFailureForSelfReferencedDataContract()
{
DataContractCollection dc = CreateDataContractCollection();
dc.DataContract = dc;
TestNonRecursiveDataContractValidator validator = new TestNonRecursiveDataContractValidator();
ValidationResults validationResults = new ValidationResults();
validator.TestDoValidate(dc.DataContract, dc, "DataContract", validationResults);
Assert.IsFalse(validationResults.IsValid);
}
private DataContractCollection CreateDefaultDataContractCollectionElement(Type collectionType)
{
DataContractCollection rootElement = new DataContractCollection(Store);
rootElement.DataContractModel = new DataContractModel(Store);
rootElement.DataContractModel.ProjectMappingTable = "WCF";
rootElement.Name = ElementName;
rootElement.Namespace = ElementNamespace;
rootElement.ObjectExtender = AttachDataContractCollectionExtender(rootElement, collectionType);
DataContract dce = new DataContract(Store);
dce.Name = PrimitiveDataElementName1;
rootElement.DataContract = dce;
return(rootElement);
}
public void TestHeaderGeneration()
{
ProjectMappingManagerSetup.InitializeManager(ServiceProvider, "ProjectMapping.DataContractDsl.Tests.xml");
DataContractCollection collectionElement = CreateDefaultDataContractCollectionElement(typeof(Collection <>));
string content = RunTemplate(collectionElement);
this.EnsureType(ref content, PrimitiveDataElementName1);
Type generatedType = CompileAndGetType(content);
Assert.IsTrue(generatedType.IsClass);
Assert.AreEqual <string>(((WCFDataContractCollection)collectionElement.ObjectExtender).CollectionType.Name, generatedType.BaseType.Name);
Assert.IsTrue(generatedType.BaseType.FullName.Contains(PrimitiveDataElementName1));
CollectionDataContractAttribute collectionAttr = TypeAsserter.AssertAttribute <CollectionDataContractAttribute>(generatedType);
Assert.AreEqual <string>(ElementNamespace, collectionAttr.Namespace);
}
public void ReturnFailureForInvalidValidCollection()
{
Store store = new Store(new MockServiceProvider(), typeof(CoreDesignSurfaceDomainModel), typeof(DataContractDslDomainModel));
using (Transaction t = store.TransactionManager.BeginTransaction())
{
DataContractCollection collection = store.ElementFactory.CreateElement(DataContractCollection.DomainClassId) as DataContractCollection;
collection.ObjectExtender = new WCFDataContractCollection();
NonEmptyDataContractCollectionBaseCollectionTypeValidator validator = new NonEmptyDataContractCollectionBaseCollectionTypeValidator(null);
ValidationResults validationResults = validator.Validate(collection);
Assert.IsFalse(validationResults.IsValid);
t.Rollback();
}
}
public void TestWalkerFromMessageContractWithDataContractCollectionMessagePart()
{
List <ModelElement> elementList = new List <ModelElement>();
using (Transaction t = DataContractStore.TransactionManager.BeginTransaction())
{
DataContractModel dcRoot = CreateDataContractRoot();
DataContract dataContract = CreateDataContract("FooDc");
DataContractCollection dataContractCollection = CreateDataContractCollection("FooDcc");
dataContractCollection.DataContract = dataContract;
dcRoot.Contracts.Add(dataContract);
dcRoot.Contracts.Add(dataContractCollection);
using (Transaction t1 = ServiceContractStore.TransactionManager.BeginTransaction())
{
ServiceContractModel scRoot = CreateServiceContractRoot();
Message request = CreateMessageContract("FooMCReq", "FooMCReq");
DataContractMessagePart part1 =
CreateDataContractMessagePart(
"FooPart1",
GetMockMoniker(dataContract));
request.MessageParts.Add(part1);
scRoot.Messages.Add(request);
FullDepthElementWalker elementWalker =
new FullDepthElementWalker(
new ModelElementVisitor(elementList),
new EmbeddingReferenceVisitorFilter(),
false);
elementWalker.DoTraverse(request);
Assert.AreEqual(2, elementList.Count); // 4 elemsn with Resolver
t1.Rollback();
}
t.Rollback();
}
}
