public void ComActionRegion_Constructor_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>());
ComSourceRegion sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
ComNamespaceRegion comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
ComActionRegion dotNetActionRegion = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()), sourceRegion, comNamespaceRegion);
//------------Assert Results-------------------------
Assert.AreEqual(0, dotNetActionRegion.Errors.Count);
Assert.IsTrue(dotNetActionRegion.IsEnabled);
}
public void ComDllNamespaceRegion_ConstructorWithSelectedNamespace_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var pluginSrc = new ComPluginSourceDefinition()
{
Id = id, ResourceName = "johnny"
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc
});
var sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
sourceRegion.SelectedSource = pluginSrc;
//------------Execute Test---------------------------
var comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Assert Results-------------------------
Assert.AreEqual(namespaceItem, comNamespaceRegion.SelectedNamespace);
Assert.IsTrue(comNamespaceRegion.CanRefresh());
}
public void Equals_WithEquivalentNamespaces_ReturnsTrue(string first, string second)
{
var firstNamespace = new NamespaceItem(first);
var secondNamespace = new NamespaceItem(second);
firstNamespace.Equals(secondNamespace).Should().BeTrue();
}
public void HashCode_WithUnequivalentNamespaces_ReturnsFalse(string first, string second)
{
var firstNamespace = new NamespaceItem(first);
var secondNamespace = new NamespaceItem(second);
firstNamespace.GetHashCode().Equals(secondNamespace.GetHashCode()).Should().BeFalse();
}
public void PackageSourceNamespacesItemParse_WithUnrecognizedItems_UnknownItemsAreIgnored()
{
// Arrange
// Arrange
var config = @"
<configuration>
<packageNamespaces>
<packageSource key=""nuget.org"">
<namespace id=""sadas"" />
<notANamespace id=""sadas"" />
</packageSource>
</packageNamespaces>
</configuration>";
var nugetConfigPath = "NuGet.Config";
using var mockBaseDirectory = TestDirectory.Create();
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
// Act and Assert
var settingsFile = new SettingsFile(mockBaseDirectory);
var section = settingsFile.GetSection("packageNamespaces");
section.Should().NotBeNull();
section.Items.Count.Should().Be(1);
var packageSourceNamespaceItem = section.Items.First() as PackageNamespacesSourceItem;
var item = packageSourceNamespaceItem.Namespaces.First();
var expectedItem = new NamespaceItem("sadas");
SettingsTestUtils.DeepEquals(item, expectedItem).Should().BeTrue();
}
} // end constructor
// TODO: a protected constructor that takes a name/path only, and finds the
// NamespaceItem from that.
internal static DbgProviderItem CreateDbgItem(NamespaceItem nsItem)
{
if (nsItem is NsContainer <DbgUModeProcess> )
{
return(new DbgUModeTarget((NsContainer <DbgUModeProcess>)nsItem));
}
else if (nsItem is NsContainer <DbgUModeThreadInfo> )
{
return(new DbgThreadContainer((NsContainer <DbgUModeThreadInfo>)nsItem));
}
else if (nsItem is NsContainer <DbgStackInfo> )
{
return(new DbgStackContainer((NsContainer <DbgStackInfo>)nsItem));
}
else if (nsItem is NsContainer <DbgStackFrameInfo> )
{
return(new DbgStackFrameContainer((NsContainer <DbgStackFrameInfo>)nsItem));
}
else if (nsItem.IsContainer)
{
return(new DbgContainer(nsItem));
}
else
{
return(new DbgLeafItem(nsItem));
}
} // end CreateDbgItem
public void ComActionRegion_ChangeActionSomethingChanged_RegionsNotRestored_Invalid()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity {
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var dotNetsrc = new ComPluginSourceDefinition()
{
Id = id
};
var action = new PluginAction {
FullName = "bravo"
};
var s2 = new ComPluginSourceDefinition {
Id = Guid.NewGuid()
};
var action1 = new PluginAction {
FullName = "bravo1"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
dotNetsrc, s2
});
ComSourceRegion sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
ComNamespaceRegion comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
ComActionRegion dotNetActionRegion = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, comNamespaceRegion);
var clone1 = new Mock <IToolRegion>();
var clone2 = new Mock <IToolRegion>();
var dep1 = new Mock <IToolRegion>();
dep1.Setup(a => a.CloneRegion()).Returns(clone1.Object);
var dep2 = new Mock <IToolRegion>();
dep2.Setup(a => a.CloneRegion()).Returns(clone2.Object);
dotNetActionRegion.Dependants = new List <IToolRegion> {
dep1.Object, dep2.Object
};
dotNetActionRegion.SelectedAction = action;
dotNetActionRegion.SelectedAction = action1;
//------------Assert Results-------------------------
dep1.Verify(a => a.RestoreRegion(clone1.Object), Times.Never);
dep2.Verify(a => a.RestoreRegion(clone2.Object), Times.Never);
}
public void Execute_GivenHasContructorWithInputs_ShouldReturnCorrectInputs()
{
//---------------Set up test pack-------------------
var type = typeof(Human);
var assembly = type.Assembly;
var namespaceItem = new NamespaceItem()
{
AssemblyLocation = assembly.Location,
AssemblyName = assembly.FullName,
FullName = type.FullName,
};
var pluginSource = new PluginSource()
{
AssemblyName = type.AssemblyQualifiedName,
AssemblyLocation = assembly.Location,
};
var pluginSourceDefinition = new PluginSourceDefinition();
var serializeToJson = pluginSourceDefinition.SerializeToJsonStringBuilder();
var nameSpace = namespaceItem.SerializeToJsonStringBuilder();
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(pluginSource);
var FetchPluginConstructors = new FetchPluginConstructors(resourceCat.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mock = new Mock <IWorkspace>();
var stringBuilder = FetchPluginConstructors.Execute(new Dictionary <string, StringBuilder>()
{
{ "source", serializeToJson },
{ "namespace", nameSpace },
},
mock.Object);
//---------------Test Result -----------------------
var executeMessage = stringBuilder.DeserializeToObject <ExecuteMessage>();
var deserializeToObject = executeMessage.Message.DeserializeToObject <List <IPluginConstructor> >();
Assert.AreEqual(3, deserializeToObject.Count);
var pluginConstructor = deserializeToObject[1];
var count = pluginConstructor.Inputs.Count;
Assert.AreEqual(1, count);
var serviceInput = pluginConstructor.Inputs[0];
var name = serviceInput.Name;
var emptyIsNull = serviceInput.EmptyToNull;
var requiredField = serviceInput.IsRequired;
var value = serviceInput.Value;
var typeName = serviceInput.TypeName;
Assert.AreEqual("name", name);
Assert.AreEqual(false, emptyIsNull);
Assert.AreEqual(true, requiredField);
Assert.IsTrue(string.IsNullOrEmpty(value));
Assert.AreEqual(typeof(string), Type.GetType(typeName));
}
public void Execute_GivenHasContructorWithInputs_ShouldReturnCorrectConstructorName()
{
//---------------Set up test pack-------------------
var type = typeof(Human);
var assembly = type.Assembly;
var namespaceItem = new NamespaceItem()
{
AssemblyLocation = assembly.Location,
AssemblyName = assembly.FullName,
FullName = type.FullName,
};
var pluginSource = new PluginSource()
{
AssemblyName = type.AssemblyQualifiedName,
AssemblyLocation = assembly.Location,
};
var pluginSourceDefinition = new PluginSourceDefinition();
var serializeToJson = pluginSourceDefinition.SerializeToJsonStringBuilder();
var nameSpace = namespaceItem.SerializeToJsonStringBuilder();
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(pluginSource);
var FetchPluginConstructors = new FetchPluginConstructors(resourceCat.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mock = new Mock <IWorkspace>();
var stringBuilder = FetchPluginConstructors.Execute(new Dictionary <string, StringBuilder>()
{
{ "source", serializeToJson },
{ "namespace", nameSpace },
},
mock.Object);
//---------------Test Result -----------------------
var executeMessage = stringBuilder.DeserializeToObject <ExecuteMessage>();
var deserializeToObject = executeMessage.Message.DeserializeToObject <List <IPluginConstructor> >();
Assert.AreEqual(3, deserializeToObject.Count);
var pluginConstructor1 = deserializeToObject[1];
var constructorName1 = pluginConstructor1.ConstructorName;
const string expectedName1 = ".ctor (System.String)";
Assert.AreEqual(expectedName1, constructorName1);
var pluginConstructor0 = deserializeToObject[0];
var constructorName0 = pluginConstructor0.ConstructorName;
const string expectedName0 = ".ctor ";
Assert.AreEqual(expectedName0, constructorName0);
var pluginConstructor2 = deserializeToObject[2];
var constructorName2 = pluginConstructor2.ConstructorName;
const string expectedName2 = ".ctor (System.String,System.String,TestingDotnetDllCascading.Food)";
Assert.AreEqual(expectedName2, constructorName2);
}
public void ToStringTest()
{
var exp = "System.Collections.Generic.Dictionary<K, V>";
var namespaceItem = GetNamespaceItemFromString();
var namespaceItem2 = new NamespaceItem();
Assert.AreEqual(exp, namespaceItem.ToString());
Assert.AreEqual(string.Empty, namespaceItem2.ToString());
}
internal DbgLeafItem(NamespaceItem nsItem)
: base(nsItem)
{
if (nsItem.IsContainer)
{
Util.Fail("A container should not be represented by a leaf.");
throw new ArgumentException("The specified item is a container, not a leaf.", "nsItem");
}
} // end constructor
} // end property Parent
// /// <summary>
// /// Indicates if the item can hold child items or not.
// /// </summary>
// public bool IsContainer { get { return NsItem.IsContainer; } }
internal DbgProviderItem(NamespaceItem nsItem)
{
if (null == nsItem)
{
throw new ArgumentNullException("nsItem");
}
NsItem = nsItem;
} // end constructor
public void Execute_GivenSourceAndNamespaceWithActionsTakingObject_ShouldObjectParameters()
{
var humanType = typeof(Human);
//------------Setup for test--------------------------
var pluginSource = new PluginSource
{
ResourceName = humanType.FullName,
ResourceID = humanType.GUID,
AssemblyName = humanType.AssemblyQualifiedName,
AssemblyLocation = humanType.Assembly.Location
};
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(pluginSource);
var fetchPluginActionsWithReturnsTypes = new FetchPluginActionsWithReturnsTypes(resourceCat.Object);
var jsonSerializer = new Dev2JsonSerializer();
var sourceDefinition = new PluginSourceDefinition
{
Id = humanType.GUID, Name = humanType.FullName, Path = humanType.Assembly.Location
};
var namespaceItem = new NamespaceItem
{
FullName = humanType.FullName,
AssemblyLocation = humanType.Assembly.Location,
AssemblyName = humanType.Assembly.FullName
};
var serialezedSource = jsonSerializer.SerializeToBuilder(sourceDefinition);
var serialezedNamespace = jsonSerializer.SerializeToBuilder(namespaceItem);
var values = new Dictionary <string, StringBuilder>
{
{ "source", serialezedSource },
{ "namespace", serialezedNamespace }
};
var workspace = new Mock <IWorkspace>();
var execute = fetchPluginActionsWithReturnsTypes.Execute(values, workspace.Object);
var results = jsonSerializer.Deserialize <ExecuteMessage>(execute);
//------------Assert Results-------------------------
Assert.IsFalse(results.HasError);
var pluginActions = jsonSerializer.Deserialize <List <IPluginAction> >(results.Message);
Assert.IsTrue(pluginActions.Any(action => action.IsVoid));
IEnumerable <IList <IServiceInput> > parameters = pluginActions.Select(action => action.Inputs);
var enumerable = parameters as IList <IServiceInput>[] ?? parameters.ToArray();
var containsObjectParameters = enumerable.Any(list => list.Any(input => input.IsObject));
var shortTypeName = enumerable.All(list => list.All(input => !string.IsNullOrEmpty(input.ShortTypeName)));
var dev2ReturnType = enumerable.All(list => list.All(input => !string.IsNullOrEmpty(input.Dev2ReturnType)));
Assert.IsTrue(containsObjectParameters);
Assert.IsTrue(shortTypeName);
Assert.IsTrue(dev2ReturnType);
}
public void GetParentNamespaceTest()
{
var exp = new NamespaceItem("System.Collections.Generic");
var namespaceItem = GetNamespaceItemFromString();
var parent = namespaceItem.GetParentNamespace();
var parent2 = new NamespaceItem().GetParentNamespace();
Assert.AreEqual(exp, parent);
Assert.AreEqual(null, parent2);
}
public void GetNamespaceWithoutFirstTest()
{
var exp = new NamespaceItem("Collections.Generic.Dictionary<K, V>");
var namespaceItem = GetNamespaceItemFromString();
var parent = namespaceItem.GetNamespaceWithoutFirst();
var parent2 = new NamespaceItem().GetNamespaceWithoutFirst();
Assert.AreEqual(exp, parent);
Assert.AreEqual(null, parent2);
}
public void GetFirstNameTest()
{
var exp = "System";
var namespaceItem = GetNamespaceItemFromString();
var first = namespaceItem.GetFirstName();
var first2 = new NamespaceItem().GetFirstName();
Assert.AreEqual(exp, first);
Assert.AreEqual(null, first2);
}
public void GetLastNameTest()
{
var exp = "Dictionary<K, V>";
var namespaceItem = GetNamespaceItemFromString();
var last = namespaceItem.GetLastName();
var last2 = new NamespaceItem().GetLastName();
Assert.AreEqual(exp, last);
Assert.AreEqual(null, last2);
}
public void Clone_CreatesEquivalentObjects(string namespaceName)
{
var original = new NamespaceItem(namespaceName);
var clone = original.Clone() as NamespaceItem;
original.Equals(clone).Should().BeTrue();
original.GetHashCode().Equals(clone.GetHashCode()).Should().BeTrue();
SettingsTestUtils.DeepEquals(original, clone).Should().BeTrue();
ReferenceEquals(original, clone).Should().BeFalse();
original.Id.Equals(clone.Id);
}
public void ComNamespaceRegion_ChangeNamespaceSomethingChanged_RestoreRegion_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var pluginSrc = new ComPluginSourceDefinition()
{
Id = id, ResourceName = "bob"
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid(), ResourceName = "bob"
};
var namespaceItem1 = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
var sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
//------------Execute Test---------------------------
var comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
var clone1 = new Mock <IToolRegion>();
var clone2 = new Mock <IToolRegion>();
var dep1 = new Mock <IToolRegion>();
dep1.Setup(a => a.CloneRegion()).Returns(clone1.Object);
var dep2 = new Mock <IToolRegion>();
dep2.Setup(a => a.CloneRegion()).Returns(clone2.Object);
comNamespaceRegion.Dependants = new List <IToolRegion> {
dep1.Object, dep2.Object
};
comNamespaceRegion.SelectedNamespace = namespaceItem;
comNamespaceRegion.SelectedNamespace = namespaceItem1;
//------------Assert Results-------------------------
dep1.Verify(a => a.RestoreRegion(clone1.Object), Times.Never);
dep2.Verify(a => a.RestoreRegion(clone2.Object), Times.Never);
}
public void Execute_GivenSourceAndNamespaceWithStringActions_ShouldReturnAStringFunction()
{
var humanType = typeof(Human);
//------------Setup for test--------------------------
var pluginSource = new PluginSource
{
ResourceName = humanType.FullName,
ResourceID = humanType.GUID,
AssemblyName = humanType.AssemblyQualifiedName,
AssemblyLocation = humanType.Assembly.Location
};
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(pluginSource);
var fetchPluginActionsWithReturnsTypes = new FetchPluginActionsWithReturnsTypes(resourceCat.Object);
var jsonSerializer = new Dev2JsonSerializer();
var sourceDefinition = new PluginSourceDefinition
{
Id = humanType.GUID, Name = humanType.FullName, Path = humanType.Assembly.Location
};
var namespaceItem = new NamespaceItem
{
FullName = humanType.FullName,
AssemblyLocation = humanType.Assembly.Location,
AssemblyName = humanType.Assembly.FullName
};
var serialezedSource = jsonSerializer.SerializeToBuilder(sourceDefinition);
var serialezedNamespace = jsonSerializer.SerializeToBuilder(namespaceItem);
var values = new Dictionary <string, StringBuilder>
{
{ "source", serialezedSource },
{ "namespace", serialezedNamespace }
};
var workspace = new Mock <IWorkspace>();
var execute = fetchPluginActionsWithReturnsTypes.Execute(values, workspace.Object);
var results = jsonSerializer.Deserialize <ExecuteMessage>(execute);
//------------Assert Results-------------------------
Assert.IsFalse(results.HasError);
var pluginActions = jsonSerializer.Deserialize <List <IPluginAction> >(results.Message);
Assert.IsTrue(pluginActions.Any(action => action.IsVoid));
var any = pluginActions.Any(action => action.Dev2ReturnType.Equals("return: String"));
Assert.IsTrue(any);
}
internal NamespaceItem GetNamespace(Namespace ns)
{
var fullName = ns.ToString();
NamespaceItem result;
if (!Namespaces.TryGetValue(fullName, out result))
{
result = new NamespaceItem(ns);
Namespaces.Add(fullName, result);
AddChild(result);
}
return(result);
}
public void ComActionRegion_ChangeActionSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity {
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var dotNetsrc = new ComPluginSourceDefinition {
Id = id
};
var s2 = new ComPluginSourceDefinition {
Id = Guid.NewGuid()
};
var action = new PluginAction {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
dotNetsrc, s2
});
ComSourceRegion sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
ComNamespaceRegion comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
ComActionRegion dotNetActionRegion = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, comNamespaceRegion);
// ReSharper disable once UseObjectOrCollectionInitializer
ComActionRegion dotNetActionRegionToRestore = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, comNamespaceRegion);
dotNetActionRegionToRestore.IsEnabled = false;
dotNetActionRegionToRestore.SelectedAction = action;
dotNetActionRegion.RestoreRegion(dotNetActionRegionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(dotNetActionRegion.SelectedAction, action);
Assert.IsFalse(dotNetActionRegion.IsEnabled);
}
public void Update_UpdatesKeyCorrectly()
{
// Arrange
var config = @"
<configuration>
<packageNamespaces>
<packageSource key=""nuget.org"">
<namespace id=""original"" />
</packageSource>
</packageNamespaces>
</configuration>";
var nugetConfigPath = "NuGet.Config";
using var mockBaseDirectory = TestDirectory.Create();
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
// Act and Assert
var settingsFile = new SettingsFile(mockBaseDirectory);
settingsFile.TryGetSection("packageNamespaces", out var section).Should().BeTrue();
section.Should().NotBeNull();
section.Items.Count.Should().Be(1);
var packageSourceNamespacesItem = section.Items.First() as PackageNamespacesSourceItem;
var updatedItem = new NamespaceItem("updated");
packageSourceNamespacesItem.Namespaces.First().Update(updatedItem);
SettingsTestUtils.DeepEquals(packageSourceNamespacesItem.Namespaces.First(), updatedItem).Should().BeTrue();
settingsFile.SaveToDisk();
// Assert
var result = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageNamespaces>
<packageSource key=""nuget.org"">
<namespace id=""updated"" />
</packageSource>
</packageNamespaces>
</configuration>";
result.Replace("\r\n", "\n")
.Should().BeEquivalentTo(
File.ReadAllText(Path.Combine(mockBaseDirectory, nugetConfigPath)).Replace("\r\n", "\n"));
}
public void ComActionRegion_ConstructorWithSelectedAction_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity {
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var dotNetsrc = new ComPluginSourceDefinition {
Id = id, ResourceName = "johnny"
};
var action = new PluginAction {
FullName = "bravo", Method = "bravo", ReturnType = typeof(string), Variables = new List <INameValue>()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
dotNetsrc
});
ComSourceRegion sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
sourceRegion.SelectedSource = dotNetsrc;
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
ComNamespaceRegion comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
ComActionRegion dotNetActionRegion = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, comNamespaceRegion);
dotNetActionRegion.SelectedAction = action;
//------------Assert Results-------------------------
Assert.AreEqual(action, dotNetActionRegion.SelectedAction);
Assert.AreEqual(action.FullName, dotNetActionRegion.SelectedAction.FullName);
Assert.AreEqual(action.Method, dotNetActionRegion.SelectedAction.Method);
Assert.AreEqual(typeof(string), dotNetActionRegion.SelectedAction.ReturnType);
Assert.AreEqual(0, dotNetActionRegion.SelectedAction.Variables.Count);
Assert.IsTrue(dotNetActionRegion.CanRefresh());
}
public void ComActionRegion_ChangeActionSomethingChanged_ExpectedChange_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity {
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var dotNetsrc = new ComPluginSourceDefinition {
Id = id
};
var evt = false;
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
var action = new PluginAction {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
dotNetsrc, s2
});
ComSourceRegion sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
ComNamespaceRegion comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
ComActionRegion dotNetActionRegion = new ComActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, comNamespaceRegion);
dotNetActionRegion.SomethingChanged += (a, b) => { evt = true; };
dotNetActionRegion.SelectedAction = action;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
public void ComNamespaceRegion_ChangeNamespaceSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var pluginSrc = new ComPluginSourceDefinition()
{
Id = id
};
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
var sourceRegion = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfComDllActivity()));
//------------Execute Test---------------------------
var comNamespaceRegion = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
var comNamespaceRegionToRestore = new ComNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
comNamespaceRegionToRestore.IsEnabled = false;
comNamespaceRegionToRestore.SelectedNamespace = namespaceItem;
comNamespaceRegion.RestoreRegion(comNamespaceRegionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(comNamespaceRegion.SelectedNamespace, namespaceItem);
Assert.IsFalse(comNamespaceRegion.IsEnabled);
}
public void Execute_GivenTestInputs_ShouldReturnConstructorList()
{
//---------------Set up test pack-------------------
var type = typeof(Human);
var assembly = type.Assembly;
var namespaceItem = new NamespaceItem()
{
AssemblyLocation = assembly.Location,
AssemblyName = assembly.FullName,
FullName = type.FullName,
};
var pluginSource = new PluginSource()
{
AssemblyName = type.AssemblyQualifiedName,
AssemblyLocation = assembly.Location,
};
var pluginSourceDefinition = new PluginSourceDefinition();
var serializeToJson = pluginSourceDefinition.SerializeToJsonStringBuilder();
var nameSpace = namespaceItem.SerializeToJsonStringBuilder();
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(pluginSource);
var FetchPluginConstructors = new FetchPluginConstructors(resourceCat.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mock = new Mock <IWorkspace>();
var stringBuilder = FetchPluginConstructors.Execute(new Dictionary <string, StringBuilder>()
{
{ "source", serializeToJson },
{ "namespace", nameSpace },
},
mock.Object);
//---------------Test Result -----------------------
var executeMessage = stringBuilder.DeserializeToObject <ExecuteMessage>();
var deserializeToObject = executeMessage.Message.DeserializeToObject <List <IPluginConstructor> >();
Assert.AreEqual(3, deserializeToObject.Count);
}
/// <summary>
/// Creates the csharp code
/// </summary>
/// <param name="namespaceItem">The namespace</param>
/// <param name="classItem">The class</param>
/// <param name="properties">The selected properties</param>
/// <returns>The generated code</returns>
public static string CreateCSharpCode(NamespaceItem namespaceItem, ClassItem classItem,
List <PropertyItem> properties)
{
var template = LoadTemplate();
if (string.IsNullOrEmpty(template))
{
return("");
}
// Step 1: Replace the namespace
template = template.Replace("{NAMESPACE}", namespaceItem.Name.Replace("\\", "\\\\"));
// Step 2: Replace the query
template = template.Replace("{QUERY}", $"SELECT * FROM {classItem.Name}");
// Step 3: Replace the class name
template = template.Replace("{CLASS}", classItem.Name);
// Step 4: Create the properties
template = template.Replace("{PROPERTY}", CreateProperties(properties));
return(template);
}
public void GetNamespaces_GivenHasError_ShouldAddIntoErrors()
{
//---------------Set up test pack-------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var pluginSrc = new ComPluginSourceDefinition()
{
Id = id
};
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
src.Setup(a => a.GetNameSpaces(It.IsAny <IComPluginSource>())).Throws(new BadImageFormatException());
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var modelItem = ModelItemUtils.CreateModelItem(new DsfComDllActivity());
var dotNetSourceRegion = new ComSourceRegion(src.Object, modelItem);
var mockPluginSource = new Mock <IComPluginSource>();
dotNetSourceRegion.SelectedSource = mockPluginSource.Object;
var sourceRegion = new ComNamespaceRegion(src.Object, modelItem, dotNetSourceRegion);
//---------------Test Result -----------------------
Assert.AreEqual(sourceRegion.Errors.Count, 1);
Assert.AreEqual(sourceRegion.Errors.Count(s => s.Contains("Format of the executable (.exe) or library (.dll) is invalid")), 1);
}
public void Execute_GivenHasError_ShouldReturnErrorState()
{
//---------------Set up test pack-------------------
var type = typeof(Human);
var assembly = type.Assembly;
var namespaceItem = new NamespaceItem()
{
AssemblyLocation = assembly.Location,
AssemblyName = assembly.FullName,
FullName = type.FullName,
};
var pluginSourceDefinition = new PluginSourceDefinition();
var serializeToJson = pluginSourceDefinition.SerializeToJsonStringBuilder();
var nameSpace = namespaceItem.SerializeToJsonStringBuilder();
var resourceCat = new Mock <IResourceCatalog>();
resourceCat.Setup(catalog => catalog.GetResource <PluginSource>(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Throws(new Exception("error"));
var FetchPluginConstructors = new FetchPluginConstructors(resourceCat.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mock = new Mock <IWorkspace>();
var stringBuilder = FetchPluginConstructors.Execute(new Dictionary <string, StringBuilder>()
{
{ "source", serializeToJson },
{ "namespace", nameSpace },
},
mock.Object);
//---------------Test Result -----------------------
var executeMessage = stringBuilder.DeserializeToObject <ExecuteMessage>();
Assert.IsTrue(executeMessage.HasError);
Assert.AreEqual("error", executeMessage.Message.ToString());
}
private void ReflectAssembly(AssemblyItem assemblyItem, Assembly asm, bool invert)
{
string ns;
NamespaceItem nsItem;
Dictionary<string, NamespaceItem> nsItems = new Dictionary<string, NamespaceItem>();
// Add the assembly item itself to the lookup.
_projectBrowser.AddLookup(assemblyItem, assemblyItem.GetID(), invert);
try
{
Type[] types = asm.GetTypes();
}
catch (ReflectionTypeLoadException exc)
{
_logView.LogExcStr(exc, "Failed to call GetTypes on " + asm.FullName);
return;
}
foreach (Type t in asm.GetTypes())
{
ns = t.Namespace;
if (string.IsNullOrEmpty(ns)) ns = "(none)";
if (!nsItems.ContainsKey(ns))
{
nsItem = new NamespaceItem(ns, assemblyItem);
nsItems.Add(ns, nsItem);
assemblyItem.NameSpaces.Add(nsItem);
_projectBrowser.AddLookup(nsItem, nsItem.GetID(), invert);
}
else
{
nsItem = nsItems[ns];
}
// Flatten nested types.
string name = t.Name;
if (t.IsNested)
{
// Flat with .id'd name.
Type parentType = t.DeclaringType;
while (parentType != null)
{
name = parentType.Name + "." + name;
parentType = parentType.DeclaringType;
}
}
try
{
TypeItem typeItem = new TypeItem(name, t.FullName, t, nsItem);
nsItem.Types.Add(typeItem);
_projectBrowser.AddLookup(typeItem, typeItem.GetID(), invert);
foreach (MethodInfo mi in GetMethods(typeItem))
{
MethodItem methodItem = new MethodItem(mi.Name, mi, typeItem);
typeItem.Methods.Add(methodItem);
_projectBrowser.AddLookup(methodItem, methodItem.GetID(), invert);
}
// Get the list of implemented interfaces.
typeItem.Implements = GetImplementedInterfaces(typeItem);
if (typeItem.TypeRef.BaseType != null)
{
typeItem.InheritsFrom = typeItem.TypeRef.BaseType.ToString();
}
else
{
typeItem.InheritsFrom = null;
}
}
catch (Exception exc)
{
_logView.LogExcStr(exc, "Generic Types issue?");
}
}
}
