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()); }