/// <inheritdoc />
public override void DetectChanges(InternalEntityEntry entry)
{
_executor.Execute(hook => hook.DetectingEntryChanges(this, entry.StateManager, entry));
base.DetectChanges(entry);
_executor.Execute(hook => hook.DetectedEntryChanges(this, entry.StateManager, entry));
}
public void ActionsCanBeExecutedNotAtTheSameThread()
{
List <int> threadIds = new List <int>();
var executer = new ActionExecutor();
executer.AddActionToQueue(() =>
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
});
executer.AddActionToQueue(() =>
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
});
executer.AddActionToQueue(() =>
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
});
executer.AddActionToQueue(() =>
{
threadIds.Add(Thread.CurrentThread.ManagedThreadId);
});
var task = executer.Execute();
task.GetAwaiter().GetResult();
var uniqueItems = threadIds.Distinct().Count();
Assert.True(uniqueItems >= 1);
}
public void ActionsCanBeAddedNotAtTheSameTime()
{
int sum = 0;
var executer = new ActionExecutor();
sum += 5;
executer.AddActionToQueue(() =>
{
sum += 10;
});
sum += 5;
executer.AddActionToQueue(() =>
{
sum += 10;
});
var task = executer.Execute();
task.GetAwaiter().GetResult();
Assert.Equal(30, sum);
}
public void Move_RoughTerrain_UnitStationary(MoveAction.Direction direction, int x, int y)
{
//Setup
var unit = CreateUnit();
unit.Setup(u => u.Location).Returns(new Point(5, 5));
var newLocation = new Point(x, y);
var state = CreateStateMock(CreateUnitList(unit));
state.Setup(s => s.Geography.GetTerrainAt(newLocation)).Returns(Geography.Terrain.ROUGH);
AddUnitToState(unit, state);
var action = new MoveAction(direction);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
//Moved in the correct direction
unit.Verify(u => u.Move(newLocation), Times.Never);
}
public void Attack_TargetHealthBelowZero_TargetDeletedFromState()
{
//Setup
var unit = CreateUnit();
var attacker = unit.As <IAttacker>();
var attack = new Random().Next(1, 10);
attacker.Setup(a => a.AttackLevel).Returns(attack);
var target = new Mock <WorldObject>();
target.Setup(t => t.ShouldRemove()).Returns(true);
var targetId = Guid.NewGuid();
var state = CreateStateMock(CreateUnitList(unit));
state.Setup(s => s.FindObject(targetId)).Returns(target.Object);
AddUnitToState(unit, state);
var action = new AttackAction(targetId);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
target.Verify(t => t.ShouldRemove());
state.Verify(s => s.Destroy(target.Object));
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
var actionExecutor = new ActionExecutor(); //Initialization of ActionExecutor class
//Select each created content
fileContents.Select((content, index) =>
{
//Add action with writing content to file to list of actions
actionExecutor.AddActionToQueue(() =>
{
Thread.Sleep(2000); //Just to make action longer and be sure that UI is not blocked
//Standart .net procudere of writing file to path
using (StreamWriter outputFile = new StreamWriter(Path.Combine(documentsPath, string.Format(fileNameTemplate, ++index))))
{
outputFile.Write(content);
}
});
return(content);
}).ToList(); //Because .Select() returns IEnumerable and it's causes LazyLoading
actionExecutor.Execute(); //Execute actions in background sequentially
this.ContentTextBox.Clear(); //Refresh TextBox
this.CountOfContentsLabel.Content = "0"; //Default value of label
}
private void PerformUpdates(IProjectManager projectManager)
{
var updateUtility = new UpdateUtility(_resolver)
{
AllowPrereleaseVersions = IncludePrerelease.IsPresent,
Logger = this,
Safe = Safe.IsPresent
};
var actions = Enumerable.Empty <Resolver.PackageAction>();
if (String.IsNullOrEmpty(ProjectName))
{
var projectManagers = PackageManager.SolutionManager.GetProjects()
.Select(p => PackageManager.GetProjectManager(p));
actions = updateUtility.ResolveActionsForUpdate(
Id, Version, projectManagers, projectNameSpecified: false);
}
else if (projectManager != null)
{
actions = updateUtility.ResolveActionsForUpdate(
Id, Version, new[] { projectManager }, projectNameSpecified: true);
}
if (WhatIf)
{
foreach (var action in actions)
{
Log(MessageLevel.Info, Resources.Log_OperationWhatIf, action);
}
return;
}
_actionExecutor.Execute(actions);
}
public void Display_DisplayUpdateCalled()
{
//Setup
var unit = CreateUnit();
SensoryDisplay display = new SensoryDisplay();
display.Taste.ResetTo(1, 5);
unit.Setup(u => u.Display.UpdateFrom(display));
var action = new DisplayAction(display);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var state = CreateStateMock(CreateUnitList(unit));
AddUnitToState(unit, state);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
unit.Verify(unit => unit.Display.UpdateFrom(display));
}
public void Take_AdjacentAvailableTarget_UnitOwnsTarget()
{
//Setup
var unit = CreateUnit();
var taker = unit.As <ITaker>();
var target = new Mock <WorldObject>();
var transfer = target.As <ITransferable>();
var targetId = Guid.NewGuid();
var state = CreateStateMock(CreateUnitList(unit));
state.Setup(s => s.FindObject(targetId)).Returns(target.Object);
AddUnitToState(unit, state);
var action = new TakeAction(targetId);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
transfer.Verify(t => t.TransferTo(unit.Object.Id));
taker.Verify(t => t.Take(transfer.Object));
}
public void Desensitizate(ModelMetadata metadata)
{
if (metadata.Model == null)
{
throw new ArgumentNullException("metadata.Model ");
}
var typeName = MethodFullName.Substring(0, MethodFullName.LastIndexOf('.'));
var methodName = MethodFullName.Substring(typeName.Length + 1);
Type type = Type.GetType(typeName);
if (type == null)
{
throw new InvalidOperationException($"无效的类型名{typeName}");
}
var methodInfo = type.GetMethod(methodName);
if (methodInfo == null)
{
throw new InvalidOperationException($"{typeName}找不到有效的方法名{methodName}");
}
if (!methodInfo.IsStatic)
{
throw new InvalidOperationException($"仅支持静态方法");
}
if (methodInfo.ReturnType != typeof(string))
{
throw new InvalidOperationException($"方法返回值因为string类型");
}
ActionExecutor executor = new ActionExecutor(methodInfo);
executor.Execute(null, new object[] { metadata.Model });
// methodInfo.Invoke(null, new object[] { metadata.Model }).ToString();
}
public void Attack_AdjacentTarget_ReducesTargetHealth()
{
//Setup
var unit = CreateUnit();
var attacker = unit.As <IAttacker>();
var attack = new Random().Next(1, 10);
attacker.Setup(a => a.AttackLevel).Returns(attack);
var target = new Mock <WorldObject>();
var targetId = Guid.NewGuid();
var state = CreateStateMock(CreateUnitList(unit));
state.Setup(s => s.FindObject(targetId)).Returns(target.Object);
AddUnitToState(unit, state);
var action = new AttackAction(targetId);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
target.Verify(t => t.TakeDamage(attack));
}
public void Drop_UnitCannotDropObject_NoActionTaken()
{
//Setup
var unit = CreateUnit();
var dropper = unit.As <IDropper>();
var state = CreateStateMock(CreateUnitList(unit));
AddUnitToState(unit, state);
var subject = new ActionExecutor(state.Object);
var transferObject = new Mock <WorldObject>();
var transferable = transferObject.As <ITransferable>();
transferable.Setup(tr => tr.Owner).Returns(unit.Object.Id);
var transferGuid = Guid.NewGuid();
var action = new DropAction(transferGuid);
state.Setup(s => s.FindObject(transferGuid)).Returns(transferObject.Object);
//Unit will not drop on its end
dropper.Setup(d => d.Drop(transferable.Object)).Returns(false);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
//Act
subject.Execute(actions);
//Assert
//Dropper asked to drop but transfer object not asked to drop
dropper.Verify(d => d.Drop(transferable.Object));
transferable.Verify(t => t.Drop(), Times.Never);
}
public void Create_ValidCreateAction_NewObjectCreatedAndAddedToState()
{
//Setup
var unit = CreateUnit();
var creator = unit.As <ICreator>();
var action = new CreateAction(0);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var obj = new Mock <WorldObject>().Object;
creator.Setup(c => c.CanCreate(action)).Returns(true);
creator.Setup(c => c.Create(action)).Returns(obj);
var state = CreateStateMock(CreateUnitList(unit));
AddUnitToState(unit, state);
var subject = new ActionExecutor(state.Object);
//Act
subject.Execute(actions);
//Assert
creator.Verify(c => c.CanCreate(action));
creator.Verify(c => c.Create(action));
state.Verify(s => s.Add(obj));
}
public void ActionsMustBeExecutedSequentially()
{
StringBuilder stringBuilder = new StringBuilder();
var executer = new ActionExecutor();
executer.AddActionToQueue(() =>
{
stringBuilder.Append("My ");
});
executer.AddActionToQueue(() =>
{
stringBuilder.Append("name ");
});
executer.AddActionToQueue(() =>
{
stringBuilder.Append("is ");
});
executer.AddActionToQueue(() =>
{
stringBuilder.Append("Dmitriy");
});
var task = executer.Execute();
task.GetAwaiter().GetResult();
Assert.Equal("My name is Dmitriy", stringBuilder.ToString());
}
public void Drop_UnownedObject_FailAction()
{
//Setup
var unit = CreateUnit();
var dropper = unit.As <IDropper>();
var state = CreateStateMock(CreateUnitList(unit));
AddUnitToState(unit, state);
var subject = new ActionExecutor(state.Object);
var transferObject = new Mock <WorldObject>();
var transferable = transferObject.As <ITransferable>();
//Has no owner
transferable.Setup(tr => tr.Owner).Returns(null);
var transferGuid = Guid.NewGuid();
var action = new DropAction(transferGuid);
state.Setup(s => s.FindObject(transferGuid)).Returns(transferObject.Object);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
//Act & Assert
Assert.Throws <BadActionException>(() => subject.Execute(actions));
}
public void Take_DistantTarget_FailsAction()
{
//Setup
var unit = CreateUnit();
var taker = unit.As <ITaker>();
var target = new Mock <WorldObject>();
var transfer = target.As <ITransferable>();
var targetId = Guid.NewGuid();
target.Setup(t => t.Location).Returns(new System.Drawing.Point(10, 10));
var state = CreateStateMock(CreateUnitList(unit));
state.Setup(s => s.FindObject(targetId)).Returns(target.Object);
AddUnitToState(unit, state);
var action = new TakeAction(targetId);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
var subject = new ActionExecutor(state.Object);
//Act & Assert
Assert.Throws <BadActionException>(() => subject.Execute(actions));
}
public void Drop_NonTransferableObject_FailsAction()
{
//Setup
var unit = CreateUnit();
var dropper = unit.As <IDropper>();
var state = CreateStateMock(CreateUnitList(unit));
AddUnitToState(unit, state);
var transferObject = new Mock <WorldObject>();
//Object not given the ITransferable interface so it will fail
var transferGuid = Guid.NewGuid();
var action = new DropAction(transferGuid);
state.Setup(s => s.FindObject(transferGuid)).Returns(transferObject.Object);
var subject = new ActionExecutor(state.Object);
UnitActionCollection actions = new UnitActionCollection();
actions.AddAction(unit.Object.Id, action);
//Act & Assert
Assert.Throws <BadActionException>(() => subject.Execute(actions));
}
public bool Match(object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
var typeName = MethodFullName.Substring(0, MethodFullName.LastIndexOf('.'));
var methodName = MethodFullName.Substring(typeName.Length + 1);
Type type = Type.GetType(typeName);
if (type == null)
{
throw new InvalidOperationException($"无效的类型名{typeName}");
}
var methodInfo = type.GetMethod(methodName);
if (methodInfo == null)
{
throw new InvalidOperationException($"{typeName}找不到有效的方法名{methodName}");
}
if (!methodInfo.IsStatic)
{
throw new InvalidOperationException($"仅支持静态方法");
}
if (methodInfo.ReturnType != typeof(bool))
{
throw new InvalidOperationException($"方法返回值因为bool类型");
}
ActionExecutor executor = new ActionExecutor(methodInfo);
return(Convert.ToBoolean(executor.Execute(null, new object[] { value })));
//return Convert.ToBoolean(methodInfo.Invoke(null, new object[] { value }));
}
private ObjectResult Execute <TRequest, TResult>
(
IAction <TRequest, TResult> action,
TRequest request,
Action <Success <TResult>, ObjectResult> onSuccess = null
)
=> _actionExecutor
.Execute(action, request, User, successPostProcessor: onSuccess);
public void Execute_ValidatesParameters()
{
// Arrange
var items = new[] { "Hello", "World" };
var executor = new ActionExecutor <string>(items);
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => executor.Execute(null /* action */));
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId"));
}
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager(_packageRepository, useFallbackForDependencies: false);
IProjectManager projectManager = packageManager.GetProjectManager(project);
EventHandler <PackageOperationEventArgs> packageReferenceRemovingHandler = (sender, e) =>
{
_scriptExecutor.Execute(
e.InstallPath,
PowerShellScripts.Uninstall,
e.Package,
project,
projectManager.GetTargetFrameworkForPackage(packageId),
NullLogger.Instance);
};
try
{
projectManager.PackageReferenceRemoving += packageReferenceRemovingHandler;
// Locate the package to uninstall
IPackage package = packageManager.LocatePackageToUninstall(
projectManager,
packageId,
version: null);
// resolve actions
var resolver = new ActionResolver()
{
RemoveDependencies = removeDependencies
};
resolver.AddOperation(PackageAction.Uninstall, package, projectManager);
var actions = resolver.ResolveActions();
// execute actions
var actionExecutor = new ActionExecutor();
actionExecutor.Execute(actions);
}
finally
{
projectManager.PackageReferenceRemoving -= packageReferenceRemovingHandler;
}
}
public void Execute_FlowsCorrectOrder()
{
// Arrange
var items = new[] { "Hello", "World" };
var executor = new ActionExecutor <string>(items);
var results = new List <string>();
// Act
executor.Execute(s => results.Add(s));
// Assert
Assert.Equal(items, results);
}
public void Accepts_EmptyArray()
{
// Arrange
var items = new string[0];
var executor = new ActionExecutor <string>(items);
bool called = false;
// Act
executor.Execute(s => called = true);
// Assert
Assert.Equal(false, called);
}
public static void Push(ActionExecutor executor, ActionType actionType, float delay = -1, float startTime = 0)
{
if (actionType == ActionType.Execute)
{
executor.Execute(delay, startTime);
}
else
{
executor.Undo(delay, startTime);
}
actionStacks.Push(new ActionStackData(executor, actionType));
//Debug.Log("Push: " + executor.ID);
}
public void ActionsMustBeExecutedInBackground()
{
var executer = new ActionExecutor();
executer.AddActionToQueue(() =>
{
Thread.Sleep(Timeout.Infinite);
});
executer.Execute();
Assert.True(true);
}
protected override bool ExecuteCore(PackageItem item)
{
IVsPackageManager activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
using (activePackageManager.SourceRepository.StartOperation(OperationName, item.Id, item.Version))
{
ShowProgressWindow();
// Resolve operations
var resolver = new ActionResolver()
{
Logger = this,
DependencyVersion = activePackageManager.DependencyVersion,
IgnoreDependencies = false,
AllowPrereleaseVersions = IncludePrerelease
};
var projectManager = activePackageManager.GetProjectManager(_project);
projectManager.Logger = this;
resolver.AddOperation(PackageAction.Install, item.PackageIdentity, projectManager);
var actions = resolver.ResolveActions();
// show license agreeement
bool acceptLicense = ShowLicenseAgreement(actions);
if (!acceptLicense)
{
return(false);
}
// execute operations
try
{
RegisterPackageOperationEvents(activePackageManager, projectManager);
var actionExecutor = new ActionExecutor()
{
Logger = this
};
actionExecutor.Execute(actions);
}
finally
{
UnregisterPackageOperationEvents(activePackageManager, projectManager);
}
return(true);
}
}
public void Can_execute_cmd_without_bat_or_exe()
{
// setup
var properties = new Dictionary<string, string>();
properties["rootDirectory"] = _testDirectory.FullName;
var execute = new ActionExecutor(new ConsoleWriter(), new RunContext { Properties = properties });
File.WriteAllText(Path.Combine(_testDirectory.FullName, "test.txt"), "test");
Directory.CreateDirectory(Path.Combine(_testDirectory.FullName, "test"));
// act
execute.Execute(new Command { Value = "xcopy /f/i \"$(rootDirectory)/test.txt\" \"$(rootDirectory)/test/\"" });
// assert
File.Exists(Path.Combine(_testDirectory.FullName, "test/test.txt"));
}
private bool InstallSatellitePackages(IFileSystem fileSystem, List<IPackage> satellitePackages)
{
if (satellitePackages.Count == 0)
{
return false;
}
var packageManager = CreatePackageManager(fileSystem, AllowMultipleVersions);
var executor = new ActionExecutor();
var operations = satellitePackages.Select(package =>
new Resolver.PackageSolutionAction(PackageActionType.AddToPackagesFolder, package, packageManager));
executor.Execute(operations);
return true;
}
public ActionExecutorTests()
{
var resolver = Substitute.For <IRequestResolver>();
resolver.GetInstance(Arg.Any <Type>()).Returns(new object());
resolver.GetInstance(null).Returns(x => { throw new Exception(); });
_action = Substitute.For <IEndpointAction>();
_action.EndpointType.Returns(typeof(TestEndpoint));
_action.Run(Arg.Any <object>(), Arg.Any <object>()).Returns(new TestViewModel());
var executor = new ActionExecutor(resolver, Substitute.For <IModelBindingController>());
_runTest = () => executor.Execute(Substitute.For <IRequest>(), _action);
}
private bool InstallSatellitePackages(IFileSystem packagesFolderFileSystem, ConcurrentQueue <IPackage> satellitePackages)
{
if (satellitePackages.Count == 0)
{
return(false);
}
var packageManager = CreatePackageManager(packagesFolderFileSystem, useSideBySidePaths: true);
var executor = new ActionExecutor();
var operations = satellitePackages.Select(package =>
new Resolver.PackageSolutionAction(PackageActionType.AddToPackagesFolder, package, packageManager));
executor.Execute(operations);
return(true);
}
protected override void ProcessRecordCore()
{
if (!SolutionManager.IsSolutionOpen)
{
// terminating
ErrorHandler.ThrowSolutionNotOpenTerminatingError();
}
// Locate the package to uninstall
IPackage package = PackageManager.LocatePackageToUninstall(
ProjectManager,
Id,
Version);
// resolve actions
var resolver = new ActionResolver()
{
Logger = this,
ForceRemove = Force.IsPresent,
RemoveDependencies = RemoveDependencies.IsPresent
};
resolver.AddOperation(
PackageAction.Uninstall,
package,
ProjectManager);
var actions = resolver.ResolveActions();
if (WhatIf)
{
foreach (var operation in actions)
{
Log(MessageLevel.Info, Resources.Log_OperationWhatIf, operation);
}
return;
}
// execute actions
var actionExecutor = new ActionExecutor()
{
Logger = this
};
actionExecutor.Execute(actions);
}
public void Can_execute_bat_without_cmd()
{
// setup
var properties = new Dictionary<string, string>();
properties["rootDirectory"] = _testDirectory.FullName;
var writer = new Mock<IConsoleWriter>();
writer.Setup(x => x.WriteError(It.IsAny<string>()));
writer.Setup(x => x.WriteMessage(It.IsAny<string>()));
var execute = new ActionExecutor(writer.Object, new RunContext { Properties = properties });
var srcFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestData/test.bat");
// act
execute.Execute(new Command { Value = srcFile, dontUseCommandExe = true });
// assert
writer.Verify(x => x.WriteMessage("\"test property " + _testDirectory.FullName + "\""));
}
public void When_invoking_power_shell_with_errors_exception_is_thrown()
{
// setup
var executor = new ActionExecutor(new ConsoleWriter(), new RunContext());
var srcFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestData/PSTestError.ps1");
// act
try
{
executor.Execute(new PowerShell { Value = srcFile });
}
catch
{
return;
}
Assert.Fail("An error wasn't thrown");
}
public void When_invoking_power_shell_script_through_workflow_should_create_folders_as_directed_by_script()
{
// setup
var properties = new Dictionary<string, string>();
properties["rootDirectory"] = _testDirectory.FullName;
var executor = new ActionExecutor(new ConsoleWriter(), new RunContext { Properties = properties });
var srcFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestData/PSTestCreateFolders.ps1");
// act
executor.Execute(new PowerShell { Value = srcFile });
// assert
Assert.IsTrue(Directory.Exists(Path.Combine(_testDirectory.FullName, "TestFolder")), "TestFolder Creation Failed");
Assert.IsTrue(Directory.Exists(Path.Combine(_testDirectory.FullName, "TestFolder\\TestFolder2")), "TestFolder\\TestFolder2 Creation Failed");
}
