public void Redo()
{
var src = Create();
var invoker = new ContextInvoker(new SynchronizationContext(), false);
var history = new History(invoker);
Remove(src, 0, history);
Remove(src, 3, history);
Remove(src, 6, history);
history.Undo();
history.Undo();
Assert.That(src.Count, Is.EqualTo(9));
Assert.That(history.Undoable, Is.True);
Assert.That(history.Redoable, Is.True);
history.Redo();
history.Redo();
history.Redo(); // ignore
Assert.That(src.Count, Is.EqualTo(7));
Assert.That(history.Undoable, Is.True);
Assert.That(history.Redoable, Is.False);
Assert.That(src[0].Value, Is.EqualTo(1));
Assert.That(src[1].Value, Is.EqualTo(2));
Assert.That(src[2].Value, Is.EqualTo(3));
Assert.That(src[3].Value, Is.EqualTo(5));
Assert.That(src[4].Value, Is.EqualTo(6));
Assert.That(src[5].Value, Is.EqualTo(7));
Assert.That(src[6].Value, Is.EqualTo(9));
}
public Task invokeAsync(object obj, ContextInvoker context)
{
var actionToExecute = context.ActionDescriptor;
actionToExecute.PropertyInfo.SetValue(obj, context);
return(Task.CompletedTask);
}
public async Task <object> InvokeAsync(ContextInvoker context)
{
var actionToExecute = context.ActionDescriptor;
var sessionId = context.SessionId;
await _batchTraking.StartAsync(actionToExecute.BatchName, sessionId);
var cancellationToken = new CancellationToken();
Task <object> task = Task.Run(async() =>
{
return(await _batchInvoker.InvokeAsync(context));
}, cancellationToken);
TimerCallback timerAction = new TimerCallback(async(a) =>
{
await _batchTraking.PingAsync(sessionId);
});
Timer timer = new Timer(timerAction, null, new TimeSpan(0, 0, 2), new TimeSpan(0, 0, 2));
var result = await task;
timer.Dispose();
await _batchTraking.StopAsync(sessionId);
return(result);
}
public async Task InvokeAsync(ContextInvoker context, BatchUrlManager urlManager, Guid?parentSessionId)
{
var batchActionProvider = _batchActionFactory.getProvider(urlManager);
string response = await batchActionProvider.InvokeAsync(urlManager, context);
response = $"{context.SessionId.ToString()} - {response}";
await context.Response.Body.WriteAsync(Encoding.UTF8.GetBytes(response), 0, response.Length);
}
public async void DefaultBatchInvokerTest_invokeAsync()
{
//Arrange
var propertyInvoker = new Mock <IPropertyInvoker>(MockBehavior.Strict);
//var methodActivator = new Mock<MethodActivator>(MockBehavior.Strict);
//methodActivator.Setup((s) => s.CreateInstance<object>(It.IsAny<IServiceProvider>(), It.IsAny<Type>()))
var methodActivator = new MethodActivator();
var isharpBatchTrackingActivator = new Mock <ISharpBatchTrackingFactory>(MockBehavior.Strict);
isharpBatchTrackingActivator.Setup((s) => s.getTrakingProvider()).Returns(new TrackingMemory()).Verifiable();
var modelSerializer = new Mock <IModelSerializer>(MockBehavior.Strict);
modelSerializer.Setup((s) => s.Serialize((object)"method1")).Returns("\"method1\"");
DefaultBatchInvoker defaultBatchInvoker = new DefaultBatchInvoker(
propertyInvoker.Object,
methodActivator,
isharpBatchTrackingActivator.Object,
modelSerializer.Object);
var requestService = new Mock <IServiceProvider>(MockBehavior.Strict);
requestService.Setup((s) => s.GetService(It.IsAny <Type>())).Returns((object)"Any").Verifiable();
var httpRequest = new Mock <HttpRequest>(MockBehavior.Strict);
httpRequest.Setup((s) => s.Path).Returns(new PathString("/batch/exec/batch/action"));
httpRequest.Setup((s) => s.QueryString).Returns(new QueryString()).Verifiable();
Stream bodyStream = new MemoryStream();
var httpResponse = new Mock <HttpResponse>(MockBehavior.Strict);
httpResponse.Setup((s) => s.Body).Returns(bodyStream).Verifiable();
var context = new Mock <HttpContext>(MockBehavior.Strict);
context.Setup((s) => s.Request).Returns(httpRequest.Object).Verifiable();
context.Setup((s) => s.Response).Returns(httpResponse.Object).Verifiable();
context.Setup((s) => s.RequestServices).Returns(requestService.Object).Verifiable();
ContextInvoker contextInvoker = ContextInvoker.Create(context.Object);
List <TypeInfo> types = new List <TypeInfo>();
types.Add(typeof(SimplePOCOBatch).GetTypeInfo());
var descriptions = AssemblyDiscoveryActionDescription.actionDescription(types);
contextInvoker.ActionDescriptor = descriptions.First();
//Act
var response = await defaultBatchInvoker.InvokeAsync(contextInvoker);
//Assert
Assert.NotNull(response);
Assert.Equal("\"method1\"", response);
}
public void Post()
{
var dest = 0;
var src = new ContextInvoker(new SynchronizationContext(), false);
src.Invoke(() => dest++);
Task.Delay(100).Wait();
Assert.That(dest, Is.EqualTo(1));
}
public async Task InvokeAsync(HttpContext context, BatchUrlManager urlManager, Guid?parentSessionId)
{
var contextInvoker = ContextInvoker.Create(context);
contextInvoker.BatchName = urlManager.RequestBatchName;
contextInvoker.ActionName = urlManager.RequestBatchAction;
contextInvoker.ActionDescriptor = null;
contextInvoker.ParentSessionId = parentSessionId;
await InvokeAsync(contextInvoker, urlManager, parentSessionId);
}
public async Task InvokeAsync(ContextInvoker context, BatchUrlManager urlManager)
{
var contextInvoker = context;
contextInvoker.BatchName = urlManager.RequestBatchName;
contextInvoker.ActionName = urlManager.RequestBatchAction;
contextInvoker.SessionId = Guid.NewGuid();
contextInvoker.ActionDescriptor = null;
await InvokeAsync(contextInvoker, urlManager, context.SessionId);
}
public async Task <string> InvokeAsync(IBatchUrlManager urlManager, ContextInvoker context)
{
switch (urlManager.RequestCommand)
{
case BatchUrlManagerCommand.Status:
var batchStaus = await _trakingProvider.GetStatusAsync(new Guid(context.Parameters["sessionid"].ToString()));
var result = _modelSerializer.Serialize(batchStaus);
return(result);
default:
throw new InvalidCastException($"Command {urlManager.RequestCommand.ToString()} not found");
}
}
public async void BatchActionProviderTest_SimplePOCOBatchMethod1Invoke()
{
//Arrange
List <TypeInfo> types = new List <TypeInfo>();
types.Add(typeof(SimplePOCOBatch).GetTypeInfo());
//act
var actionDescriptions = AssemblyDiscoveryActionDescription.actionDescription(types.AsEnumerable());
var filteredActionDescription = actionDescriptions.Where(p => p.ActionName == "method1");
var batchUrlManager = new Mock <IBatchUrlManager>(MockBehavior.Strict);
batchUrlManager.Setup((s) => s.RequestCommand)
.Returns(BatchUrlManagerCommand.Exec)
.Verifiable();
batchUrlManager.Setup((s) => s.isBatch).Returns(true).Verifiable();
batchUrlManager.Setup((s) => s.RequestBatchName).Returns("SimplePOCO").Verifiable();
batchUrlManager.Setup((s) => s.RequestBatchAction).Returns("method1").Verifiable();
var context = new ContextInvoker()
{
ActionDescriptor = null,
ActionName = "method1",
BatchName = "SimplePOCO",
SessionId = Guid.NewGuid()
};
var applicationBatchManager = new Mock <IApplicationBatchManager>(MockBehavior.Strict);
applicationBatchManager.Setup((s) => s.SearcByNameAndAction("SimplePOCO", "method1")).Returns(filteredActionDescription).Verifiable();
var batchInvokerProvider = new Mock <IBatchInvokerProvider>(MockBehavior.Strict);
batchInvokerProvider.Setup((s) => s.InvokeAsync(context)).Returns(Task.FromResult((object)"method1")).Verifiable();
BatchActionProvider batchActionProvider = new BatchActionProvider(applicationBatchManager.Object, batchInvokerProvider.Object);
//Act
var result = await batchActionProvider.InvokeAsync(batchUrlManager.Object, context);
//Assert
Assert.NotNull(result);
Assert.Equal("method1", result);
Assert.Same(filteredActionDescription.First(), context.ActionDescriptor);
batchInvokerProvider.Verify();
applicationBatchManager.Verify();
}
public async void DefaultPropertyInvokerTest_invoke()
{
//Arrange
DefaultPropertyInvoker propertyInvoker = new DefaultPropertyInvoker();
SimplePOCOPropertyBatch simplePOCO = new SimplePOCOPropertyBatch();
ContextInvoker contextInvoker = new ContextInvoker()
{
ActionDescriptor = new BatchActionDescriptor()
};
contextInvoker.ActionDescriptor.PropertyInfo = typeof(SimplePOCOPropertyBatch).GetTypeInfo().GetDeclaredProperty("context");
//Act
await propertyInvoker.invokeAsync(simplePOCO, contextInvoker);
//Assert
Assert.NotNull(simplePOCO.context);
}
public async void BatchActionProviderTest_SimplePOCOBatchMultipleMethodMatch()
{
List <TypeInfo> types = new List <TypeInfo>();
types.Add(typeof(SimplePOCOBatch).GetTypeInfo());
//act
var actionDescriptions = AssemblyDiscoveryActionDescription.actionDescription(types.AsEnumerable());
var batchUrlManager = new Mock <IBatchUrlManager>(MockBehavior.Strict);
batchUrlManager.Setup((s) => s.RequestCommand)
.Returns(BatchUrlManagerCommand.Exec)
.Verifiable();
batchUrlManager.Setup((s) => s.isBatch).Returns(true).Verifiable();
batchUrlManager.Setup((s) => s.RequestBatchName).Returns("SimplePOCO").Verifiable();
batchUrlManager.Setup((s) => s.RequestBatchAction).Returns("method1").Verifiable();
var context = new ContextInvoker()
{
ActionDescriptor = null,
ActionName = "method1",
BatchName = "SimplePOCO",
SessionId = Guid.NewGuid()
};
var applicationBatchManager = new Mock <IApplicationBatchManager>(MockBehavior.Strict);
applicationBatchManager.Setup((s) => s.SearcByNameAndAction("SimplePOCO", "method1")).Returns(actionDescriptions).Verifiable();
var batchInvokerProvider = new Mock <IBatchInvokerProvider>(MockBehavior.Strict);
batchInvokerProvider.Setup((s) => s.InvokeAsync(context)).Returns(Task.FromResult((object)"method1")).Verifiable();
BatchActionProvider batchActionProvider = new BatchActionProvider(applicationBatchManager.Object, batchInvokerProvider.Object);
var response = await Assert.ThrowsAsync <Exception>(() => batchActionProvider.InvokeAsync(batchUrlManager.Object, context));
Assert.Equal("Too many batch satisfy the search", response.Message);
}
public void Properties()
{
var name = nameof(Properties);
var text = "GetText";
var invoker = new ContextInvoker(new SynchronizationContext(), false);
using (var dest = new RibbonElement(name, () => text, invoker))
{
Assert.That(dest.Name, Is.EqualTo(name));
Assert.That(dest.Text, Is.EqualTo(text));
Assert.That(dest.Tooltip, Is.EqualTo(text));
Assert.That(dest.LargeIcon, Is.EqualTo($"pack://application:,,,/Assets/Large/{name}.png"));
Assert.That(dest.SmallIcon, Is.EqualTo($"pack://application:,,,/Assets/Small/{name}.png"));
Locale.Set(Language.French);
Assert.That(dest.Text, Is.EqualTo(text));
Assert.That(dest.Tooltip, Is.EqualTo(text));
}
Locale.Set(Language.Japanese);
}
public async Task <string> InvokeAsync(IBatchUrlManager urlManager, ContextInvoker context)
{
try
{
var batchActionDescriptor = Search(urlManager.RequestBatchName, urlManager.RequestBatchAction);
context.ActionDescriptor = batchActionDescriptor;
if (batchActionDescriptor.IsAsync)
{
var response = _batchInvokerProvider.InvokeAsync(context);
return("Batch Started");
}
else
{
var response = await _batchInvokerProvider.InvokeAsync(context) as string;
return(response?.ToString());
}
}catch (Exception ex)
{
throw ex;
}
}
public void Undo()
{
var src = Create();
var invoker = new ContextInvoker(new SynchronizationContext(), false);
var history = new History(invoker);
Assert.That(src.Count, Is.EqualTo(10));
Assert.That(history.Undoable, Is.False);
Assert.That(history.Redoable, Is.False);
Remove(src, 3, history);
Remove(src, 5, history);
Remove(src, 7, history);
Assert.That(src.Count, Is.EqualTo(7));
Assert.That(history.Undoable, Is.True);
Assert.That(history.Redoable, Is.False);
history.Undo();
Assert.That(src.Count, Is.EqualTo(8));
Assert.That(history.Undoable, Is.True);
Assert.That(history.Redoable, Is.True);
history.Undo();
history.Undo();
history.Undo(); // ignore
Assert.That(src.Count, Is.EqualTo(10));
Assert.That(history.Undoable, Is.False);
Assert.That(history.Redoable, Is.True);
for (var i = 0; i < 10; ++i)
{
Assert.That(src[i].Value, Is.EqualTo(i));
}
}
public async Task <object> InvokeAsync(ContextInvoker context)
{
var actionToExecute = context.ActionDescriptor;
var executor = MethodExecutor.Create(actionToExecute.ActionInfo, actionToExecute.BatchTypeInfo);
var activatorInstance = _activator.CreateInstance <object>(context.RequestServices, actionToExecute.BatchTypeInfo.AsType());
//Check Propertyes to activate
if (actionToExecute.PropertyInfo != null)
{
await _propertyInvoker.invokeAsync(activatorInstance, context);
}
var batchExecutionContext = BatchExecutionContext.Create(context);
//Execute attribute onExecuting
foreach (var executionAttribute in actionToExecute.ExecutionAttribute)
{
executionAttribute.onExecuting(batchExecutionContext);
}
var parameterBinding = new DefaultBatchInvokerParameterBinding(context.Parameters, actionToExecute.ActionInfo, _modelSerializer);
var parameters = parameterBinding.Bind();
object result = null;
object response = null;
try
{
result = executor.Execute(activatorInstance, parameters);
if (actionToExecute.IsAsync)
{
var task = result as Task;
await task;
var responseType = result.GetType();
var taskTType = responseType.GetGenericArguments()[0];
var resultProperty = typeof(Task <>).MakeGenericType(taskTType).GetProperty("Result");
response = resultProperty.GetValue(task);
}
else
{
response = result;
}
//Save response in ShareMessage
IResponseObject responseObject = new ResponseObject(response, context.SessionId);
context.ShareMessage.Set <IResponseObject>(responseObject);
}catch (Exception ex)
{
IResponseObject responseObject = new ResponseObject(ex, context.SessionId);
context.ShareMessage.Set <IResponseObject>(responseObject);
await _sharpBatchTraking.AddExAsync(context.SessionId, ex);
foreach (var item in actionToExecute.ExceptionAttribute)
{
item.onExecuted(batchExecutionContext, ex);
}
}
foreach (var executionAttribute in actionToExecute.ExecutionAttribute)
{
executionAttribute.onExecuted(batchExecutionContext);
}
var serializedResult = "";
//If result not null i serialize it
if (result != null)
{
serializedResult = _modelSerializer.Serialize(response);
}
return(serializedResult);
}
public async void DefaultBatchInvokerProviderTest_InvokeAsync()
{
//Arrange
var batchInvoker = new Mock <IBatchInvoker>(MockBehavior.Strict);
var tracking = new Mock <ISharpBatchTracking>(MockBehavior.Strict);
tracking.Setup(s => s.StartAsync(It.IsAny <string>(), It.IsAny <Guid>())).Returns(Task.CompletedTask);
tracking.Setup(s => s.PingAsync(It.IsAny <Guid>())).Returns(Task.CompletedTask);
tracking.Setup(s => s.StopAsync(It.IsAny <Guid>())).Returns(Task.CompletedTask);
var sharpBatchTrakingFactory = new Mock <ISharpBatchTrackingFactory>(MockBehavior.Strict);
sharpBatchTrakingFactory.Setup((s) => s.getTrakingProvider())
.Returns(tracking.Object)
.Verifiable();
var defaultBatchInvokerProvider = new DefaultBatchInvokerProvider(batchInvoker.Object, sharpBatchTrakingFactory.Object);
batchInvoker.Setup((s) => s.InvokeAsync(It.IsAny <ContextInvoker>()))
.Returns(Task.FromResult <object>("executed"))
.Verifiable();
var requestService = new Mock <IServiceProvider>(MockBehavior.Strict);
requestService.Setup((s) => s.GetService(It.IsAny <Type>()))
.Returns((object)"Any")
.Verifiable();
var httpRequest = new Mock <HttpRequest>(MockBehavior.Strict);
httpRequest.Setup((s) => s.Path)
.Returns(new PathString("/batch/exec/batch/action"));
httpRequest.Setup((s) => s.QueryString)
.Returns(new QueryString())
.Verifiable();
Stream bodyStream = new MemoryStream();
var httpResponse = new Mock <HttpResponse>(MockBehavior.Strict);
httpResponse.Setup((s) => s.Body).Returns(bodyStream).Verifiable();
var context = new Mock <HttpContext>(MockBehavior.Strict);
context.Setup((s) => s.Request).Returns(httpRequest.Object).Verifiable();
context.Setup((s) => s.Response).Returns(httpResponse.Object).Verifiable();
context.Setup((s) => s.RequestServices).Returns(requestService.Object).Verifiable();
//var contextInvoker = ContextInvoker.Create(context.Object);
var contextInvoker = ContextInvoker.Create(context.Object);
contextInvoker.SessionId = Guid.NewGuid();
contextInvoker.ActionDescriptor = new BatchActionDescriptor()
{
BatchName = "Name"
};
//Act
var response = await defaultBatchInvokerProvider.InvokeAsync(contextInvoker);
//Assert
Assert.NotNull(response);
Assert.Equal("executed", response);
}
private string createFullFileName(string fileName, string fileExtention, string path, bool timeStampToken, bool sessionIdInFileName, ContextInvoker context)
{
var fullFileName = $"{path ?? ""}{fileName}";
if (sessionIdInFileName)
{
fullFileName += $"-{context.SessionId.ToString()}";
}
if (timeStampToken)
{
fullFileName += $"-{DateTime.Now.ToString("yyyyMMddHHmmssfff")}";
}
if (!string.IsNullOrEmpty(fileExtention))
{
fullFileName += $".{fileExtention}";
}
return(fullFileName);
}
public void BaseBatch_ToTrackingStringContent()
{
//Arrange
var serializedContent = "";
var modelSerializer = new Mock <IModelSerializer>(MockBehavior.Strict);
modelSerializer.Setup((s) => s.Serialize(It.IsAny <object>())).Returns(serializedContent);
var trackingProvider = new Mock <ISharpBatchTracking>(MockBehavior.Strict);
trackingProvider.Setup((s) => s.AddMessageAsync(It.IsAny <Guid>(), It.IsAny <string>())).Returns(Task.CompletedTask).Verifiable();
var trackingFactory = new Mock <ISharpBatchTrackingFactory>(MockBehavior.Strict);
trackingFactory.Setup((s) => s.getTrakingProvider()).Returns(trackingProvider.Object).Verifiable();
var requestService = new Mock <IServiceProvider>(MockBehavior.Strict);
requestService.Setup((s) => s.GetService(It.Is <Type>(t => t.Name.Equals(nameof(ISharpBatchTrackingFactory)))))
.Returns(trackingFactory.Object)
.Verifiable();
requestService.Setup((s) => s.GetService(It.Is <Type>(t => t.Name.Equals(nameof(IModelSerializer)))))
.Returns(modelSerializer.Object)
.Verifiable();
Stream bodyStream = new MemoryStream();
var httpResponse = new Mock <HttpResponse>(MockBehavior.Strict);
httpResponse.Setup((s) => s.Body).Returns(bodyStream).Verifiable();
var httpRequest = new Mock <HttpRequest>(MockBehavior.Strict);
httpRequest.Setup((s) => s.QueryString)
.Returns(new QueryString("?param=123"));
var localBatch = new BaseBatch();
var context = new Mock <HttpContext>(MockBehavior.Strict);
context.Setup((s) => s.RequestServices).Returns(requestService.Object).Verifiable();
context.Setup((s) => s.Request).Returns(httpRequest.Object).Verifiable();
context.Setup((s) => s.Response).Returns(httpResponse.Object).Verifiable();
localBatch.BatchContext = ContextInvoker.Create(context.Object);
localBatch.BatchContext.SessionId = Guid.NewGuid();
var dataTotrack = new TestData()
{
Name = "name",
Surname = "surname"
};
//Act
var ex = Record.Exception(() =>
{
localBatch.ToTracking(dataTotrack);
requestService.Verify();
});
//Assert
Assert.Null(ex);
}
