public void SettingNamedArgumentsToNullJustClearsOutAnyNamedArguments()
{
MethodInvoker vkr = new MethodInvoker();
vkr.AddNamedArgument("age", 10);
vkr.NamedArguments = null;
Assert.IsNotNull(vkr.NamedArguments);
Assert.AreEqual(0, vkr.NamedArguments.Count);
}
public void ArgumentsProperty()
{
MethodInvoker vkr = new MethodInvoker();
vkr.Arguments = null;
Assert.IsNotNull(vkr.Arguments); // should always be the empty object array, never null
Assert.AreEqual(0, vkr.Arguments.Length);
vkr.Arguments = new string[] {"Chank Pop"};
Assert.AreEqual(1, vkr.Arguments.Length);
}
public void TestMethodInvoker_MethodSetCorrectly()
{
InvocationCountingJob job = new InvocationCountingJob();
MethodInvoker mi = new MethodInvoker();
mi.TargetObject = job;
mi.TargetMethod = "Invoke";
mi.Prepare();
methodInvokingJob.MethodInvoker = mi;
methodInvokingJob.Execute(CreateMinimalJobExecutionContext());
Assert.AreEqual(1, job.CounterValue, "Job was not invoked once");
}
public void InvokeWithStaticMethod()
{
MethodInvoker mi = new MethodInvoker();
mi.TargetType = typeof(Int32);
mi.TargetMethod = "Parse";
mi.Arguments = new object[] { "27" };
mi.Prepare();
object actual = mi.Invoke();
Assert.IsNotNull(actual);
Assert.AreEqual(typeof(int), actual.GetType());
Assert.AreEqual(27, (int)actual);
}
public OperationResponse Post(OperationRequest request)
{
var st = new Stopwatch();
st.Start();
OperationResponse response = new OperationResponse()
{
TargetOperation = request.TargetOperation,
TargetMethod = request.TargetMethod
};
try
{
MethodInvoker methodInvoker = new MethodInvoker();
object targetOperation = SpringContext.GetObject(request.TargetOperation);
if (targetOperation == null)
throw new ObjectDefinitionStoreException(string.Format("The operation id named '{0}' could not be found in spring context.", request.TargetOperation));
methodInvoker.TargetObject = targetOperation;
methodInvoker.TargetMethod = request.TargetMethod;
methodInvoker.Arguments = SerializerHelper.DeserializeBinary(request.Arguments);
methodInvoker.Prepare();
object result = methodInvoker.Invoke();
response.Result.Value = SerializerHelper.SerializeBinary(new object[] { result });
response.Result.Status = OperationResultType.Success;
}
catch (Exception ex)
{
response.Result.Exception = new OperationException(ex);
response.Result.Status = OperationResultType.Error;
}
finally
{
st.Stop();
response.ElapsedTotalSeconds = st.Elapsed.TotalSeconds;
logger.DebugFormat("Invoking method [{0}] of operation [{1}] done in {2} seconds [status={3}].", response.TargetMethod, response.TargetOperation, response.ElapsedTotalSeconds, response.Result.Status);
if (response.Result.Status == OperationResultType.Error)
{
logger.Error("---------------------------------------------------------------------------------------------------------------------------------------");
logger.ErrorFormat("[Message]: {0} ", response.Result.Exception.Message);
logger.ErrorFormat("[Source]: {0}", response.Result.Exception.Source);
logger.ErrorFormat("[StackTrace]: {0}", response.Result.Exception.StackTrace);
logger.Error("---------------------------------------------------------------------------------------------------------------------------------------");
}
}
return response;
}
/// <summary>
/// Constructor for JobMethodInvocationFailedException.
/// </summary>
/// <param name="methodInvoker">the MethodInvoker used for reflective invocation</param>
/// <param name="cause">the root cause (as thrown from the target method)</param>
public JobMethodInvocationFailedException(MethodInvoker methodInvoker, Exception cause) :
base("Invocation of method '" + methodInvoker.TargetMethod +
"' on target class [" + methodInvoker.TargetType + "] failed", cause)
{
}
public void InvokeWithGenericStaticMethod()
{
MethodInvoker mi = new MethodInvoker();
mi.TargetType = typeof(Activator);
mi.TargetMethod = "CreateInstance<Spring.Objects.TestObject>";
mi.Prepare();
object actual = mi.Invoke();
Assert.IsNotNull(actual);
Assert.AreEqual(typeof(TestObject), actual.GetType());
}
public void InvokeWithNamedArgument()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.AddNamedArgument("years", 10);
vkr.Prepare();
object actual = vkr.Invoke();
Assert.AreEqual(98, actual);
}
public void InvokeWithNullArgument()
{
MethodInvoker methodInvoker = new MethodInvoker();
methodInvoker.TargetType = GetType();
methodInvoker.TargetMethod = "NullArgument";
methodInvoker.Arguments = new object[] {null};
methodInvoker.Prepare();
methodInvoker.Invoke();
}
public void TestMethodInvoker_PrivateMethod()
{
InvocationCountingJob job = new InvocationCountingJob();
MethodInvoker mi = new MethodInvoker();
mi.TargetObject = job;
mi.TargetMethod = "PrivateMethod";
mi.Prepare();
methodInvokingJob.MethodInvoker = mi;
methodInvokingJob.Execute(CreateMinimalJobExecutionContext());
}
public void NamedArgumentsOverwriteEachOther()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.AddNamedArgument("years", 10);
// this second setting must overwrite the first...
vkr.AddNamedArgument("years", 200);
vkr.Prepare();
object actual = vkr.Invoke();
Assert.IsFalse(98.Equals(actual), "The first named argument setter is sticking; must allow itslf to be overwritten.");
Assert.AreEqual(288, actual, "The second named argument was not applied (it must be).");
}
public void Instantiation()
{
MethodInvoker vkr = new MethodInvoker();
Assert.IsNotNull(vkr.Arguments);
}
public void InvokeWithWeIRdLyCasedNamedArgument()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "gROwOldeR";
vkr.AddNamedArgument("YEarS", 10);
vkr.Prepare();
object actual = vkr.Invoke();
Assert.AreEqual(98, actual);
}
public void InvokeWithArgumentOfWrongType()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.AddNamedArgument("years", "Bingo");
vkr.Prepare();
Assert.Throws<MethodInvocationException>(() => vkr.Invoke(), "At least one of the arguments passed to this MethodInvoker was incompatible with the signature of the invoked method.");
}
public void InvokeWithNamedArgumentThatDoesNotExist()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.AddNamedArgument("southpaw", 10);
Assert.Throws<ArgumentException>(() => vkr.Prepare(), "The named argument 'southpaw' could not be found on the 'GrowOlder' method of class [Spring.Objects.Support.MethodInvokerTests+Foo].");
}
public void InvokeWithMixOfNamedAndPlainVanillaArgumentsOfDifferingTypes()
{
int maximumAge = 95;
string expectedStatus = "Old Age Pensioner";
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "GrowOlderUntilMaximumAgeReachedAndSetStatusName";
vkr.AddNamedArgument("years", 10);
vkr.AddNamedArgument("status", expectedStatus);
vkr.Arguments = new object[] {maximumAge};
vkr.Prepare();
object actual = vkr.Invoke();
Assert.AreEqual(maximumAge, actual);
Assert.AreEqual(expectedStatus, foo.Status);
}
public void InvokeWithMixOfNamedAndPlainVanillaArguments()
{
int maximumAge = 95;
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "GrowOlderUntilMaximumAgeReached";
vkr.AddNamedArgument("years", 10);
vkr.Arguments = new object[] {maximumAge};
vkr.Prepare();
object actual = vkr.Invoke();
Assert.AreEqual(maximumAge, actual);
}
private static object InvokeOperation(MethodInvoker methodInvoker)
{
try
{
return methodInvoker.Invoke();
}
catch (Exception ex)
{
Log.Error("Exception -------------- " + ex.GetType());
Log.Error(" Invoke operation error: " + ex.Message);
throw ex.InnerException;
}
}
public void TestMethodInvoker_ShouldSetResultToExecutionContext()
{
InvocationCountingJob job = new InvocationCountingJob();
MethodInvoker mi = new MethodInvoker();
mi.TargetObject = job;
mi.TargetMethod = "InvokeWithReturnValue";
mi.Prepare();
methodInvokingJob.MethodInvoker = mi;
IJobExecutionContext context = CreateMinimalJobExecutionContext();
methodInvokingJob.Execute(context);
Assert.AreEqual(InvocationCountingJob.DefaultReturnValue, context.Result, "result value was not set to context");
}
public static OperationResponse ProcessRequest(OperationRequest request)
{
var st = new Stopwatch();
st.Start();
OperationResponse response = new OperationResponse()
{
Request = new OperationRequest()
{
TargetOperationId = request.TargetOperationId,
TargetMethod = request.TargetMethod,
Url = request.Url,
InvokerType = request.InvokerType
}
};
try
{
object targetOperation = SpringContext.GetObject(request.TargetOperationId);
if (Log.IsDebugEnabled)
Log.DebugFormat("Looking up operation object by id '{0}'", request.TargetOperationId);
if (targetOperation == null)
throw new ObjectDefinitionStoreException(string.Format("The operation id named '{0}' could not be found in spring context.", request.TargetOperationId));
MethodInvoker methodInvoker = new MethodInvoker();
methodInvoker.TargetObject = targetOperation;
methodInvoker.TargetMethod = request.TargetMethod;
object[] deserializedArguments = null;
if (request.InvokerType == InvokerType.WEB)
deserializedArguments = SerializerUtils.DeserializeBinary((Byte[])request.OperationArgs);
else
deserializedArguments = (object[])request.OperationArgs;
methodInvoker.Arguments = deserializedArguments;
methodInvoker.Prepare();
object result = InvokeOperation(methodInvoker);
if (request.InvokerType == InvokerType.WEB)
{
byte[] serializedResult = SerializerUtils.SerializeBinary(new object[] { result });
byte[] compressedResult = SevenZipUtils.CompressBytes(serializedResult);
response.Result.Value = compressedResult;
}
else
{
response.Result.Value = result;
}
response.Result.Type = OperationResultType.Ok;
}
catch (NoSuchObjectDefinitionException ex)
{
response.Result.Message = ex.Message;
}
catch (ObjectDefinitionStoreException ex)
{
response.Result.Message = ex.Message;
}
catch (System.MissingMethodException ex)
{
response.Result.Message = ex.Message;
}
catch (Spring.Core.MethodInvocationException ex)
{
response.Result.Message = ex.Message;
}
catch (OperationAccessException ex)
{
response.Result.Message = ex.Message;
}
catch (Exception ex)
{
response.Result.Message = ex.Message;
Log.Error(ex);
}
finally
{
st.Stop();
response.ElapsedTotalSeconds = st.Elapsed.TotalSeconds;
string messageFormat = "Invoking method [{0}] of operation [{1}] done in {2} seconds.";
if (Log.IsDebugEnabled)
{
Log.DebugFormat
( messageFormat
, response.Request.TargetMethod
, response.Request.TargetOperationId
, response.ElapsedTotalSeconds
);
}
}
return response;
}
public void InvokeWithArgumentOfWrongType()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.AddNamedArgument("years", "Bingo");
vkr.Prepare();
vkr.Invoke();
}
public void TestMethodInvoker_MethodSetCorrectlyThrowsException()
{
InvocationCountingJob job = new InvocationCountingJob();
MethodInvoker mi = new MethodInvoker();
mi.TargetObject = job;
mi.TargetMethod = "InvokeAndThrowException";
mi.Prepare();
methodInvokingJob.MethodInvoker = mi;
try
{
methodInvokingJob.Execute(CreateMinimalJobExecutionContext());
Assert.Fail("Successful invoke when method threw exception");
}
catch (JobMethodInvocationFailedException)
{
// ok
}
Assert.AreEqual(1, job.CounterValue, "Job was not invoked once");
}
public void PrepareWithOnlyTargetMethodSet()
{
MethodInvoker vkr = new MethodInvoker();
vkr.TargetMethod = "Foo";
vkr.Prepare();
}
public void PrepareWithOnlyTargetMethodSet()
{
MethodInvoker vkr = new MethodInvoker();
vkr.TargetMethod = "Foo";
Assert.Throws<ArgumentException>(() => vkr.Prepare(), "One of either the 'TargetType' or 'TargetObject' properties is required.");
}
public void InvokeWithOKArgumentsAndMixedCaseMethodName()
{
Foo foo = new Foo();
foo.Age = 88;
MethodInvoker vkr = new MethodInvoker();
vkr.TargetObject = foo;
vkr.TargetMethod = "growolder";
vkr.Arguments = new object[] {10};
vkr.Prepare();
object actual = vkr.Invoke();
Assert.AreEqual(98, actual);
}
/// <summary>Invokes the specified listener method.</summary>
/// <param name="methodName">The name of the listener method.</param>
/// <param name="arguments">The message arguments to be passed in.</param>
/// <returns>The result returned from the listener method.</returns>
protected object InvokeListenerMethod(string methodName, object[] arguments)
{
try
{
var methodInvoker = new MethodInvoker();
methodInvoker.TargetObject = this.handlerObject;
methodInvoker.TargetMethod = methodName;
methodInvoker.Arguments = arguments;
methodInvoker.Prepare();
var result = methodInvoker.Invoke();
if (result == MethodInvoker.Void)
{
return null;
}
return result;
}
catch (TargetInvocationException ex)
{
var targetEx = ex.InnerException;
if (targetEx is IOException)
{
throw new AmqpIOException(targetEx);
}
else
{
throw new ListenerExecutionFailedException("Listener method '" + methodName + "' threw exception", targetEx);
}
}
catch (Exception ex)
{
throw new ListenerExecutionFailedException(this.BuildInvocationFailureMessage(methodName, arguments), ex);
}
}
public void Instantiation()
{
MethodInvoker vkr = new MethodInvoker();
Assert.IsNotNull(vkr.Arguments);
}
