private void QueueWorkerMethod(object dummy)
{
_resumer.WaitOne();
try
{
foreach (var trigger in TriggerQueue.GetConsumingEnumerable())
{
if (_tokenSource.IsCancellationRequested)
{
RaiseStateMachineSystemEvent("StateMachine : QueueWorker", "Processing canceled");
return;
}
foreach (var transition in CurrentState.StateTransitionList.Where(t => trigger == t.Value.Trigger))
{
ExecuteTransition(transition.Value);
}
}
}
catch (Exception e)
{
RaiseStateMachineSystemEvent("StateMachine: QueueWorker", "Processing canceled. Exception: " + e);
Start();
}
}
public void TriggerQueue_Equals_MisMatch_Expect_False()
{
var mockResource = new Mock <IResource>();
mockResource.Setup(resource => resource.ResourceID).Returns(Guid.NewGuid());
var mockOption = new Mock <IOption>();
var mockInputs = new Mock <ICollection <IServiceInputBase> >();
var resourceId = Guid.NewGuid();
var triggerQueue = new TriggerQueue
{
QueueSourceId = resourceId,
QueueName = "Queue",
WorkflowName = "Workflow",
Concurrency = 100,
UserName = "******",
Password = "******",
Options = new[] { mockOption.Object },
QueueSinkId = resourceId,
DeadLetterQueue = "DeadLetterQueue",
DeadLetterOptions = new[] { mockOption.Object },
MapEntireMessage = true,
Inputs = mockInputs.Object,
ResourceId = resourceId
};
var otherTriggerQueue = new TriggerQueue {
Concurrency = 2
};
var equals = triggerQueue.Equals(otherTriggerQueue);
Assert.IsFalse(equals);
Assert.AreEqual(resourceId, triggerQueue.ResourceId);
}
public void TriggerQueue_Equals_Other_IsNull_Expect_False()
{
var triggerQueue = new TriggerQueue();
var equals = triggerQueue.Equals(null);
Assert.IsFalse(equals);
}
public void TriggersCatalog_FileSystemWatcher_Error()
{
var directory = "some path";
var fileName = Guid.NewGuid().ToString() + ".bite";
var oldName = Guid.NewGuid().ToString() + ".bite";
var files = new string[] { fileName };
var mockDirectoryWrapper = new Mock <IDirectory>();
mockDirectoryWrapper.Setup(directoryWrapper => directoryWrapper.GetFiles("some path")).Returns(files);
var mockFileWrapper = new Mock <IFile>();
var mockSerializer = new Mock <ISerializer>();
var mockFileSystemWatcher = new Mock <IFileSystemWatcher>();
var triggerId = Guid.NewGuid();
var decryptedTrigger = "serialized queue data";
var expected = DpapiWrapper.Encrypt(decryptedTrigger);
mockFileWrapper.Setup(o => o.ReadAllText(fileName)).Returns(expected);
var expectedTrigger = new TriggerQueue
{
TriggerId = triggerId
};
mockSerializer.Setup(o => o.Deserialize <ITriggerQueue>(decryptedTrigger)).Returns(expectedTrigger);
var catalog = GetTriggersCatalog(mockDirectoryWrapper.Object, mockFileWrapper.Object, directory, mockSerializer.Object, mockFileSystemWatcher.Object);
mockFileSystemWatcher.Raise(fileWatcher => fileWatcher.Error += null, null, new ErrorEventArgs(new Exception()));
mockDirectoryWrapper.Verify(directoryWrapper => directoryWrapper.GetFiles(directory), Times.Exactly(1));
Assert.AreEqual(1, catalog.Queues.Count);
Assert.AreEqual(triggerId, catalog.Queues[0].TriggerId);
}
public void TriggersCatalog_LoadQueuesByResourceId_ExpectQueue()
{
var mockDirectoryWrapper = new Mock <IDirectory>();
const string fileName = "somefile.bite";
mockDirectoryWrapper.Setup(o => o.GetFiles(It.IsAny <string>())).Returns(new[] { fileName });
var mockFileWrapper = new Mock <IFile>();
var mockSerializer = new Mock <ISerializer>();
var mockFileSystemWatcher = new Mock <IFileSystemWatcher>();
var expectedResourceId = Guid.NewGuid();
var decryptedTrigger = "serialized queue data";
var expected = DpapiWrapper.Encrypt(decryptedTrigger);
mockFileWrapper.Setup(o => o.ReadAllText("somefile.bite")).Returns(expected);
var expectedTrigger = new TriggerQueue {
ResourceId = expectedResourceId
};
mockSerializer.Setup(o => o.Deserialize <ITriggerQueue>(decryptedTrigger)).Returns(expectedTrigger);
var catalog = GetTriggersCatalog(mockDirectoryWrapper.Object, mockFileWrapper.Object, "some path", mockSerializer.Object, mockFileSystemWatcher.Object);
var triggerQueue = catalog.LoadQueueTriggerFromFile("somefile.bite");
mockSerializer.Verify(o => o.Deserialize <ITriggerQueue>(decryptedTrigger), Times.Exactly(2));
Assert.AreEqual(expectedTrigger, triggerQueue);
var triggerQueues = catalog.LoadQueuesByResourceId(expectedResourceId);
Assert.AreEqual(1, triggerQueues.Count);
}
public void TriggerQueue_ReferenceEquals_Match_Expect_True()
{
var triggerQueue = new TriggerQueue {
Concurrency = 1
};
var otherTriggerQueue = triggerQueue;
var equals = triggerQueue.Equals(otherTriggerQueue);
Assert.IsTrue(equals);
}
private void EnterTrigger(string newTrigger)
{
try
{
TriggerQueue.Add(newTrigger);
}
catch (Exception e)
{
RaiseStateMachineSystemEvent("ActiveStateMachine - Error entering Trigger", newTrigger + " - " + e.ToString());
}
RaiseStateMachineSystemEvent("ActiveStateMachine - Trigger entered", newTrigger);
}
public void DeployStatsViewerViewModel_TryCalculate_DeployTriggers_Expect_Result()
{
var mockDeployDestinationExplorerViewModel = new Mock <IDeployDestinationExplorerViewModel>();
mockDeployDestinationExplorerViewModel.Setup(o => o.DeployTriggers).Returns(true);
var guid = Guid.NewGuid();
var triggerQueue = new TriggerQueue {
ResourceId = guid
};
var triggerQueues = new List <ITriggerQueue> {
triggerQueue
};
var mockResourceRepository = new Mock <IResourceRepository>();
mockResourceRepository.Setup(o => o.LoadResourceTriggersForDeploy(guid)).Returns(triggerQueues);
mockResourceRepository.Setup(o => o.LoadResourceTestsForDeploy(guid)).Returns(new List <IServiceTestModelTO>());
var mockServer = new Mock <IServer>();
mockServer.Setup(o => o.ResourceRepository).Returns(mockResourceRepository.Object);
var mockExplorerItemViewModel = new Mock <IExplorerItemViewModel>();
mockExplorerItemViewModel.Setup(o => o.ResourceType).Returns(@"WorkflowService");
mockExplorerItemViewModel.Setup(o => o.IsResourceChecked).Returns(true);
mockExplorerItemViewModel.Setup(o => o.Server).Returns(mockServer.Object);
var mockExplorerTreeItem = new Mock <IExplorerTreeItem>();
mockExplorerTreeItem.Setup(o => o.ResourceId).Returns(guid);
mockExplorerTreeItem.Setup(o => o.ResourceType).Returns(@"WorkflowService");
mockExplorerTreeItem.Setup(o => o.IsResourceChecked).Returns(true);
mockExplorerTreeItem.Setup(o => o.Server).Returns(mockServer.Object);
var explorerTreeItems = new List <IExplorerTreeItem> {
mockExplorerTreeItem.Object
};
var deployStatsViewerViewModel = new DeployStatsViewerViewModel(explorerTreeItems, mockDeployDestinationExplorerViewModel.Object);
//-------------------------Act--------------------------------
deployStatsViewerViewModel.TryCalculate(explorerTreeItems);
Assert.AreEqual(1, deployStatsViewerViewModel.Services);
Assert.AreEqual(1, deployStatsViewerViewModel.Triggers);
Assert.AreEqual(0, deployStatsViewerViewModel.Tests);
}
private static IWorkerContext ConstructWorkerContext(out RabbitMQSource rabbitSource, out RabbitMQSource rabbitSink)
{
var mockArgs = new Mock <IArgs>();
mockArgs.Setup(o => o.TriggerId).Returns(_resourceId.ToString());
mockArgs.Setup(o => o.ServerEndpoint).Returns(new Uri("http://somehost:1234"));
var mockResourceCatalogProxy = new Mock <IResourceCatalogProxy>();
var mockFilePath = new Mock <IFilePath>();
mockFilePath.Setup(o => o.GetDirectoryName(It.IsAny <string>())).Returns("C:\\ProgramData\\Warewolf\\Triggers\\Queue");
mockFilePath.Setup(o => o.GetFileName(It.IsAny <string>())).Returns(_resourceId.ToString() + ".bite");
rabbitSource = new RabbitMQSource
{
ResourceID = _sourceId,
HostName = "somehost",
ResourceName = "my somehost resource",
};
rabbitSink = new RabbitMQSource
{
ResourceID = _sinkId,
HostName = "somehost",
ResourceName = "my somehost resource",
};
mockResourceCatalogProxy.Setup(o => o.GetResourceById <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, _sourceId)).Returns(rabbitSource);
mockResourceCatalogProxy.Setup(o => o.GetResourceById <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, _sinkId)).Returns(rabbitSink);
var mockTriggerCatalog = new Mock <ITriggersCatalog>();
var triggerQueue = new TriggerQueue
{
QueueSourceId = _sourceId,
QueueSinkId = _sinkId,
Options = new IOption[] { new OptionBool {
Name = "Durable", Value = true
} },
ResourceId = _resourceId,
QueueName = _queueName,
WorkflowName = _workflowName,
Inputs = new List <IServiceInputBase> {
_expectedIServiceInput
},
};
mockTriggerCatalog.Setup(o => o.PathFromResourceId(It.IsAny <string>())).Returns("C:\\ProgramData\\Warewolf\\Triggers\\Queue");
mockTriggerCatalog.Setup(o => o.LoadQueueTriggerFromFile(It.IsAny <string>())).Returns(triggerQueue);
return(new WorkerContext(mockArgs.Object, mockResourceCatalogProxy.Object, mockTriggerCatalog.Object, mockFilePath.Object));
}
/// <summary>
/// Enter a trigger to the queue
/// </summary>
/// <param name="newTrigger"></param>
private void EnterTrigger(string newTrigger)
{
// Put trigger in queue
try
{
TriggerQueue.Add(newTrigger);
}
catch (Exception ex)
{
RaiseStateMachineSystemEvent(
"ActiveStateMachine - Error entering trigger",
$"{newTrigger} - {ex.ToString()}");
}
// Raise an event
RaiseStateMachineSystemEvent(
"ActiveStateMachine - Trigger entered", newTrigger);
}
/// <summary>
/// Worker method for trigger queue
/// </summary>
/// <param name="token">a instatnce of CancellationToken</param>
private void QueueWorkerMethod(object token)
{
var cancellationToken = (CancellationToken)token;
// Blocks execution until it is reset.
// Used to pause the state machine.
_resumer.WaitOne();
// Block the queue and loop through all triggers available.
// Blocking queue guarantees FIFO and the GetConsumingEnumerable
// method automatically removes triggers from queue!
try
{
foreach (var trigger in TriggerQueue.GetConsumingEnumerable())
{
if (cancellationToken.IsCancellationRequested)
{
RaiseStateMachineSystemEvent(
"State machine: QueueWorker",
"Processing canceled!");
return;
}
// Compare trigger
foreach (var transition in
CurrentState.StateTransitionList
.Where(t => trigger == t.Value.Trigger))
{
ExecuteTransition(transition.Value);
}
}
// Do not place any code here, because it will not be
// executed! The foreach loop keeps spinning on the queue
// until thread is canceled.
}
catch (Exception ex)
{
RaiseStateMachineSystemEvent(
"State machine: QueueWorker",
"Processing canceled! Exception: " + ex.ToString());
// Create a new queue worker task. The previous one is
// completing right now.
Start();
}
}
public void FetchTriggerQueues_Execute_ExpectTestList()
{
//------------Setup for test--------------------------
var fetchTriggerQueues = new FetchTriggerQueues();
var triggerQueue1 = new TriggerQueue();
triggerQueue1.WorkflowName = "My WF";
var triggerQueue2 = new TriggerQueue();
triggerQueue2.TriggerId = Guid.NewGuid();
var triggerQueue3 = new TriggerQueue();
triggerQueue3.QueueName = "My Queue Name";
var listOfTriggerQueues = new List <ITriggerQueue>
{
triggerQueue1, triggerQueue2, triggerQueue3
};
var repo = new Mock <ITriggersCatalog>();
var ws = new Mock <IWorkspace>();
repo.Setup(a => a.Queues).Returns(listOfTriggerQueues).Verifiable();
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
fetchTriggerQueues.TriggersCatalog = repo.Object;
//------------Execute Test---------------------------
var res = fetchTriggerQueues.Execute(inputs, ws.Object);
var msg = serializer.Deserialize <CompressedExecuteMessage>(res);
var triggerQueues = serializer.Deserialize <List <ITriggerQueue> >(msg.GetDecompressedMessage());
//------------Assert Results-------------------------
repo.Verify(a => a.Queues);
Assert.AreEqual(listOfTriggerQueues.Count, triggerQueues.Count);
Assert.AreEqual(listOfTriggerQueues[0].WorkflowName, triggerQueues[0].WorkflowName);
Assert.AreEqual(listOfTriggerQueues[1].TriggerId, triggerQueues[1].TriggerId);
Assert.AreEqual(listOfTriggerQueues[2].QueueName, triggerQueues[2].QueueName);
}
public void TriggersCatalog_LoadQueueTriggerFromFile()
{
var directoryWrapper = new Mock <IDirectory>().Object;
var mockFileWrapper = new Mock <IFile>();
var mockSerializer = new Mock <ISerializer>();
var mockFileSystemWatcher = new Mock <IFileSystemWatcher>();
var decryptedTrigger = "serialized queue data";
var expected = DpapiWrapper.Encrypt(decryptedTrigger);
mockFileWrapper.Setup(o => o.ReadAllText("somefile.bite")).Returns(expected);
var expectedTrigger = new TriggerQueue();
mockSerializer.Setup(o => o.Deserialize <ITriggerQueue>(decryptedTrigger)).Returns(expectedTrigger);
var catalog = GetTriggersCatalog(directoryWrapper, mockFileWrapper.Object, "some path", mockSerializer.Object, mockFileSystemWatcher.Object);
var actual = catalog.LoadQueueTriggerFromFile("somefile.bite");
mockSerializer.Verify(o => o.Deserialize <ITriggerQueue>(decryptedTrigger), Times.Once);
Assert.AreEqual(expectedTrigger, actual);
}
private void QueueWorkerMethod(object dummy)
{
_resumer.WaitOne();
try
{
foreach (var trigger in TriggerQueue.GetConsumingEnumerable()) //not using take method, using this one to get avail triggers in the queue
{
if (_tokenSource.IsCancellationRequested)
{
}
foreach (var transition in CurrentState.StateTransitionList.Where(transition => trigger == transition.Value.Trigger))
{
ExecuteTransition(transition.Value);
}
}
}
catch (Exception ex)
{
RaiseStateMachineSystemEvent("State machine: Queueworker", "Processing canceled! Exception: " + ex.ToString());
Start();
}
}
public void TriggerQueueView_ToModel()
{
var mockOption = new Mock <IOption>();
var mockInputs = new Mock <ICollection <IServiceInputBase> >();
var triggerQueue = new TriggerQueue
{
Name = "TestTriggerQueueName",
QueueSourceId = _queueResourceId,
QueueName = "TestQueue",
WorkflowName = "TestWorkflow",
Concurrency = 1000,
UserName = "******",
Password = "******",
Options = new IOption[] { mockOption.Object },
QueueSinkId = _queueResourceId,
DeadLetterQueue = "TestDeadLetterQueue",
DeadLetterOptions = new IOption[] { mockOption.Object },
Inputs = mockInputs.Object
};
var triggerQueueView = CreateViewModel();
triggerQueueView.ToModel(triggerQueue);
Assert.AreEqual(triggerQueue.Name, triggerQueueView.TriggerQueueName);
Assert.AreEqual(triggerQueue.QueueSourceId, triggerQueueView.SelectedQueueSource.ResourceID);
Assert.AreEqual(triggerQueue.QueueName, triggerQueueView.QueueName);
Assert.AreEqual(triggerQueue.WorkflowName, triggerQueueView.WorkflowName);
Assert.AreEqual(triggerQueue.Concurrency, triggerQueueView.Concurrency);
Assert.AreEqual(triggerQueue.UserName, triggerQueueView.UserName);
Assert.AreEqual(triggerQueue.Password, triggerQueueView.Password);
Assert.AreEqual(triggerQueue.Options.Count(), triggerQueueView.Options.Count);
Assert.AreEqual(triggerQueue.QueueSinkId, triggerQueueView.SelectedDeadLetterQueueSource.ResourceID);
Assert.AreEqual(triggerQueue.DeadLetterQueue, triggerQueueView.DeadLetterQueue);
Assert.AreEqual(triggerQueue.DeadLetterOptions.Count(), triggerQueueView.DeadLetterOptions.Count);
Assert.AreEqual(triggerQueue.Inputs.Count, triggerQueueView.Inputs.Count);
}
TriggerQueue SaveRandomTriggerQueue(ITriggersCatalog triggerCatalog, Guid triggerId)
{
var randomizer = new Random();
var source = "TestResource" + randomizer.Next(1, 10000);
var queue = "TestQueueName" + randomizer.Next(1, 10000);
var workflowName = "TestWorkflow" + randomizer.Next(1, 10000);
var mockResource = new Mock <IResource>();
mockResource.Setup(resource => resource.ResourceName).Returns(source);
mockResource.Setup(resource => resource.ResourceID).Returns(Guid.NewGuid());
var triggerQueueEvent = new TriggerQueue
{
TriggerId = triggerId,
QueueSourceId = mockResource.Object.ResourceID,
QueueName = queue,
WorkflowName = workflowName
};
triggerCatalog.SaveTriggerQueue(triggerQueueEvent);
return(triggerQueueEvent);
}
public void TriggersCatalog_SaveTriggerQueue_WhenHasTriggerId_ShouldSave_NotUpdateTriggerId()
{
var queueTriggersPath = QueueTriggersPath;
var source = "TestResource";
var queue = "TestQueueName";
var workflowName = "TestWorkflow";
var triggerId = Guid.NewGuid();
var mockResource = new Mock <IResource>();
mockResource.Setup(resource => resource.ResourceName).Returns(source);
mockResource.Setup(resource => resource.ResourceID).Returns(Guid.NewGuid());
var triggerQueueEvent = new TriggerQueue
{
QueueSourceId = mockResource.Object.ResourceID,
QueueName = queue,
WorkflowName = workflowName,
TriggerId = triggerId
};
var serializer = new Dev2.Common.Serializers.Dev2JsonSerializer();
var mockSerializer = new Mock <IBuilderSerializer>();
mockSerializer.Setup(o => o.Serialize(It.IsAny <ITriggerQueue>())).Returns(serializer.Serialize(triggerQueueEvent));
var serializerInstance = mockSerializer.Object;
var path = queueTriggersPath + "\\" + triggerId + ".bite";
var directory = new Mock <IDirectory>().Object;
var mockFile = new Mock <IFile>();
var savedData = string.Empty;
mockFile.Setup(o => o.WriteAllText(It.IsAny <string>(), It.IsAny <string>())).Callback <string, string>((filename, data) => {
savedData = data;
});
var file = mockFile.Object;
var fileSystemWatcherWrapper = new Mock <IFileSystemWatcher>().Object;
var triggerCatalog = GetTriggersCatalog(directory, file, queueTriggersPath, serializerInstance, fileSystemWatcherWrapper);
triggerCatalog.SaveTriggerQueue(triggerQueueEvent);
mockFile.Verify(o => o.WriteAllText(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
var isEncrypted = DpapiWrapper.CanBeDecrypted(savedData);
Assert.IsTrue(isEncrypted);
var decryptedTrigger = DpapiWrapper.Decrypt(savedData);
var theSavedTrigger = serializer.Deserialize <ITriggerQueue>(decryptedTrigger);
Assert.IsNotNull(theSavedTrigger);
Assert.AreEqual(workflowName, theSavedTrigger.WorkflowName);
Assert.AreEqual(triggerId, theSavedTrigger.TriggerId);
mockFile.Setup(o => o.Exists(path)).Returns(() => savedData != string.Empty);
triggerCatalog.DeleteTriggerQueue(triggerQueueEvent);
mockFile.Verify(o => o.Delete(path), Times.Once);
Assert.AreEqual(0, triggerCatalog.Queues.Count);
}
private Mock <IServer> SetupForTriggerQueueView(Resource resource)
{
Mock <IResource> _mockQueueSource;
Guid _queueResourceId = Guid.NewGuid();
var mockServer = new Mock <IServer>();
var mockOption = new Mock <IOption>();
var mockInputs = new Mock <ICollection <IServiceInputBase> >();
var triggerQueue = new TriggerQueue
{
Name = "TestTriggerQueueName",
QueueSourceId = _queueResourceId,
QueueName = "TestQueue",
WorkflowName = "TestWorkflow",
Concurrency = 1000,
UserName = "******",
Password = "******",
Options = new IOption[] { mockOption.Object },
QueueSinkId = _queueResourceId,
DeadLetterQueue = "TestDeadLetterQueue",
DeadLetterOptions = new IOption[] { mockOption.Object },
Inputs = mockInputs.Object
};
List <ITriggerQueue> expectedTriggers = new List <ITriggerQueue>
{
triggerQueue
};
string[] tempValues = new string[3];
tempValues[0] = "value1";
tempValues[1] = "value2";
tempValues[2] = "value3";
List <IOption> expectedOptions = SetupOptionsView();
var expectedQueueNames = new Dictionary <string, string[]>
{
{ "QueueNames", tempValues }
};
var queueSource2 = new Mock <IResource>();
_mockQueueSource = new Mock <IResource>();
_mockQueueSource.Setup(source => source.ResourceID).Returns(_queueResourceId);
var expectedList = new List <IResource>
{
_mockQueueSource.Object, queueSource2.Object
};
var mockResourceRepository = new Mock <IResourceRepository>();
if (resource == null)
{
mockResourceRepository.Setup(resourceRepository => resourceRepository.FindOptions(mockServer.Object, _mockQueueSource.Object)).Returns(expectedOptions);
}
else
{
mockResourceRepository.Setup(resourceRepository => resourceRepository.FindOptions(mockServer.Object, resource)).Returns(expectedOptions);
}
mockResourceRepository.Setup(resourceRepository => resourceRepository.FindResourcesByType <IQueueSource>(mockServer.Object)).Returns(expectedList);
mockResourceRepository.Setup(resourceRepository => resourceRepository.GetTriggerQueueHistory(Guid.NewGuid())).Returns(new List <IExecutionHistory>());
mockResourceRepository.Setup(resourceRepository => resourceRepository.FindAutocompleteOptions(mockServer.Object, _mockQueueSource.Object)).Returns(expectedQueueNames);
mockResourceRepository.Setup(resourceRepository => resourceRepository.FetchTriggerQueues()).Returns(expectedTriggers);
var dataList = "<DataList><Name>Test</Name><Surname>test1</Surname><Person><Name>sdas</Name><Surname>asdsad</Surname></Person></DataList>";
var mockResourceModel = new Mock <IContextualResourceModel>();
mockResourceModel.Setup(resourceModel => resourceModel.DataList).Returns(dataList);
mockResourceRepository.Setup(resourceRepository => resourceRepository.LoadContextualResourceModel(_workflowResourceId)).Returns(mockResourceModel.Object);
mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object);
return(mockServer);
}
