static ServerExplorerRepository()
{
Instance = new ServerExplorerRepository
{
ResourceCatalogue = ResourceCatalog.Instance,
TestCatalog = Runtime.TestCatalog.Instance,
ExplorerItemFactory = new ExplorerItemFactory(ResourceCatalog.Instance, new DirectoryWrapper(), ServerAuthorizationService.Instance),
Directory = new DirectoryWrapper(),
VersionRepository = new ServerVersionRepository(new VersionStrategy(), ResourceCatalog.Instance, new DirectoryWrapper(), EnvironmentVariables.GetWorkspacePath(GlobalConstants.ServerWorkspaceID), new FileWrapper())
};
}
public void ServerExplorerRepository_Constructor_ExpectValid()
{
//------------Setup for test--------------------------
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var catalogue = new Mock<IResourceCatalog>();
// ReSharper disable ObjectCreationAsStatement
var sync = new Mock<IExplorerRepositorySync>();
var repo = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object,new FileWrapper());
Assert.AreEqual(repo.Directory, dir.Object);
Assert.AreEqual(repo.ResourceCatalogue, catalogue.Object);
// ReSharper restore ObjectCreationAsStatement
}
public void MoveVersions(Guid resourceId, string newPath)
{
var resource = _catalogue.GetResource(Guid.Empty, resourceId);
if (resource == null || resource.VersionInfo == null)
{
return;
}
var path = GetVersionFolderFromResource(resource);
// ReSharper disable ImplicitlyCapturedClosure
var files = _directory.GetFiles(path).Where(a => a.Contains(resource.VersionInfo.VersionId.ToString()));
var versionPath = Path.Combine(ServerExplorerRepository.DirectoryStructureFromPath(newPath), "VersionControl");
if (!_directory.Exists(versionPath))
{
_directory.CreateIfNotExists(versionPath);
}
// ReSharper restore ImplicitlyCapturedClosure
IEnumerable <string> enumerable = files as IList <string> ?? files.ToList();
// ReSharper disable once AssignNullToNotNullAttribute
enumerable.ForEach(a => _file.Move(a, Path.Combine(versionPath, Path.GetFileName(a))));
}
public void ServerExplorerRepository_DeleteFolder_NestedItemsRecursiveNestedFails_ExpectFailue()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var res = new Mock<IResource>();
var guid = Guid.NewGuid();
res.Setup(a => a.ResourceName).Returns("mona");
res.Setup(a => a.ResourcePath).Returns("bob");
res.Setup(a => a.ResourceID).Returns(guid);
res.Setup(a => a.ResourceType).Returns(ResourceType.EmailSource);
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(true);
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
catalogue.Setup(a => a.GetResourceList(It.IsAny<Guid>())).Returns(new List<IResource> { res.Object });
catalogue.Setup(a => a.DeleteResource(It.IsAny<Guid>(), "mona", ResourceType.EmailSource.ToString(), null, true)).Returns(new ResourceCatalogResult { Status = ExecStatus.Fail, Message = "fanta" }).Verifiable();
//------------Execute Test---------------------------
res.Setup(a => a.ResourcePath).Returns("bob\\");
var result = serverExplorerRepository.DeleteFolder("bob", true, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "Failed to delete child items");
Assert.AreEqual(result.Status, ExecStatus.Fail);
catalogue.Verify(a => a.DeleteResource(It.IsAny<Guid>(), "mona", ResourceType.EmailSource.ToString(), null, true));
dir.Verify(a => a.Delete(It.IsAny<string>(), true), Times.Never());
}
public void ServerExplorerRepository_DeleteFolder_Root_ExpectFailureMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var res = new Mock<IResource>();
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(true);
catalogue.Setup(a => a.GetResourceList(It.IsAny<Guid>())).Returns(new List<IResource> { res.Object });
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---------------------------
res.Setup(a => a.ResourcePath).Returns("bob");
var result = serverExplorerRepository.DeleteFolder(" ", false, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "You may not delete the root path");
Assert.AreEqual(result.Status, ExecStatus.Fail);
}
public void ServerExplorerRepository_DeleteFolder_NonExistent_ExpectFailureMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var res = new Mock<IResource>();
dir.Setup(a => a.Exists(It.IsAny<string>())).Returns(false);
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---------------------------
res.Setup(a => a.ResourcePath).Returns("bob");
var result = serverExplorerRepository.DeleteFolder("bob", false, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "Requested folder does not exist on server. Folder: " + "bob");
Assert.AreEqual(result.Status, ExecStatus.Fail);
}
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 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 ServerExplorerRepository_RenameItem_DuplicateExists_AssertItemCallCorrectMethods_ExpectErrorMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var guid = Guid.NewGuid();
var res = new Mock<IResource>();
res.Setup(a => a.ResourceName).Returns("dave");
res.Setup(a => a.ResourcePath).Returns("bob");
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);
catalogue.Setup(a => a.GetResource(It.IsAny<Guid>(), guid)).Returns(res.Object);
catalogue.Setup(a => a.RenameResource(It.IsAny<Guid>(), guid, "dave")).Returns(new ResourceCatalogResult { Message = "moo", Status = ExecStatus.AccessViolation }).Verifiable();
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
catalogue.Setup(a => a.GetResourceList(It.IsAny<Guid>())).Returns(new List<IResource> { res.Object });
//------------Execute Test---------------------------
var result = serverExplorerRepository.RenameItem(explorerItem, "dave", Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual("There is an item that exists with the same name and path", result.Message);
Assert.AreEqual(result.Status, ExecStatus.Fail);
}
public void ServerExplorerRepository_RenameFolder_FolderDoesNotexist_ExpectFailureMessage()
{
//------------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>();
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, "Requested folder does not exist on server. Folder: monkey");
Assert.AreEqual(result.Status, ExecStatus.NoMatch);
}
public void ServerExplorerRepository_RenameFolder_ResourceCatalogFailure_ErrorReturnedNoDelete()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
ResourceCatalogResult resourceCatalogResult = new ResourceCatalogResult { Status = ExecStatus.Fail, Message = "Error Renaming" };
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 res = new Mock<IResource>();
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.Move(It.IsAny<string>(), It.IsAny<string>())).Verifiable();
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
catalogue.Setup(a => a.GetResourceList(It.IsAny<Guid>())).Returns(new List<IResource> { res.Object });
catalogue.Setup(a => a.SaveResource(It.IsAny<Guid>(), res.Object, null, It.IsAny<string>(), It.IsAny<string>())).Verifiable();
res.Setup(a => a.ResourcePath).Returns("monkey2");
//------------Execute Test---------------------------
var result = serverExplorerRepository.RenameFolder("monkey", "moocowimpi", Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "Error Renaming");
Assert.AreEqual(result.Status, ExecStatus.Fail);
dir.Verify(a => a.Delete(It.IsAny<string>(), It.IsAny<bool>()), Times.Never());
catalogue.Verify(a => a.RenameCategory(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once());
}
public void ServerExplorerRepository_DeleteItemFolder_AssertItemCallCorrectMethods_ExpectErrorMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var guid = Guid.NewGuid();
var explorerItem = new ServerExplorerItem(
"dave", guid,
ResourceType.Folder,
new List<IExplorerItem>()
, Permissions.Administrator, "bob"
);
factory.Setup(a => a.CreateRootExplorerItem(It.IsAny<string>(), It.IsAny<Guid>())).Returns(explorerItem);
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.DeleteItem(explorerItem, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "Requested folder does not exist on server. Folder: bob");
Assert.AreEqual(result.Status, ExecStatus.Fail);
}
public void ServerExplorerRepository_DeleteItem_AssertItemCallCorrectMethods_ExpectErrorMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
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);
catalogue.Setup(a => a.DeleteResource(It.IsAny<Guid>(), "dave", "DbSource", null,true)).Returns(new ResourceCatalogResult { Message = "bob", Status = ExecStatus.DuplicateMatch });
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.DeleteItem(explorerItem, Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "bob");
Assert.AreEqual(result.Status, ExecStatus.DuplicateMatch);
catalogue.Verify(a => a.DeleteResource(It.IsAny<Guid>(), "dave", "DbSource", null,true));
}
public void ServerExplorerRepository_MoveItem_ResourceDoesNotexist_ExpectErrorMessage()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var guid = Guid.NewGuid();
var res = new Mock<IResource>();
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);
catalogue.Setup(a => a.GetResource(It.IsAny<Guid>(), guid)).Returns(res.Object);
catalogue.Setup(a => a.RenameCategory(It.IsAny<Guid>(), "bob", "dave", It.IsAny<List<IResource>>()))
.Returns(new ResourceCatalogResult { Message = "moo", Status = ExecStatus.AccessViolation })
.Verifiable();
var sync = new Mock<IExplorerRepositorySync>();
var fileWrapper = new Mock<IFile>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, fileWrapper.Object);
catalogue.Setup(a => a.GetResourceList(It.IsAny<Guid>())).Returns(new List<IResource> { res.Object });
//------------Execute Test---------------------------
var result = serverExplorerRepository.MoveItem(explorerItem, "dave", Guid.NewGuid());
//------------Assert Results-------------------------
Assert.AreEqual(result.Message, "moo");
Assert.AreEqual(result.Status, ExecStatus.AccessViolation);
catalogue.Verify(a => a.RenameCategory(It.IsAny<Guid>(), "bob", "dave", It.IsAny<List<IResource>>()));
catalogue.Verify(a => a.GetResourceList(It.IsAny<Guid>()));
}
public void ServerExplorerRepository_MessageSubscription_ParamIsNull_ThrowsException()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var sync = new Mock<IExplorerRepositorySync>();
var repo = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
//------------Execute Test---------------------------
repo.MessageSubscription(null);
}
public void ServerExplorerRepository_RenameItem_VerifyNullThrowsException()
{
//------------Setup for test--------------------------
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var catalogue = new Mock<IResourceCatalog>();
// ReSharper disable ObjectCreationAsStatement
var sync = new Mock<IExplorerRepositorySync>();
var repo = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
var res = repo.RenameItem(null, "bob", Guid.NewGuid());
Assert.AreEqual(res.Status, ExecStatus.Fail);
Assert.AreEqual(res.Message, "Item to rename was null");
// ReSharper restore ObjectCreationAsStatement
}
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 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 ServerExplorerRepository_Load_FilteredTypeAndPath_AssertRootLevelIsFolder_ExpectFolder()
{
//------------Setup for test--------------------------
var catalogue = new Mock<IResourceCatalog>();
var factory = new Mock<IExplorerItemFactory>();
var dir = new Mock<IDirectory>();
var explorerItem = new ServerExplorerItem(
"d", Guid.NewGuid(),
ResourceType.Folder,
new List<IExplorerItem>
{
new ServerExplorerItem("Services", Guid.NewGuid(), ResourceType.Folder,
new List<IExplorerItem>(), Permissions.Administrator, "bob"),
new ServerExplorerItem("Bobs", Guid.NewGuid(), ResourceType.Folder, new List<IExplorerItem>(),
Permissions.Administrator, "bob")
}
, Permissions.Administrator, "bob"
);
var sync = new Mock<IExplorerRepositorySync>();
var serverExplorerRepository = new ServerExplorerRepository(catalogue.Object, factory.Object, dir.Object, sync.Object, new Mock<IServerVersionRepository>().Object, new FileWrapper());
factory.Setup(a => a.CreateRootExplorerItem(ResourceType.Folder, It.IsAny<string>(), It.IsAny<Guid>())).Returns(explorerItem);
//------------Execute Test---------------------------
var root = serverExplorerRepository.Load(ResourceType.Folder, "monkey");
//------------Assert Results-------------------------
Assert.AreEqual(root.ResourceType, ResourceType.Folder);
factory.Verify(a => a.CreateRootExplorerItem(ResourceType.Folder, It.IsAny<string>(), It.IsAny<Guid>()));
}
