public void ComSourceRegion_ChangeSourceSomethingChanged_ExpectedChange_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
};
var evt = false;
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
var region = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
region.SomethingChanged += (a, b) => { evt = true; };
region.SelectedSource = s2;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
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 ComSourceRegion_ConstructorWithSelectedSource_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
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc
});
//------------Execute Test---------------------------
var region = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
//------------Assert Results-------------------------
Assert.AreEqual(pluginSrc, region.SelectedSource);
Assert.IsTrue(region.CanEditSource());
}
public void ComPluginSourceDefinition_Equals_ComPluginSource_Expected_False()
{
const string expectedComName = "testComName";
const string expectedClsId = "testClsId";
const bool expectedIs32Bit = false;
var expectedResourceID = Guid.NewGuid();
const string expectedResourceName = "testResource";
var mockComPlugin = new Mock <IComPlugin>();
mockComPlugin.Setup(comPlugin => comPlugin.ComName).Returns(expectedComName);
mockComPlugin.Setup(comPlugin => comPlugin.ClsId).Returns(expectedClsId);
mockComPlugin.Setup(comPlugin => comPlugin.Is32Bit).Returns(expectedIs32Bit);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceID).Returns(expectedResourceID);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceName).Returns(expectedResourceName);
var comPluginSourceDefinition = new ComPluginSourceDefinition(mockComPlugin.Object);
var mockComPluginDup = new Mock <IComPlugin>();
mockComPluginDup.Setup(comPlugin => comPlugin.ComName).Returns("NewComName");
mockComPluginDup.Setup(comPlugin => comPlugin.ClsId).Returns(expectedClsId);
mockComPluginDup.Setup(comPlugin => comPlugin.Is32Bit).Returns(expectedIs32Bit);
mockComPluginDup.Setup(comPlugin => comPlugin.ResourceID).Returns(expectedResourceID);
mockComPluginDup.Setup(comPlugin => comPlugin.ResourceName).Returns(expectedResourceName);
var comPluginSourceDefinitionDup = new ComPluginSourceDefinition(mockComPluginDup.Object);
var isEqual = comPluginSourceDefinition.Equals(comPluginSourceDefinitionDup);
Assert.IsFalse(isEqual);
Assert.IsTrue(comPluginSourceDefinition != comPluginSourceDefinitionDup);
}
public void ComPluginSourceDefinition_Validate_FileSystemAssemblyName()
{
const string expectedComName = "testComName";
const string expectedClsId = "testClsId";
const bool expectedIs32Bit = false;
var expectedResourceID = Guid.NewGuid();
const string expectedSavePath = "";
const string expectedResourceName = "testResource";
var mockComPlugin = new Mock <IComPlugin>();
mockComPlugin.Setup(comPlugin => comPlugin.ComName).Returns(expectedComName);
mockComPlugin.Setup(comPlugin => comPlugin.ClsId).Returns(expectedClsId);
mockComPlugin.Setup(comPlugin => comPlugin.Is32Bit).Returns(expectedIs32Bit);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceID).Returns(expectedResourceID);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceName).Returns(expectedResourceName);
var fileListing = new DllListing
{
Name = expectedComName,
ClsId = expectedClsId,
Children = new Collection <IFileListing>(),
IsDirectory = false
};
var comPluginSourceDefinition = new ComPluginSourceDefinition(mockComPlugin.Object);
Assert.AreEqual(fileListing, comPluginSourceDefinition.SelectedDll);
Assert.AreEqual(expectedResourceID, comPluginSourceDefinition.Id);
Assert.AreEqual(expectedSavePath, comPluginSourceDefinition.ResourcePath);
Assert.AreEqual(expectedClsId, comPluginSourceDefinition.ClsId);
Assert.AreEqual(expectedIs32Bit, comPluginSourceDefinition.Is32Bit);
Assert.AreEqual(expectedResourceName, comPluginSourceDefinition.ResourceName);
}
public void ComNamespaceRegion_ChangeNamespaceSomethingChanged_CloneRegion_ExpectedClone()
{
//------------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()
};
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 cloned = comNamespaceRegion.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(cloned.IsEnabled, comNamespaceRegion.IsEnabled);
Assert.AreEqual(((ComNamespaceRegion)cloned).SelectedNamespace, comNamespaceRegion.SelectedNamespace);
}
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 ComPluginSourceDefinition_GetHashCode_Expect_Zero()
{
var comPluginSourceDefinition = new ComPluginSourceDefinition();
var hashCode = comPluginSourceDefinition.GetHashCode();
Assert.AreEqual(0, hashCode);
}
public IComPluginSource FetchSource(Guid pluginSourceId)
{
var xaml = _queryProxy.FetchResourceXaml(pluginSourceId);
var db = new ComPluginSource(xaml.ToXElement());
var def = new ComPluginSourceDefinition(db);
return(def);
}
public void ComPluginSourceDefinition_Equals_Object_Null_Expected_False()
{
var comPluginSourceDefinition = new ComPluginSourceDefinition();
const object comPluginSource = null;
var isEqual = comPluginSourceDefinition.Equals(comPluginSource);
Assert.IsFalse(isEqual);
}
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 Equals_WithNotEqualOperator_ShouldNotBeEqual()
{
//---------------Set up test pack-------------------
var firstObject = new ComPluginSourceDefinition()
{
Id = id
};
var secondObject = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.IsTrue(firstObject != secondObject, "ComPluginSourceDefinition object not equals operator broken.");
}
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 ComSourceRegion_ChangeSourceSomethingChanged_RegionsNotRestored_Invalid()
{
//------------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()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
var region = new ComSourceRegion(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 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 GivenIOpenPluginSource(string name)
{
var pluginSrc = new ComPluginSourceDefinition
{
ResourceName = name,
Id = Guid.NewGuid(),
ResourcePath = "",
ClsId = Guid.NewGuid().ToString(),
Is32Bit = true,
SelectedDll = new DllListing()
{
ClsId = Guid.NewGuid().ToString(), Name = "Object", Is32Bit = false, FullName = "System.Object", IsDirectory = false
},
};
var managePluginSourceControl = ScenarioContext.Current.Get <ManageComPluginSourceControl>(Utils.ViewNameKey);
var mockStudioUpdateManager = FeatureContext.Current.Get <Mock <IManageComPluginSourceModel> >("updateManager").Object;
var mockEventAggregator = FeatureContext.Current.Get <Mock <IEventAggregator> >("eventAggregator").Object;
var mockSynchronousAsyncWorker = FeatureContext.Current.Get <Mock <SynchronousAsyncWorker> >("synchronousAsyncWorker").Object;
try
{
var managePluginSourceViewModel = new ManageComPluginSourceViewModel(mockStudioUpdateManager, mockEventAggregator, pluginSrc, new SynchronousAsyncWorker(), a => {
try
{
a.Invoke();
}
catch
{
// ignored
}
});
managePluginSourceControl.DataContext = managePluginSourceViewModel;
ScenarioContext.Current.Remove("viewModel");
ScenarioContext.Current.Add("viewModel", managePluginSourceViewModel);
}
catch (Exception)
{
// ignored
}
}
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 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 ComPluginSourceDefinition_GetHashCode_Not_Equal_To_Zero()
{
const string expectedComName = "testComName";
const string expectedClsId = "testClsId";
const bool expectedIs32Bit = false;
var expectedResourceID = Guid.NewGuid();
const string expectedResourceName = "testResource";
var mockComPlugin = new Mock <IComPlugin>();
mockComPlugin.Setup(comPlugin => comPlugin.ComName).Returns(expectedComName);
mockComPlugin.Setup(comPlugin => comPlugin.ClsId).Returns(expectedClsId);
mockComPlugin.Setup(comPlugin => comPlugin.Is32Bit).Returns(expectedIs32Bit);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceID).Returns(expectedResourceID);
mockComPlugin.Setup(comPlugin => comPlugin.ResourceName).Returns(expectedResourceName);
var comPluginSourceDefinition = new ComPluginSourceDefinition(mockComPlugin.Object);
var hashCode = comPluginSourceDefinition.GetHashCode();
Assert.AreNotEqual(0, hashCode);
}
public void Execute_GivenResourceDefination_GivenExising_ShouldReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new ComPluginSourceDefinition()
{
Id = Guid.Empty,
ResourceName = "Name",
ClsId = Guid.NewGuid().ToString(),
ResourcePath = Environment.CurrentDirectory,
SelectedDll = new DllListing()
{
Name = "k"
}
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "ComPluginSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
var comPluginSource = new ComPluginSource();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.ResourceName, It.IsAny <string>(), It.IsAny <string>())).Returns(comPluginSource);
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), comPluginSource, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
var saveComPluginSource = new SaveComPluginSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
StringBuilder jsonResult = saveComPluginSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.ResourceName, It.IsAny <string>(), It.IsAny <string>()));
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), comPluginSource, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
}
public void ComSourceRegion_ChangeSourceSomethingChanged_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()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
ComSourceRegion region = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
// ReSharper disable once UseObjectOrCollectionInitializer
ComSourceRegion regionToRestore = new ComSourceRegion(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 ComActionRegion_ChangeActionSomethingChanged_CloneRegion_ExpectedClone()
{
//------------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()
};
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 cloned = dotNetActionRegion.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(cloned.IsEnabled, dotNetActionRegion.IsEnabled);
Assert.AreEqual(((ComActionRegion)cloned).SelectedAction, dotNetActionRegion.SelectedAction);
}
