static Mock <ModelItem> GenerateMockModelItem()
{
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var displayName = new Mock <ModelProperty>();
displayName.Setup(p => p.ComputedValue).Returns("Activity");
properties.Add("DisplayName", displayName);
propertyCollection.Protected().Setup <ModelProperty>("Find", "DisplayName", true).Returns(displayName.Object);
var mockModelItem = new Mock <ModelItem>();
mockModelItem.Setup(mi => mi.ItemType).Returns(typeof(TestActivity));
mockModelItem.Setup(s => s.Properties).Returns(propertyCollection.Object);
var repo = new Mock <IResourceRepository>();
repo.Setup(r => r.FetchResourceDefinition(It.IsAny <IServer>(), It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <bool>())).Returns(new ExecuteMessage());
var env = EnvironmentRepositoryTest.CreateMockEnvironment();
env.Setup(e => e.ResourceRepository).Returns(repo.Object);
var crm = new Mock <IContextualResourceModel>();
crm.Setup(r => r.Environment).Returns(env.Object);
crm.Setup(r => r.ResourceName).Returns("Test");
var wfd = CreateWorkflowDesignerViewModel(crm.Object);
mockModelItem.Setup(mi => mi.View).Returns(wfd.DesignerView);
return(mockModelItem);
}
public void AddItem_Given_MergeToolModel_VerifyCalls()
{
//------------Setup for test--------------------------
var serverRepo = new Mock <IServerRepository>();
CustomContainer.Register(serverRepo.Object);
var repo = new Mock <IResourceRepository>();
repo.Setup(repository => repository.SaveToServer(It.IsAny <IResourceModel>(), It.IsAny <string>())).Verifiable();
var env = EnvironmentRepositoryTest.CreateMockEnvironment();
env.Setup(e => e.ResourceRepository).Returns(repo.Object);
var crm = new Mock <IContextualResourceModel>();
crm.Setup(r => r.Environment).Returns(env.Object);
crm.Setup(r => r.ResourceName).Returns("Test");
crm.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var wh = new Mock <IWorkflowHelper>();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var environmentRepository = SetupEnvironmentRepo(Guid.Empty); // Set the active environment
var testAct = DsfActivityFactory.CreateDsfActivity(crm.Object, new DsfActivity(), true, environmentRepository, true);
var actId = Guid.NewGuid();
testAct.UniqueID = actId.ToString();
var eventAggregator = new Mock <IEventAggregator>();
eventAggregator.Setup(aggregator => aggregator.Publish(It.IsAny <UpdateResourceMessage>())).Verifiable();
eventAggregator.Setup(aggregator => aggregator.Publish(It.IsAny <AddWorkSurfaceMessage>())).Verifiable();
var _moq = new Mock <WorkflowDesigner>();
var modelService = new Mock <ModelService>();
var viewStateService = new Mock <ViewStateService>();
var chart = new Flowchart();
chart.Nodes.Add(testAct.GetFlowNode());
var flowChart = ModelItemUtils.CreateModelItem(chart);
modelService.Setup(p => p.Root).Returns(flowChart).Verifiable();
modelService.Setup(p => p.Find(flowChart, typeof(Flowchart))).Returns(() => new List <ModelItem>()
{
flowChart
}).Verifiable();
var dHelper = new Mock <IWorkflowDesignerWrapper>();
dHelper.Setup(p => p.GetService <ModelService>(It.IsAny <WorkflowDesigner>())).Returns(modelService.Object).Verifiable();
dHelper.Setup(p => p.GetService <ViewStateService>(It.IsAny <WorkflowDesigner>())).Returns(viewStateService.Object);
var wd = new MergePreviewWorkflowDesignerViewModelMock(dHelper.Object, crm.Object, wh.Object, eventAggregator.Object, _moq.Object);
var obj = new Mock <IToolConflictItem>();
obj.Setup(o => o.UniqueId).Returns(actId);
wd.AddItem(obj.Object);
dHelper.VerifyAll();
modelService.VerifyAll();
viewStateService.Verify(p => p.RemoveViewState(It.IsAny <ModelItem>(), It.IsAny <string>()));
viewStateService.Verify(p => p.StoreViewState(It.IsAny <ModelItem>(), It.IsAny <string>(), It.IsAny <Point>()));
}
static void TestLoad(bool useParameterless)
{
var targetEnv = EnvironmentRepositoryTest.CreateMockEnvironment(EnvironmentRepositoryTest.Server1Source);
var repository = new Mock <IServerRepository>();
repository.Setup(r => r.All()).Returns(new[] { targetEnv.Object });
CustomContainer.DeRegister <IServerRepository>();
CustomContainer.Register(repository.Object);
if (useParameterless)
{
ServerRepository.Instance.IsLoaded = true; // so that we don't connect to a server!
ServerRepository.Instance.Clear();
ServerRepository.Instance.Save(targetEnv.Object);
}
var provider = new TestServerProvider();
var servers = useParameterless ? provider.Load() : provider.Load(repository.Object);
Assert.AreEqual(1, servers.Count);
Assert.AreSame(servers[0], targetEnv.Object);
Assert.AreEqual(servers[0].EnvironmentID, targetEnv.Object.EnvironmentID);
Assert.AreEqual(servers[0].Name, targetEnv.Object.Name);
// remove the last two properties from mock ;)
}
static IServerRepository SetupEnvironmentRepo(Guid environmentId)
{
var mockResourceRepository = new Mock <IResourceRepository>();
var mockEnvironment = EnvironmentRepositoryTest.CreateMockEnvironment(mockResourceRepository.Object, "localhost");
mockEnvironment.Setup(model => model.EnvironmentID).Returns(environmentId);
return(GetEnvironmentRepository(mockEnvironment));
}
public void SetupForTest()
{
AppUsageStats.LocalHost = "http://localhost:3142";
var mockShellViewModel = new Mock <IShellViewModel>();
var lcl = new Mock <IServer>();
lcl.Setup(a => a.DisplayName).Returns("Localhost");
mockShellViewModel.Setup(x => x.LocalhostServer).Returns(lcl.Object);
mockShellViewModel.Setup(x => x.ActiveServer).Returns(new Mock <IServer>().Object);
var connectControlSingleton = new Mock <IConnectControlSingleton>();
var explorerTooltips = new Mock <IExplorerTooltips>();
CustomContainer.Register(mockShellViewModel.Object);
CustomContainer.Register(new Mock <Microsoft.Practices.Prism.PubSubEvents.IEventAggregator>().Object);
CustomContainer.Register(connectControlSingleton.Object);
CustomContainer.Register(explorerTooltips.Object);
var targetEnv = EnvironmentRepositoryTest.CreateMockEnvironment(EnvironmentRepositoryTest.Server1Source);
var serverRepo = new Mock <IServerRepository>();
serverRepo.Setup(r => r.All()).Returns(new[] { targetEnv.Object });
CustomContainer.Register(serverRepo.Object);
}
public static void MyClassInitialize(TestContext testContext)
{
EnvironmentRepositoryTest.MyClassInitialize(testContext);
}
public void SwitchDesignerViewModel_DisplayName_Setup_HasValue()
{
//------------Setup for test--------------------------
#region setup first Mock ModelItem
var popupController = new Mock <IPopupController>();
CustomContainer.Register(popupController.Object);
var env = EnvironmentRepositoryTest.CreateMockEnvironment();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowDecisionActivity {
ExpressionText = "Not Null Test Value"
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Condition", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(prop.Object);
var mockModelItem = new Mock <ModelItem>();
mockModelItem.Setup(s => s.Properties).Returns(propertyCollection.Object);
#endregion
#region setup decision Mock ModelItem
var crmDecision = new Mock <IContextualResourceModel>();
crmDecision.Setup(r => r.Environment).Returns(env.Object);
crmDecision.Setup(r => r.ResourceName).Returns("Test");
crmDecision.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var decisionProperties = new Dictionary <string, Mock <ModelProperty> >();
var decisionPropertyCollection = new Mock <ModelPropertyCollection>();
var decisionProp = new Mock <ModelProperty>();
decisionProp.Setup(p => p.ComputedValue).Returns(string.Empty);
decisionProperties.Add("Condition", decisionProp);
decisionPropertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(decisionProp.Object);
var decisionModelItem = new Mock <ModelItem>();
decisionModelItem.Setup(s => s.Properties).Returns(decisionPropertyCollection.Object);
decisionModelItem.Setup(s => s.ItemType).Returns(typeof(FlowDecision));
prop.Setup(p => p.Value).Returns(decisionModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
//------------Execute Test---------------------------
var switchDesigner = new SwitchDesignerViewModel(mockModelItem.Object, "TrueArm");
//------------Assert Results-------------------------
Assert.IsNotNull(switchDesigner);
Assert.AreEqual("TrueArm", switchDesigner.DisplayText);
}
public void SwitchDesignerViewModel_UpdateHelp_ShouldCallToHelpViewMode()
{
//------------Setup for test--------------------------
var mockMainViewModel = new Mock <IShellViewModel>();
var mockHelpViewModel = new Mock <IHelpWindowViewModel>();
mockHelpViewModel.Setup(model => model.UpdateHelpText(It.IsAny <string>())).Verifiable();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(mockHelpViewModel.Object);
CustomContainer.Register(mockMainViewModel.Object);
#region setup first Mock ModelItem
var popupController = new Mock <IPopupController>();
CustomContainer.Register(popupController.Object);
var env = EnvironmentRepositoryTest.CreateMockEnvironment();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowDecisionActivity {
ExpressionText = "Not Null Test Value"
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Condition", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(prop.Object);
var mockModelItem = new Mock <ModelItem>();
mockModelItem.Setup(s => s.Properties).Returns(propertyCollection.Object);
#endregion
#region setup decision Mock ModelItem
var crmDecision = new Mock <IContextualResourceModel>();
crmDecision.Setup(r => r.Environment).Returns(env.Object);
crmDecision.Setup(r => r.ResourceName).Returns("Test");
crmDecision.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var decisionProperties = new Dictionary <string, Mock <ModelProperty> >();
var decisionPropertyCollection = new Mock <ModelPropertyCollection>();
var decisionProp = new Mock <ModelProperty>();
decisionProp.Setup(p => p.ComputedValue).Returns(string.Empty);
decisionProperties.Add("Condition", decisionProp);
decisionPropertyCollection.Protected().Setup <ModelProperty>("Find", "Condition", true).Returns(decisionProp.Object);
var decisionModelItem = new Mock <ModelItem>();
decisionModelItem.Setup(s => s.Properties).Returns(decisionPropertyCollection.Object);
decisionModelItem.Setup(s => s.ItemType).Returns(typeof(FlowSwitch <string>));
prop.Setup(p => p.Value).Returns(decisionModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
var switchDesigner = new SwitchDesignerViewModel(mockModelItem.Object, "");
//------------Execute Test---------------------------
switchDesigner.UpdateHelpDescriptor("help");
//------------Assert Results-------------------------
mockHelpViewModel.Verify(model => model.UpdateHelpText(It.IsAny <string>()), Times.Once());
}
public void FlowController_ConfigureSwitch_Handle_Switch()
{
//------------Setup for test--------------------------
var popupController = new Mock <IPopupController>();
CustomContainer.Register(popupController.Object);
var env = EnvironmentRepositoryTest.CreateMockEnvironment();
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var testAct = new DsfFlowSwitchActivity {
ExpressionText = ""
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
properties.Add("Expression", prop);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Expression", true).Returns(prop.Object);
var source = new Mock <ModelItem>();
source.Setup(s => s.Properties).Returns(propertyCollection.Object);
#region setup decision Mock ModelItem
var crmSwitch = new Mock <IContextualResourceModel>();
crmSwitch.Setup(r => r.Environment).Returns(env.Object);
crmSwitch.Setup(r => r.ResourceName).Returns("Test");
crmSwitch.Setup(res => res.WorkflowXaml).Returns(new StringBuilder(StringResourcesTest.xmlServiceDefinition));
var switchProperties = new Dictionary <string, Mock <ModelProperty> >();
var switchPropertyCollection = new Mock <ModelPropertyCollection>();
var switchProp = new Mock <ModelProperty>();
switchProp.Setup(p => p.ComputedValue).Returns(string.Empty);
switchProperties.Add("Expression", switchProp);
switchPropertyCollection.Protected().Setup <ModelProperty>("Find", "Expression", true).Returns(switchProp.Object);
var switchModelItem = new Mock <ModelItem>();
switchModelItem.Setup(s => s.Properties).Returns(switchPropertyCollection.Object);
switchModelItem.Setup(s => s.ItemType).Returns(typeof(FlowSwitch <string>));
prop.Setup(p => p.Value).Returns(switchModelItem.Object);
#endregion
#region setup Environment Model
env.Setup(c => c.Connection).Returns(new Mock <IEnvironmentConnection>().Object);
#endregion
var flowController = new FlowController();
var message = new ConfigureSwitchExpressionMessage
{
ModelItem = source.Object,
Server = env.Object,
IsNew = true
};
//------------Execute Test---------------------------
flowController.Handle(message);
//------------Assert Results-------------------------
}
