public void GivenIOpenPluginSource(string name)
{
var pluginSrc = new PluginSourceDefinition
{
Name = name,
Id = Guid.NewGuid(),
Path = "",
SelectedDll = name.Equals("Test", StringComparison.OrdinalIgnoreCase) ? _dllListingForGac : _dllListingForFile,
};
pluginSrc.GACAssemblyName = _dllListingForGac.FullName;
pluginSrc.FileSystemAssemblyName = _dllListingForFile.FullName;
var managePluginSourceControl = ScenarioContext.Current.Get <ManagePluginSourceControl>(Utils.ViewNameKey);
var mockStudioUpdateManager = FeatureContext.Current.Get <Mock <IManagePluginSourceModel> >("updateManager").Object;
var mockEventAggregator = FeatureContext.Current.Get <Mock <IEventAggregator> >("eventAggregator").Object;
var mockSynchronousAsyncWorker = FeatureContext.Current.Get <Mock <SynchronousAsyncWorker> >("synchronousAsyncWorker").Object;
try
{
var managePluginSourceViewModel = new ManagePluginSourceViewModel(mockStudioUpdateManager, mockEventAggregator, pluginSrc, new SynchronousAsyncWorker());
managePluginSourceControl.DataContext = managePluginSourceViewModel;
ScenarioContext.Current.Remove("viewModel");
ScenarioContext.Current.Add("viewModel", managePluginSourceViewModel);
}
catch (Exception)
{
// ignored
}
}
public void DotNetSourceRegion_ConstructorWithSelectedSource_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc
});
//------------Execute Test---------------------------
var region = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
//------------Assert Results-------------------------
Assert.AreEqual(pluginSrc, region.SelectedSource);
Assert.IsTrue(region.CanEditSource());
}
public void DotNetSourceRegion_ChangeSourceSomethingChanged_CloneRegion_ExpectedClone()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
var region = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
var cloned = region.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(cloned.IsEnabled, region.IsEnabled);
Assert.AreEqual(((DotNetSourceRegion)cloned).SelectedSource, region.SelectedSource);
}
public void DotNetSourceRegion_ChangeSourceSomethingChanged_ExpectedChange_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
var evt = false;
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
var region = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
region.SomethingChanged += (a, b) => { evt = true; };
region.SelectedSource = s2;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
public void DotNetNamespaceRegion_ConstructorWithSelectedNamespace_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id, Name = "johnny"
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
sourceRegion.SelectedSource = pluginSrc;
//------------Execute Test---------------------------
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Assert Results-------------------------
Assert.AreEqual(namespaceItem, dotNetNamespaceRegion.SelectedNamespace);
Assert.IsTrue(dotNetNamespaceRegion.CanRefresh());
}
public void PluginSourceDefinition_Equals_Object_GetType_Expected_False()
{
const string expectedAssemblyLocation = "testAssemblyPath";
const string expectedAssemblyName = "testAssemblyName";
var expectedResourceID = Guid.NewGuid();
const string expectedSavePath = "Path\\ResourcePath";
const string expectedResourceName = "testResource";
const string expectedConfigFilePath = "testConfigFilePath";
var mockPlugin = new Mock <IPlugin>();
mockPlugin.Setup(plugin => plugin.AssemblyLocation).Returns(expectedAssemblyLocation);
mockPlugin.Setup(plugin => plugin.AssemblyName).Returns(expectedAssemblyName);
mockPlugin.Setup(plugin => plugin.ResourceID).Returns(expectedResourceID);
mockPlugin.Setup(plugin => plugin.GetSavePath()).Returns(expectedSavePath);
mockPlugin.Setup(plugin => plugin.ResourceName).Returns(expectedResourceName);
mockPlugin.Setup(plugin => plugin.ConfigFilePath).Returns(expectedConfigFilePath);
var pluginSourceDefinition = new PluginSourceDefinition(mockPlugin.Object);
var pluginSource = new object();
var isEqual = pluginSourceDefinition.Equals(pluginSource);
Assert.IsFalse(isEqual);
}
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 DotNetActionRegion_ChangeActionSomethingChanged_RegionsNotRestored_Invalid()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity {
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var dotNetsrc = new PluginSourceDefinition()
{
Id = id
};
var action = new PluginAction {
FullName = "bravo"
};
var s2 = new PluginSourceDefinition {
Id = Guid.NewGuid()
};
var action1 = new PluginAction {
FullName = "bravo1"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
dotNetsrc, s2
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
DotNetActionRegion dotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
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 PluginSourceDefinition_GetHashCode_Expect_Zero()
{
var pluginSourceDefinition = new PluginSourceDefinition();
var hashCode = pluginSourceDefinition.GetHashCode();
Assert.AreEqual(0, hashCode);
}
public IPluginSource FetchSource(Guid resourceID)
{
var xaml = _queryProxy.FetchResourceXaml(resourceID);
var db = new PluginSource(xaml.ToXElement());
var def = new PluginSourceDefinition(db);
return(def);
}
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 PluginSourceDefinition_Equals_Object_Null_Expected_False()
{
var pluginSourceDefinition = new PluginSourceDefinition();
const object pluginSource = null;
var isEqual = pluginSourceDefinition.Equals(pluginSource);
Assert.IsFalse(isEqual);
}
void ToItem()
{
Item = new PluginSourceDefinition
{
Id = _pluginSource.Id,
Name = _pluginSource.Name,
Path = _pluginSource.Path,
FileSystemAssemblyName = _pluginSource.FileSystemAssemblyName,
ConfigFilePath = _pluginSource.ConfigFilePath,
GACAssemblyName = _pluginSource.GACAssemblyName
};
}
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);
}
public void DotNetSourceRegion_ChangeSourceSomethingChanged_RegionsNotRestored_Invalid()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
var region = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
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);
region.Dependants = new List <IToolRegion> {
dep1.Object, dep2.Object
};
region.SelectedSource = s2;
region.SelectedSource = pluginSrc;
//------------Assert Results-------------------------
dep1.Verify(a => a.RestoreRegion(clone1.Object), Times.Never);
dep2.Verify(a => a.RestoreRegion(clone2.Object), Times.Never);
}
public void DotNetActionRegion_ChangeActionSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity {
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var dotNetsrc = new PluginSourceDefinition {
Id = id
};
var s2 = new PluginSourceDefinition {
Id = Guid.NewGuid()
};
var action = new PluginAction {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
dotNetsrc, s2
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
DotNetActionRegion dotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
// ReSharper disable once UseObjectOrCollectionInitializer
DotNetActionRegion dotNetActionRegionToRestore = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
dotNetActionRegionToRestore.IsEnabled = false;
dotNetActionRegionToRestore.SelectedAction = action;
dotNetActionRegion.RestoreRegion(dotNetActionRegionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(dotNetActionRegion.SelectedAction, action);
Assert.IsFalse(dotNetActionRegion.IsEnabled);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
var list = Resources.GetResourceList <PluginSource>(GlobalConstants.ServerWorkspaceID).Select(a =>
{
if (a is PluginSource res)
{
var pluginSourceDefinition = new PluginSourceDefinition
{
Id = res.ResourceID,
Name = res.ResourceName,
Path = res.GetSavePath(),
SelectedDll = new DllListing
{
Name = res.AssemblyName,
FullName = res.AssemblyLocation,
Children = new IFileListing[0],
},
ConfigFilePath = res.ConfigFilePath
};
if (!string.IsNullOrEmpty(res.AssemblyLocation) && res.AssemblyLocation.EndsWith(".dll"))
{
pluginSourceDefinition.FileSystemAssemblyName = res.AssemblyLocation;
pluginSourceDefinition.GACAssemblyName = string.Empty;
}
else
{
if (!string.IsNullOrEmpty(res.AssemblyLocation) && res.AssemblyLocation.StartsWith("GAC:"))
{
pluginSourceDefinition.GACAssemblyName = res.AssemblyLocation;
pluginSourceDefinition.FileSystemAssemblyName = string.Empty;
}
}
return(pluginSourceDefinition);
}
return(null);
}).ToList();
return(serializer.SerializeToBuilder(new ExecuteMessage {
HasError = false, Message = serializer.SerializeToBuilder(list)
}));
}
public void DotNetActionRegion_ConstructorWithSelectedAction_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity {
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var dotNetsrc = new PluginSourceDefinition {
Id = id, Name = "johnny"
};
var action = new PluginAction {
FullName = "bravo", Method = "bravo", ReturnType = typeof(string), Variables = new List <INameValue>()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
dotNetsrc
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
sourceRegion.SelectedSource = dotNetsrc;
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
DotNetActionRegion dotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
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 DotNetActionRegion_ChangeActionSomethingChanged_ExpectedChange_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity {
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var dotNetsrc = new PluginSourceDefinition {
Id = id
};
var evt = false;
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
var action = new PluginAction {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
dotNetsrc, s2
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
DotNetActionRegion dotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
dotNetActionRegion.SomethingChanged += (a, b) => { evt = true; };
dotNetActionRegion.SelectedAction = action;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
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);
}
public void GetNamespaces_GivenHasError_ShouldAddIntoErrors()
{
//---------------Set up test pack-------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
var namespaceItem = new NamespaceItem {
FullName = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc, s2
});
src.Setup(a => a.GetNameSpaces(It.IsAny <IPluginSource>())).Throws(new BadImageFormatException());
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var modelItem = ModelItemUtils.CreateModelItem(new DsfPluginActivity());
DotNetSourceRegion dotNetSourceRegion = new DotNetSourceRegion(src.Object, modelItem);
var mockPluginSource = new Mock <IPluginSource>();
dotNetSourceRegion.SelectedSource = mockPluginSource.Object;
DotNetNamespaceRegion sourceRegion = new DotNetNamespaceRegion(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());
}
public void DotNetSourceRegion_ChangeSourceSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var pluginSrc = new PluginSourceDefinition()
{
Id = id
};
var s2 = new PluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
DotNetSourceRegion region = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
// ReSharper disable once UseObjectOrCollectionInitializer
DotNetSourceRegion regionToRestore = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
regionToRestore.IsEnabled = false;
regionToRestore.SelectedSource = s2;
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(region.SelectedSource, s2);
Assert.IsFalse(region.IsEnabled);
}
public void DotNetActionRegion_ChangeActionSomethingChanged_CloneRegion_ExpectedClone()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfPluginActivity {
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var dotNetsrc = new PluginSourceDefinition {
Id = id
};
var s2 = new PluginSourceDefinition {
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>()
{
dotNetsrc, s2
});
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfPluginActivity()));
var namespaceItem = new NamespaceItem {
FullName = "johnny"
};
DotNetNamespaceRegion dotNetNamespaceRegion = new DotNetNamespaceRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion);
dotNetNamespaceRegion.SelectedNamespace = namespaceItem;
//------------Execute Test---------------------------
DotNetActionRegion dotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, dotNetNamespaceRegion);
var cloned = dotNetActionRegion.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(cloned.IsEnabled, dotNetActionRegion.IsEnabled);
Assert.AreEqual(((DotNetActionRegion)cloned).SelectedAction, dotNetActionRegion.SelectedAction);
}
public void PluginSourceDefinition_GetHashCode_Not_Equal_To_Zero()
{
const string expectedAssemblyLocation = "testAssemblyPath";
const string expectedAssemblyName = "testAssemblyName";
var expectedResourceID = Guid.NewGuid();
const string expectedSavePath = "Path\\ResourcePath";
const string expectedResourceName = "testResource";
const string expectedConfigFilePath = "testConfigFilePath";
var mockPlugin = new Mock <IPlugin>();
mockPlugin.Setup(plugin => plugin.AssemblyLocation).Returns(expectedAssemblyLocation);
mockPlugin.Setup(plugin => plugin.AssemblyName).Returns(expectedAssemblyName);
mockPlugin.Setup(plugin => plugin.ResourceID).Returns(expectedResourceID);
mockPlugin.Setup(plugin => plugin.GetSavePath()).Returns(expectedSavePath);
mockPlugin.Setup(plugin => plugin.ResourceName).Returns(expectedResourceName);
mockPlugin.Setup(plugin => plugin.ConfigFilePath).Returns(expectedConfigFilePath);
var pluginSourceDefinition = new PluginSourceDefinition(mockPlugin.Object);
var hashCode = pluginSourceDefinition.GetHashCode();
Assert.AreNotEqual(0, hashCode);
}
public void PluginSourceDefinition_Validate_GACAssemblyName()
{
const string expectedAssemblyLocation = "GAC:testAssemblyPath";
const string expectedAssemblyName = "testAssemblyName";
var expectedResourceID = Guid.NewGuid();
const string expectedSavePath = "Path\\ResourcePath";
const string expectedResourceName = "testResource";
const string expectedConfigFilePath = "testConfigFilePath";
var mockPlugin = new Mock <IPlugin>();
mockPlugin.Setup(plugin => plugin.AssemblyLocation).Returns(expectedAssemblyLocation);
mockPlugin.Setup(plugin => plugin.AssemblyName).Returns(expectedAssemblyName);
mockPlugin.Setup(plugin => plugin.ResourceID).Returns(expectedResourceID);
mockPlugin.Setup(plugin => plugin.GetSavePath()).Returns(expectedSavePath);
mockPlugin.Setup(plugin => plugin.ResourceName).Returns(expectedResourceName);
mockPlugin.Setup(plugin => plugin.ConfigFilePath).Returns(expectedConfigFilePath);
var fileListing = new DllListing
{
FullName = expectedAssemblyLocation,
Name = expectedAssemblyName,
Children = new Collection <IFileListing>(),
IsDirectory = false
};
var pluginSourceDefinition = new PluginSourceDefinition(mockPlugin.Object);
Assert.AreEqual(fileListing, pluginSourceDefinition.SelectedDll);
Assert.AreEqual(expectedResourceID, pluginSourceDefinition.Id);
Assert.AreEqual(expectedSavePath, pluginSourceDefinition.Path);
Assert.AreEqual(expectedResourceName, pluginSourceDefinition.Name);
Assert.AreEqual(expectedConfigFilePath, pluginSourceDefinition.ConfigFilePath);
Assert.AreEqual(string.Empty, pluginSourceDefinition.FileSystemAssemblyName);
Assert.AreEqual(expectedAssemblyLocation, pluginSourceDefinition.GACAssemblyName);
}
public void Execute_GivenNoNamespace_ShouldReturnEmpyt()
{
//------------Setup for test--------------------------
var pluginSource = new PluginSource
{
ResourceName = "ResourceName",
FilePath = "ResourcePath",
ResourceID = Guid.Empty
};
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 = Guid.Empty, Name = "SourceName", Path = "SourcePath"
};
var serialezedSource = jsonSerializer.SerializeToBuilder(sourceDefinition);
var values = new Dictionary <string, StringBuilder>
{
{ "source", serialezedSource },
{ "namespace", new StringBuilder("") }
};
var workspace = new Mock <IWorkspace>();
//-------------------------Test Execution -----------------
var execute = fetchPluginActionsWithReturnsTypes.Execute(values, workspace.Object);
var results = jsonSerializer.Deserialize <ExecuteMessage>(execute);
//------------Assert Results-------------------------
Assert.IsFalse(results.HasError);
Assert.AreEqual("[]", results.Message.ToString());
}
