public void Execute_GivenSomeArgs_Returns_Id()
{
//------------Setup for test-------------------------
var deleteAllTests = new DeleteAllTests();
var workspaceMock = new Mock <IWorkspace>();
//------------Execute Test---------------------------
var value = new List <string> {
"Test1", "Test2"
}.SerializeToJsonStringBuilder();
var requestArgs = new Dictionary <string, StringBuilder>
{
{ "excludeList", value }
};
var executeResults = deleteAllTests.Execute(requestArgs, workspaceMock.Object);
var jsonSerializer = new Dev2JsonSerializer();
Assert.IsNotNull(executeResults);
var deserializedResults = jsonSerializer.Deserialize <CompressedExecuteMessage>(executeResults);
//------------Assert Results-------------------------
Assert.IsNotNull(deserializedResults);
Assert.IsFalse(deserializedResults.HasError);
var message = CompressedExecuteMessage.Decompress(deserializedResults.Message.ToString());
Assert.AreEqual("Test reload succesful", message);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Tests Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("resourceID", out StringBuilder resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
if (!Guid.TryParse(resourceIdString.ToString(), out Guid resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var tests = TestCatalog.Fetch(resourceId);
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
var guidCsv = string.Empty;
string type = null;
values.TryGetValue("GuidCsv", out StringBuilder tmp);
if (tmp != null)
{
guidCsv = tmp.ToString();
}
values.TryGetValue("ResourceType", out tmp);
if (tmp != null)
{
type = tmp.ToString();
}
var resources = ResourceCatalog.Instance.GetResourceList(theWorkspace.ID, new Dictionary <string, string> {
{ "guidCsv", guidCsv }, { "type", type }
});
IList <SerializableResource> resourceList = resources.Select(r => new FindResourceHelper().SerializeResourceForStudio(r, theWorkspace.ID)).ToList();
var serializer = new Dev2JsonSerializer();
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(resourceList));
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
throw;
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new CompressedExecuteMessage {
HasError = false
};
var jsonSerializer = new Dev2JsonSerializer();
try
{
values.TryGetValue("excludeList", out StringBuilder excludeTests);
var testsToLive = jsonSerializer.Deserialize <List <string> >(excludeTests);
TestCatalog.DeleteAllTests(testsToLive.Select(a => a.ToUpper()).ToList());
result.SetMessage("Test reload succesful");
}
catch (Exception ex)
{
result.HasError = true;
result.SetMessage("Error reloading tests...");
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public void SaveElasticsearchSource_Execute_GivenResourceDefination_ShouldSaveNewSourceReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new ElasticsearchSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = "HostName",
Port = "3679",
AuthenticationType = AuthenticationType.Anonymous,
SearchIndex = "warewolflogs"
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "ElasticsearchSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.Name));
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), It.IsAny <IResource>(), It.IsAny <string>()));
var elasticsearchSource = new SaveElasticsearchSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = elasticsearchSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), It.IsAny <IResource>(), It.IsAny <string>()));
}
public void Execute_GivenResourceDefination_ShouldReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var listOfTests = new List <ServiceTestModelTO>
{
new ServiceTestModelTO
{
AuthenticationType = AuthenticationType.Public,
Enabled = true,
TestName = "Test MyWF"
}
};
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(listOfTests));
var values = new Dictionary <string, StringBuilder> {
{ "resourceID", new StringBuilder(Guid.NewGuid().ToString()) }, { "resourcePath", "Home".ToStringBuilder() }
};
var saveTests = new SaveTests();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = saveTests.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsTrue(result.HasError);
Assert.AreEqual("testDefinition is missing", result.Message.ToString());
}
public void SaveTriggers_Execute_GivenResourceDefinition_ShouldReturnResourceDefinitionMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var triggerQueues = new List <ITriggerQueue>
{
new TriggerQueue
{
QueueName = "Test Queue"
}
};
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(triggerQueues));
var values = new Dictionary <string, StringBuilder> {
{ "resourceID", new StringBuilder(Guid.NewGuid().ToString()) }, { "resourcePath", "Home".ToStringBuilder() }
};
var saveTriggers = new SaveTriggers();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = saveTriggers.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsTrue(result.HasError);
Assert.AreEqual("triggerDefinitions is missing", result.Message.ToString());
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Trigger Queue Service", GlobalConstants.WarewolfInfo);
var triggerQueues = TriggersCatalog.Queues;
var message = new CompressedExecuteMessage
{
HasError = false
};
message.SetMessage(serializer.Serialize(triggerQueues));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
var msg = new ExecuteMessage
{
HasError = true,
Message = new StringBuilder(err.Message)
};
Dev2Logger.Error("Fetch Queue Service Failed: " + err.Message, GlobalConstants.WarewolfError);
return(serializer.SerializeToBuilder(msg));
}
}
CompressedExecuteMessage GetExplorerItems(Dev2JsonSerializer serializer, bool reloadResourceCatalogue)
{
var item = ServerExplorerRepo.Load(GlobalConstants.ServerWorkspaceID, reloadResourceCatalogue);
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(item));
return(message);
}
public void HangfireServer_Program_ConnectionString_Exists()
{
var args = new Args
{
ShowConsole = true,
};
var implConfig = SetupHangfireImplementationConfigs(out var mockWriter, out var mockPauseHelper, out var mockExecutionLogPublisher);
var dbSource = new DbSource
{
ConnectionString = "connectionString",
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = dbSource.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var mockSerializer = new Mock <IBuilderSerializer>();
var mockFile = new Mock <IFile>();
var mockDirectory = new Mock <IDirectory>();
var persistenceSettings = new PersistenceSettings("some path", mockFile.Object, mockDirectory.Object)
{
Enable = false,
PersistenceDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Data Source", Value = Guid.Empty, Payload = serializeToJsonString
},
};
mockSerializer.Setup(o => o.Deserialize <DbSource>(persistenceSettings.PersistenceDataSource.Payload)).Returns(dbSource).Verifiable();
var mockContext = new HangfireContext(args);
var mockEventWaitHandle = new Mock <IEventWaitHandle>();
mockEventWaitHandle.Setup(o => o.New()).Verifiable();
mockEventWaitHandle.Setup(o => o.WaitOne()).Verifiable();
var item = new Implementation(mockContext, implConfig, persistenceSettings, mockSerializer.Object, mockEventWaitHandle.Object);
item.Run();
mockWriter.Verify(o => o.WriteLine("Starting Hangfire server..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Starting Hangfire server..."), Times.Once);
mockSerializer.Verify(o => o.Deserialize <DbSource>(persistenceSettings.PersistenceDataSource.Payload), Times.Once);
mockWriter.Verify(o => o.WriteLine("Hangfire dashboard started..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire dashboard started..."), Times.Once);
mockWriter.Verify(o => o.WriteLine("Hangfire server started..."), Times.Once);
mockExecutionLogPublisher.Verify(o => o.Info("Hangfire server started..."), Times.Once);
mockPauseHelper.Verify(o => o.Pause(), Times.Never);
mockEventWaitHandle.Verify(o => o.New(), Times.Never);
mockEventWaitHandle.Verify(o => o.WaitOne(), Times.Never);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
if (values == null)
{
throw new InvalidDataContractException(ErrorResource.NoParameter);
}
string serializedSource = null;
values.TryGetValue("Search", out StringBuilder searchValueSB);
values.TryGetValue("SearchInput", out StringBuilder searchInputSB);
if (searchValueSB != null)
{
serializedSource = searchValueSB.ToString();
}
if (string.IsNullOrEmpty(serializedSource))
{
var message = new ExecuteMessage();
message.HasError = true;
message.SetMessage("No Search found");
Dev2Logger.Debug("No Search found", GlobalConstants.WarewolfDebug);
return(serializer.SerializeToBuilder(message));
}
var searchResults = new List <ISearchResult>();
var searchValue = serializer.Deserialize <ISearch>(serializedSource);
if (searchValue != null)
{
var searchers = new List <ISearcher>
{
new ActivitySearcher(ResourceCatalog.Instance),
new TestSearcher(ResourceCatalog.Instance, TestCatalog.Instance),
new VariableListSearcher(ResourceCatalog.Instance),
new ResourceSearcher(ResourceCatalog.Instance)
};
searchResults = searchValue.GetSearchResults(searchers);
}
return(serializer.SerializeToBuilder(searchResults));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public void SaveTests_Execute_ExpectName()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
var saveTests = new SaveTests();
var listOfTests = new List <ServiceTestModelTO>
{
new ServiceTestModelTO
{
AuthenticationType = AuthenticationType.Public,
Enabled = true,
TestName = "Test MyWF"
}
};
var testModels = new List <IServiceTestModelTO>();
var testCatalogMock = new Mock <ITestCatalog>();
var resourceCatalog = new Mock <IResourceCatalog>();
var resourceMock = new Mock <IResource>();
resourceMock.SetupGet(resource => resource.ResourceID).Returns(resourceID);
resourceMock.Setup(resource => resource.GetResourcePath(It.IsAny <Guid>())).Returns("Home");
resourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceID)).Returns(resourceMock.Object);
var ws = new Mock <IWorkspace>();
var resID = Guid.Empty;
testCatalogMock.Setup(a => a.SaveTests(It.IsAny <Guid>(), It.IsAny <List <IServiceTestModelTO> >())).Callback((Guid id, List <IServiceTestModelTO> testModelTos) =>
{
resID = id;
testModels = testModelTos;
}).Verifiable();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(listOfTests));
inputs.Add("testDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "Home".ToStringBuilder());
saveTests.TestCatalog = testCatalogMock.Object;
saveTests.ResourceCatalog = resourceCatalog.Object;
//------------Execute Test---------------------------
saveTests.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
testCatalogMock.Verify(a => a.SaveTests(It.IsAny <Guid>(), It.IsAny <List <IServiceTestModelTO> >()));
Assert.AreEqual(listOfTests.Count, testModels.Count);
Assert.AreEqual(listOfTests[0].TestName, testModels[0].TestName);
Assert.AreEqual(resourceID, resID);
}
public void SaveTriggers_Execute_ExpectName()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceId = Guid.NewGuid();
var saveTriggers = new SaveTriggers();
var triggerQueues = new List <ITriggerQueue>
{
new TriggerQueue
{
QueueName = "Test Queue"
}
};
var emptyTriggerQueues = new List <ITriggerQueue>();
var mockTriggersCatalog = new Mock <ITriggersCatalog>();
var mockResourceCatalog = new Mock <IResourceCatalog>();
var mockResource = new Mock <IResource>();
mockResource.SetupGet(resource => resource.ResourceID).Returns(resourceId);
mockResource.Setup(resource => resource.GetResourcePath(It.IsAny <Guid>())).Returns("somePath");
mockResourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId)).Returns(mockResource.Object);
var ws = new Mock <IWorkspace>();
var resID = Guid.Empty;
mockTriggersCatalog.Setup(a => a.SaveTriggers(It.IsAny <Guid>(), It.IsAny <List <ITriggerQueue> >())).Callback((Guid id, List <ITriggerQueue> queues) =>
{
resID = id;
emptyTriggerQueues = queues;
}).Verifiable();
inputs.Add("resourceID", new StringBuilder(resourceId.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(triggerQueues));
inputs.Add("triggerDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "somePath".ToStringBuilder());
saveTriggers.TriggersCatalog = mockTriggersCatalog.Object;
saveTriggers.ResourceCatalog = mockResourceCatalog.Object;
//------------Execute Test---------------------------
saveTriggers.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
mockTriggersCatalog.Verify(a => a.SaveTriggers(It.IsAny <Guid>(), It.IsAny <List <ITriggerQueue> >()));
Assert.AreEqual(triggerQueues.Count, emptyTriggerQueues.Count);
Assert.AreEqual(triggerQueues[0].QueueName, emptyTriggerQueues[0].QueueName);
Assert.AreEqual(resourceId, resID);
}
public void Execute_GivenResourceMoved_ShouldSaveTests()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
var saveTests = new SaveTests();
var listOfTests = new List <ServiceTestModelTO>
{
new ServiceTestModelTO
{
AuthenticationType = AuthenticationType.Public,
Enabled = true,
TestName = "Test MyWF"
}
};
var resourceMock = new Mock <IResource>();
resourceMock.SetupGet(resource => resource.ResourceID).Returns(resourceID);
resourceMock.Setup(resource => resource.GetResourcePath(It.IsAny <Guid>())).Returns("Home");
var testCatalogMock = new Mock <ITestCatalog>();
var resourceCatalog = new Mock <IResourceCatalog>();
resourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceID)).Returns(resourceMock.Object);
testCatalogMock.Setup(a => a.SaveTests(It.IsAny <Guid>(), It.IsAny <List <IServiceTestModelTO> >())).Verifiable();
var ws = new Mock <IWorkspace>();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(listOfTests));
inputs.Add("testDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "AnathorPath".ToStringBuilder());
saveTests.TestCatalog = testCatalogMock.Object;
saveTests.ResourceCatalog = resourceCatalog.Object;
var stringBuilder = saveTests.Execute(inputs, ws.Object);
//---------------Assert Precondition----------------
var msg = serializer.Deserialize <ExecuteMessage>(stringBuilder);
var testSaveResult = serializer.Deserialize <TestSaveResult>(msg.Message);
Assert.AreEqual(SaveResult.ResourceUpdated, testSaveResult.Result);
Assert.AreEqual("Resource AnathorPath has changed to Home. Tests have been saved for this resource.", testSaveResult.Message);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
testCatalogMock.Verify(a => a.SaveTests(It.IsAny <Guid>(), It.IsAny <List <IServiceTestModelTO> >()), Times.Once);
}
public TestSaveResult SaveTests(IResourceModel resource, List <IServiceTestModelTO> tests)
{
var comsController = GetCommunicationController("SaveTests");
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
comsController.AddPayloadArgument("resourceID", resource.ID.ToString());
comsController.AddPayloadArgument("resourcePath", string.IsNullOrEmpty(resource.Category) ? resource.ResourceName : resource.Category);
comsController.AddPayloadArgument("testDefinitions", serializer.SerializeToBuilder(message));
var result = comsController.ExecuteCommand <ExecuteMessage>(_server.Connection, GlobalConstants.ServerWorkspaceID);
var res = serializer.Deserialize <TestSaveResult>(result?.Message);
return(res);
}
private ExecuteMessage SaveResource(IServer targetEnvironment, StringBuilder resourceDefinition, Guid workspaceId, string savePath)
{
var comsController = GetCommunicationController("SaveResourceService");
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(resourceDefinition.ToString());
Dev2JsonSerializer ser = new Dev2JsonSerializer();
comsController.AddPayloadArgument("savePath", savePath);
comsController.AddPayloadArgument("ResourceXml", ser.SerializeToBuilder(message));
comsController.AddPayloadArgument("WorkspaceID", workspaceId.ToString());
var con = targetEnvironment.Connection;
var result = comsController.ExecuteCommand <ExecuteMessage>(con, con.WorkspaceID);
return(result);
}
public void SaveTriggers_Execute_GivenResourceMoved_ShouldSaveTriggers()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceId = Guid.NewGuid();
var saveTriggers = new SaveTriggers();
var triggerQueues = new List <ITriggerQueue>
{
new TriggerQueue
{
QueueName = "Test Queue"
}
};
var mockResource = new Mock <IResource>();
mockResource.SetupGet(resource => resource.ResourceID).Returns(resourceId);
mockResource.Setup(resource => resource.GetResourcePath(It.IsAny <Guid>())).Returns("somePath");
var mockTriggersCatalog = new Mock <ITriggersCatalog>();
var mockResourceCatalog = new Mock <IResourceCatalog>();
mockResourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId)).Returns(mockResource.Object);
mockTriggersCatalog.Setup(a => a.SaveTriggers(It.IsAny <Guid>(), It.IsAny <List <ITriggerQueue> >())).Verifiable();
var ws = new Mock <IWorkspace>();
inputs.Add("resourceID", new StringBuilder(resourceId.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(triggerQueues));
inputs.Add("triggerDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "otherPath".ToStringBuilder());
saveTriggers.TriggersCatalog = mockTriggersCatalog.Object;
saveTriggers.ResourceCatalog = mockResourceCatalog.Object;
var stringBuilder = saveTriggers.Execute(inputs, ws.Object);
//---------------Assert Precondition----------------
var msg = serializer.Deserialize <ExecuteMessage>(stringBuilder);
Assert.IsFalse(msg.HasError);
Assert.IsTrue(msg.Message.Contains("Resource otherPath has changed to somePath. Triggers have been saved for this resource."));
//------------Execute Test---------------------------
//------------Assert Results-------------------------
mockTriggersCatalog.Verify(a => a.SaveTriggers(It.IsAny <Guid>(), It.IsAny <List <ITriggerQueue> >()), Times.Once);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2Logger.Info("Fetch Duplicate ResourcesError", GlobalConstants.WarewolfInfo);
var serializer = new Dev2JsonSerializer();
try
{
var item = ServerExplorerRepo.LoadDuplicate();
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(item));
return(serializer.SerializeToBuilder(message));
}
catch (Exception e)
{
Dev2Logger.Info("Fetch Duplicate ResourcesError", e, GlobalConstants.WarewolfInfo);
IExplorerRepositoryResult error = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
return(serializer.SerializeToBuilder(error));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2Logger.Info("Fetch Explorer Items");
var serializer = new Dev2JsonSerializer();
try
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
StringBuilder tmp;
values.TryGetValue("ReloadResourceCatalogue", out tmp);
string reloadResourceCatalogueString = "";
if (tmp != null)
{
reloadResourceCatalogueString = tmp.ToString();
}
bool reloadResourceCatalogue = false;
if (!string.IsNullOrEmpty(reloadResourceCatalogueString))
{
if (!bool.TryParse(reloadResourceCatalogueString, out reloadResourceCatalogue))
{
reloadResourceCatalogue = false;
}
}
if (reloadResourceCatalogue)
{
ResourceCatalog.Instance.Reload();
}
var item = ServerExplorerRepo.Load(GlobalConstants.ServerWorkspaceID, reloadResourceCatalogue);
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(item));
return(serializer.SerializeToBuilder(message));
}
catch (Exception e)
{
Dev2Logger.Info("Fetch Explorer Items Error", e);
IExplorerRepositoryResult error = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
return(serializer.SerializeToBuilder(error));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Delete Test Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
StringBuilder testName;
values.TryGetValue("testName", out testName);
if (string.IsNullOrEmpty(testName?.ToString()))
{
throw new InvalidDataContractException("testName is missing");
}
TestCatalog.DeleteTest(resourceId, testName.ToString());
CompressedExecuteMessage message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public void Execute_GivenNullResource_ShouldReturnResourceDeletedMsg()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
var saveTests = new SaveTests();
var listOfTests = new List <ServiceTestModelTO>
{
new ServiceTestModelTO
{
AuthenticationType = AuthenticationType.Public,
Enabled = true,
TestName = "Test MyWF"
}
};
var testCatalogMock = new Mock <ITestCatalog>();
var resourceCatalog = new Mock <IResourceCatalog>();
resourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceID)).Returns(default(IResource));
var ws = new Mock <IWorkspace>();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(listOfTests));
inputs.Add("testDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "Home".ToStringBuilder());
saveTests.TestCatalog = testCatalogMock.Object;
saveTests.ResourceCatalog = resourceCatalog.Object;
//------------Execute Test---------------------------
var stringBuilder = saveTests.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
var msg = serializer.Deserialize <ExecuteMessage>(stringBuilder);
var testSaveResult = serializer.Deserialize <TestSaveResult>(msg.Message);
Assert.AreEqual(SaveResult.ResourceDeleted, testSaveResult.Result);
Assert.AreEqual("Resource Home has been deleted. No Tests can be saved for this resource.", testSaveResult.Message);
}
public void Execute_GivenResourceDefination_GivenExising_ShouldReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new ComPluginSourceDefinition()
{
Id = Guid.Empty,
ResourceName = "Name",
ClsId = Guid.NewGuid().ToString(),
ResourcePath = Environment.CurrentDirectory,
SelectedDll = new DllListing()
{
Name = "k"
}
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "ComPluginSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
var comPluginSource = new ComPluginSource();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.ResourceName, It.IsAny <string>(), It.IsAny <string>())).Returns(comPluginSource);
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), comPluginSource, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
var saveComPluginSource = new SaveComPluginSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
StringBuilder jsonResult = saveComPluginSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.ResourceName, It.IsAny <string>(), It.IsAny <string>()));
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), comPluginSource, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new CompressedExecuteMessage {
HasError = false
};
try
{
TestCatalog.Load();
result.SetMessage("Test reload succesful");
}
catch (Exception ex)
{
result.HasError = true;
result.SetMessage("Error reloading tests...");
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Tests for deploy Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var tests = TestCatalog.Fetch(resourceId);
foreach (var serviceTestModelTO in tests.Where(to => !string.IsNullOrEmpty(to.Password)))
{
serviceTestModelTO.Password = SecurityEncryption.Encrypt(serviceTestModelTO.Password);
}
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Reload All Tests", GlobalConstants.WarewolfInfo);
TestCatalog.ReloadAllTests();
var message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public void SaveTriggers_Execute_GivenNullResource_ShouldReturnResourceDeletedMsg()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceId = Guid.NewGuid();
var saveTriggers = new SaveTriggers();
var triggerQueues = new List <ITriggerQueue>
{
new TriggerQueue
{
QueueName = "Test Queue"
}
};
var mockTriggersCatalog = new Mock <ITriggersCatalog>();
var mockResourceCatalog = new Mock <IResourceCatalog>();
mockResourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId)).Returns(default(IResource));
var ws = new Mock <IWorkspace>();
inputs.Add("resourceID", new StringBuilder(resourceId.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(triggerQueues));
inputs.Add("triggerDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "somePath".ToStringBuilder());
saveTriggers.TriggersCatalog = mockTriggersCatalog.Object;
saveTriggers.ResourceCatalog = mockResourceCatalog.Object;
//------------Execute Test---------------------------
var stringBuilder = saveTriggers.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
var msg = serializer.Deserialize <ExecuteMessage>(stringBuilder);
Assert.IsFalse(msg.HasError);
Assert.IsTrue(msg.Message.Contains("Resource somePath has been deleted. No Triggers can be saved for this resource."));
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Triggers for Deploy Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("resourceID", out var resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
if (!Guid.TryParse(resourceIdString.ToString(), out var resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var triggerQueues = TriggersCatalog.LoadQueuesByResourceId(resourceId);
var message = new CompressedExecuteMessage
{
HasError = false
};
message.SetMessage(serializer.Serialize(triggerQueues));
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error("Fetch Triggers For Deploy Failed: " + err.Message, GlobalConstants.WarewolfError);
var msg = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(msg));
}
}
private IEnumerable <DeployResult> DeployResource(Guid resourceId, StringBuilder roles, Dev2JsonSerializer serializer, IHubProxy proxy, bool doTestDeploy)
{
var toReturn = new List <DeployResult>();
var savePath = new StringBuilder();
var resourceContent = ResourceCatalog.GetResourceContents(GlobalConstants.ServerWorkspaceID, resourceId);
var resource = ResourceCatalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId);
if (!resource.IsService)
{
var fetchResourceService = new FetchResourceDefinition();
resourceContent = fetchResourceService.DecryptAllPasswords(resourceContent);
}
savePath.Append(resource.GetSavePath());
var esbExecuteRequest = new EsbExecuteRequest {
ServiceName = "DeployResourceService"
};
esbExecuteRequest.AddArgument("savePath", savePath);
esbExecuteRequest.AddArgument("ResourceDefinition", resourceContent);
esbExecuteRequest.AddArgument("Roles", roles);
Envelope envelope = new Envelope
{
Content = serializer.SerializeToBuilder(esbExecuteRequest).ToString(),
PartID = 0,
Type = typeof(Envelope)
};
var messageId = Guid.NewGuid();
proxy.Invoke <Receipt>("ExecuteCommand", envelope, true, Guid.Empty, Guid.Empty, messageId).Wait();
Task <string> fragmentInvoke = proxy.Invoke <string>("FetchExecutePayloadFragment", new FutureReceipt {
PartID = 0, RequestID = messageId
});
var fragmentInvokeResult = fragmentInvoke.Result;
var execResult = serializer.Deserialize <ExecuteMessage>(fragmentInvokeResult) ?? new ExecuteMessage {
HasError = true, Message = new StringBuilder("Deploy Fialed")
};
toReturn.Add(new DeployResult(execResult, resource.ResourceName));
if (doTestDeploy)
{
var testsToDeploy = TestCatalog.Fetch(resourceId);
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(testsToDeploy));
var testDeployRequest = new EsbExecuteRequest {
ServiceName = "SaveTests"
};
testDeployRequest.AddArgument("resourceID", resourceId.ToString().ToStringBuilder());
testDeployRequest.AddArgument("resourcePath", savePath);
testDeployRequest.AddArgument("testDefinitions", serializer.SerializeToBuilder(message));
Envelope deployEnvelope = new Envelope
{
Content = serializer.SerializeToBuilder(testDeployRequest).ToString(),
PartID = 0,
Type = typeof(Envelope)
};
var deployMessageId = Guid.NewGuid();
proxy.Invoke <Receipt>("ExecuteCommand", deployEnvelope, true, Guid.Empty, Guid.Empty, deployMessageId).Wait();
Task <string> deployFragmentInvoke = proxy.Invoke <string>("FetchExecutePayloadFragment", new FutureReceipt {
PartID = 0, RequestID = deployMessageId
});
var deployFragmentInvokeResult = deployFragmentInvoke.Result;
var deployExecResult = serializer.Deserialize <ExecuteMessage>(deployFragmentInvokeResult) ?? new ExecuteMessage {
HasError = true, Message = new StringBuilder("Deploy Fialed")
};
toReturn.Add(new DeployResult(deployExecResult, $"{resource.ResourceName} Tests"));
}
return(toReturn);
}
