/// <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"); }