public void Init()
{
var newServerRepo = new Mock <IServerRepository>();
CustomContainer.Register(newServerRepo.Object);
}
public void UpdateHelpDescriptor(string helpText)
{
var mainViewModel = CustomContainer.Get <IShellViewModel>();
mainViewModel?.HelpViewModel.UpdateHelpText(helpText);
}
public void StudioTestViewModel_DoDeactivate_CanSave_ExpectedFalse()
{
//------------Setup for test--------------------------
var mockWorkSurfaceViewModel = new Mock <IWorkflowDesignerViewModel>();
var mockedConn = new Mock <IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
var mockEnvironmentModel = new Mock <IServer>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.Setup(e => e.Name).Returns("My Env");
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(environmentModel);
//------------Execute Test---------------------------
var mvm = new Mock <IShellViewModel>();
mvm.Setup(model => model.HelpViewModel.UpdateHelpText(It.IsAny <string>()));
CustomContainer.Register(mvm.Object);
CustomContainer.Register(new Mock <IPopupController>().Object);
var eventAggregator = new Mock <IEventAggregator>();
var resourceModel = new Mock <IContextualResourceModel>();
resourceModel.Setup(model => model.IsWorkflowSaved).Returns(true);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(resourceModel.Object);
var serviceTestViewModel = new Mock <IServiceTestViewModel>();
serviceTestViewModel.Setup(model => model.WorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new StudioTestViewModel(eventAggregator.Object, serviceTestViewModel.Object, new Mock <IPopupController>().Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsNotNull(vm.DebugOutputViewModel);
Assert.IsFalse(vm.HasVariables);
Assert.IsTrue(vm.HasDebugOutput);
Assert.IsNull(vm.DisplayName);
Assert.AreEqual("ServiceTestsViewer", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(vm.IsDirty);
vm.HelpText = string.Empty;
var env = new Mock <IServer>();
var con = new Mock <IEnvironmentConnection>();
var debugTreeMock = new Mock <List <IDebugTreeViewItemViewModel> >();
resourceModel.Setup(model => model.Environment).Returns(env.Object);
resourceModel.Setup(model => model.Environment.Connection).Returns(con.Object);
resourceModel.Setup(model => model.Environment.Connection.IsConnected).Returns(true);
var message = new NewTestFromDebugMessage {
ResourceModel = resourceModel.Object, RootItems = debugTreeMock.Object
};
var testViewModel = new ServiceTestViewModel(resourceModel.Object, new SynchronousAsyncWorker(), new Mock <IEventAggregator>().Object, new Mock <IExternalProcessExecutor>().Object, new Mock <IWorkflowDesignerViewModel>().Object, message, new Mock <IPopupController>().Object);
testViewModel.WebClient = new Mock <IWarewolfWebClient>().Object;
testViewModel.SelectedServiceTest.TestName = "New Test Name";
vm.ViewModel = testViewModel;
var expectedValue = vm.DoDeactivate(false);
//------------Assert Results-------------------------
Assert.IsTrue(vm.IsDirty);
Assert.AreEqual(string.Empty, vm.HelpText);
Assert.IsTrue(expectedValue);
mvm.Verify(model => model.HelpViewModel.UpdateHelpText(It.IsAny <string>()));
}
public async Task <IExplorerItem> LoadExplorer(bool reloadCatalogue)
{
var explorerItems = await QueryManagerProxy.Load(reloadCatalogue, CustomContainer.Get <IPopupController>()).ConfigureAwait(true);
return(explorerItems);
}
public SettingsViewModel()
: this(EventPublishers.Aggregator, new PopupController(), new AsyncWorker(), (IWin32Window)System.Windows.Application.Current.MainWindow, CustomContainer.Get <IShellViewModel>().ActiveServer, null)
{
}
public EnvironmentViewModel(IServer server, IShellViewModel shellViewModel, bool isDialog, Action <IExplorerItemViewModel> selectAction)
: this()
{
Server = server ?? throw new ArgumentNullException(nameof(server));
_shellViewModel = shellViewModel ?? throw new ArgumentNullException(nameof(shellViewModel));
_isDialog = isDialog;
_controller = CustomContainer.Get <IPopupController>();
_children = new ObservableCollection <IExplorerItemViewModel>();
ExplorerTooltips = CustomContainer.Get <IExplorerTooltips>();
NewServiceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewService(ResourcePath);
});
NewServerCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewServerSource(ResourcePath);
});
NewSqlServerSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewSqlServerSource(ResourcePath);
});
NewMySqlSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewMySqlSource(ResourcePath);
});
NewPostgreSqlSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewPostgreSqlSource(ResourcePath);
});
NewOracleSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewOracleSource(ResourcePath);
});
NewOdbcSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewOdbcSource(ResourcePath);
});
NewPluginSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewPluginSource(ResourcePath);
});
NewComPluginSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewComPluginSource(ResourcePath);
});
NewWcfSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewWcfSource(ResourcePath);
});
NewWebSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewWebSource(ResourcePath);
});
NewEmailSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewEmailSource(ResourcePath);
});
NewExchangeSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewExchangeSource(ResourcePath);
});
NewRabbitMqSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewRabbitMQSource(ResourcePath);
});
NewSharepointSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewSharepointSource(ResourcePath);
});
NewDropboxSourceSourceCommand = new DelegateCommand(() =>
{
UpdateActiveEnvironment(shellViewModel);
shellViewModel.NewDropboxSource(ResourcePath);
});
ViewApisJsonCommand = new DelegateCommand(() =>
{
var environmentModel = ServerRepository.Instance.FindSingle(model => model.EnvironmentID == Server.EnvironmentID);
shellViewModel.ViewApisJson(ResourcePath, environmentModel.Connection.WebServerUri);
});
ViewExecutionLoggingCommand = new DelegateCommand(() =>
{
Process.Start(Resources.Languages.Core.MyWarewolfUrl);
});
DeployCommand = new DelegateCommand(() =>
{
shellViewModel.AddDeploySurface(AsList().Union <IExplorerTreeItem>(new[] { this }));
});
DisplayName = server.DisplayName;
RefreshCommand = new DelegateCommand(async() =>
{
await RefreshAsync().ConfigureAwait(true);
});
IsServerIconVisible = true;
SelectAction = selectAction ?? (a => { });
Expand = new DelegateCommand <int?>(clickCount =>
{
if (clickCount != null && clickCount == 2)
{
IsExpanded = !IsExpanded;
}
});
IsConnected = server.IsConnected;
server.NetworkStateChanged += (args, server1) =>
{
IsConnected = server1.IsConnected;
if (args.State == ConnectionNetworkState.Connected)
{
Application.Current.Dispatcher.Invoke(async() =>
{
await RefreshAsync().ConfigureAwait(true);
}, DispatcherPriority.Background);
}
};
AllowEdit = server.AllowEdit;
ShowServerVersionCommand = new DelegateCommand(ShowServerVersionAbout);
CanCreateFolder = Server.UserPermissions == Permissions.Administrator || server.UserPermissions == Permissions.Contribute;
CanDeploy = Server.UserPermissions == Permissions.Administrator || server.UserPermissions == Permissions.Contribute;
CreateFolderCommand = new DelegateCommand(CreateFolder);
Parent = null;
ResourceType = @"ServerSource";
ResourcePath = string.Empty;
ResourceName = DisplayName;
CanShowServerVersion = true;
AreVersionsVisible = false;
IsVisible = true;
SetPropertiesForDialogFromPermissions(new WindowsGroupPermission());
SelectAll = () => { };
CanDrag = false;
CanDrop = false;
IsMergeVisible = false;
ResourceId = server.EnvironmentID;
CanViewApisJson = true;
CanViewExecutionLogging = true;
if (ForcedRefresh)
{
ForcedRefresh = true;
}
}
protected override ExecuteMessage ExecuteImpl(Dev2JsonSerializer serializer, Guid resourceId, Dictionary <string, StringBuilder> values)
{
var versionNumber = IsValid(values, out var environmentString, out var startActivityId, out var currentUserPrincipal);
var executingUser = BuildClaimsPrincipal(DpapiWrapper.DecryptIfEncrypted(currentUserPrincipal.ToString()));
var environment = DpapiWrapper.DecryptIfEncrypted(environmentString.ToString());
var decodedEnv = HttpUtility.UrlDecode(environment);
var executionEnv = new ExecutionEnvironment();
executionEnv.FromJson(decodedEnv);
Int32.TryParse(versionNumber.ToString(), out int parsedVersionNumber);
var dataObject = new DsfDataObject("", Guid.NewGuid())
{
ResourceID = resourceId,
Environment = executionEnv,
VersionNumber = parsedVersionNumber,
ExecutingUser = executingUser,
IsDebug = true
};
if (!CanExecute(dataObject))
{
var errorMessage = string.Format(ErrorResource.AuthenticationError, executingUser.Identity.Name);
Dev2Logger.Error(errorMessage, GlobalConstants.WarewolfError);
return(new ExecuteMessage {
HasError = true, Message = new StringBuilder(errorMessage)
});
}
ResourceCatalogInstance.Reload();
var dynamicService = ResourceCatalogInstance.GetService(GlobalConstants.ServerWorkspaceID, resourceId, "");
if (dynamicService is null)
{
return(new ExecuteMessage {
HasError = true, Message = new StringBuilder($"Error resuming. ServiceAction is null for Resource ID:{resourceId}")
});
}
var sa = dynamicService.Actions.FirstOrDefault();
if (sa is null)
{
return(new ExecuteMessage {
HasError = true, Message = new StringBuilder($"Error resuming. ServiceAction is null for Resource ID:{resourceId}")
});
}
var container = CustomContainer.Get <IResumableExecutionContainerFactory>()?.New(startActivityId, sa, dataObject) ?? CustomContainer.CreateInstance <IResumableExecutionContainer>(startActivityId, sa, dataObject);
container.Execute(out ErrorResultTO errors, 0);
if (errors.HasErrors())
{
return(new ExecuteMessage {
HasError = true, Message = new StringBuilder(errors.MakeDisplayReady())
});
}
return(new ExecuteMessage {
HasError = false, Message = new StringBuilder("Execution Completed.")
});
}
public static void Init(TestContext context)
{
var pCounter = new Mock <IWarewolfPerformanceCounterLocater>();
CustomContainer.Register(pCounter.Object);
}
static async void ShowSaveDialog(IContextualResourceModel resourceModel, WebsiteCallbackHandler callbackHandler, Action loaded = null, bool loadingFromServer = true, string originalPath = "")
{
try
{
if (resourceModel == null)
{
throw new ArgumentNullException(nameof(resourceModel));
}
var server = resourceModel.Environment;
ServerRepository.Instance.ActiveServer = server ?? throw new ArgumentNullException("environment");
if (server.Permissions == null)
{
server.Permissions = new List <IWindowsGroupPermission>();
server.Permissions.AddRange(server.AuthorizationService.SecurityService.Permissions);
}
if (resourceModel.Category == null)
{
resourceModel.Category = "";
}
var selectedPath = resourceModel.Category.Contains("Unassigned") || string.IsNullOrEmpty(resourceModel.Category) ? "" : resourceModel.Category;
var lastIndexOf = selectedPath.LastIndexOf("\\", StringComparison.Ordinal);
if (lastIndexOf != -1)
{
selectedPath = selectedPath.Substring(0, lastIndexOf);
}
selectedPath = selectedPath.Replace("\\", "\\\\");
var mainViewModel = CustomContainer.Get <IShellViewModel>();
var environmentViewModel = mainViewModel?.ExplorerViewModel?.Environments.FirstOrDefault(model => model.Server.EnvironmentID == resourceModel.Environment.EnvironmentID);
if (environmentViewModel == null)
{
return;
}
var header = string.IsNullOrEmpty(resourceModel.Category) ? "Unsaved Item" : resourceModel.Category;
var lastHeaderIndexOf = header.LastIndexOf("\\", StringComparison.Ordinal);
if (lastHeaderIndexOf != -1)
{
header = header.Substring(lastHeaderIndexOf, header.Length - lastHeaderIndexOf);
header = header.Replace("\\", "");
}
var requestViewModel = await RequestServiceNameViewModel.CreateAsync(environmentViewModel, selectedPath, header);
var messageBoxResult = requestViewModel.ShowSaveDialog();
if (messageBoxResult == MessageBoxResult.OK)
{
var value = new { resourceName = requestViewModel.ResourceName.Name, resourcePath = requestViewModel.ResourceName.Path, resourceLoadingFromServer = loadingFromServer, OriginalPath = originalPath };
var serializeObject = JsonConvert.SerializeObject(value);
callbackHandler.Save(serializeObject, server);
}
else
{
if (!loadingFromServer)
{
mainViewModel.CloseResource(resourceModel, server.EnvironmentID);
}
}
loaded?.Invoke();
}
catch (Exception)
{
loaded?.Invoke();
throw;
}
}
public WfExecutionContainer(ServiceAction sa, IDSFDataObject dataObj, IWorkspace theWorkspace, IEsbChannel esbChannel)
: this(sa, dataObj, theWorkspace, esbChannel, CustomContainer.Get <IExecutionManager>())
{
}
public Query()
{
Container = new Container();
Custom = new CustomContainer();
}
public void Eval(DynamicActivity flowchartProcess, IDSFDataObject dsfDataObject, int update)
{
var resource = CustomContainer.Get <IActivityParser>()?.Parse(flowchartProcess) ?? new ActivityParser().Parse(flowchartProcess);
EvalInner(dsfDataObject, resource, update);
}
public async Task <T> ExecuteCommandAsync <T>(IEnvironmentConnection connection, Guid workspaceId) where T : class
{
// build the service request payload ;)
var serializer = new Dev2JsonSerializer();
if (connection == null || !connection.IsConnected)
{
if (connection != null && !connection.IsConnecting)
{
var popupController = CustomContainer.Get <IPopupController>();
popupController?.Show(string.Format(ErrorResource.ServerDisconnected, connection.DisplayName) + Environment.NewLine +
ErrorResource.ServerReconnectForActions, ErrorResource.ServerDisconnectedHeader, MessageBoxButton.OK,
MessageBoxImage.Information, "", false, false, true, false, false, false);
}
return(default(T));
}
try
{
if (ServicePayload == null)
{
ServicePayload = new EsbExecuteRequest();
}
ServicePayload.ServiceName = ServiceName;
var toSend = serializer.SerializeToBuilder(ServicePayload);
var payload = await connection.ExecuteCommandAsync(toSend, workspaceId).ConfigureAwait(true);
var executeCommand = serializer.Deserialize <T>(payload);
if (executeCommand == null)
{
var execMessage = serializer.Deserialize <ExecuteMessage>(payload);
if (execMessage != null)
{
return(CheckAuthorization <T>(execMessage));
}
}
else
{
if (typeof(T) == typeof(ExecuteMessage))
{
return(CheckAuthorization <T>(executeCommand as ExecuteMessage));
}
return(executeCommand);
}
}
catch (ServiceNotAuthorizedException ex)
{
ShowAuthorizationErrorPopup(ex.Message);
return(default(T));
}
catch (AggregateException ex)
{
var aggregateException = ex.Flatten();
var baseException = aggregateException.GetBaseException();
var isAuthorizationError = baseException is ServiceNotAuthorizedException;
if (isAuthorizationError)
{
ShowAuthorizationErrorPopup(ex.Message);
return(default(T));
}
}
return(default(T));
}
public void Setup()
{
CustomContainer.Register <IActivityParser>(new Mock <IActivityParser>().Object);
}
public void StudioTestViewModel_PropertyChanged_ViewModel_IsTrue()
{
//------------Setup for test--------------------------
var mockWorkSurfaceViewModel = new Mock <IWorkflowDesignerViewModel>();
var mockedConn = new Mock <IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
var mockEnvironmentModel = new Mock <IServer>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.Setup(e => e.Name).Returns("My Env");
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(environmentModel);
//------------Execute Test---------------------------
CustomContainer.Register(new Mock <IPopupController>().Object);
var mockMainViewModel = new Mock <IShellViewModel>();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(new Mock <IHelpWindowViewModel>().Object);
CustomContainer.Register(mockMainViewModel.Object);
var eventAggregator = new Mock <IEventAggregator>();
var resourceModel = new Mock <IContextualResourceModel>();
resourceModel.Setup(model => model.IsWorkflowSaved).Returns(true);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(resourceModel.Object);
var serviceTestViewModel = new Mock <IServiceTestViewModel>();
serviceTestViewModel.Setup(model => model.WorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var env = new Mock <IServer>();
var con = new Mock <IEnvironmentConnection>();
var debugTreeMock = new Mock <List <IDebugTreeViewItemViewModel> >();
resourceModel.Setup(model => model.Environment).Returns(env.Object);
resourceModel.Setup(model => model.Environment.Connection).Returns(con.Object);
resourceModel.Setup(model => model.Environment.Connection.IsConnected).Returns(true);
var message = new NewTestFromDebugMessage {
ResourceModel = resourceModel.Object, RootItems = debugTreeMock.Object
};
var testViewModel = new ServiceTestViewModel(resourceModel.Object, new SynchronousAsyncWorker(), new Mock <IEventAggregator>().Object, new Mock <IExternalProcessExecutor>().Object, new Mock <IWorkflowDesignerViewModel>().Object, message, new Mock <IPopupController>().Object);
testViewModel.WebClient = new Mock <IWarewolfWebClient>().Object;
var vm = new StudioTestViewModel(eventAggregator.Object, testViewModel, new Mock <IPopupController>().Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsNotNull(vm.DebugOutputViewModel);
Assert.IsFalse(vm.HasVariables);
Assert.IsTrue(vm.HasDebugOutput);
Assert.AreEqual(" - Tests - *", vm.DisplayName);
Assert.AreEqual("ServiceTestsViewer", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsTrue(vm.IsDirty);
testViewModel.SelectedServiceTest.TestName = "New Test Name";
vm.ViewModel = testViewModel;
var wasCalled = false;
vm.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "DisplayName")
{
wasCalled = true;
}
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
vm.ViewModel.RefreshCommands();
//---------------Test Result -----------------------
Assert.IsTrue(wasCalled);
}
/// <summary>
/// Deploys the selected items
/// </summary>
private void Deploy()
{
Tracker.TrackEvent(TrackerEventGroup.Deploy, TrackerEventName.DeployClicked);
if (_deployStatsCalculator != null &&
_deployStatsCalculator.ConflictingResources != null &&
_deployStatsCalculator.ConflictingResources.Count > 0)
{
var deployDialogViewModel = new DeployDialogViewModel(_deployStatsCalculator.ConflictingResources);
ShowDialog(deployDialogViewModel);
if (deployDialogViewModel.DialogResult == ViewModelDialogResults.Cancel)
{
return;
}
}
if (SelectedDestinationServer != null && (SelectedDestinationServer.Connection.WebServerUri != null && (SelectedDestinationServer.Connection != null && (SelectedDestinationServer != null && SelectedDestinationServer.Connection.WebServerUri.Scheme == "http"))))
{
var popupController = CustomContainer.Get <IPopupController>();
if (popupController != null)
{
var messageBuilder = new StringBuilder();
messageBuilder.AppendLine("The destination server selected is not connected via https");
messageBuilder.AppendLine("This means that all sensitive information such as passwords will not be encrypted during deployment.");
messageBuilder.AppendLine("Are you sure you wish to continue deployment?");
var messageBoxResult = popupController.Show(messageBuilder.ToString(), "Unsecure Destination Server", MessageBoxButton.YesNo, MessageBoxImage.Exclamation, null);
if (messageBoxResult == MessageBoxResult.No || messageBoxResult == MessageBoxResult.Cancel || messageBoxResult == MessageBoxResult.None)
{
return;
}
}
}
//
//Get the resources to deploy
//
if (_deployStatsCalculator != null)
{
var deployResourceRepo = SelectedSourceServer.ResourceRepository;
var resourcesToDeploy = Source.ExplorerItemModels.SelectMany(model => model.Descendants()).Where(_deployStatsCalculator.SelectForDeployPredicate).Select(model => deployResourceRepo.FindSingle(resourceModel => resourceModel.ID == model.ResourceId)).ToList();
if (HasNoResourcesToDeploy(resourcesToDeploy, deployResourceRepo))
{
return;
}
//
// Deploy the resources
//
var deployDto = new DeployDto {
ResourceModels = resourcesToDeploy
};
try
{
IsDeploying = true;
var env = _getActive();
_setActive(SelectedDestinationServer);
// bobcar
deployResourceRepo.DeployResources(SelectedSourceServer, SelectedDestinationServer, deployDto, EventPublisher);
_setActive(env);
DeploySuccessfull = true;
}
catch (Exception)
{
DeploySuccessfull = false;
IsDeploying = false;
}
finally
{
IsDeploying = false;
}
}
_source.Update();
_target.Update();
CalculateStats(false);
}
public void StudioTestViewModel_DoDeactivate_CanSave_MessageBoxYesHasDuplicates()
{
//------------Setup for test--------------------------
var serverRepo = new Mock <IServerRepository>();
CustomContainer.DeRegister <IServerRepository>();
CustomContainer.Register(serverRepo.Object);
var mockWorkSurfaceViewModel = new Mock <IWorkflowDesignerViewModel>();
var mockedConn = new Mock <IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
var mockEnvironmentModel = new Mock <IServer>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.Setup(e => e.Name).Returns("My Env");
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(environmentModel);
//------------Execute Test---------------------------
var popupController = new Mock <IPopupController>();
popupController.Setup(controller => controller.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), MessageBoxImage.Information, "", false, false, true, false, false, false)).Returns(MessageBoxResult.Yes);
CustomContainer.Register(popupController.Object);
var eventAggregator = new Mock <IEventAggregator>();
var resourceModel = new Mock <IContextualResourceModel>();
resourceModel.Setup(model => model.IsWorkflowSaved).Returns(true);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(resourceModel.Object);
var serviceTestViewModel = new Mock <IServiceTestViewModel>();
serviceTestViewModel.Setup(model => model.WorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new StudioTestViewModel(eventAggregator.Object, serviceTestViewModel.Object, popupController.Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsNotNull(vm.DebugOutputViewModel);
Assert.IsFalse(vm.HasVariables);
Assert.IsTrue(vm.HasDebugOutput);
Assert.IsNull(vm.DisplayName);
Assert.AreEqual("ServiceTestsViewer", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(vm.IsDirty);
var env = new Mock <IServer>();
var con = new Mock <IEnvironmentConnection>();
var debugTreeMock = new Mock <List <IDebugTreeViewItemViewModel> >();
resourceModel.Setup(model => model.Environment).Returns(env.Object);
resourceModel.Setup(model => model.Environment.Connection).Returns(con.Object);
resourceModel.Setup(model => model.Environment.Connection.IsConnected).Returns(true);
var message = new NewTestFromDebugMessage {
ResourceModel = resourceModel.Object, RootItems = debugTreeMock.Object
};
var testViewModel = new ServiceTestViewModel(resourceModel.Object, new SynchronousAsyncWorker(), new Mock <IEventAggregator>().Object, new Mock <IExternalProcessExecutor>().Object, new Mock <IWorkflowDesignerViewModel>().Object, message, new Mock <IPopupController>().Object);
testViewModel.WebClient = new Mock <IWarewolfWebClient>().Object;
var serviceTestModel = new ServiceTestModel();
serviceTestModel.TestName = "Test 1";
testViewModel.Tests.Add(serviceTestModel);
vm.ViewModel = testViewModel;
var expectedValue = vm.DoDeactivate(true);
//------------Assert Results-------------------------
Assert.IsTrue(vm.IsDirty);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(expectedValue);
}
EnvironmentViewModel()
{
var connectControlSingleton = CustomContainer.Get <IConnectControlSingleton>();
_connectControlSingleton = connectControlSingleton ?? ConnectControlSingleton.Instance;
}
