protected void CreateFullExportsAndVm()
{
CreateResourceRepo();
var environmentRepo = GetEnvironmentRepository();
_eventAggregator = new Mock <IEventAggregator>();
EventPublishers.Aggregator = _eventAggregator.Object;
_popupController = new Mock <IPopupController>();
_windowManager = new Mock <IWindowManager>();
CustomContainer.Register(_windowManager.Object);
CustomContainer.Register(_popupController.Object);
_browserPopupController = new Mock <IBrowserPopupController>();
var asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var mockWorkspaceItemRepository = GetworkspaceItemRespository();
new WorkspaceItemRepository(mockWorkspaceItemRepository.Object);
var explorerViewModel = new Mock <IExplorerViewModel>();
var vieFactory = new Mock <IViewFactory>();
var viewMock = new Mock <IView>();
vieFactory.Setup(factory => factory.GetViewGivenServerResourceType(It.IsAny <string>()))
.Returns(viewMock.Object);
_shellViewModel = new ShellViewModel(_eventAggregator.Object, asyncWorker.Object, environmentRepo, new Mock <IVersionChecker>().Object, vieFactory.Object, false, _browserPopupController.Object, _popupController.Object, explorerViewModel.Object);
var activeEnvironment = new Mock <IServer>();
activeEnvironment.Setup(server => server.DisplayName).Returns("localhost");
_activeEnvironment = activeEnvironment;
_authorizationService = new Mock <IAuthorizationService>();
_activeEnvironment.Setup(e => e.AuthorizationService).Returns(_authorizationService.Object);
_shellViewModel.ActiveServer = _activeEnvironment.Object;
}
protected void CreateFullExportsAndVmWithEmptyRepo()
{
CreateResourceRepo();
var mockEnv = new Mock <IServerRepository>();
mockEnv.SetupProperty(g => g.ActiveServer); // Start tracking changes
mockEnv.Setup(g => g.All()).Returns(new List <IServer>());
CustomContainer.Register(mockEnv.Object);
var mockEnvironmentModel = new Mock <IServer>();
var mockEnvironmentConnection = SetupMockConnection();
mockEnvironmentModel.SetupGet(it => it.Connection).Returns(mockEnvironmentConnection.Object);
mockEnvironmentModel.Setup(model => model.AuthorizationService).Returns(new Mock <IAuthorizationService>().Object);
mockEnv.Setup(repository => repository.Source).Returns(mockEnvironmentModel.Object);
var environmentRepo = mockEnv.Object;
EmptyEnvRepo = mockEnv;
_eventAggregator = new Mock <IEventAggregator>();
_popupController = new Mock <IPopupController>();
_windowManager = new Mock <IWindowManager>();
var asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var mockWorkspaceItemRepository = GetworkspaceItemRespository();
new WorkspaceItemRepository(mockWorkspaceItemRepository.Object);
var vieFactory = new Mock <IViewFactory>();
var viewMock = new Mock <IView>();
vieFactory.Setup(factory => factory.GetViewGivenServerResourceType(It.IsAny <string>()))
.Returns(viewMock.Object);
_shellViewModel = new ShellViewModel(_eventAggregator.Object, asyncWorker.Object, environmentRepo, new Mock <IVersionChecker>().Object, vieFactory.Object, false, null, _popupController.Object);
}
protected static DeployStatsCalculator SetupDeployViewModel(out DeployViewModel deployViewModel)
{
var source = EnviromentRepositoryTest.CreateMockEnvironment();
var destination = EnviromentRepositoryTest.CreateMockEnvironment();
source.Setup(a => a.AuthorizationService).Returns(new Mock <IAuthorizationService>().Object);
destination.Setup(a => a.AuthorizationService).Returns(new Mock <IAuthorizationService>().Object);
var serverProvider = new Mock <IEnvironmentModelProvider>();
serverProvider.Setup(s => s.Load()).Returns(new List <IEnvironmentModel> {
source.Object, destination.Object
});
var repo = new TestEnvironmentRespository(source.Object, destination.Object);
var deployStatsCalculator = new DeployStatsCalculator();
IExplorerItemModel resourceVm;
var studioResourceRepository = CreateModels(false, source.Object, out resourceVm);
deployViewModel = new DeployViewModel(AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, serverProvider.Object, repo, new Mock <IEventAggregator>().Object, studioResourceRepository, new Mock <IConnectControlViewModel>().Object, new Mock <IConnectControlViewModel>().Object, deployStatsCalculator)
{
SelectedSourceServer = source.Object,
SelectedDestinationServer = destination.Object
};
return(deployStatsCalculator);
}
protected void CreateFullExportsAndVm()
{
CreateResourceRepo();
var environmentRepo = GetEnvironmentRepository();
EventAggregator = new Mock <IEventAggregator>();
EventPublishers.Aggregator = EventAggregator.Object;
PopupController = new Mock <IPopupController>();
WebController = new Mock <IWebController>();
WindowManager = new Mock <IWindowManager>();
CustomContainer.Register(WindowManager.Object);
BrowserPopupController = new Mock <IBrowserPopupController>();
MockStudioResourceRepository = new Mock <IStudioResourceRepository>();
Mock <IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
Mock <IWorkspaceItemRepository> mockWorkspaceItemRepository = GetworkspaceItemRespository();
// ReSharper disable ObjectCreationAsStatement
new WorkspaceItemRepository(mockWorkspaceItemRepository.Object);
// ReSharper restore ObjectCreationAsStatement
Mock <IConnectControlViewModel> mockConnectControlViewModel = new Mock <IConnectControlViewModel>();
MainViewModel = new MainViewModel(EventAggregator.Object, asyncWorker.Object, environmentRepo,
new Mock <IVersionChecker>().Object, false, BrowserPopupController.Object, PopupController.Object
, WindowManager.Object, WebController.Object, MockStudioResourceRepository.Object, new Mock <IConnectControlSingleton>().Object, mockConnectControlViewModel.Object);
ActiveEnvironment = new Mock <IEnvironmentModel>();
AuthorizationService = new Mock <IAuthorizationService>();
ActiveEnvironment.Setup(e => e.AuthorizationService).Returns(AuthorizationService.Object);
MainViewModel.ActiveEnvironment = ActiveEnvironment.Object;
}
protected void CreateFullExportsAndVm()
{
CreateResourceRepo();
var environmentRepo = GetEnvironmentRepository();
EventAggregator = new Mock <IEventAggregator>();
EventPublishers.Aggregator = EventAggregator.Object;
PopupController = new Mock <IPopupController>();
WindowManager = new Mock <IWindowManager>();
CustomContainer.Register(WindowManager.Object);
CustomContainer.Register(PopupController.Object);
BrowserPopupController = new Mock <IBrowserPopupController>();
Mock <IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
Mock <IWorkspaceItemRepository> mockWorkspaceItemRepository = GetworkspaceItemRespository();
// ReSharper disable ObjectCreationAsStatement
new WorkspaceItemRepository(mockWorkspaceItemRepository.Object);
// ReSharper restore ObjectCreationAsStatement
ShellViewModel = new ShellViewModel(EventAggregator.Object, asyncWorker.Object, environmentRepo,
new Mock <IVersionChecker>().Object, false, BrowserPopupController.Object, PopupController.Object);
var activeEnvironment = new Mock <IServer>();
activeEnvironment.Setup(server => server.DisplayName).Returns("localhost");
ActiveEnvironment = activeEnvironment;
AuthorizationService = new Mock <IAuthorizationService>();
ActiveEnvironment.Setup(e => e.AuthorizationService).Returns(AuthorizationService.Object);
ShellViewModel.ActiveServer = ActiveEnvironment.Object;
}
protected void CreateFullExportsAndVmWithEmptyRepo()
{
CreateResourceRepo();
var mockEnv = new Mock <IEnvironmentRepository>();
mockEnv.SetupProperty(g => g.ActiveEnvironment); // Start tracking changes
mockEnv.Setup(g => g.All()).Returns(new List <IEnvironmentModel>());
mockEnv.Setup(c => c.ReadSession()).Returns(new[] { Guid.NewGuid() });
var mockEnvironmentModel = new Mock <IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.AuthorizationService).Returns(new Mock <IAuthorizationService>().Object);
mockEnv.Setup(repository => repository.Source).Returns(mockEnvironmentModel.Object);
var environmentRepo = mockEnv.Object;
EventAggregator = new Mock <IEventAggregator>();
PopupController = new Mock <IPopupController>();
WebController = new Mock <IWebController>();
WindowManager = new Mock <IWindowManager>();
MockStudioResourceRepository = new Mock <IStudioResourceRepository>();
Mock <IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
Mock <IWorkspaceItemRepository> mockWorkspaceItemRepository = GetworkspaceItemRespository();
// ReSharper disable ObjectCreationAsStatement
new WorkspaceItemRepository(mockWorkspaceItemRepository.Object);
// ReSharper restore ObjectCreationAsStatement
MainViewModel = new MainViewModel(EventAggregator.Object, asyncWorker.Object, environmentRepo,
new Mock <IVersionChecker>().Object, false, null, PopupController.Object,
WindowManager.Object, WebController.Object, MockStudioResourceRepository.Object, new Mock <IConnectControlSingleton>().Object, new Mock <IConnectControlViewModel>().Object);
}
public WorkflowDesignerViewModelMock(IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, bool createDesigner = false)
: base(
new Mock <IEventAggregator>().Object,
resource, workflowHelper,
popupController, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, createDesigner, false, false)
{
_moq.SetupAllProperties();
_wd = _moq.Object;
}
static ContentPaneFactory SetupPane(out WorkSurfaceContextViewModel workSurfaceContextViewModel, out ContentPane userControl, MessageBoxResult messageBoxResult)
{
var pane = new ContentPaneFactory();
var eventAggregator = new Mock <IEventAggregator>();
var workSurfaceViewModel = new Mock <ITestWorkSurfaceViewModel>();
workSurfaceViewModel.SetupGet(w => w.WorkSurfaceContext).Returns(WorkSurfaceContext.Workflow);
workSurfaceViewModel.SetupGet(w => w.ResourceModel).Returns(new TestResourceModel {
Authorized = true
});
var localhost = new Mock <IEnvironmentModel>();
localhost.Setup(e => e.ID).Returns(Guid.Empty);
localhost.Setup(e => e.IsConnected).Returns(true);
var environmentRepository = new Mock <IEnvironmentRepository>();
environmentRepository.Setup(c => c.All()).Returns(new[] { localhost.Object });
environmentRepository.Setup(c => c.Source).Returns(localhost.Object);
var eventPublisher = new Mock <IEventAggregator>();
var asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var versionChecker = new Mock <IVersionChecker>();
var browserPopupController = new Mock <IBrowserPopupController>();
var savePopup = new Mock <IPopupController>();
savePopup.Setup(s => s.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), It.IsAny <MessageBoxImage>(), It.IsAny <string>())).Returns(messageBoxResult);
var mainViewModel = new MainViewModelMock(eventPublisher.Object, asyncWorker.Object, environmentRepository.Object, versionChecker.Object, new Mock <IStudioResourceRepository>().Object, new Mock <IConnectControlSingleton>().Object, new Mock <IConnectControlViewModel>().Object, false, browserPopupController.Object)
{
IsBusyDownloadingInstaller = () => false, PopupProvider = savePopup.Object
};
workSurfaceContextViewModel = new WorkSurfaceContextViewModel(eventAggregator.Object, new WorkSurfaceKey
{
EnvironmentID = Guid.NewGuid(),
ResourceID = Guid.NewGuid(),
ServerID = Guid.NewGuid(),
WorkSurfaceContext = WorkSurfaceContext.Workflow
}, workSurfaceViewModel.Object, new Mock <IPopupController>().Object, (a, b) => { })
{
Parent = mainViewModel
};
pane.ItemsSource = new List <WorkSurfaceContextViewModel>
{
workSurfaceContextViewModel
};
userControl = new ContentPane {
DataContext = workSurfaceContextViewModel
};
return(pane);
}
public void Webserver_Send_NullEnvironment_ShouldNotMakeCallToExecuteCommand()
{
//------------Setup for test--------------------------
var mockEnvironment = new Mock <IEnvironmentModel>();
var mockConnection = new Mock <IEnvironmentConnection>();
mockConnection.Setup(connection => connection.WorkspaceID).Returns(Guid.NewGuid());
mockConnection.Setup(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>())).Verifiable();
mockConnection.Setup(connection => connection.IsConnected).Returns(true);
mockEnvironment.Setup(model => model.Connection).Returns(mockConnection.Object);
mockEnvironment.Setup(model => model.IsConnected).Returns(true);
//------------Execute Test---------------------------
WebServer.Send(WebServerMethod.POST, null, "DataPayLoad", AsyncWorkerTests.CreateSynchronousAsyncWorker().Object);
//------------Assert Results-------------------------
mockConnection.Verify(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never());
}
protected Mock <IEnvironmentRepository> SetupForDeleteServer()
{
CreateResourceRepo();
var models = new List <IEnvironmentModel> {
EnvironmentModel.Object
};
var mock = new Mock <IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(s => s.Get(It.IsAny <Guid>())).Returns(EnvironmentModel.Object);
mock.Setup(s => s.Source).Returns(EnvironmentModel.Object);
mock.Setup(s => s.ReadSession()).Returns(new[] { EnvironmentModel.Object.ID });
mock.Setup(s => s.Remove(It.IsAny <IEnvironmentModel>()))
.Callback <IEnvironmentModel>(s =>
Assert.AreEqual(EnvironmentModel.Object, s))
.Verifiable();
PopupController = new Mock <IPopupController>();
EventAggregator = new Mock <IEventAggregator>();
EventAggregator.Setup(e => e.Publish(It.IsAny <EnvironmentDeletedMessage>()))
.Callback <object>(m =>
{
var removeMsg = (EnvironmentDeletedMessage)m;
Assert.AreEqual(EnvironmentModel.Object, removeMsg.EnvironmentModel);
})
.Verifiable();
SetupDefaultMef();
Mock <IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
MainViewModel = new MainViewModel(EventAggregator.Object, asyncWorker.Object, mock.Object, new Mock <IVersionChecker>().Object, false, connectControlSingleton: new Mock <IConnectControlSingleton>().Object);
SetupForDelete();
FirstResource.Setup(r => r.ResourceType).Returns(ResourceType.Source);
FirstResource.Setup(r => r.ServerResourceType).Returns("Server");
FirstResource.Setup(r => r.ConnectionString)
.Returns(TestResourceStringsTest.ResourceToHydrateConnectionString1);
EnvironmentConnection = new Mock <IEnvironmentConnection>();
EnvironmentConnection.Setup(c => c.AppServerUri)
.Returns(new Uri(TestResourceStringsTest.ResourceToHydrateActualAppUri));
EnvironmentModel.Setup(r => r.Connection).Returns(EnvironmentConnection.Object);
return(mock);
}
protected static DeployViewModel SetupDeployViewModel(out Mock <IEnvironmentModel> destEnv, out Mock <IEnvironmentModel> destServer)
{
var destConnection = new Mock <IEnvironmentConnection>();
destEnv = new Mock <IEnvironmentModel>();
destEnv.Setup(e => e.Connection).Returns(destConnection.Object);
IAuthorizationService service = new Mock <IAuthorizationService>().Object;
destEnv.Setup(a => a.AuthorizationService).Returns(service);
destServer = destEnv;
var envRepo = new Mock <IEnvironmentRepository>();
envRepo.Setup(r => r.Fetch(It.IsAny <IEnvironmentModel>())).Returns(destEnv.Object);
var servers = new List <IEnvironmentModel> {
destEnv.Object
};
var serverProvider = new Mock <IEnvironmentModelProvider>();
serverProvider.Setup(s => s.Load()).Returns(servers);
// ReSharper disable RedundantAssignment
int deployItemCount;
var statsCalc = new Mock <IDeployStatsCalculator>();
statsCalc.Setup(c => c.CalculateStats(It.IsAny <IEnumerable <ExplorerItemModel> >(), It.IsAny <Dictionary <string, Func <IExplorerItemModel, bool> > >(), It.IsAny <ObservableCollection <DeployStatsTO> >(), out deployItemCount));
var mockStudioResourceRepository = new Mock <IStudioResourceRepository>();
mockStudioResourceRepository.Setup(repository => repository.Filter(It.IsAny <Func <IExplorerItemModel, bool> >())).Returns(new ObservableCollection <IExplorerItemModel>());
var deployViewModel = new DeployViewModel(AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, serverProvider.Object, envRepo.Object, new Mock <IEventAggregator>().Object, mockStudioResourceRepository.Object, new Mock <IConnectControlViewModel>().Object, new Mock <IConnectControlViewModel>().Object, statsCalc.Object)
{
Source = { ExplorerItemModels = new ObservableCollection <IExplorerItemModel>() }, Target = { ExplorerItemModels = new ObservableCollection <IExplorerItemModel>() }
};
return(deployViewModel);
}
protected static Guid SetupVmForMessages(out IEnvironmentModel server, out DeployViewModel vm, Mock <IEventAggregator> mockEventAggregator = null)
{
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var envId = env.Object.ID;
server = env.Object;
var serverProvider = new Mock <IEnvironmentModelProvider>();
serverProvider.Setup(s => s.Load()).Returns(new List <IEnvironmentModel> {
server
});
var repo = CreateEnvironmentRepositoryMock();
if (mockEventAggregator == null)
{
mockEventAggregator = new Mock <IEventAggregator>();
}
var studioResourceRepository = new Mock <IStudioResourceRepository>();
studioResourceRepository.Setup(repository => repository.Filter(It.IsAny <Func <IExplorerItemModel, bool> >())).Returns(new ObservableCollection <IExplorerItemModel>());
vm = new DeployViewModel(AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, serverProvider.Object, repo.Object, mockEventAggregator.Object, studioResourceRepository.Object, new Mock <IConnectControlViewModel>().Object, new Mock <IConnectControlViewModel>().Object);
return(envId);
}
public void ThrowsNullExceptionForEnvironmentRepo()
{
// ReSharper disable ObjectCreationAsStatement
new ExplorerViewModel(EventPublishers.Aggregator, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, null, new Mock <IStudioResourceRepository>().Object, new Mock <IConnectControlSingleton>().Object, new Mock <IMainViewModel>().Object, connectControlViewModel: new Mock <IConnectControlViewModel>().Object);
// ReSharper restore ObjectCreationAsStatement
}
public static string ExecuteServiceOnLocalhostUsingProxy(string serviceName, Dictionary <string, string> payloadArguments)
{
CommunicationControllerFactory fact = new CommunicationControllerFactory();
var comm = fact.CreateController(serviceName);
var prx = new ServerProxy("http://localhost:3142", CredentialCache.DefaultNetworkCredentials, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object);
prx.Connect(Guid.NewGuid());
foreach (var payloadArgument in payloadArguments)
{
comm.AddPayloadArgument(payloadArgument.Key, payloadArgument.Value);
}
if (comm != null)
{
var messageToExecute = comm.ExecuteCommand <ExecuteMessage>(prx, Guid.Empty);
if (messageToExecute != null)
{
var responseMessage = messageToExecute.Message;
if (responseMessage != null)
{
var actual = responseMessage.ToString();
return(actual);
}
return("Error: response message empty!");
}
return("Error: message to send to localhost server could not be generated.");
}
return("Error: localhost server controller could not be created.");
}
public void ResourcePickerDialog_Constructor_Properties_Initialized()
{
//------------Setup for test-------------------------
SetupMef();
var dialogWindow = new Mock <IDialog>();
const enDsfActivityType ActivityType = enDsfActivityType.All;
const bool IsFromActivityDrop = true;
var repository = new StudioResourceRepository(GetTestData(), Guid.Empty, _Invoke);
var envRepo = new TestLoadEnvironmentRespository(new Mock <IEnvironmentModel>().Object);
//var envRepo = EnvironmentRepository.Create(new Mock<IEnvironmentModel>().Object);
//------------Execute Test---------------------------
var dialog = new TestResourcePickerDialog(ActivityType, envRepo, new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, IsFromActivityDrop, repository)
{
CreateDialogResult = dialogWindow.Object
};
// Need to invoke ShowDialog in order to get the DsfActivityDropViewModel
dialog.ShowDialog();
//------------Assert Results-------------------------
Assert.AreEqual(ActivityType, dialog.CreateDialogDataContext.ActivityType);
Assert.AreEqual(IsFromActivityDrop, dialog.CreateDialogDataContext.NavigationViewModel.IsFromActivityDrop);
}
protected static void SetupResources(DeployStatsCalculator deployStatsCalculator, bool isChecked)
{
IEnvironmentModel environmentModel;
IExplorerItemModel resourceVm;
var studioResourceRepository = CreateModels(isChecked, out environmentModel, out resourceVm);
var navVm = new DeployNavigationViewModel(new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock <IEnvironmentRepository>().Object, studioResourceRepository, true, new Mock <IConnectControlSingleton>().Object)
{
Environment = environmentModel
};
resourceVm.IsChecked = isChecked;
deployStatsCalculator.DeploySummaryPredicateExisting(resourceVm, navVm);
}
public void ResourcePickerDialog_SelectedResourceNotContextualResourceModel_NavigationViewModelActivityDropViewModelItemNotSelected()
{
//------------Setup for test-------------------------
SetupMef();
var dialogWindow = new Mock <IDialog>();
const enDsfActivityType ActivityType = enDsfActivityType.All;
const bool IsFromActivityDrop = true;
var repository = new StudioResourceRepository(GetTestData(), Guid.Empty, _Invoke);
var mockEnvironmentModel = new Mock <IEnvironmentModel>();
var mockEventAggregator = new Mock <IEventAggregator>();
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.CanStudioExecute).Returns(true);
var mockEnvironmentConnection = new Mock <IEnvironmentConnection>();
mockEnvironmentConnection.Setup(connection => connection.AppServerUri).Returns(new Uri("http://localhost"));
mockEnvironmentConnection.Setup(connection => connection.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockEnvironmentConnection.Object);
var mockResourceRepository = CreateMockResourceRepository(mockEnvironmentModel);
mockEnvironmentModel.Setup(model => model.ResourceRepository).Returns(mockResourceRepository.Object);
var envRepo = new TestLoadEnvironmentRespository(mockEnvironmentModel.Object);
var selectedResource = mockResourceRepository.Object.All().ToList()[1];
var dialog = new TestResourcePickerDialog(ActivityType, envRepo, mockEventAggregator.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, IsFromActivityDrop, repository)
{
CreateDialogResult = dialogWindow.Object,
SelectedResource = new Mock <IResourceModel>().Object
};
//------------Execute Test---------------------------
// Need to invoke ShowDialog in order to get the DsfActivityDropViewModel
dialog.ShowDialog();
//------------Assert Results-------------------------
Assert.AreNotEqual(selectedResource, dialog.CreateDialogDataContext.SelectedResourceModel);
}
public void ActivityDesignerViewModel_Collapse_HelpButtonGetsRemovedOnCollapse()
{
//------------Setup for test--------------------------
var mockModelItem = GenerateMockModelItem();
Mock <IContextualResourceModel> setupResourceModelMock = Dev2MockFactory.SetupResourceModelMock();
ErrorInfo errorInfo = new ErrorInfo {
InstanceID = new Guid()
};
var envRepo = new Mock <IEnvironmentRepository>();
envRepo.Setup(e => e.ActiveEnvironment).Returns(setupResourceModelMock.Object.Environment);
IObservableReadOnlyList <IErrorInfo> testErrors = new ObservableReadOnlyList <IErrorInfo> {
errorInfo
};
setupResourceModelMock.Setup(c => c.Errors).Returns(testErrors);
setupResourceModelMock.Setup(c => c.GetErrors(It.IsAny <Guid>())).Returns(new List <IErrorInfo> {
errorInfo
});
var viewModel = new ServiceDesignerViewModel(mockModelItem.Object, setupResourceModelMock.Object, envRepo.Object, new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object);
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
viewModel.ShowLarge = true;
Assert.AreEqual(2, viewModel.TitleBarToggles.Count);
//------------Execute Test---------------------------
viewModel.Collapse();
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
}
public void ResourcePickerDialog_WithEnvironmentModel_NavigationViewModelFiltered()
{
//------------Setup for test-------------------------
SetupMef();
var dialogWindow = new Mock <IDialog>();
const enDsfActivityType ActivityType = enDsfActivityType.All;
const bool IsFromActivityDrop = true;
var mockEventAggregator = new Mock <IEventAggregator>();
var mockEnvironmentModel = new Mock <IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.CanStudioExecute).Returns(true);
mockEnvironmentModel.Setup(model => model.ID).Returns(Guid.Empty);
var environment2Id = Guid.NewGuid();
var mockEnvironmentModel2 = new Mock <IEnvironmentModel>();
mockEnvironmentModel2.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel2.Setup(model => model.CanStudioExecute).Returns(true);
mockEnvironmentModel2.Setup(model => model.ID).Returns(environment2Id);
var mockEnvironmentConnection = new Mock <IEnvironmentConnection>();
mockEnvironmentConnection.Setup(connection => connection.AppServerUri).Returns(new Uri("http://localhost"));
mockEnvironmentConnection.Setup(connection => connection.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockEnvironmentConnection.Object);
var mockEnvironmentConnection2 = new Mock <IEnvironmentConnection>();
mockEnvironmentConnection2.Setup(connection => connection.AppServerUri).Returns(new Uri("http://tests:3142"));
mockEnvironmentConnection2.Setup(connection => connection.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
mockEnvironmentModel2.Setup(model => model.Connection).Returns(mockEnvironmentConnection2.Object);
var mockResourceRepository = CreateMockResourceRepository(mockEnvironmentModel);
mockEnvironmentModel.Setup(model => model.ResourceRepository).Returns(mockResourceRepository.Object);
var envRepo = new TestLoadEnvironmentRespository(mockEnvironmentModel.Object, mockEnvironmentModel2.Object);
var selectedResource = mockResourceRepository.Object.All().ToList()[1];
var mockExplorerResourceRepository = new Mock <IExplorerResourceRepository>();
var repository = new StudioResourceRepository(GetTestData(), Guid.Empty, _Invoke)
{
GetExplorerProxy = id => mockExplorerResourceRepository.Object
};
ExplorerItemModel server2Item = new ExplorerItemModel {
EnvironmentId = environment2Id, DisplayName = "Server 2", ResourceType = Common.Interfaces.Data.ResourceType.Server
};
ExplorerItemModel resourceItemServer2 = new ExplorerItemModel {
EnvironmentId = environment2Id, DisplayName = "Resource Server 2", ResourceType = Common.Interfaces.Data.ResourceType.WorkflowService
};
server2Item.Children.Add(resourceItemServer2);
repository.ExplorerItemModels.Add(server2Item);
var dialog = new TestResourcePickerDialog(ActivityType, envRepo, mockEventAggregator.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, IsFromActivityDrop, repository)
{
CreateDialogResult = dialogWindow.Object,
SelectedResource = new Mock <IResourceModel>().Object
};
//------------Execute Test---------------------------
// Need to invoke ShowDialog in order to get the DsfActivityDropViewModel
dialog.ShowDialog(mockEnvironmentModel2.Object);
//------------Assert Results-------------------------
Assert.AreNotEqual(selectedResource, dialog.CreateDialogDataContext.SelectedResourceModel);
}
public void GivenHasAScheduleOf(string scheduleName, Table table)
{
AppSettings.LocalHost = "http://localhost:3142";
var mockServer = new Mock <IServer>();
var mockshell = new Mock <IShellViewModel>();
mockshell.Setup(a => a.ActiveServer).Returns(mockServer.Object);
mockshell.Setup(a => a.LocalhostServer).Returns(mockServer.Object);
mockServer.Setup(a => a.GetServerVersion()).Returns("1.0.0.0");
CustomContainer.Register(mockServer.Object);
CustomContainer.Register(mockshell.Object);
var mockPopupController = new Mock <IPopupController>();
mockPopupController.Setup(controller => controller.ShowDeleteConfirmation(It.IsAny <string>())).Returns(MessageBoxResult.Yes);
SchedulerViewModel scheduler = new SchedulerViewModel(EventPublishers.Aggregator, new DirectoryObjectPickerDialog(), mockPopupController.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock <IServer>().Object, a => new Mock <IServer>().Object);
IServer server = ServerRepository.Instance.Source;
server.Connect();
scheduler.ScheduledResourceModel = new ClientScheduledResourceModel(server, () => { });
scheduler.CurrentEnvironment = server;
scheduler.CreateNewTask();
scheduler.SelectedTask.Name = _scenarioContext["ScheduleName"].ToString();
scheduler.SelectedTask.OldName = "bob";
scheduler.SelectedTask.UserName = _scenarioContext["UserName"].ToString();
scheduler.SelectedTask.Password = _scenarioContext["Password"].ToString();
scheduler.SelectedTask.WorkflowName = _scenarioContext["WorkFlow"].ToString();
scheduler.SelectedTask.ResourceId = new Guid("acb75027-ddeb-47d7-814e-a54c37247ec1");
scheduler.SelectedTask.NumberOfHistoryToKeep = (int)_scenarioContext["HistoryCount"];
scheduler.SelectedTask.Status = (SchedulerStatus)_scenarioContext["TaskStatus"];
scheduler.Errors.ClearErrors();
var task = scheduler.SelectedTask;
UpdateTrigger(task, table);
PrivateObject po = new PrivateObject(scheduler.CurrentEnvironment);
var mockAuth = new Mock <IAuthorizationService>();
mockAuth.Setup(a => a.IsAuthorized(It.IsAny <AuthorizationContext>(), null)).Returns(true);
po.SetFieldOrProperty("AuthorizationService", mockAuth.Object);
_scenarioContext["Scheduler"] = scheduler;
try
{
scheduler.SaveCommand.Execute("");
if (scheduler.HasErrors)
{
_scenarioContext["Error"] = scheduler.Error;
}
}
catch (Exception e)
{
_scenarioContext["Error"] = e.Message;
}
}
public TestEqualityConnection(Guid serverID, string serverUri)
: base(serverUri, CredentialCache.DefaultCredentials, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object)
{
ServerID = serverID;
}
DeployNavigationViewModel CreateViewModel(IEnvironmentRepository environmentRepository, Mock <IResourceRepository> mockResourceRepository)
{
StudioResourceRepository studioResourceRepository = BuildExplorerItems(mockResourceRepository.Object);
var navigationViewModel = new DeployNavigationViewModel(new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, environmentRepository, studioResourceRepository, _target, new Mock <IConnectControlSingleton>().Object);
return(navigationViewModel);
}
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, StudioResourceRepository studioResourceRepository)
{
return(CreateDeployNavigationViewModel(environmentModel, new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock <IEnvironmentRepository>().Object, studioResourceRepository));
}
public TestServerProxy()
: base("http://localhost:8080", CredentialCache.DefaultCredentials, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object)
{
}
