public void Paths_Expected_JSONSources()
{
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
var servicesPath = Path.Combine(workspacePath, "Services");
var sourcesPath = Path.Combine(workspacePath, "Sources");
var pluginsPath = Path.Combine(workspacePath, "Plugins");
try
{
Directory.CreateDirectory(servicesPath);
Directory.CreateDirectory(sourcesPath);
Directory.CreateDirectory(pluginsPath);
var xml = XmlResource.Fetch("Calculate_RecordSet_Subtract");
xml.Save(Path.Combine(servicesPath, "Calculate_RecordSet_Subtract.xml"));
xml = XmlResource.Fetch("HostSecurityProviderServerSigned");
xml.Save(Path.Combine(sourcesPath, "HostSecurityProviderServerSigned.xml"));
var testResources = new Dev2.Runtime.ServiceModel.Resources();
var actual = testResources.Paths("", workspaceID, Guid.Empty);
Assert.AreEqual("[\"Integration Test Services\\\\Calculate_RecordSet_Subtract\"]", actual);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void EmailSourcesGetWithValidArgsExpectedReturnsSource()
{
var expected = CreateYahooSource();
var saveArgs = expected.ToString();
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
var handler = new EmailSources();
handler.Save(saveArgs, workspaceID, Guid.Empty);
var actual = handler.Get(expected.ResourceID.ToString(), workspaceID, Guid.Empty);
VerifySource(actual, expected);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void SourcesWithValidArgsExpectedReturnsList()
{
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
const int Modulo = 2;
const int ExpectedCount = 6;
for (var i = 0; i < ExpectedCount; i++)
{
var resource = new Resource
{
ResourceID = Guid.NewGuid(),
ResourceName = string.Format("My Name {0}", i),
ResourcePath = string.Format("My Path {0}", i),
ResourceType = (i % Modulo == 0) ? ResourceType.DbSource : ResourceType.Unknown
};
ResourceCatalog.Instance.SaveResource(workspaceID, resource);
}
var resources = new Dev2.Runtime.ServiceModel.Resources();
var result = resources.Sources("{\"resourceType\":\"" + ResourceType.DbSource + "\"}", workspaceID, Guid.Empty);
Assert.AreEqual(ExpectedCount / Modulo, result.Count);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void WebSourcesGetWithValidArgsExpectedReturnsSource()
{
var expected = CreateWebSource();
var saveArgs = expected.ToString();
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
var handler = new WebSources();
handler.Save(saveArgs, workspaceID, Guid.Empty);
var actual = handler.Get(expected.ResourceID.ToString(), workspaceID, Guid.Empty);
VerifySource(actual, expected);
}
finally
{
try
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
}
}
public void DbServices_Save_ValidArgsAndEmptyResourceID_AssignsNewResourceID()
{
var svc = CreateDev2TestingDbService();
svc.ResourceID = Guid.Empty;
var args = svc.ToString();
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
var services = new TestDbServices();
//------------Execute Test---------------------------
var result = services.Save(args, workspaceID, Guid.Empty);
//Assert Assigns New Resource ID
var service = JsonConvert.DeserializeObject <Service>(result);
Assert.AreNotEqual(Guid.Empty, service.ResourceID);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void DbServices_Save_ValidArgs_SavesXmlToDisk()
{
var svc = CreateDev2TestingDbService();
var args = svc.ToString();
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
var path = workspacePath;
var fileName = String.Format("{0}\\{1}.xml", path, svc.ResourcePath);
try
{
var services = new TestDbServices();
//------------Execute Test---------------------------
services.Save(args, workspaceID, Guid.Empty);
//Assert Saves Xml To Disk
var exists = File.Exists(fileName);
Assert.IsTrue(exists);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public string GetResourcePath(Guid workspaceID)
{
if (FilePath == null && IsReservedService)
{
return(ResourceName);
}
return(FilePath?.Replace(EnvironmentVariables.GetWorkspacePath(workspaceID) + "\\", "").Replace(".xml", "").Replace(".bite", "") ?? "");
}
public IExplorerItem Load(Guid workSpaceId, bool reload = false)
{
if (_root == null || reload)
{
_root = ExplorerItemFactory.CreateRootExplorerItem(EnvironmentVariables.GetWorkspacePath(workSpaceId), workSpaceId);
}
return(_root);
}
// ReSharper disable InconsistentNaming
public void Resources_UnitTest_PluginPathsAndNames_AllServicePathsExeptWorkflows()
// ReSharper restore InconsistentNaming
{
//Isolate PathsAndNames for workflows as a functional unit
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
const int Modulo = 3;
const int TotalResourceCount = 9;
for (var i = 0; i < TotalResourceCount; i++)
{
var resource = new Resource
{
ResourceID = Guid.NewGuid(),
ResourceName = string.Format("My Name {0}", i),
ResourcePath = string.Format("My Path {0}\\{1}", i, string.Format("My Name {0}", i))
};
switch (i % Modulo)
{
case 0:
resource.ResourcePath = ResourceType.WorkflowService + "\\" + resource.ResourceName;
resource.ResourceType = ResourceType.WorkflowService;
break;
case 1:
resource.ResourcePath = ResourceType.DbService + "\\" + resource.ResourceName;
resource.ResourceType = ResourceType.DbService;
break;
case 2:
resource.ResourcePath = ResourceType.PluginService + "\\" + resource.ResourceName;
resource.ResourceType = ResourceType.PluginService;
break;
}
ResourceCatalog.Instance.SaveResource(workspaceID, resource);
}
var resources = new Dev2.Runtime.ServiceModel.Resources();
const string ExpectedJson = "{\"Names\":[\"My Name 1\",\"My Name 4\",\"My Name 7\"],\"Paths\":[\"DbService\"]}";
//Run PathsAndNames
var actualJson = resources.PathsAndNames("DbService", workspaceID, Guid.Empty);
//Assert CorrectListReturned
Assert.AreEqual(ExpectedJson, actualJson, "Incorrect list of names and paths for workflow services");
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void EnvironmentVariables_GetWorkspacePath_GuidEmpty()
{
//------------Setup for test--------------------------
const string folderPart = "ProgramData\\Warewolf\\Resources";
//------------Execute Test---------------------------
var folderPath = EnvironmentVariables.GetWorkspacePath(Guid.Empty);
//------------Assert Results-------------------------
StringAssert.Contains(folderPath, folderPart);
}
public void GetLatest(IWorkspace workspace, IList <string> servicesToIgnore)
{
lock (_readLock)
{
var filesToIgnore = servicesToIgnore.Select(s => s + ".bite").ToList();
var targetPath = EnvironmentVariables.GetWorkspacePath(workspace.ID);
_resourceCatalog.SyncTo(ServerWorkspacePath, targetPath, true, true, filesToIgnore);
}
}
/// <summary>
/// Overwrites this workspace with the server versions except for those provided.
/// </summary>
/// <param name="workspace">The workspace to be queried.</param>
/// <param name="servicesToIgnore">The services being to be ignored.</param>
public void GetLatest(IWorkspace workspace, IList <string> servicesToIgnore)
{
lock (_readLock)
{
// ReSharper disable RedundantAssignment
var filesToIgnore = servicesToIgnore.Select(s => s += ".xml").ToList();
// ReSharper restore RedundantAssignment
var targetPath = EnvironmentVariables.GetWorkspacePath(workspace.ID);
_resourceCatalog.SyncTo(ServerWorkspacePath, targetPath, true, true, filesToIgnore);
}
}
public void EnvironmentVariables_GetWorkspacePath_Guid()
{
var guid = new Guid("c550ca0d-d324-45de-92bb-0c91879eb8b3");
//------------Setup for test--------------------------
const string folderPart = "ProgramData\\Warewolf\\Workspaces\\c550ca0d-d324-45de-92bb-0c91879eb8b3\\Resources";
//------------Execute Test---------------------------
var folderPath = EnvironmentVariables.GetWorkspacePath(guid);
//------------Assert Results-------------------------
StringAssert.Contains(folderPath, folderPart);
}
public void PluginServicesMethodsWithReturnsWithValidArgsExpectedReturnsList()
{
var service = CreatePluginService();
var workspaceID = Guid.NewGuid();
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new PluginServices();
var result = services.MethodsWithReturns(service);
Assert.AreEqual(7, result.Count);
}
public void Iterate(string resourcePath, Guid workspaceID, Func <ResourceIteratorResult, bool> action, params ResourceDelimiter[] delimiters)
{
if (delimiters == null || delimiters.Length == 0 || action == null || string.IsNullOrEmpty(resourcePath))
{
return;
}
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
var folders = new List <string> {
workspacePath
};
folders.AddRange(Directory.EnumerateDirectories(workspacePath, "*", SearchOption.AllDirectories));
foreach (var path in folders.Select(folder => Path.Combine(workspacePath, folder)))
{
if (Directory.Exists(path))
{
var files = Directory.GetFiles(path, "*.xml");
foreach (var file in files)
{
if (!string.IsNullOrEmpty(resourcePath))
{
if (!file.Contains(resourcePath))
{
continue;
}
}
// XML parsing will add overhead - so just read file and use string ops instead
var content = File.ReadAllText(file);
var iteratorResult = new ResourceIteratorResult {
Content = content
};
var delimiterFound = false;
foreach (var delimiter in delimiters)
{
string value;
if (delimiter.TryGetValue(content, out value))
{
delimiterFound = true;
iteratorResult.Values.Add(delimiter.ID, value);
}
}
if (delimiterFound)
{
if (!action(iteratorResult))
{
return;
}
}
}
}
}
}
public void ComPluginServicesMethodsWithValidArgsExpectedReturnsList()
{
var service = CreatePluginService();
var workspaceID = Guid.NewGuid();
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new ComPluginServices();
var result = services.Methods(service, workspaceID, Guid.Empty);
Assert.IsTrue(result.Count > 5, "Not enough items in COM server method list.");
}
public void PluginServicesConstructorsWithValidArgsExpectedReturnsList()
{
var service = CreatePluginService();
var workspaceID = Guid.NewGuid();
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new PluginServices();
var result = services.Constructors(service, workspaceID, Guid.Empty);
Assert.AreEqual(2, result.Count);
}
public void ComPluginServicesNamespacesWithValidArgsExpectedReturnsList()
{
var source = CreatePluginSource();
var args = source.ToString();
var workspaceID = Guid.NewGuid();
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new ComPluginServices();
var result = services.Namespaces(source, workspaceID, Guid.Empty);
Assert.IsTrue(result.Count > 0);
}
public void PluginServicesNamespacesWithValidArgsExpectedReturnsList()
{
var source = CreatePluginSource();
var args = source.ToString();
var workspaceID = Guid.NewGuid();
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new PluginServices();
var result = services.Namespaces(source, workspaceID, Guid.Empty);
// DO NOT assert equality on Count as this will
// change as new namespaces are added to this assembly!
Assert.IsTrue(result.Count > 0);
}
public string SetResourceFilePath(Guid workspaceID, IResource resource, ref string savedPath)
{
if (savedPath.EndsWith("\\"))
{
savedPath = savedPath.TrimEnd('\\');
}
if (savedPath.StartsWith("\\"))
{
savedPath = savedPath.TrimStart('\\');
}
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
var directoryName = Path.Combine(workspacePath, savedPath);
var resourceFilePath = Path.Combine(directoryName, resource.ResourceName + ".bite");
resource.FilePath = resourceFilePath;
return(directoryName);
}
public void DBServices_DbMethods_ValidArgs_ReturnsList()
{
var source = SqlServerTests.CreateDev2TestingDbSource();
var args = source.ToString();
var workspaceID = Guid.NewGuid();
var resourceCatalog = new Mock <IResourceCatalog>();
resourceCatalog.Setup(catalog => catalog.GetResource <DbSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(source);
EnvironmentVariables.GetWorkspacePath(workspaceID);
var services = new TestDbServices(resourceCatalog.Object);
//------------Execute Test---------------------------
var result = services.DbMethods(args, workspaceID, Guid.Empty);
// Assert Returns Valid List
Assert.IsTrue(result.Count >= 25, "DbMethods does not return a list");
}
public void DataListInputWhereValidArgsDataListHasNoInputsExpectEmptyString()
{
//------------Setup for test--------------------------
LoadActivitiesPresentationDll();
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
string completePath = Path.Combine(workspacePath, "Bugs");
if (Directory.Exists(completePath))
{
Directory.Delete(completePath);
}
var xml = XmlResource.Fetch("Bug6619");
var resourcePath = xml.Element("Category");
Directory.CreateDirectory(completePath);
Assert.IsNotNull(resourcePath);
xml.Save(Path.Combine(workspacePath, resourcePath.Value + ".xml"));
var resources = new Resources();
//-----------------Assert Preconditions-----------------------------
Assert.IsNotNull(resourcePath);
var resource = ResourceCatalog.Instance.GetResource(workspaceID, resourcePath.Value);
Assert.IsNotNull(resource);
//------------Execute Test---------------------------
var dataListInputVariables = resources.DataListInputVariables(resource.ResourceID.ToString(), workspaceID, Guid.Empty);
//------------Assert Results-------------------------
Assert.IsTrue(string.IsNullOrEmpty(dataListInputVariables));
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void DBServices_Get_ValidArgs_ReturnsService()
{
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
//------------Setup for test--------------------------
var svc = CreateDev2TestingDbService();
var getArgs = string.Format("{{\"resourceID\":\"{0}\",\"resourceType\":\"{1}\"}}", svc.ResourceID, ResourceType.DbService);
var resourceCatalog = new Mock <IResourceCatalog>();
resourceCatalog.Setup(c => c.GetResourceContents(workspaceID, svc.ResourceID))
.Returns((Guid wsID, Guid resourceID) => svc.ToXml().ToStringBuilder())
.Verifiable();
var services = new TestDbServices(resourceCatalog.Object);
//------------Execute Test---------------------------
var getResult = services.Get(getArgs, workspaceID, Guid.Empty);
//------------Assert Results-------------------------
resourceCatalog.Verify(c => c.GetResourceContents(workspaceID, svc.ResourceID));
Assert.AreEqual(svc.ResourceID, getResult.ResourceID);
Assert.AreEqual(svc.ResourceName, getResult.ResourceName);
Assert.AreEqual(svc.ResourcePath, getResult.ResourcePath);
Assert.AreEqual(svc.ResourceType, getResult.ResourceType);
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public void DataListInputWhereValidArgsDataListHasInputsScalarsAndRecSetExpectCorrectString()
{
//------------Setup for test--------------------------
var workspaceID = Guid.NewGuid();
var workspacePath = EnvironmentVariables.GetWorkspacePath(workspaceID);
try
{
string completePath = Path.Combine(workspacePath, "Mo");
if (Directory.Exists(completePath))
{
Directory.Delete(completePath);
}
var xml = XmlResource.Fetch("TestForEachOutput");
var resourcePath = xml.Element("Category");
Directory.CreateDirectory(completePath);
Assert.IsNotNull(resourcePath);
xml.Save(Path.Combine(workspacePath, resourcePath.Value + ".xml"));
var resources = new Dev2.Runtime.ServiceModel.Resources();
//---------------Assert Preconditions------------------------------
Assert.IsNotNull(resourcePath);
var resource = ResourceCatalog.Instance.GetResource(workspaceID, resourcePath.Value);
Assert.IsNotNull(resource);
//------------Execute Test---------------------------
var dataListInputVariables = resources.DataListInputVariables(resource.ResourceID.ToString(), workspaceID, Guid.Empty);
//------------Assert Results-------------------------
StringAssert.Contains(dataListInputVariables, "inputScalar");
StringAssert.Contains(dataListInputVariables, "bothScalar");
}
finally
{
if (Directory.Exists(workspacePath))
{
DirectoryHelper.CleanUp(workspacePath);
}
}
}
public IExplorerItem Load(string type, Guid workSpaceId)
{
return(ExplorerItemFactory.CreateRootExplorerItem(type, EnvironmentVariables.GetWorkspacePath(workSpaceId), workSpaceId));
}
public IExplorerItem Load(string type, string filter)
{
return(ExplorerItemFactory.CreateRootExplorerItem(type, Path.Combine(EnvironmentVariables.GetWorkspacePath(Guid.Empty), filter), Guid.Empty));
}
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())
};
}
List <IResource> LoadWorkspaceImpl(Guid workspaceID)
{
var workspacePath = workspaceID == GlobalConstants.ServerWorkspaceID ? EnvironmentVariables.ResourcePath : EnvironmentVariables.GetWorkspacePath(workspaceID);
IList <IResource> userServices = new List <IResource>();
if (Directory.Exists(workspacePath))
{
var folders = Directory.EnumerateDirectories(workspacePath, "*", SearchOption.AllDirectories);
var allFolders = folders.ToList();
allFolders.Add(workspacePath);
userServices = LoadWorkspaceViaBuilder(workspacePath, workspaceID == GlobalConstants.ServerWorkspaceID, allFolders.ToArray());
}
var result = userServices.Union(ManagementServices.Values);
var resources = result.ToList();
return(resources);
}
public ResourceCatalog(IEnumerable <DynamicService> managementServices)
{
InitializeWorkspaceResources();
_serverVersionRepository = new ServerVersionRepository(new VersionStrategy(), this, _directoryWrapper, EnvironmentVariables.GetWorkspacePath(GlobalConstants.ServerWorkspaceID), new FileWrapper(), new FilePathWrapper());
_catalogPluginContainer = new ResourceCatalogPluginContainer(_serverVersionRepository, WorkspaceResources, managementServices);
_catalogPluginContainer.Build(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCatalog" /> class.
/// <remarks>
/// DO NOT instantiate directly - use static Instance property instead; this is for testing only!
/// </remarks>
/// </summary>
/// <param name="managementServices">The management services to be loaded.</param>
public ResourceCatalog(IEnumerable <DynamicService> managementServices = null)
{
InitializeWorkspaceResources();
// MUST load management services BEFORE server workspace!!
IServerVersionRepository versioningRepository = new ServerVersionRepository(new VersionStrategy(), this, new DirectoryWrapper(), EnvironmentVariables.GetWorkspacePath(GlobalConstants.ServerWorkspaceID), new FileWrapper());
_catalogPluginContainer = new ResourceCatalogPluginContainer(versioningRepository, WorkspaceResources, managementServices);
_catalogPluginContainer.Build(this);
}