public void TestExecutor_Fail_BadExpression() { this.UserContext.Foo = "Bar"; ExpressionExecutor ex = new ExpressionExecutor(session: null, userContext: this.UserContext); string expression = "UserContext.Foo"; Assert.ThrowsException <InvalidCastException>(() => { ex.Execute <bool>(expression).GetAwaiter().GetResult(); }, "Expected ExpressionExecutor to fail evaluating an expression that cannot be evaluated."); }
public void TestExecutor_Success_ChangingFunctionReturnType() { ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null); // Changing return type of GetCount string expression = "UserContext.GetCount = new Func<string>(() => \"Test\")"; Assert.AreEqual(this.UserContext.GetCount(), 1); // Since expected return type has been updated, this should pass ex.Execute <Func <string> >(expression).GetAwaiter().GetResult(); Assert.AreEqual(this.UserContext.GetCount(), "Test"); }
public void TestExecutor_Success_CompileExpressionWithMissingDependenciesButOtherExternalTypesInSameNamespace() { this.UserContext.Foo = ExternalTestType.TestEnum; this.UserContext.Bar = TestType.Test; List <Type> dependencies = new List <Type>(); dependencies.Add(typeof(ExternalTestType)); ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, dependencies); string expression = "UserContext.Foo.ToString() == ExternalTestType.TestEnum.ToString() && UserContext.Bar.ToString() == TestType.Test.ToString()"; Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult(), "Expected ExpressionExecutor to successfully evaluate a true expression."); }
public void TestExecutor_ScriptCacheContainsKey() { this.UserContext.Foo = "Bar"; string expression = "UserContext.Foo == \"Bar\" && UserContext.GetTopic(\"TopicName\").ResourceType == \"Node\""; // Test - confirm ExpressionExecutor script cache does not contain script before executing. ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null); Assert.IsFalse(ex.ScriptCacheContainsKey(expression)); // Test - confirm ExpressionExecutor script cache does contain script after executing. Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult()); Assert.IsTrue(ex.ScriptCacheContainsKey(expression)); }
public void TestExecutor_Success_CompileExpressionWithForgeDefaultDependenciesBeingPassedInExternally() { this.UserContext.Foo = "Foo"; List <Type> dependencies = new List <Type>(); // Tasks dependency needed by Forge by default. dependencies.Add(typeof(Task)); // Reflection dependency needed by Forge for runtime compilation. dependencies.Add(typeof(Type)); // Default dependencies are expected to be tossed away internally in ExpressionExecutor. ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null); string expression = "UserContext.Foo == \"Foo\""; Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult(), "Expected ExpressionExecutor to successfully evaluate a true expression."); }
public void Invoke(ExpressionExecutor executor, string messageContent) { Exception exception = null; try { OnBeforeExecution(); executor.Execute(messageContent); } catch (Exception e) { exception = e; throw; } finally { OnAfterExecution(exception); } }
public void TestExecutor_Success_WaitForDelegateAsync() { this.UserContext.Foo = "Bar"; string expression = "(Func<Task<bool>>)(() => {return Task.FromResult(UserContext.Foo == \"Bar\");})"; // Casting the expression to Func<bool> since the executor will return a delegate of type Func<bool> ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null); dynamic expressionResult = ex.Execute <Delegate>(expression).GetAwaiter().GetResult(); if (expressionResult.GetType() == typeof(Func <Task <bool> >)) { // expressionResult() return Task<bool>, doing .GetAwaiter().GetResult() again returns bool Assert.IsTrue(expressionResult().GetAwaiter().GetResult()); this.UserContext.Foo = "Far"; Assert.IsFalse(expressionResult().GetAwaiter().GetResult()); } else { Assert.Fail(string.Format("Expected expression to be of type Task<bool> but was {0}", expressionResult.GetType())); } }
private ResultState ProcessQueueMessages(int queueId, int batchSize, bool archiveMessages) { var state = new ResultState { IsFailed = false }; var messages = Repository.FetchQueueMessages(queueId, batchSize); if (messages != null) { foreach (var message in messages) { var timer = Stopwatch.StartNew(); var messageId = message.MessageId; state.LastMessageId = messageId; try { var messageContext = GetMessageContext(message.Context); state.MaxRetries = messageContext.Settings.MaxRetriesBeforeFail.GetValueOrDefault(); state.RecoveryMode = messageContext.Settings.RecoveryMode; PublishSettings settings = messageContext.Settings; using (var transaction = Repository.CreateProcessingTransaction(settings.JobIsolationLevel, settings.JobTimeout)) { var executor = new ExpressionExecutor(_serializer, _jobActivator); if (!string.IsNullOrWhiteSpace(message.ContextFactory)) { using (var context = executor.Execute<ExecutionContext>(message.ContextFactory)) { if (context != null) { context.Invoke(executor, message.Content); } else { executor.Execute(message.Content); } } } else { executor.Execute(message.Content); } if (transaction.TransactionStatus.HasValue) { var transactionStatus = transaction.TransactionStatus.Value; if (transactionStatus == TransactionStatus.Aborted || transactionStatus == TransactionStatus.InDoubt) { throw new Exception($"Invalid transaction status: [{transactionStatus}]! Unable to commit!"); } } Repository.RemoveMessage(messageId, archiveMessages && !settings.DiscardWhenComplete, transaction); transaction.Complete(); } state.ProcessedMessages += 1; } catch (Exception e) { var error = e.GetFormattedError(messageId); Logger.Error(error); state.Error = error; state.IsFailed = true; } finally { timer.Stop(); Logger.Trace("Message {0} processed in {1}", messageId, timer.Elapsed); } if (Canceled || state.IsFailed) { break; } } } return state; }
public object Execute(Expression expression) { return(ExpressionExecutor.Execute(expression)); }