public void ServerExplorerItem_GetHashCode_ExpectHashCodeSameAsID()
{
//------------Setup for test--------------------------
var guid = Guid.NewGuid();
const string name = "a";
const ResourceType explorerItemType = ResourceType.PluginService;
var children = new List<IExplorerItem>();
const Permissions permissions = Permissions.DeployFrom;
//------------Execute Test---------------------------
var serverExplorerItem = new ServerExplorerItem(name, guid, explorerItemType, children, permissions, "");
//------------Assert Results-------------------------
Assert.AreEqual(guid.GetHashCode(), serverExplorerItem.GetHashCode());
}
public void FetchExplorerItems_Execute_ExpectName()
{
//------------Setup for test--------------------------
var fetchExplorerItems = new FetchExplorerItems();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock<IExplorerServerResourceRepository>();
var ws = new Mock<IWorkspace>();
repo.Setup(a => a.Load(It.IsAny<Guid>())).Returns(item).Verifiable();
var serializer = new Dev2JsonSerializer();
ws.Setup(a => a.ID).Returns(Guid.Empty);
fetchExplorerItems.ServerExplorerRepo = repo.Object;
//------------Execute Test---------------------------
var ax = fetchExplorerItems.Execute(new Dictionary<string, StringBuilder>(), ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.Load(It.IsAny<Guid>()));
Assert.AreEqual(serializer.Deserialize<IExplorerItem>(ax.ToString()).ResourceId, item.ResourceId);
}
public void GetVersions_Execute_ExpectName()
{
//------------Setup for test--------------------------
var getVersions = new GetVersions();
var resourceId = Guid.NewGuid();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock<IServerVersionRepository>();
var ws = new Mock<IWorkspace>();
repo.Setup(a => a.GetVersions(resourceId)).Returns(new List<IExplorerItem> {item});
var serializer = new Dev2JsonSerializer();
ws.Setup(a => a.ID).Returns(Guid.Empty);
getVersions.ServerVersionRepo = repo.Object;
//------------Execute Test---------------------------
var ax = getVersions.Execute(new Dictionary<string, StringBuilder> {{"resourceId",new StringBuilder( resourceId.ToString())}}, ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.GetVersions(It.IsAny<Guid>()));
Assert.AreEqual(serializer.Deserialize<IList<IExplorerItem>>(ax.ToString())[0].ResourceId, item.ResourceId);
}
public void ServerExplorerItem_Constructor_Construct_ExpectAllFieldsAreSetup()
{
//------------Setup for test--------------------------
var guid = Guid.NewGuid();
const string name = "a";
const ResourceType explorerItemType = ResourceType.Folder;
var children = new List<IExplorerItem>();
const Permissions permissions = Permissions.DeployFrom;
//------------Execute Test---------------------------
var serverExplorerItem = new ServerExplorerItem(name, guid, explorerItemType, children, permissions, "/");
//------------Assert Results-------------------------
Assert.AreEqual(children, serverExplorerItem.Children);
Assert.AreEqual(name, serverExplorerItem.DisplayName);
Assert.AreEqual(serverExplorerItem.ResourceType, explorerItemType);
Assert.AreEqual(permissions, serverExplorerItem.Permissions);
Assert.AreEqual(guid, serverExplorerItem.ResourceId);
}
public void CreateFolder_Execute_ExpectCreateCalled()
{
//------------Setup for test--------------------------
var createFolderService = new AddFolderService();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock<IExplorerServerResourceRepository>();
var ws = new Mock<IWorkspace>();
repo.Setup(a => a.AddItem(item, It.IsAny<Guid>())).Returns(new ExplorerRepositoryResult(ExecStatus.Fail, "noddy"));
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary<string, StringBuilder>();
inputs.Add("itemToAdd", serializer.SerializeToBuilder(item));
ws.Setup(a => a.ID).Returns(Guid.Empty);
createFolderService.ServerExplorerRepo = repo.Object;
//------------Execute Test---------------------------
createFolderService.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.AddItem(It.IsAny<IExplorerItem>(), It.IsAny<Guid>()));
}
public void ServerExplorerItem_Equals_ExpectEqualityOnGuidOnly()
{
//------------Setup for test--------------------------
var guid = Guid.NewGuid();
const string name = "a";
const ResourceType explorerItemType = ResourceType.PluginService;
var children = new List<IExplorerItem>();
const Permissions permissions = Permissions.DeployFrom;
//------------Execute Test---------------------------
var serverExplorerItem = new ServerExplorerItem(name, guid, explorerItemType, children, permissions, "");
var serverExplorerItem2 = new ServerExplorerItem(name, guid, explorerItemType, children, Permissions.Administrator, "");
var serverExplorerItem3 = new ServerExplorerItem(name, Guid.NewGuid(), explorerItemType, children, permissions, "");
//------------Assert Results-------------------------
Assert.AreEqual(serverExplorerItem, serverExplorerItem2);
Assert.AreNotEqual(serverExplorerItem, null);
Assert.AreEqual(serverExplorerItem, serverExplorerItem);
Assert.AreNotEqual(serverExplorerItem, guid);
Assert.AreNotEqual(serverExplorerItem, serverExplorerItem3);
}
public void StudioResourceRepository_GetEnvironmentModel_HasMatchingID_ReturnsTrue()
{
//------------Setup for test--------------------------
var environmentModel = new Mock<IEnvironmentModel>();
var environmentId = Guid.NewGuid();
environmentModel.Setup(model => model.ID).Returns(environmentId);
var mockConnection = new Mock<IEnvironmentConnection>();
mockConnection.Setup(connection => connection.WebServerUri).Returns(new Uri("http://bob:3142/"));
var serverID = Guid.NewGuid();
mockConnection.Setup(connection => connection.ServerID).Returns(serverID);
environmentModel.Setup(a => a.Connection).Returns(mockConnection.Object);
ServerExplorerItem serverExplorerItem = new ServerExplorerItem { WebserverUri = "http://bob:3142/", ServerId = serverID };
//------------Execute Test---------------------------
var found = StudioResourceRepository.GetEnvironmentModel(environmentModel.Object, serverExplorerItem, environmentId);
//------------Assert Results-------------------------
Assert.IsTrue(found);
}
private IList<IExplorerItem> BuildStructureFromFilePath(IDirectory directory, string path, string rootPath)
{
var firstGen =
directory.GetDirectories(path)
.Where(a => !a.EndsWith("VersionControl"));
IList<IExplorerItem> children = new List<IExplorerItem>();
foreach(var resource in firstGen)
{
var resourcePath = resource.Replace(rootPath, "").Substring(1);
var node = new ServerExplorerItem(new DirectoryInfo(resource).Name, Guid.NewGuid(), ResourceType.Folder, null, _authService.GetResourcePermissions(Guid.Empty), resourcePath);
children.Add(node);
node.Children = BuildStructureFromFilePath(directory, resource, rootPath);
}
return children;
}
public void StudioResourceRepository_UpdateRootAndFoldersPermissions_SetPermissionsToView_ExplorerItemsAreUpdatedToView()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.Server,
DisplayName = "Azure server",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
repo.GetCurrentEnvironment = () => Guid.Empty;
//------------Execute Test---------------------------
repo.UpdateRootAndFoldersPermissions(Permissions.View, Guid.Empty);
//------------Assert Results-------------------------
var permissions = repo.ExplorerItemModels.First().Descendants().Select(s => s.Permissions);
Assert.IsTrue(permissions.All(p => p == Permissions.View));
}
private IExplorerItem GetTestData(string workFlowId = "DF279411-F678-4FCC-BE88-A1B613EE51E3",
string dbServiceId = "DF279411-F678-4FCC-BE88-A1B613EE51E3", Guid? folderID = null)
{
var workflow1 = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "workflow1",
ResourceId = string.IsNullOrEmpty(workFlowId) ? Guid.NewGuid() : Guid.Parse(workFlowId),
Permissions = Permissions.Administrator
};
var dbService1 = new ServerExplorerItem { ResourceType = ResourceType.DbService, DisplayName = "dbService1", ResourceId = string.IsNullOrEmpty(dbServiceId) ? Guid.NewGuid() : Guid.Parse(dbServiceId), Permissions = Permissions.Contribute };
var webService1 = new ServerExplorerItem { ResourceType = ResourceType.WebService, DisplayName = "webService1", ResourceId = Guid.NewGuid(), Permissions = Permissions.View };
var pluginService1 = new ServerExplorerItem { ResourceType = ResourceType.PluginService, DisplayName = "pluginService1", ResourceId = Guid.NewGuid(), Permissions = Permissions.View };
var dbSource1 = new ServerExplorerItem { ResourceType = ResourceType.DbSource, DisplayName = "dbSource1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var webSource1 = new ServerExplorerItem { ResourceType = ResourceType.WebSource, DisplayName = "webSource1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var pluginSource1 = new ServerExplorerItem { ResourceType = ResourceType.PluginSource, DisplayName = "pluginSource1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var emailSource1 = new ServerExplorerItem { ResourceType = ResourceType.EmailSource, DisplayName = "emailSource1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var serverSource1 = new ServerExplorerItem { ResourceType = ResourceType.ServerSource, DisplayName = "serverSource1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var folder1 = new ServerExplorerItem { ResourceType = ResourceType.Folder, DisplayName = "folder1", ResourceId = folderID ?? Guid.NewGuid(), Permissions = Permissions.Administrator };
var folder2 = new ServerExplorerItem { ResourceType = ResourceType.Folder, DisplayName = "folder2", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var subfolder1 = new ServerExplorerItem { ResourceType = ResourceType.Folder, DisplayName = "subfolder1", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
var localhost = new ServerExplorerItem { ResourceType = ResourceType.Server, DisplayName = "localhost", ResourceId = Guid.NewGuid(), Permissions = Permissions.Administrator };
dbService1.Parent = webService1.Parent = pluginService1.Parent = subfolder1.Parent = folder1;
dbSource1.Parent = webSource1.Parent = pluginSource1.Parent = emailSource1.Parent = serverSource1.Parent = folder2;
folder2.Children = new List<IExplorerItem>
{
dbSource1,
webSource1,
pluginSource1,
emailSource1,
serverSource1
};
folder1.Children = new List<IExplorerItem>
{
dbService1,
webService1,
pluginService1,
subfolder1
};
localhost.Children = new List<IExplorerItem> { folder1, workflow1 };
workflow1.Parent = localhost;
folder1.Parent = localhost;
return localhost;
}
public void ServerExplorerRepository_RenameFolder_FilesystemError_ExpectFailureMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
ResourceCatalogResult resourceCatalogResult = new ResourceCatalogResult { Status = ExecStatus.Success, Message = "" };
catalogue.Setup(catalog => catalog.RenameCategory(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>())).Returns(resourceCatalogResult);
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var guid = Guid.NewGuid();
var explorerItem = new ServerExplorerItem(
"dave", guid,
ResourceType.DbSource,
new List<IExplorerItem>()
, Permissions.Administrator, "bob"
);
factory.Setup(a => a.CreateRootExplorerItem(It.IsAny<string>(), It.IsAny<Guid>())).Returns(explorerItem);
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(true);
dir.Setup(a => a.Delete(It.IsAny<string>(), It.IsAny<bool>())).Throws(new FieldAccessException("bob has an error")).Verifiable();
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
//------------Execute Test---------------------------
var result = serverExplorerRepository.RenameFolder("monkey", "moocowimpi", Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "bob has an error");
Assert.AreEqual(result.Status, ExecStatus.AccessViolation);
}
public void StudioResourceRepository_GetServerVersion_CallsProxy_ReturnsDefault_IfError()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty,
GetEnvironmentRepository = () => new Mock<IEnvironmentRepository>().Object
};
var env = Guid.NewGuid();
mockExplorerResourceRepository.Setup(a => a.GetServerVersion()).Throws(new Exception());
//------------Execute Test---------------------------
Assert.AreEqual("Less than 0.4.19.1", repo.GetServerVersion(env));
mockExplorerResourceRepository.Verify(a=>a.GetServerVersion());
}
public void StudioResourceRepository_GetVersion_VersionIsNull_ThrowsException()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
//------------Execute Test---------------------------
repo.GetVersion(null, Guid.Empty);
}
protected bool Equals(ServerExplorerItem other)
{
return(ResourceId.Equals(other.ResourceId));
}
protected bool Equals(ServerExplorerItem other)
{
return ResourceId.Equals(other.ResourceId);
}
public void GetDirectoriesRelativeToServer_UnitTest_ExecuteWithDirectory_ExpectDirectoryStructure()
{
//----------------Setup---------------------------------------------
var esb = new GetDirectoriesRelativeToServer();
Mock<IExplorerServerResourceRepository> mockRepo = new Mock<IExplorerServerResourceRepository>();
ServerExplorerItem serverExplorerItem = new ServerExplorerItem();
serverExplorerItem.ResourceType = ResourceType.Server;
ServerExplorerItem levelOneFolder = new ServerExplorerItem();
levelOneFolder.ResourceType = ResourceType.Folder;
levelOneFolder.DisplayName = "Test1";
levelOneFolder.ResourcePath = "Test1";
serverExplorerItem.Children.Add(levelOneFolder);
IExplorerItem levelOneFolderTwo = new ServerExplorerItem();
levelOneFolderTwo.ResourceType = ResourceType.Folder;
levelOneFolderTwo.DisplayName = "Test2";
levelOneFolderTwo.ResourcePath = "Test2";
ServerExplorerItem levelTwoFolderInFolderTwo = new ServerExplorerItem();
levelTwoFolderInFolderTwo.ResourceType = ResourceType.Folder;
levelTwoFolderInFolderTwo.DisplayName = "InnerTest2";
levelTwoFolderInFolderTwo.ResourcePath = levelOneFolderTwo.ResourcePath + "\\InnerTest2";
levelOneFolderTwo.Children.Add(levelTwoFolderInFolderTwo);
serverExplorerItem.Children.Add(levelOneFolderTwo);
mockRepo.Setup(repository => repository.Load(ResourceType.Folder, It.IsAny<string>())).Returns(serverExplorerItem);
esb.ServerExplorerRepo = mockRepo.Object;
//----------------Execute------------------------------------------------
var actual = esb.Execute(new Dictionary<string, StringBuilder> { { "Directory", new StringBuilder("Resources") } }, null);
//----------------Assert Results-----------------------------------------
Assert.AreNotEqual(string.Empty, actual);
const string expected = @"<JSON>{
""$type"": ""Dev2.Runtime.ESB.Management.Services.JsonTreeNode, Dev2.Runtime.Services"",
""title"": ""Root"",
""isFolder"": true,
""key"": ""root"",
""isLazy"": false,
""children"": [
{
""$type"": ""Dev2.Runtime.ESB.Management.Services.JsonTreeNode, Dev2.Runtime.Services"",
""title"": ""Test1"",
""isFolder"": true,
""key"": ""Test1"",
""isLazy"": false,
""children"": []
},
{
""$type"": ""Dev2.Runtime.ESB.Management.Services.JsonTreeNode, Dev2.Runtime.Services"",
""title"": ""Test2"",
""isFolder"": true,
""key"": ""Test2"",
""isLazy"": false,
""children"": [
{
""$type"": ""Dev2.Runtime.ESB.Management.Services.JsonTreeNode, Dev2.Runtime.Services"",
""title"": ""InnerTest2"",
""isFolder"": true,
""key"": ""Test2\\\\InnerTest2"",
""isLazy"": false,
""children"": []
}
]
}
]
}</JSON>
";
var actuals = actual.ToString().Trim();
Assert.AreEqual(expected.Trim(), actuals);
}
protected bool Equals(ServerExplorerItem other) => ResourceId.Equals(other.ResourceId);
public void ServerExplorerRepository_CreateItem_FileSystemException_ExpectErrorMessageFromException()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(false);
dir.Setup(a => a.CreateIfNotExists(It.IsAny<string>())).Throws(new FileNotFoundException("bobe"));
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
var item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom,
"/bob/dave");
//------------Execute Test---------------------------
var result = serverExplorerRepository.AddItem(item, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "bobe");
Assert.AreEqual(result.Status, ExecStatus.Fail);
dir.Verify(a => a.Exists(It.IsAny<string>()));
dir.Verify(a => a.CreateIfNotExists(It.IsAny<string>()));
}
public void AddResouceItem(IContextualResourceModel resourceModel)
{
var explorerItemModel = new ServerExplorerItem { ResourcePath = resourceModel.Category, DisplayName = resourceModel.DisplayName, ResourceId = resourceModel.ID, Permissions = resourceModel.UserPermissions,ServerId = resourceModel.Environment.ID};
ResourceType resourceType;
Enum.TryParse(resourceModel.ServerResourceType, out resourceType);
explorerItemModel.ResourceType = resourceType;
ItemAddedMessageHandler(explorerItemModel);
}
public IExplorerItem BuildRoot()
{
ServerExplorerItem serverExplorerItem = new ServerExplorerItem(RootName, Guid.Empty, ResourceType.Server, new List<IExplorerItem>(), _authService.GetResourcePermissions(Guid.Empty), "") { ServerId = HostSecurityProvider.Instance.ServerID, WebserverUri = EnvironmentVariables.WebServerUri };
return serverExplorerItem;
}
public void StudioResourceRepository_ShowVersionHistory_NoItemsReturned_InfoItemAttachedToParent()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
mockVersionRepository.Setup(m => m.GetVersions(It.IsAny<Guid>())).Returns(new List<IExplorerItem>());
var superWFId = Guid.NewGuid();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = superWFId,
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
//------------Execute Test---------------------------
repo.ShowVersionHistory(Guid.Empty, superWFId);
//------------Assert Results-------------------------
var actual = repo.FindItemById(superWFId);
Assert.AreEqual(1, actual.Children.Count);
Assert.AreEqual("There is no version history to display", actual.Children[0].DisplayName);
}
public void MoveItem_Execute_ExpectRename()
{
//------------Setup for test--------------------------
var MoveItemService = new MoveItemService();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock<IExplorerServerResourceRepository>();
var ws = new Mock<IWorkspace>();
repo.Setup(a => a.MoveItem(It.IsAny<IExplorerItem>(), It.IsAny<string>(), It.IsAny<Guid>())).Returns(new ExplorerRepositoryResult(ExecStatus.Success, "")).Verifiable();
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary<string, StringBuilder>
{
{
"itemToMove", serializer.SerializeToBuilder(item)
},
{
"newPath", new StringBuilder("bob")
}
};
ws.Setup(a => a.ID).Returns(Guid.Empty);
MoveItemService.ServerExplorerRepo = repo.Object;
//------------Execute Test---------------------------
MoveItemService.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.MoveItem(It.IsAny<IExplorerItem>(), It.IsAny<string>(), It.IsAny<Guid>()));
}
public void StudioResourceRepository_HideHistory_ClearsChildren()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var superWFId = Guid.NewGuid();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = superWFId,
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER",
Children = new List<IExplorerItem>
{
new ServerExplorerItem{ ResourceType = ResourceType.WebService, DisplayName = "v2 2012-10-10 Save", ResourceId = Guid.NewGuid(), Permissions = Permissions.View },
new ServerExplorerItem{ ResourceType = ResourceType.WebService, DisplayName = "v2 2012-10-10 Save", ResourceId = Guid.NewGuid(), Permissions = Permissions.View }
}
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
//------------Execute Test---------------------------
repo.HideVersionHistory(Guid.Empty, superWFId);
//------------Assert Results-------------------------
var actual = repo.FindItemById(superWFId);
Assert.AreEqual(0, actual.Children.Count);
}
public void ServerExplorerRepository_CreateItem_ValidFolder_ExpectCreatedFolder()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var sync = new Mock<IExplorerRepositorySync>();
sync.Setup(m => m.AddItemMessage(It.IsAny<IExplorerItem>())).Verifiable();
var dir = new Mock<IDirectory>();
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(false);
dir.Setup(a => a.CreateIfNotExists(It.IsAny<string>()));
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
var item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom,
"/bob/dave");
//------------Execute Test---------------------------
var result = serverExplorerRepository.AddItem(item, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "");
Assert.AreEqual(result.Status, ExecStatus.Success);
dir.Verify(a => a.Exists(It.IsAny<string>()));
dir.Verify(a => a.CreateIfNotExists(It.IsAny<string>()));
sync.Verify(m => m.AddItemMessage(It.IsAny<IExplorerItem>()), Times.Once());
}
public void StudioResourceRepository_DeleteVersion_TwoItemsReturned_ItemsAttachedToParent()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var v1 = new Mock<IVersionInfo>();
v1.Setup(v => v.VersionNumber).Returns("1");
var v2 = new Mock<IVersionInfo>();
v2.Setup(v => v.VersionNumber).Returns("2");
mockVersionRepository.Setup(m => m.DeleteVersion(It.IsAny<Guid>(), It.IsAny<string>()))
.Returns(new List<IExplorerItem>
{
new ServerExplorerItem { ResourceType = ResourceType.WebService, DisplayName = "v2 2012-10-10 Save", ResourceId = Guid.NewGuid(), Permissions = Permissions.View, VersionInfo = v1.Object },
new ServerExplorerItem { ResourceType = ResourceType.WebService, DisplayName = "v1 2012-10-10 Save", ResourceId = Guid.NewGuid(), Permissions = Permissions.View , VersionInfo = v2.Object }
})
.Verifiable();
var superWFId = Guid.NewGuid();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = superWFId,
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
var versionInfo = new VersionInfo
{
DateTimeStamp = DateTime.Now,
Reason = "Rollback",
ResourceId = superWFId,
User = "",
VersionId = Guid.NewGuid(),
VersionNumber = "3"
};
//------------Execute Test---------------------------
repo.DeleteVersion(versionInfo, Guid.Empty);
//------------Assert Results-------------------------
var actual = repo.FindItemById(superWFId);
Assert.AreEqual(2, actual.Children.Count);
mockVersionRepository.Verify(m => m.DeleteVersion(It.IsAny<Guid>(), It.IsAny<string>()), Times.Once());
}
public void StudioResourceRepository_MoveItem_ParentExistsOnTree_AddedSuccessfully()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.Folder,
DisplayName = "SUB FOLDER",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\SUB FOLDER"
};
var mockResourceRepo = SetupEnvironmentRepo(Guid.Empty);
mockResourceRepo.Setup(repository => repository.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), false)).Returns(new Mock<IResourceModel>().Object);
mockResourceRepo.Setup(repository => repository.ReloadResource(It.IsAny<Guid>(), It.IsAny<Studio.Core.AppResources.Enums.ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>()));
// ReSharper disable ObjectCreationAsStatement
mockExplorerResourceRepository.Setup(a => a.MoveItem(It.IsAny<IExplorerItem>(), It.IsAny<string>(), Guid.Empty)).Returns(new ExplorerRepositoryResult(ExecStatus.Success, ""));
new StudioResourceRepository(parent, Guid.Empty, _invoke)
// ReSharper restore ObjectCreationAsStatement
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
var studioResourceRepository = StudioResourceRepository.Instance;
//------------Execute Test---------------------------
var itemToMove = new ExplorerItemModel(studioResourceRepository, new Mock<IAsyncWorker>().Object,
new Mock<IConnectControlSingleton>().Object)
{
ResourcePath = "dave",
DisplayName = "dave\bob",
Children = new ObservableCollection<IExplorerItemModel> { new ExplorerItemModel(new Mock<IConnectControlSingleton>().Object, studioResourceRepository) },
Parent = new ExplorerItemModel { Children = new ObservableCollection<IExplorerItemModel>() }
};
Assert.AreEqual(itemToMove.Children.Count, 1);
studioResourceRepository.MoveItem(itemToMove, "bob");
mockExplorerResourceRepository.Verify(a => a.MoveItem(It.IsAny<IExplorerItem>(), "bob", Guid.Empty));
Assert.AreEqual(itemToMove.Children.Count,0);
}
public void StudioResourceRepository_GetVersion_CallsVersionOnTheProxy()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
mockVersionRepository.Setup(m => m.GetVersion(It.IsAny<IVersionInfo>())).Verifiable();
var superWFId = Guid.NewGuid();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.WorkflowService,
DisplayName = "SuperWF",
ResourceId = superWFId,
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
var versionInfo = new VersionInfo
{
DateTimeStamp = DateTime.Now,
Reason = "Rollback",
ResourceId = superWFId,
User = "",
VersionId = Guid.NewGuid(),
VersionNumber = "3"
};
//------------Execute Test---------------------------
repo.GetVersion(versionInfo, superWFId);
//------------Assert Results-------------------------
mockVersionRepository.Verify(m => m.GetVersion(It.IsAny<IVersionInfo>()), Times.Once());
}
public void StudioResourceRepository_ItemAddedMessageHandler_ItemNotServerNode_AddedSuccessfully()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.Folder,
DisplayName = "SUB FOLDER",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\SUB FOLDER"
};
var mockResourceRepo = SetupEnvironmentRepo(Guid.Empty);
mockResourceRepo.Setup(repository => repository.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), false)).Returns(new Mock<IResourceModel>().Object);
mockResourceRepo.Setup(repository => repository.ReloadResource(It.IsAny<Guid>(), It.IsAny<Studio.Core.AppResources.Enums.ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>()));
// ReSharper disable ObjectCreationAsStatement
new StudioResourceRepository(parent, Guid.Empty, _invoke)
// ReSharper restore ObjectCreationAsStatement
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
var studioResourceRepository = StudioResourceRepository.Instance;
var before = studioResourceRepository.ExplorerItemModels[0].Children.Count();
//------------Execute Test---------------------------
studioResourceRepository.ItemAddedMessageHandler(new ServerExplorerItem
{
DisplayName = "TEST FOLDER",
ResourcePath = "MANFOLDER\\SUB FOLDER\\TEST FOLDER",
ResourceId = Guid.NewGuid()
});
var after = studioResourceRepository.ExplorerItemModels[0].Children.Count();
//------------Assert Results-------------------------
mockResourceRepo.Verify(repository => repository.ReloadResource(It.IsAny<Guid>(), It.IsAny<Studio.Core.AppResources.Enums.ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>()), Times.Never());
Assert.AreEqual(0, before);
Assert.AreEqual(1, after);
}
public void ServerExplorerRepository_CreateItem_InvalidItemType_ExpectErrorResult()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(false);
var sync = new Mock<IExplorerRepositorySync>();
sync.Setup(m => m.AddItemMessage(It.IsAny<IExplorerItem>())).Verifiable();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
var item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.ReservedService, null, Permissions.DeployFrom,
"/bob/dave");
//------------Execute Test---------------------------
var result = serverExplorerRepository.AddItem(item, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "Only user resources can be added from this repository");
Assert.AreEqual(result.Status, ExecStatus.Fail);
sync.Verify(m => m.AddItemMessage(It.IsAny<IExplorerItem>()), Times.Never());
}
public void StudioResourceRepository_ItemAddedMessageHandler_ParentDoesNotExistsOnTree_NotAdded()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.Folder,
DisplayName = "SUB FOLDER",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\APRIL WORK\\SUB FOLDER"
};
SetupEnvironmentRepo(Guid.Empty);
var repo = new StudioResourceRepository(parent, Guid.Empty, _invoke)
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
repo.GetCurrentEnvironment = () => Guid.Empty;
var studioResourceRepository = StudioResourceRepository.Instance;
var before = studioResourceRepository.ExplorerItemModels[0].Children.Count();
//------------Execute Test---------------------------
studioResourceRepository.ItemAddedMessageHandler(new ServerExplorerItem
{
DisplayName = "TEST FOLDER",
ResourcePath = "MANFOLDER\\APRIL\\TEST FOLDER"
});
var after = studioResourceRepository.ExplorerItemModels[0].Children.Count();
//------------Assert Results-------------------------
Assert.AreEqual(0, before);
Assert.AreEqual(0, after);
}
public void StudioResourceRepository_ItemAddedMessageHandler_ItemNotFoundInResourceRepo_Workflow_AddedSuccessfully()
{
//------------Setup for test--------------------------
var mockExplorerResourceRepository = new Mock<IClientExplorerResourceRepository>();
var mockVersionRepository = new Mock<IVersionRepository>();
var parent = new ServerExplorerItem
{
ResourceType = ResourceType.Folder,
DisplayName = "SUB FOLDER",
ResourceId = Guid.NewGuid(),
Permissions = Permissions.Contribute,
ResourcePath = "MANFOLDER\\SUB FOLDER"
};
var mockResourceRepo = SetupEnvironmentRepo(Guid.Empty);
mockResourceRepo.Setup(repository => repository.ReloadResource(It.IsAny<Guid>(), It.Is<Studio.Core.AppResources.Enums.ResourceType>(type => type == Studio.Core.AppResources.Enums.ResourceType.WorkflowService), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>()));
// ReSharper disable ObjectCreationAsStatement
new StudioResourceRepository(parent, Guid.Empty, _invoke)
// ReSharper restore ObjectCreationAsStatement
{
GetVersionProxy = id => mockVersionRepository.Object,
GetExplorerProxy = id => mockExplorerResourceRepository.Object,
GetCurrentEnvironment = () => Guid.Empty
};
var studioResourceRepository = StudioResourceRepository.Instance;
//------------Execute Test---------------------------
studioResourceRepository.ItemAddedMessageHandler(new ServerExplorerItem
{
DisplayName = "TEST FOLDER",
ResourcePath = "MANFOLDER\\SUB FOLDER\\TEST FOLDER",
ResourceType = ResourceType.WorkflowService
});
//------------Assert Results-------------------------
mockResourceRepo.Verify(repository => repository.ReloadResource(It.IsAny<Guid>(), It.Is<Studio.Core.AppResources.Enums.ResourceType>(type => type == Studio.Core.AppResources.Enums.ResourceType.WorkflowService), It.IsAny<IEqualityComparer<IResourceModel>>(), It.IsAny<bool>()), Times.Once());
}
public ServerExplorerItem CreateResourceItem(IResource resource)
{
Guid resourceId = resource.ResourceID;
var childNode = new ServerExplorerItem(resource.ResourceName, resourceId, resource.ResourceType == ResourceType.Server ? ResourceType.ServerSource : resource.ResourceType, null,
_authService.GetResourcePermissions(resourceId), resource.ResourcePath);
return childNode;
}
