public void InvokeOperation_EntityParameter_Invalid()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
A inputA = new A()
{
BID1 = 1
};
ValidationException expectedException = null;
try
{
var invoke = provider.IncrementBid1ForABy(inputA, 4);
}
catch (ValidationException e)
{
expectedException = e;
}
Assert.IsNotNull(expectedException);
Assert.AreEqual(typeof(RangeAttribute), expectedException.ValidationAttribute.GetType());
Assert.AreEqual(4, expectedException.Value);
Assert.AreEqual("The field delta must be between 5 and 10.", expectedException.Message);
EnqueueTestComplete();
}
public void Submit_POCO_Insert5Simple()
{
TestProvider_Scenarios dc = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
for (int i = 0; i < 5; i++)
{
dc.POCONoValidations.Add(new POCONoValidation()
{
ID = i,
A = "A" + i,
B = "B" + i,
C = "C" + i,
D = "D" + i,
E = "E" + i
});
}
SubmitOperation so = dc.SubmitChanges();
EnqueueConditional(delegate
{
return(so.IsComplete);
});
EnqueueCallback(delegate
{
TestHelperMethods.AssertOperationSuccess(so);
});
EnqueueTestComplete();
}
public void InvokeOperation_ReturnsIDictionary()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
Dictionary <string, int> dictionary = new Dictionary <string, int>();
foreach (var i in new[] { 1, 2, 3 })
{
dictionary.Add(i.ToString(), i);
}
InvokeOperation invoke = provider.ReturnsDictionary(dictionary, TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
object returnValue = invoke.Value;
Assert.IsNotNull(invoke.Value);
Dictionary <string, int> returnValueAsDictonary = returnValue as Dictionary <string, int>;
Assert.IsNotNull(returnValueAsDictonary);
foreach (var kvp in dictionary)
{
Assert.IsTrue(returnValueAsDictonary.ContainsKey(kvp.Key));
Assert.AreEqual(kvp.Value, returnValueAsDictonary[kvp.Key]);
}
});
EnqueueTestComplete();
}
public void UpdateThrows_ChangeSetStillReturned()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
SubmitOperation so = null;
LoadOperation lo = provider.Load(provider.GetAsQuery(), false);
this.EnqueueCompletion(() => lo);
EnqueueCallback(delegate
{
Assert.IsNull(lo.Error);
Assert.IsTrue(lo.Entities.Count() > 0);
A entity = provider.As.First();
entity.BID1++;
so = provider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
this.EnqueueCompletion(() => so);
EnqueueCallback(delegate
{
Assert.IsNotNull(so.Error);
Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Validation, so.Error.Message);
Assert.IsNotNull(so.ChangeSet);
Assert.AreEqual(1, so.ChangeSet.ModifiedEntities.Count);
});
EnqueueTestComplete();
}
[FullTrustTest] // ISerializable types cannot be deserialized in medium trust.
public void InvokeOperationReturn_TestPrimitive()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
// execute tests with different types
this.VerifyOnlineMethodReturn <Boolean>(provider, provider.ReturnsBoolean_Online, true);
this.VerifyOnlineMethodReturn <Byte>(provider, provider.ReturnsByte_Online, 123);
this.VerifyOnlineMethodReturn <SByte>(provider, provider.ReturnsSByte_Online, 123);
this.VerifyOnlineMethodReturn <Int16>(provider, provider.ReturnsInt16_Online, 123);
this.VerifyOnlineMethodReturn <UInt16>(provider, provider.ReturnsUInt16_Online, 123);
this.VerifyOnlineMethodReturn <Int32>(provider, provider.ReturnsInt32_Online, 123);
this.VerifyOnlineMethodReturn <UInt32>(provider, provider.ReturnsUInt32_Online, 123);
this.VerifyOnlineMethodReturn <Int64>(provider, provider.ReturnsInt64_Online, 123);
this.VerifyOnlineMethodReturn <UInt64>(provider, provider.ReturnsUInt64_Online, 123);
this.VerifyOnlineMethodReturn <Double>(provider, provider.ReturnsDouble_Online, 123.123);
this.VerifyOnlineMethodReturn <Single>(provider, provider.ReturnsSingle_Online, (Single)123.123);
this.VerifyOnlineMethodReturn <Char>(provider, provider.ReturnsChar_Online, (char)123);
this.VerifyOnlineMethodReturn <TimeSpan>(provider, provider.ReturnsTimeSpan_Online, TimeSpan.FromSeconds(123));
this.VerifyOnlineMethodReturn <IEnumerable <string> >(provider, provider.ReturnsStrings_Online, new string[] { "hello", "world" }.ToList());
this.VerifyOnlineMethodReturn <DateTime[]>(provider, provider.ReturnsDateTimes_Online, new DateTime[] { new DateTime(2009, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2009, 1, 6, 0, 5, 0, DateTimeKind.Utc) });
this.VerifyOnlineMethodReturn <DateTimeOffset[]>(provider, provider.ReturnsDateTimeOffsets_Online, new DateTimeOffset[] { new DateTimeOffset(new DateTime(2009, 1, 1, 0, 0, 0), new TimeSpan(3, 0, 0)), new DateTimeOffset(new DateTime(2009, 1, 6, 0, 5, 0), new TimeSpan(-6, 10, 0)) });
this.VerifyOnlineMethodReturn <IEnumerable <TimeSpan> >(provider, provider.ReturnsTimeSpans_Online, new TimeSpan[] { TimeSpan.FromSeconds(123), TimeSpan.FromMinutes(3) }.ToList());
this.VerifyOnlineMethodReturn <Uri>(provider, provider.ReturnsUri_Online, new Uri("http://localhost"));
this.VerifyOnlineMethodReturn <Char>(provider, provider.ReturnsChar_Online, (char)0);
EnqueueTestComplete();
}
public void InvokeOperationReturn_TestNullable_WithNull()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
// execute tests with different types
this.VerifyOnlineMethodReturn <Boolean?>(provider, provider.ReturnsNullableBoolean_Online, null);
this.VerifyOnlineMethodReturn <Byte?>(provider, provider.ReturnsNullableByte_Online, null);
this.VerifyOnlineMethodReturn <SByte?>(provider, provider.ReturnsNullableSByte_Online, null);
this.VerifyOnlineMethodReturn <Int16?>(provider, provider.ReturnsNullableInt16_Online, null);
this.VerifyOnlineMethodReturn <UInt16?>(provider, provider.ReturnsNullableUInt16_Online, null);
this.VerifyOnlineMethodReturn <Int32?>(provider, provider.ReturnsNullableInt32_Online, null);
this.VerifyOnlineMethodReturn <UInt32?>(provider, provider.ReturnsNullableUInt32_Online, null);
this.VerifyOnlineMethodReturn <Int64?>(provider, provider.ReturnsNullableInt64_Online, null);
this.VerifyOnlineMethodReturn <UInt64?>(provider, provider.ReturnsNullableUInt64_Online, null);
this.VerifyOnlineMethodReturn <Double?>(provider, provider.ReturnsNullableDouble_Online, null);
this.VerifyOnlineMethodReturn <Single?>(provider, provider.ReturnsNullableSingle_Online, null);
this.VerifyOnlineMethodReturn <Char?>(provider, provider.ReturnsNullableChar_Online, null);
this.VerifyOnlineMethodReturn <Decimal?>(provider, provider.ReturnsNullableDecimal_Online, null);
this.VerifyOnlineMethodReturn <Guid?>(provider, provider.ReturnsNullableGuid_Online, null);
this.VerifyOnlineMethodReturn <DateTime?>(provider, provider.ReturnsNullableDateTime_Online, null);
this.VerifyOnlineMethodReturn <DateTimeOffset?>(provider, provider.ReturnsNullableDateTimeOffset_Online, null);
this.VerifyOnlineMethodReturn <TestEnum?>(provider, provider.ReturnsNullableEnum_Online, null);
EnqueueTestComplete();
}
[FullTrustTest] // ISerializable types cannot be deserialized in medium trust.
public void InvokeOperationReturn_TestNullable()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
// execute tests with different types
this.VerifyOnlineMethodReturn <Boolean?>(provider, provider.ReturnsNullableBoolean_Online, true);
this.VerifyOnlineMethodReturn <Byte?>(provider, provider.ReturnsNullableByte_Online, 123);
this.VerifyOnlineMethodReturn <SByte?>(provider, provider.ReturnsNullableSByte_Online, 123);
this.VerifyOnlineMethodReturn <Int16?>(provider, provider.ReturnsNullableInt16_Online, 123);
this.VerifyOnlineMethodReturn <UInt16?>(provider, provider.ReturnsNullableUInt16_Online, 123);
this.VerifyOnlineMethodReturn <Int32?>(provider, provider.ReturnsNullableInt32_Online, 123);
this.VerifyOnlineMethodReturn <UInt32?>(provider, provider.ReturnsNullableUInt32_Online, 123);
this.VerifyOnlineMethodReturn <Int64?>(provider, provider.ReturnsNullableInt64_Online, 123);
this.VerifyOnlineMethodReturn <UInt64?>(provider, provider.ReturnsNullableUInt64_Online, 123);
this.VerifyOnlineMethodReturn <Double?>(provider, provider.ReturnsNullableDouble_Online, 123.123);
this.VerifyOnlineMethodReturn <Single?>(provider, provider.ReturnsNullableSingle_Online, (Single)123.123);
this.VerifyOnlineMethodReturn <Char?>(provider, provider.ReturnsNullableChar_Online, (Char)123);
this.VerifyOnlineMethodReturn <Decimal?>(provider, provider.ReturnsNullableDecimal_Online, 123);
this.VerifyOnlineMethodReturn <Guid?>(provider, provider.ReturnsNullableGuid_Online, new Guid("12345678-1234-1234-1234-123456789012"));
this.VerifyOnlineMethodReturn <DateTime?>(provider, provider.ReturnsNullableDateTime_Online, new DateTime(2009, 9, 10));
this.VerifyOnlineMethodReturn <DateTimeOffset?>(provider, provider.ReturnsNullableDateTimeOffset_Online, new DateTimeOffset(new DateTime(2009, 1, 1, 0, 0, 0), new TimeSpan(3, 0, 0)));
this.VerifyOnlineMethodReturn <TestEnum?>(provider, provider.ReturnsNullableEnum_Online, TestEnum.Value1);
this.VerifyOnlineMethodReturn <TestEnum?>(provider, provider.ReturnsNullableEnum_Online, TestEnum.Value1 | TestEnum.Value2);
EnqueueTestComplete();
}
public void InvokeOperationReturn_TestBigString()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
string str = new string('x', 10000);
this.VerifyOnlineMethodReturn <string>(provider, provider.ReturnsString_Online, str);
EnqueueTestComplete();
}
public void InvokeOperation_HasNoSideEffects()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation <string> invokeOp = provider.ReturnHttpMethodWithoutSideEffects_Online(TestHelperMethods.DefaultOperationAction, null);
this.EnqueueConditional(() => invokeOp.IsComplete);
this.EnqueueCallback(() =>
{
Assert.IsFalse(invokeOp.HasError, "Expected operation to complete without error.");
Assert.AreEqual("GET", invokeOp.Value);
});
this.EnqueueTestComplete();
}
public void InvokeOperation_VoidInputAndOutput()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = provider.VoidMethod(TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(invoke.Value);
});
EnqueueTestComplete();
}
public void InvokeOperation_ReturnsEntityCollection()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = provider.ReturnsEntityCollection_Online(3, TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
TestHelperMethods.AssertOperationSuccess(invoke);
IEnumerable <MixedType> mts = invoke.Value as IEnumerable <MixedType>;
Assert.AreEqual(3, mts.Count());
});
EnqueueTestComplete();
}
public async Task InvokeOperation_ServerValidationException()
{
TestProvider_Scenarios provider = ServerTestHelper.CreateInitializedDomainService <TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(typeof(TestProvider_Scenarios));
DomainOperationEntry throwValidationExceptionMethod = serviceDescription.GetInvokeOperation("ThrowValidationException");
Assert.IsNotNull(throwValidationExceptionMethod);
var invokeResult = await provider.InvokeAsync(new InvokeDescription(throwValidationExceptionMethod, Array.Empty <object>()), CancellationToken.None);
Assert.IsNull(invokeResult.Result);
Assert.IsNotNull(invokeResult.ValidationErrors);
Assert.AreEqual(1, invokeResult.ValidationErrors.Count);
Assert.AreEqual("Validation error.", invokeResult.ValidationErrors.ElementAt(0).ErrorMessage);
}
public void Invoke_RoundtripString()
{
TestProvider_Scenarios dc = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
string str = "Hello, World!";
InvokeOperation <string> io = dc.ReturnsString_Online(str);
this.EnqueueCompletion(() => io);
EnqueueCallback(delegate
{
TestHelperMethods.AssertOperationSuccess(io);
Assert.AreEqual(str, io.Value);
});
EnqueueTestComplete();
}
public void Bug706128_InvokeOperationCancellation()
{
TestProvider_Scenarios ctxt = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = ctxt.ReturnsString_Online("Ruby", TestHelperMethods.DefaultOperationAction, null);
invoke.Cancel();
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(invoke.Value);
Assert.IsTrue(invoke.IsCanceled);
});
EnqueueTestComplete();
}
public void InvokeOperation_ServerValidationException()
{
TestProvider_Scenarios provider = ServerTestHelper.CreateInitializedDomainService <TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(typeof(TestProvider_Scenarios));
DomainOperationEntry throwValidationExceptionMethod = serviceDescription.GetInvokeOperation("ThrowValidationException");
Assert.IsNotNull(throwValidationExceptionMethod);
IEnumerable <ValidationResult> validationErrors;
object result = provider.Invoke(new InvokeDescription(throwValidationExceptionMethod, new object[0]), out validationErrors);
Assert.IsNull(result);
Assert.IsNotNull(validationErrors);
Assert.AreEqual(1, validationErrors.Count());
Assert.AreEqual("Validation error.", validationErrors.ElementAt(0).ErrorMessage);
}
[FullTrustTest] // ISerializable types cannot be deserialized in medium trust.
public void InvokeOperationReturn_TestPredefined()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
// execute tests with different types
this.VerifyOnlineMethodReturn <String>(provider, provider.ReturnsString_Online, "Hello There!");
this.VerifyOnlineMethodReturn <Decimal>(provider, provider.ReturnsDecimal_Online, 123);
this.VerifyOnlineMethodReturn <Guid>(provider, provider.ReturnsGuid_Online, new Guid("12345678-1234-1234-1234-123456789012"));
this.VerifyOnlineMethodReturn <DateTime>(provider, provider.ReturnsDateTime_Online, new DateTime(2009, 9, 10));
this.VerifyOnlineMethodReturn <DateTimeOffset>(provider, provider.ReturnsDateTimeOffset_Online, new DateTimeOffset(new DateTime(2009, 1, 1, 0, 0, 0), new TimeSpan(-3, 0, 0)));
this.VerifyOnlineMethodReturn <byte[]>(provider, provider.ReturnsByteArray_Online, new byte[] { 111, 222 });
this.VerifyOnlineMethodReturn <byte[]>(provider, provider.ReturnsBinary_Online, new byte[] { 111, 222 });
this.VerifyOnlineMethodReturn <TestEnum>(provider, provider.ReturnsEnum_Online, TestEnum.Value1);
this.VerifyOnlineMethodReturn <TestEnum>(provider, provider.ReturnsEnum_Online, TestEnum.Value1 | TestEnum.Value2);
EnqueueTestComplete();
}
public void InvokeOperation_ReturnsEntity()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
MixedType mt = new MixedType();
InvokeOperation invoke = provider.ReturnsEntity_Online(mt, "MixedType_Other", TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
TestHelperMethods.AssertOperationSuccess(invoke);
mt = invoke.Value as MixedType;
Assert.IsNotNull(mt);
Assert.AreEqual("MixedType_Other", mt.ID);
});
EnqueueTestComplete();
}
public void Bug706146_ValidationErrorsInitialization()
{
TestProvider_Scenarios ctxt = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = ctxt.ThrowOnlineException(TestHelperMethods.DefaultOperationAction, null);
// verify that all operation properties can be accessed before completion
Assert.AreEqual(0, invoke.ValidationErrors.Count());
Assert.IsNull(invoke.Value);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(invoke.Value);
Assert.IsNotNull(invoke.Error);
});
EnqueueTestComplete();
}
[FullTrustTest] // ISerializable types cannot be deserialized in medium trust.
public void InvokeOperation_ReturnsXElement()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
string elementName = "Foo", elementValue = "Bar";
var xml = XElement.Parse(string.Format("<{0} xmlns=\"foo\">{1}</{0}>", elementName, elementValue));
InvokeOperation invoke = provider.ReturnsXElement(xml, TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
object returnValue = invoke.Value;
Assert.IsNotNull(invoke.Value);
Assert.AreEqual(typeof(XElement), returnValue.GetType());
Assert.AreEqual(xml.ToString(), returnValue.ToString());
});
EnqueueTestComplete();
}
public void InvokeOperation_VariousParameterTypes()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = provider.VariousParameterTypes("hello", 2, true, TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
// 8 because "hello".Length (5) + 2 + true (1) = 8.
Assert.AreEqual("VariousParameterTypes", invoke.OperationName);
Assert.AreEqual(3, invoke.Parameters.Count);
Assert.AreEqual("hello", invoke.Parameters["str"]);
Assert.AreEqual(2, invoke.Parameters["integer"]);
Assert.AreEqual(true, invoke.Parameters["boolean"]);
Assert.AreEqual(8, (int)invoke.Value);
});
EnqueueTestComplete();
}
public void InvokeOperation_Exceptions()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = provider.ThrowOnlineException(TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(invoke.Value);
Assert.IsNotNull(invoke.Error);
Assert.IsInstanceOfType(invoke.Error, typeof(DomainOperationException));
DomainOperationException dpe = invoke.Error as DomainOperationException;
Assert.AreEqual(string.Format(Resource.DomainContext_InvokeOperationFailed, "ThrowOnlineException", "Invalid operation."), dpe.Message);
Assert.AreEqual(OperationErrorStatus.NotSupported, dpe.Status);
Assert.AreEqual(400, dpe.ErrorCode);
});
EnqueueTestComplete();
}
public void InvokeOperation_AuthenticationTest()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
InvokeOperation invoke = provider.MethodRequiresAuthentication(TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(invoke.Value);
Assert.IsNotNull(invoke.Error);
Assert.IsInstanceOfType(invoke.Error, typeof(DomainOperationException));
DomainOperationException dpe = invoke.Error as DomainOperationException;
Assert.AreEqual(string.Format(Resource.DomainContext_InvokeOperationFailed, "MethodRequiresAuthentication", "Access to operation 'MethodRequiresAuthentication' was denied."), dpe.Message);
Assert.AreEqual(OperationErrorStatus.Unauthorized, dpe.Status);
Assert.AreEqual(401, dpe.ErrorCode);
});
EnqueueTestComplete();
}
public void EntityRefCaching_MultipartKeys()
{
TestProvider_Scenarios ctxt = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
B b = new B
{
ID1 = 1, ID2 = 2
};
A a = new A {
ID = 1
};
ctxt.EntityContainer.LoadEntities(new Entity[] { a, b });
int propChangeCount = 0;
a.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "B")
{
propChangeCount++;
}
};
a.B = b;
Assert.AreSame(b, a.B);
Assert.AreEqual(2, propChangeCount);
// if we set the FK member directly, we expect the
// cached reference to be reset
a.BID2 = 0;
Assert.IsNull(a.B);
Assert.AreEqual(3, propChangeCount);
// if we set all values of the multipart
// key back to valid values we expect to
// get the valid entity
a.BID1 = 1;
a.BID2 = 2;
Assert.AreSame(b, a.B);
Assert.AreEqual(4, propChangeCount);
}
public void InvokeOperation_EntityParameter()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
A inputA = new A()
{
BID1 = 1,
RequiredString = "Foo"
};
InvokeOperation <int> invoke = provider.IncrementBid1ForA(inputA, TestHelperMethods.DefaultOperationAction, null);
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNotNull(invoke.Value);
Assert.AreEqual(inputA.BID1 + 1, invoke.Value);
});
EnqueueTestComplete();
}
public void DomainContext_Load_SelectMethodThrows()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
LoadOperation lo = provider.Load(provider.GetMixedTypesThrowQuery(), false);
this.EnqueueCompletion(() => lo);
EnqueueCallback(delegate
{
Assert.IsNotNull(lo.Error);
// verify we propagate the top level exception message as well
// as the inner exception message (to one level deep)
Assert.IsTrue(lo.Error.Message.Contains("Not implemented yet."));
Assert.IsTrue(lo.Error.Message.Contains("InnerException1"));
Assert.IsFalse(lo.Error.Message.Contains("InnerException2"));
});
EnqueueTestComplete();
}
public async Task InvokeOperation_ServerValidationError()
{
TestProvider_Scenarios provider = ServerTestHelper.CreateInitializedDomainService <TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(typeof(TestProvider_Scenarios));
DomainOperationEntry incrementBid1ForAByMethod = serviceDescription.GetInvokeOperation("IncrementBid1ForABy");
Assert.IsNotNull(incrementBid1ForAByMethod);
TestDomainServices.A inputA = new TestDomainServices.A()
{
BID1 = 1
};
var invokeResult = await provider.InvokeAsync(new InvokeDescription(incrementBid1ForAByMethod, new object[] { inputA, 2 }), CancellationToken.None);
Assert.IsNull(invokeResult.Result);
Assert.IsNotNull(invokeResult.ValidationErrors);
Assert.AreEqual(2, invokeResult.ValidationErrors.Count);
Assert.AreEqual("The field delta must be between 5 and 10.", invokeResult.ValidationErrors.ElementAt(0).ErrorMessage);
Assert.AreEqual("The RequiredString field is required.", invokeResult.ValidationErrors.ElementAt(1).ErrorMessage);
}
public void InvokeOperation_VariousParameterTypes_WithInvalidParameter()
{
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
ValidationException expectedException = null;
try
{
InvokeOperation invoke = provider.VariousParameterTypes(null, 2, true, TestHelperMethods.DefaultOperationAction, null);
}
catch (ValidationException e)
{
expectedException = e;
}
Assert.IsNotNull(expectedException);
Assert.AreEqual(typeof(RequiredAttribute), expectedException.ValidationAttribute.GetType());
Assert.AreEqual("The str field is required.", expectedException.Message);
EnqueueTestComplete();
}
private void ExecuteQuery(Func <TestProvider_Scenarios, EntityQuery <CityWithCacheData> > getQuery, string expectedCacheData)
{
LoadOperation <CityWithCacheData> loadOp = null;
EnqueueCallback(delegate
{
TestProvider_Scenarios dc = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
loadOp = dc.Load(getQuery(dc));
});
EnqueueConditional(() => loadOp.IsComplete);
EnqueueCallback(delegate
{
if (loadOp.Error != null)
{
Assert.Fail(loadOp.Error.ToString());
}
CityWithCacheData city = loadOp.Entities.First();
Assert.AreEqual(expectedCacheData, city.CacheData, "Incorrect cache data");
});
}
public void InvokeOperation_ServerValidationError()
{
TestProvider_Scenarios provider = ServerTestHelper.CreateInitializedDomainService <TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(typeof(TestProvider_Scenarios));
DomainOperationEntry incrementBid1ForAByMethod = serviceDescription.GetInvokeOperation("IncrementBid1ForABy");
Assert.IsNotNull(incrementBid1ForAByMethod);
IEnumerable <ValidationResult> validationErrors;
TestDomainServices.A inputA = new TestDomainServices.A()
{
BID1 = 1
};
object result = provider.Invoke(new InvokeDescription(incrementBid1ForAByMethod, new object[] { inputA, 2 }), out validationErrors);
Assert.IsNull(result);
Assert.IsNotNull(validationErrors);
Assert.AreEqual(2, validationErrors.Count());
Assert.AreEqual("The field delta must be between 5 and 10.", validationErrors.ElementAt(0).ErrorMessage);
Assert.AreEqual("The RequiredString field is required.", validationErrors.ElementAt(1).ErrorMessage);
}
[FullTrustTest] // ISerializable types cannot be deserialized in medium trust.
public void InvokeOperationParams_TestNullable()
{
InvokeOperation <bool> invoke = null;
TestProvider_Scenarios provider = new TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
MixedType changedObj = null;
MixedType valuesObj = null;
LoadOperation lo = provider.Load(provider.GetMixedTypesQuery(), false);
// wait for Load to complete, then invoke some domain methods
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
changedObj = provider.MixedTypes.Single(t => (t.ID == "MixedType_Max"));
valuesObj = provider.MixedTypes.Single(t => (t.ID == "MixedType_Other"));
// invoke invoke operation
invoke = provider.TestNullable_Online(changedObj, valuesObj.NullableBooleanProp, valuesObj.NullableByteProp, valuesObj.NullableSByteProp,
valuesObj.NullableInt16Prop, valuesObj.NullableUInt16Prop, valuesObj.NullableInt32Prop, valuesObj.NullableUInt32Prop,
valuesObj.NullableInt64Prop, valuesObj.NullableUInt64Prop, valuesObj.NullableCharProp, valuesObj.NullableDoubleProp,
valuesObj.NullableSingleProp, valuesObj.NullableDecimalProp, valuesObj.NullableDateTimeProp,
valuesObj.NullableTimeSpanProp, valuesObj.NullableGuidProp, valuesObj.NullableEnumProp,
valuesObj.NullableTimeSpanListProp, valuesObj.NullableDateTimeOffsetProp, TestHelperMethods.DefaultOperationAction, null);
});
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
// verify invocation completed succesfully
Assert.IsNull(invoke.Error, "InvokeEventArgs.Error should be null");
Assert.IsFalse(invoke.ValidationErrors.Any());
Assert.IsTrue(invoke.Value);
});
EnqueueTestComplete();
}
