public void GetArtifactsReturnsNull()
{
MockServiceProvider mockServiceProvider = new MockServiceProvider();
IArtifactLinkContainer links = ModelCollector.GetArtifacts(mockServiceProvider);
Assert.IsNull(links);
}
public void AccessibilityRespected_ReturnsPublicOnly()
{
var tree = CSharpSyntaxTree.ParseText(@"
public class A : IController<Controller>
{
const int A_Constant = 0;
private string B { get; set }
static string C { get; set }
public string Included { get; set }
public void AMember()
{
}
}"
);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.VisitClassDeclaration(root.DescendantNodes().OfType <ClassDeclarationSyntax>().First());
Assert.IsNotNull(modelCollector.Models);
Assert.IsNotNull(modelCollector.Models.First().Properties);
Assert.AreEqual(1, modelCollector.Models.First().Properties.Count());
}
static void Main(string[] args)
{
var code =
@" using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HelloWorld
{
public class MyAwesomeModel
{
public string MyProperty {get;set;}
public int MyProperty1 {get;set;}
}
}";
var tree = CSharpSyntaxTree.ParseText(code);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.Visit(root);
Console.WriteLine(JsonConvert.SerializeObject(modelCollector.models));
}
public void ObsoleteFields_ShouldBeMarkedObsolete()
{
var tree = CSharpSyntaxTree.ParseText(@"
public class A
{
public int NonObsoleteProperty { get; set; }
[Obsolete]
public int ObsoleteProperty { get; set; }
[Obsolete]
public int ObsoleteField;
}"
);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.Visit(root);
var modelProperties = modelCollector.Models.Single().Properties.ToArray();
var modelFields = modelCollector.Models.Single().Fields.ToArray();
Assert.That(modelProperties[0].Identifier, Is.EqualTo("NonObsoleteProperty"));
Assert.That(modelProperties[0].IsObsolete, Is.False);
Assert.That(modelProperties[1].Identifier, Is.EqualTo("ObsoleteProperty"));
Assert.That(modelProperties[1].IsObsolete, Is.True);
Assert.That(modelFields[0].Identifier, Is.EqualTo("ObsoleteField"));
Assert.That(modelFields[0].IsObsolete, Is.True);
}
public PropertyLocator(string path, ModelCollector collector, Stack <Interpreter.IteratorManager> loopStack)
{
Path = path;
PathElements = path.Split('.');
CurrentRoot = null;
Collector = collector;
LoopStack = loopStack;
}
private void GenerateAllArtifacts()
{
HashSet <ModelElement> elementList = new HashSet <ModelElement>();
FullDepthElementWalker elementWalker = new FullDepthElementWalker(
new ModelElementVisitor(elementList), new EmbeddingReferenceVisitorFilter(), false);
elementWalker.DoTraverse(DomainModelHelper.GetModelElement(this.FocusedSelection));
IArtifactLinkContainer links = ModelCollector.GetArtifacts(elementList);
GenerateArtifacts(links);
elementList.Clear();
}
public void DictionaryInheritance_ReturnsIndexAccessor()
{
var tree = CSharpSyntaxTree.ParseText(@"public class A : Dictionary<string, string> { }");
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.VisitClassDeclaration(root.DescendantNodes().OfType <ClassDeclarationSyntax>().First());
Assert.IsNotNull(modelCollector.Models);
Assert.IsNotNull(modelCollector.Models.First().BaseClasses);
Assert.AreEqual(new[] { "Dictionary<string, string>" }, modelCollector.Models.First().BaseClasses);
}
protected override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
{
base.DoValidate(objectToValidate, currentTarget, key, validationResults);
IArtifactLinkContainer container = objectToValidate as IArtifactLinkContainer;
if (validationResults.IsValid &&
ModelCollector.HasValidArtifacts(container) &&
!ModelCollector.HasRoles(container))
{
this.LogValidationResult(validationResults,
ValidatorUtility.ShowFormattedMessage(Resources.ExtenderObjectValidatorMessage, currentTarget),
currentTarget,
key);
}
}
public void OnMenuChangeGenerateCode(object sender, EventArgs e)
{
try
{
if (IsValidModel())
{
IArtifactLinkContainer links = ModelCollector.GetArtifacts(this.ServiceProvider);
GenerateArtifacts(links);
}
}
catch (Exception error)
{
Logger.Write(error);
}
}
public void OnMenuChangeViewGeneratedCode(object sender, EventArgs e)
{
IArtifactLinkContainer container = ModelCollector.GetArtifacts(DomainModelHelper.GetSelectedElement(this.ServiceProvider));
foreach (IArtifactLink link in container.ArtifactLinks)
{
string fullPath = GetFullPath(link);
if (File.Exists(fullPath))
{
EnvDTE.DTE dte = (EnvDTE.DTE) this.ServiceProvider.GetService(typeof(EnvDTE.DTE));
if (dte != null)
{
dte.ItemOperations.OpenFile(fullPath, EnvDTE.Constants.vsViewKindCode);
}
return;
}
}
}
public void InterfaceImport_ReturnsSyntaxClassFromInterface()
{
var tree = CSharpSyntaxTree.ParseText(@"
public interface IPhoneNumber {
string Label { get; set; }
string Number { get; set; }
int MyProperty { get; set; }
}
public interface IPoint
{
// Property signatures:
int x
{
get;
set;
}
int y
{
get;
set;
}
}
public class X {
public IPhoneNumber test { get; set; }
public IPoint test2 { get; set; }
}"
);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.Visit(root);
Assert.IsNotNull(modelCollector.Models);
Assert.AreEqual(3, modelCollector.Models.Count);
Assert.AreEqual(3, modelCollector.Models.First().Properties.Count());
}
public void TypedInheritance_ReturnsInheritance()
{
var tree = CSharpSyntaxTree.ParseText(@"
public class A : IController<Controller>
{
public void AMember()
{
}
}"
);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.VisitClassDeclaration(root.DescendantNodes().OfType <ClassDeclarationSyntax>().First());
Assert.IsNotNull(modelCollector.Models);
Assert.AreEqual(new[] { "IController<Controller>" }, modelCollector.Models.First().BaseClasses);
}
private bool IsValidSelectedContainer()
{
IArtifactLinkContainer container = ModelCollector.GetArtifacts(DomainModelHelper.GetSelectedElement(this.ServiceProvider));
bool isValid = (container != null && container.ArtifactLinks.Count > 0);
if (isValid)
{
foreach (IArtifactLink link in container.ArtifactLinks)
{
if (!File.Exists(GetFullPath(link)))
{
isValid = false;
break;
}
}
}
return(isValid);
}
public void OnStatusChangeInGenerateCode(object sender, EventArgs e)
{
DynamicStatusMenuCommand command = sender as DynamicStatusMenuCommand;
bool activateCommand = false;
if (!this.IsCurrentDiagramEmpty() &&
this.IsSingleSelection())
{
try
{
activateCommand = ModelCollector.HasValidArtifactsAndRoles(this.ServiceProvider);
}
catch (Exception error)
{
Logger.Write(error);
}
}
command.Visible = command.Enabled = activateCommand;
}
public void BasicInheritance_ReturnsInheritedClass()
{
const string baseClasses = "B, C, D";
var tree = CSharpSyntaxTree.ParseText(@"
public class A : B, C, D
{
public void AMember()
{
}
}"
);
var root = (CompilationUnitSyntax)tree.GetRoot();
var modelCollector = new ModelCollector();
modelCollector.VisitClassDeclaration(root.DescendantNodes().OfType <ClassDeclarationSyntax>().First());
Assert.IsNotNull(modelCollector.Models);
Assert.AreEqual(modelCollector.Models.First().BaseClasses, baseClasses);
}
protected override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
{
//TODO: Fix this call if not working
if (objectToValidate != null)
{
// Ignore objects than have already been validated.
//
if (IsValidated(objectToValidate))
{
return;
}
Type targetType = objectToValidate.GetType();
using (FileConfigurationSource configurationSource = new FileConfigurationSource(TargetConfigurationFile))
{
Validator v = ValidationFactory.CreateValidator(targetType, "Common", configurationSource);
v.Validate(objectToValidate, validationResults);
v = ValidationFactory.CreateValidator(targetType, targetRuleset, configurationSource);
v.Validate(objectToValidate, validationResults);
}
Debug.WriteLine(String.Format(CultureInfo.CurrentUICulture, "{0} {1}", objectToValidate.ToString(), validationResults.IsValid ? "Succeeded" : "Failed"));
}
//base.DoValidate(objectToValidate, currentTarget, key, validationResults);
IArtifactLinkContainer container = objectToValidate as IArtifactLinkContainer;
if (validationResults.IsValid &&
ModelCollector.HasValidArtifacts(container) &&
!ModelCollector.HasRoles(container))
{
this.LogValidationResult(validationResults,
ValidatorUtility.ShowFormattedMessage(Resources.ExtenderObjectValidatorMessage, currentTarget),
currentTarget,
key);
}
}
