public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace) { StringBuilder itemXml; string isLocal = string.Empty; StringBuilder tmp; values.TryGetValue("ItemXml", out itemXml); values.TryGetValue("IsLocalSave", out tmp); if (tmp != null) { isLocal = tmp.ToString(); } bool isLocalSave; bool.TryParse(isLocal, out isLocalSave); var res = new ExecuteMessage { HasError = false}; if(itemXml == null || itemXml.Length == 0) { res.SetMessage("Invalid workspace item definition " + DateTime.Now); res.HasError = true; } else { try { XElement xe = itemXml.ToXElement(); var workspaceItem = new WorkspaceItem(xe); if (workspaceItem.WorkspaceID != theWorkspace.ID) { res.SetMessage("Cannot update a workspace item from another workspace " + DateTime.Now); res.HasError = true; } else { theWorkspace.Update(workspaceItem, isLocalSave); res.SetMessage("Workspace item updated " + DateTime.Now); } } catch(Exception ex) { res.SetMessage("Error updating workspace item " + DateTime.Now); res.SetMessage(ex.Message); res.SetMessage(ex.StackTrace); res.HasError = true; } } Dev2JsonSerializer serializer = new Dev2JsonSerializer(); return serializer.SerializeToBuilder(res); }
public void ServiceCallbackHandler_CheckForServerMessages_OnlyDependantIsInWorkspaceItemRepo_DontShowDependancyViewer() { //------------------------------Setup------------------------------------------------- Mock<IShowDependencyProvider> showDependencyProvider; Mock<IResourceRepository> resourceRepo; Guid resourceId = Guid.NewGuid(); SetupObjects(out showDependencyProvider, out resourceRepo, resourceId); var compileMessageTos = new List<ICompileMessageTO> { new CompileMessageTO() }; var envConnection = SetupConnectionWithCompileMessageList(compileMessageTos, new List<string> { "Unsaved 1" }); var envModel = new Mock<IEnvironmentModel>(); envModel.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object); envModel.Setup(e => e.Connection).Returns(envConnection.Object); var aggregator = new Mock<IEventAggregator>(); var envRepo = new Mock<IEnvironmentRepository>(); var handler = new ServiceCallbackHandlerMock(aggregator.Object, envRepo.Object, showDependencyProvider.Object); var workspace = new Mock<IWorkspaceItemRepository>(); var workspaceItem = new WorkspaceItem(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>()) { ServiceName = "Unsaved 1" }; workspace.Setup(c => c.WorkspaceItems).Returns(new List<IWorkspaceItem> { workspaceItem }); //------------------------------Execute ------------------------------------------------- handler.TestCheckForServerMessages(envModel.Object, resourceId, workspace.Object); //------------------------------Assert Result ------------------------------------------------- showDependencyProvider.Verify(provider => provider.ShowDependencyViewer(It.IsAny<IContextualResourceModel>(), new List<string> { "" }), Times.Never()); }
public void MainViewModelConstructorWithWorkspaceItemsInRepositoryExpectedNotLoadsWorkspaceItemsWithSameEnvID() { lock (syncroot) { var workspaceID = Guid.NewGuid(); var serverID = Guid.NewGuid(); var resourceName = "TestResource_" + Guid.NewGuid(); var resourceID = Guid.NewGuid(); Guid environmentID = Guid.NewGuid(); var wsi = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID) { ServiceName = resourceName, ServiceType = WorkspaceItem.ServiceServiceType }; var wsiRepo = new Mock<IWorkspaceItemRepository>(); wsiRepo.Setup(r => r.WorkspaceItems).Returns(new List<IWorkspaceItem>(new[] { wsi })); wsiRepo.Setup(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>())).Verifiable(); SetupImportServiceForPersistenceTests(wsiRepo); var resourceModel = new Mock<IContextualResourceModel>(); resourceModel.Setup(m => m.ResourceName).Returns(resourceName); resourceModel.Setup(m => m.ID).Returns(resourceID); resourceModel.Setup(m => m.ResourceType).Returns(ResourceType.WorkflowService); var resourceRepo = new Mock<IResourceRepository>(); resourceRepo.Setup(r => r.All()).Returns(new List<IResourceModel>(new[] { resourceModel.Object })); resourceRepo.Setup(r => r.ReloadResource(It.IsAny<string>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>())).Verifiable(); var dsfChannel = new Mock<IStudioClientContext>(); dsfChannel.Setup(c => c.WorkspaceID).Returns(workspaceID); dsfChannel.Setup(c => c.ServerID).Returns(serverID); var envConn = new Mock<IEnvironmentConnection>(); var env = new Mock<IEnvironmentModel>(); env.Setup(e => e.DsfChannel).Returns(dsfChannel.Object); env.Setup(e => e.Connection).Returns(envConn.Object); env.Setup(e => e.IsConnected).Returns(true); env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object); env.Setup(e => e.ID).Returns(environmentID); resourceModel.Setup(m => m.Environment).Returns(env.Object); var envRepo = new Mock<IEnvironmentRepository>(); envRepo.Setup(r => r.All()).Returns(new List<IEnvironmentModel>(new[] { env.Object })); var viewModel = new MainViewModelPersistenceMock(envRepo.Object, false); resourceRepo.Verify(r => r.ReloadResource(It.IsAny<string>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>()), Times.AtLeastOnce()); wsiRepo.Verify(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>()), Times.AtLeastOnce()); Assert.AreEqual(2, viewModel.Items.Count); // 1 extra for the help tab! var expected = viewModel.Items.FirstOrDefault(i => i.WorkSurfaceKey.ResourceID == resourceID); Assert.IsNotNull(expected); } }
public void MainViewModelConstructorWithWorkspaceItemsInRepositoryExpectedNotLoadsWorkspaceItemsWithSameEnvID() { var workspaceID = Guid.NewGuid(); var serverID = Guid.NewGuid(); var resourceName = "TestResource_" + Guid.NewGuid(); var resourceID = Guid.NewGuid(); Guid environmentID = Guid.NewGuid(); var wsi = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID) { ServiceName = resourceName, ServiceType = WorkspaceItem.ServiceServiceType }; var wsiRepo = new Mock<IWorkspaceItemRepository>(); wsiRepo.Setup(r => r.WorkspaceItems).Returns(new List<IWorkspaceItem>(new[] { wsi })); wsiRepo.Setup(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>())).Verifiable(); SetupImportServiceForPersistenceTests(wsiRepo); WorkspaceItemRepository.Instance.WorkspaceItems.Clear(); WorkspaceItemRepository.Instance.WorkspaceItems.Add(wsi); var resourceModel = new Mock<IContextualResourceModel>(); resourceModel.Setup(m => m.ResourceName).Returns(resourceName); resourceModel.Setup(m => m.ID).Returns(resourceID); resourceModel.Setup(m => m.ResourceType).Returns(ResourceType.WorkflowService); var resourceRepo = new Mock<IResourceRepository>(); resourceRepo.Setup(r => r.All()).Returns(new List<IResourceModel>(new[] { resourceModel.Object })); resourceRepo.Setup(r => r.ReloadResource(It.IsAny<Guid>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), true)).Verifiable(); resourceRepo.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage()); var envConn = new Mock<IEnvironmentConnection>(); envConn.Setup(conn => conn.WorkspaceID).Returns(workspaceID); envConn.Setup(conn => conn.ServerID).Returns(serverID); envConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object); var env = new Mock<IEnvironmentModel>(); env.Setup(e => e.Connection).Returns(envConn.Object); env.Setup(e => e.IsConnected).Returns(true); env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object); env.Setup(e => e.ID).Returns(environmentID); resourceModel.Setup(m => m.Environment).Returns(env.Object); var envRepo = new Mock<IEnvironmentRepository>(); envRepo.Setup(r => r.All()).Returns(new List<IEnvironmentModel>(new[] { env.Object })); envRepo.Setup(r => r.Source).Returns(env.Object); Mock<IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker(); var viewModel = new MainViewModelPersistenceMock(envRepo.Object, asyncWorker.Object, false); wsiRepo.Verify(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>()), Times.AtLeastOnce()); Assert.AreEqual(2, viewModel.Items.Count); // 1 extra for the help tab! var expected = viewModel.Items.FirstOrDefault(i => i.WorkSurfaceKey.ResourceID == resourceID); Assert.IsNotNull(expected); }
public void WorkspaceItem_UnitTest_ConstructorWhereParametersXML_ObjectHasProperties() { //------------Setup for test-------------------------- Guid workspaceID = Guid.NewGuid(); Guid resourceID = Guid.NewGuid(); Guid environmentID = Guid.NewGuid(); Guid serverID = Guid.NewGuid(); WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID); workspaceItem.IsWorkflowSaved = true; XElement xElement = workspaceItem.ToXml(); //------------Execute Test--------------------------- WorkspaceItem newWorkspaceItem = new WorkspaceItem(xElement); //------------Assert Results------------------------- Assert.AreEqual(workspaceID, newWorkspaceItem.WorkspaceID); Assert.AreEqual(serverID, newWorkspaceItem.ServerID); Assert.AreEqual(environmentID, newWorkspaceItem.EnvironmentID); Assert.IsTrue(newWorkspaceItem.IsWorkflowSaved); }
public void WorkspaceItem_UnitTest_ConstructorWhereParametersPassed_ObjectHasProperties() { //------------Setup for test-------------------------- Guid workspaceID = Guid.NewGuid(); Guid resourceID = Guid.NewGuid(); Guid environmentID = Guid.NewGuid(); Guid serverID = Guid.NewGuid(); //------------Execute Test--------------------------- WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID); //------------Assert Results------------------------- Assert.AreEqual(workspaceID, workspaceItem.WorkspaceID); Assert.AreEqual(serverID, workspaceItem.ServerID); Assert.AreEqual(environmentID, workspaceItem.EnvironmentID); }
public void WorkspaceItem_UnitTest_ToXMLWhereParametersXML_HasElementWithAttributes() { //------------Setup for test-------------------------- Guid workspaceID = Guid.NewGuid(); Guid resourceID = Guid.NewGuid(); Guid environmentID = Guid.NewGuid(); Guid serverID = Guid.NewGuid(); WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID); workspaceItem.IsWorkflowSaved = true; //------------Execute Test--------------------------- XElement xElement = workspaceItem.ToXml(); //------------Assert Results------------------------- Assert.IsNotNull(xElement); Assert.AreEqual(xElement.Name, "WorkspaceItem"); Assert.AreEqual(workspaceItem.ID.ToString(), xElement.Attribute("ID").Value); Assert.AreEqual(workspaceID.ToString(), xElement.Attribute("WorkspaceID").Value); Assert.AreEqual(serverID.ToString(), xElement.Attribute("ServerID").Value); Assert.AreEqual(environmentID.ToString(), xElement.Attribute("EnvironmentID").Value); Assert.AreEqual(workspaceItem.Action.ToString(), xElement.Attribute("Action").Value); }
// 2012.10.18 - 5782: TWR public string UpdateWorkspaceItem(string itemXml, string roles) { dynamic xmlResponse = new UnlimitedObject(Resources.DynamicService_ServiceResponseTag); if(string.IsNullOrEmpty(itemXml)) { xmlResponse.Error = "Invalid workspace item definition"; } else { try { var workspaceItem = new WorkspaceItem(XElement.Parse(itemXml)); if(workspaceItem.WorkspaceID != _workspace.ID) { xmlResponse.Error = "Cannot update a workspace item from another workspace"; } else { _workspace.Update(workspaceItem, roles); xmlResponse.Response = "Workspace item updated"; } } catch(Exception ex) { xmlResponse.Error = "Error updating workspace item"; xmlResponse.ErrorDetail = ex.Message; xmlResponse.ErrorStackTrace = ex.StackTrace; } } return xmlResponse.XmlString; }
private void AddWorkspaceItem(IContextualResourceModel model) { // TODO: Check model server uri IWorkspaceItem workspaceItem = WorkspaceItems.FirstOrDefault(wi => wi.ServiceName == model.ResourceName); if (workspaceItem != null) return; var context = (IStudioClientContext)model.Environment.DsfChannel; workspaceItem = new WorkspaceItem(context.AccountID, context.ServerID) { ServiceName = model.ResourceName, ServiceType = model.ResourceType == ResourceType.Source ? WorkspaceItem.SourceServiceType : WorkspaceItem.ServiceServiceType, }; WorkspaceItems.Add(workspaceItem); SaveWorkspaceItems(); }