public void ObjectName_GivenIsObjectAndObjectResult_ShouldUpdateDatalist()
{
//---------------Set up test pack-------------------
CustomContainer.DeRegister <IShellViewModel>();
var shellVm = new Mock <IShellViewModel>();
shellVm.Setup(model => model.UpdateCurrentDataListWithObjectFromJson(It.IsAny <string>(), It.IsAny <string>())).Verifiable();
CustomContainer.Register(shellVm.Object);
var act = new DsfWebGetActivity {
SourceId = Guid.NewGuid(), Outputs = null, IsObject = true
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true)
{
ObjectResult = this.SerializeToJsonString(new DefaultSerializationBinder())
};
//---------------Assert Precondition----------------
Assert.IsTrue(outputsRegion.IsObject);
Assert.IsTrue(!string.IsNullOrEmpty(outputsRegion.ObjectResult));
Assert.IsTrue(FsInteropFunctions.ParseLanguageExpressionWithoutUpdate("[[@objName]]").IsJsonIdentifierExpression);
//---------------Execute Test ----------------------
outputsRegion.ObjectName = "[[@objName]]";
//---------------Test Result -----------------------
shellVm.Verify(model => model.UpdateCurrentDataListWithObjectFromJson(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
Assert.AreEqual(outputsRegion.ObjectName, act.ObjectName);
}
public void FetchExplorerItems_ExecuteReloadTrueWithExecutionManager_ExpectCallsStartAndStopRefresh()
{
//------------Setup for test--------------------------
var fetchExplorerItems = new FetchExplorerItems();
var exeManager = new Mock <IExecutionManager>();
CustomContainer.Register(exeManager.Object);
var item = new ServerExplorerItem("a", Guid.NewGuid(), "Folder", null, Permissions.DeployFrom, "");
Assert.IsNotNull(item);
var repo = new Mock <IExplorerServerResourceRepository>();
var ws = new Mock <IWorkspace>();
repo.Setup(a => a.Load(GlobalConstants.ServerWorkspaceID, true))
.Returns(item).Verifiable();
var serializer = new Dev2JsonSerializer();
ws.Setup(a => a.ID).Returns(Guid.Empty);
fetchExplorerItems.ServerExplorerRepo = repo.Object;
//------------Execute Test---------------------------
var execute = fetchExplorerItems.Execute(new Dictionary <string, StringBuilder> {
{ "ReloadResourceCatalogue", new StringBuilder("true") }
}, ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.Load(GlobalConstants.ServerWorkspaceID, true));
var message = serializer.Deserialize <CompressedExecuteMessage>(execute);
Assert.AreEqual(serializer.Deserialize <IExplorerItem>(message.GetDecompressedMessage()).ResourceId, item.ResourceId);
exeManager.Verify(manager => manager.StartRefresh(), Times.Once);
exeManager.Verify(manager => manager.StopRefresh(), Times.AtLeastOnce());
CustomContainer.DeRegister <IExecutionManager>();
}
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 ;)
}
public void CreateKeysWithDebugStateExpectedKeysCreatedWhenHasWorkspaceID()
{
var resId = Guid.NewGuid();
var serverId = Guid.NewGuid();
var enviroId = Guid.NewGuid();
var enviroId2 = Guid.NewGuid();
var serverRepo = new Mock <IServerRepository>();
CustomContainer.DeRegister <IServerRepository>();
CustomContainer.Register(serverRepo.Object);
var source = new Mock <IServer>();
var sourceConnection = new Mock <IEnvironmentConnection>();
sourceConnection.Setup(connection => connection.WorkspaceID).Returns(Guid.NewGuid);
source.Setup(model => model.Connection).Returns(sourceConnection.Object);
var e1 = new Mock <IServer>();
e1.Setup(model => model.EnvironmentID).Returns(Guid.NewGuid);
//serverRepo.Setup(repository => repository.FindSingle(server => ))
// .Returns(source.Object);
var connection1 = new Mock <IEnvironmentConnection>();
connection1.Setup(connection => connection.WorkspaceID).Returns(enviroId);
e1.Setup(model => model.Connection).Returns(connection1.Object);
var e2 = new Mock <IServer>();
e2.Setup(model => model.EnvironmentID).Returns(Guid.NewGuid);
var connection2 = new Mock <IEnvironmentConnection>();
connection2.Setup(connection => connection.WorkspaceID).Returns(enviroId2);
e2.Setup(model => model.Connection).Returns(connection2.Object);
var repo = new TestLoadServerRespository(source.Object, e1.Object, e2.Object);
new ServerRepository(repo);
var debugState = new Mock <IDebugState>();
debugState.Setup(c => c.OriginatingResourceID).Returns(resId);
debugState.Setup(c => c.ServerID).Returns(serverId);
debugState.Setup(c => c.WorkspaceID).Returns(enviroId);
serverRepo.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IServer, bool> > >()))
.Returns(e1.Object);
var key1 = WorkSurfaceKeyFactory.CreateKey(debugState.Object);
var debugState2 = new Mock <IDebugState>();
debugState2.Setup(c => c.OriginatingResourceID).Returns(resId);
debugState2.Setup(c => c.ServerID).Returns(serverId);
debugState2.Setup(c => c.WorkspaceID).Returns(enviroId2);
var key2 = WorkSurfaceKeyFactory.CreateKey(debugState2.Object);
Assert.IsFalse(WorkSurfaceKeyEqualityComparer.Current.Equals(key1, key2), "keys should not be equal");
}
public void FetchPerformanceCounters_Manager_ExceptionIfContainerNotRegistered()
{
//------------Setup for test--------------------------
var fetchPerformanceCounters = new FetchPerformanceCounters();
CustomContainer.DeRegister <IPerformanceCounterRepository>();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
PrivateObject p = new PrivateObject(fetchPerformanceCounters);
var nll = p.GetProperty("Manager");
Assert.IsNull(nll);
}
protected IServerRepository GetEnvironmentRepository()
{
var models = new List <IServer> {
_environmentModel.Object
};
var mock = new Mock <IServerRepository>();
CustomContainer.DeRegister <IServerRepository>();
CustomContainer.Register(mock.Object);
mock.Setup(s => s.All()).Returns(models);
mock.Setup(s => s.Source).Returns(_environmentModel.Object);
mock.Setup(repo => repo.Get(It.IsAny <Guid>())).Returns(_environmentModel.Object);
mock.Setup(repo => repo.ActiveServer).Returns(_environmentModel.Object);
_serverRepo = mock.Object;
return(_serverRepo);
}
public void CustomContainer_Deregister_TypeExists_TypeRemoved()
{
//------------Setup for test--------------------------
var o = new SimpleObject();
CustomContainer.Register <ISimpleObject>(o);
var simpleObject = CustomContainer.Get <ISimpleObject>();
//------------Preconditions--------------------------
Assert.IsNotNull(simpleObject);
//------------Execute Test---------------------------
CustomContainer.DeRegister <ISimpleObject>();
//------------Assert Results-------------------------
var objectAfterDeregister = CustomContainer.Get <ISimpleObject>();
Assert.IsNull(objectAfterDeregister);
}
public void IntellisenseTextBox_Text_NotLatinCharacter_ShowMessageBox_TextMadeEmpty()
{
//------------Setup for test--------------------------
CustomContainer.DeRegister <IPopupController>();
var mockPopupController = new Mock <IPopupController>();
mockPopupController.Setup(controller => controller.ShowInvalidCharacterMessage(It.IsAny <string>()));
CustomContainer.Register(mockPopupController.Object);
var intellisenseProvider = new Mock <IIntellisenseProvider>();
intellisenseProvider.Setup(a => a.HandlesResultInsertion).Returns(false);
//------------Execute Test---------------------------
var textBox = new IntellisenseTextBox();
var checkHasUnicodeInText = textBox.CheckHasUnicodeInText("أَبْجَدِي");
//------------Assert Results-------------------------
Assert.IsTrue(checkHasUnicodeInText);
Assert.AreEqual("", textBox.Text);
mockPopupController.Verify(controller => controller.ShowInvalidCharacterMessage(It.IsAny <string>()), Times.AtLeastOnce());
}
public void GetDontShowAgainOptionExpectedPersistedToXML()
{
const string data = @"<root>
<Option Key=""1"" Value=""OK"" />
</root>";
CustomContainer.DeRegister <IFilePersistenceProvider>();
Mock <IFilePersistenceProvider> filePersistenceProvider = new Mock <IFilePersistenceProvider>();
filePersistenceProvider.Setup(p => p.Read(It.IsAny <string>())).Returns(() => data);
CustomContainer.Register(filePersistenceProvider.Object);
Dev2MessageBoxViewModel.ResetAllDontShowAgainOptions();
Tuple <bool, MessageBoxResult> result = Dev2MessageBoxViewModel.GetDontShowAgainOption("1");
Assert.AreEqual(true, result.Item1, "Failed to hydrate options from XML data.");
Assert.AreEqual(MessageBoxResult.OK, result.Item2, "Options incorrectly hydrated from XML data.");
}
public void DropboxFileList_dropBoxFileListViewModel_NewSourcePublishesMessage()
{
var agg = new Mock <IEventAggregator>();
var model = CreateModelItem();
CustomContainer.DeRegister <IShellViewModel>();
var shellViewModelMock = new Mock <IShellViewModel>();
shellViewModelMock.Setup(viewModel => viewModel.NewDropboxSource(It.IsAny <string>()));
CustomContainer.Register(shellViewModelMock.Object);
//------------Setup for test--------------------------
var dropBoxUploadViewModel = new DropBoxFileListDesignerViewModel(model, TestResourceCatalog.LazySourceManager.Value)
{
SelectedSource = new DropBoxSource()
};
//------------Execute Test---------------------------
dropBoxUploadViewModel.NewSourceCommand.Execute(null);
//------------Assert Results-------------------------
shellViewModelMock.Verify(viewModel => viewModel.NewDropboxSource(It.IsAny <string>()), Times.Once);
CustomContainer.DeRegister <IShellViewModel>();
}
public void DropboxFileList_dropBoxFileListViewModel_EditSourcePublishesMessage()
{
var agg = new Mock <IEventAggregator>();
var model = CreateModelItem();
var mockShellViewModel = new Mock <IShellViewModel>();
var serverMock = new Mock <IServer>();
mockShellViewModel.Setup(viewModel => viewModel.OpenResource(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <IServer>()));
mockShellViewModel.Setup(viewModel => viewModel.ActiveServer).Returns(() => serverMock.Object);
CustomContainer.Register(mockShellViewModel.Object);
//------------Setup for test--------------------------
var dropBoxFileListViewModel = new DropBoxFileListDesignerViewModel(model, TestResourceCatalog.LazySourceManager.Value)
{
SelectedSource = new DropBoxSource()
};
dropBoxFileListViewModel.EditDropboxSourceCommand.Execute(null);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
mockShellViewModel.Verify(viewModel => viewModel.OpenResource(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <IServer>()));
CustomContainer.DeRegister <IShellViewModel>();
}
// ReSharper disable InconsistentNaming
public void SetDontShowAgainOptionExpectedPersistedToXML()
{
const string expected = @"<root>
<Option Key=""1"" Value=""OK"" />
</root>";
string actual = null;
CustomContainer.DeRegister <IFilePersistenceProvider>();
Mock <IFilePersistenceProvider> filePersistenceProvider = new Mock <IFilePersistenceProvider>();
filePersistenceProvider.Setup(p => p.Write(It.IsAny <string>(), It.IsAny <string>())).Callback((string p1, string p2) =>
{
actual = p2;
});
CustomContainer.Register(filePersistenceProvider.Object);
Dev2MessageBoxViewModel.ResetAllDontShowAgainOptions();
Dev2MessageBoxViewModel.SetDontShowAgainOption("1", MessageBoxResult.OK);
Assert.AreEqual(expected, actual, "Serialization resulted in an unexpected format.");
}
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);
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);
}
public void CleanUp()
{
CustomContainer.DeRegister <IActivityParser>();
CustomContainer.DeRegister <IShellViewModel>();
}
