public void AuthorizationAttribute_Query_Custom_Attribute() { IPrincipal user = this.CreateIPrincipal("user1"); // Instantiate a new DomainService to use for a Query using (AuthorizationTestDomainService testDomainService = new AuthorizationTestDomainService()) { testDomainService.Initialize(new DomainServiceContext(new MockDataService(user), DomainOperationType.Query)); // Get a DomainServiceDescription for that same domain service DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(AuthorizationTestDomainService)); // Locate the QueryAllow query DomainOperationEntry entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "QueryAllow"); Assert.IsNotNull(entry, "Did not find QueryAllow entry"); Assert.AreEqual("Query", entry.OperationType, "Query operation type expected for query operation"); // Ask the domain service to perform authorization. // The principal will be located via the mock data service created above. AuthorizationResult result = testDomainService.IsAuthorized(entry, entity: null); if (result != AuthorizationResult.Allowed) { Assert.Fail("Expected QueryAllow to be approved: " + result.ErrorMessage); } // Try again with a different query that will be denied entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "QueryDeny"); Assert.IsNotNull(entry, "Did not find QueryDeny entry"); result = testDomainService.IsAuthorized(entry, entity: null); Assert.AreNotSame(AuthorizationResult.Allowed, result, "Expected QueryDeny to be denied"); } }
public void AuthorizationAttribute_Invoke_Allowed_No_Attributes() { IPrincipal user = this.CreateIPrincipal("user1"); // Instantiate a new DomainService to use for an Invoke using (AuthorizationTestDomainService testDomainService = new AuthorizationTestDomainService()) { testDomainService.Initialize(new DomainServiceContext(new MockDataService(user), DomainOperationType.Invoke)); // Get a DomainServiceDescription for that same domain service DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(AuthorizationTestDomainService)); // Locate the invoke method DomainOperationEntry invokeEntry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "InvokeNoAuth"); Assert.IsNotNull(invokeEntry, "Could not locate InvokeNoAuth invoke"); Assert.AreEqual("Invoke", invokeEntry.OperationType, "Invoke operation entry should show Invoke operation type"); // Ask the domain service to perform authorization. // The principal will be located via the mock data service created above. // Invokes do not expect an entity instance. AuthorizationResult result = testDomainService.IsAuthorized(invokeEntry, entity: null); Assert.AreSame(AuthorizationResult.Allowed, result, "Expected invoke with no auth attributes to be allowed."); } }
private static void Generate <T>() { new AuthenticationCodeProcessor(new CSharpCodeProvider()).ProcessGeneratedCode( DomainServiceDescription.GetDescription(typeof(T)), null /* unused in negative tests */, null /* unused in negative tests */); }
public void AuthorizationAttribute_Invoke_Custom_Attribute() { IPrincipal user = this.CreateIPrincipal("user1"); // Instantiate a new DomainService to use for an Invoke using (AuthorizationTestDomainService testDomainService = new AuthorizationTestDomainService()) { testDomainService.Initialize(new DomainServiceContext(new MockDataService(user), DomainOperationType.Invoke)); // Get a DomainServiceDescription for that same domain service DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(AuthorizationTestDomainService)); // Locate the invoke method DomainOperationEntry invokeEntry = description.DomainOperationEntries.Single(p => p.Name == "InvokeAllow"); // Ask the domain service to perform authorization. // The principal will be located via the mock data service created above. // Invokes do not expect an entity instance. AuthorizationResult result = testDomainService.IsAuthorized(invokeEntry, entity: null); Assert.AreSame(AuthorizationResult.Allowed, result, "Expected invoke with custom auth attributes to be allowed."); // Do that again but using an Invoke that will deny based on its own name invokeEntry = description.DomainOperationEntries.Single(p => p.Name == "InvokeDeny"); result = testDomainService.IsAuthorized(invokeEntry, entity: null); Assert.AreNotSame(AuthorizationResult.Allowed, result, "Expected invoke with denying custom attributes to be denied."); } }
/// <summary> /// Helper method performs a query operation against a given proxy instance. /// </summary> /// <param name="domainService">The type of <see cref="DomainService"/> to perform this query operation against.</param> /// <param name="context">The current context.</param> /// <param name="domainServiceInstances">The list of tracked <see cref="DomainService"/> instances that any newly created /// <see cref="DomainServices"/> will be added to.</param> /// <param name="queryName">The name of the query to invoke.</param> /// <param name="parameters">The query parameters.</param> /// <returns>The query results. May be null if there are no query results.</returns> /// <exception cref="ArgumentNullException">if <paramref name="context"/> is null.</exception> /// <exception cref="ArgumentNullException">if <paramref name="queryName"/> is null or an empty string.</exception> /// <exception cref="InvalidOperationException">if no match query operation exists on the <paramref name="context"/>.</exception> /// <exception cref="OperationException">if operation errors are thrown during execution of the query operation.</exception> public static IEnumerable Query(Type domainService, DomainServiceContext context, IList <DomainService> domainServiceInstances, string queryName, object[] parameters) { context = new DomainServiceContext(context, DomainOperationType.Query); DomainService service = CreateDomainServiceInstance(domainService, context, domainServiceInstances); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType()); DomainOperationEntry queryOperation = serviceDescription.GetQueryMethod(queryName); if (queryOperation == null) { string errorMessage = string.Format( CultureInfo.InvariantCulture, Resource.DomainServiceProxy_QueryOperationNotFound, queryName, domainService); throw new InvalidOperationException(errorMessage); } int totalCount; IEnumerable <ValidationResult> validationErrors; object[] parameterValues = parameters ?? new object[0]; QueryDescription queryDescription = new QueryDescription(queryOperation, parameterValues); IEnumerable result = service.Query(queryDescription, out validationErrors, out totalCount); if (validationErrors != null && validationErrors.Any()) { IEnumerable <ValidationResultInfo> operationErrors = validationErrors.Select(ve => new ValidationResultInfo(ve.ErrorMessage, ve.MemberNames)); throw new OperationException(Resource.DomainServiceProxy_OperationError, operationErrors); } return(result); }
public void QueryAttribute_DomainService_Illegal_Default_With_Params() { ExceptionHelper.ExpectInvalidOperationException(delegate { DomainServiceDescription.GetDescription(typeof(QueryAttribute_DomainService_Default_Query_Has_Params)); }, string.Format(CultureInfo.CurrentCulture, Resource.DomainServiceDescription_DefaultQuery_Cannot_Have_Params, "GetEntity1")); }
public void ETagPropertyUpdatesEntity() { // Create the DSD to register type descriptors DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TMPT_DomainService)); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(TMPT_MockEntity1)); PropertyDescriptor descriptor = properties["ETag"]; Assert.IsNotNull(descriptor, "There should be a property descriptor for ETag."); TMPT_MockEntity1 entity = new TMPT_MockEntity1(); Assert.AreEqual(entity.GetETag(), descriptor.GetValue(entity), "The value returned should match the entity."); string etag = "etag"; entity.SetETag(etag); Assert.AreEqual(entity.GetETag(), descriptor.GetValue(entity), "The value returned should match the updated entity."); etag = "etag2"; descriptor.SetValue(entity, etag); Assert.AreEqual(etag, entity.GetETag(), "The entity value should match the updated etag."); Assert.AreEqual(etag, descriptor.GetValue(entity), "The descriptor value should match the updated etag."); descriptor.ResetValue(entity); Assert.AreEqual(entity.GetETag(), descriptor.GetValue(entity), "The reset value returned should match the entity."); }
public void DefaultRowKeyMetadata() { // Create the DSD to register type descriptors DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TMPT_DomainService)); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(TMPT_MockEntity1)); PropertyDescriptor descriptor = properties["RowKey"]; Assert.IsNotNull(descriptor, "There should be a property descriptor for RowKey."); Assert.AreEqual(typeof(string), descriptor.PropertyType, "The RowKey type should be a string."); KeyAttribute keyAttribute = (KeyAttribute)descriptor.Attributes[typeof(KeyAttribute)]; Assert.IsNotNull(keyAttribute, "The RowKey should have a KeyAttribute."); EditableAttribute editableAttribute = (EditableAttribute)descriptor.Attributes[typeof(EditableAttribute)]; Assert.IsNotNull(editableAttribute, "The RowKey should have an EditableAttribute."); Assert.IsFalse(editableAttribute.AllowEdit, "The RowKey should not allow editing."); Assert.IsTrue(editableAttribute.AllowInitialValue, "The RowKey should allow an initial value."); DisplayAttribute displayAttribute = (DisplayAttribute)descriptor.Attributes[typeof(DisplayAttribute)]; Assert.IsNotNull(displayAttribute, "The RowKey should have an DisplayAttribute."); Assert.IsFalse(displayAttribute.AutoGenerateField, "The RowKey should not be included in autogeneration."); }
public void ETagProperty() { // Create the DSD to register type descriptors DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TMPT_DomainService)); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(TMPT_MockEntity1)); PropertyDescriptor descriptor = properties["ETag"]; Assert.IsNotNull(descriptor, "There should be a property descriptor for ETag."); Assert.AreEqual(typeof(string), descriptor.PropertyType, "The ETag type should be a string."); EditableAttribute editableAttribute = (EditableAttribute)descriptor.Attributes[typeof(EditableAttribute)]; Assert.IsNotNull(editableAttribute, "The ETag should have an EditableAttribute."); Assert.IsFalse(editableAttribute.AllowEdit, "The ETag should not allow editing."); Assert.IsFalse(editableAttribute.AllowInitialValue, "The ETag should not allow an initial value."); DisplayAttribute displayAttribute = (DisplayAttribute)descriptor.Attributes[typeof(DisplayAttribute)]; Assert.IsNotNull(displayAttribute, "The ETag should have an DisplayAttribute."); Assert.IsFalse(displayAttribute.AutoGenerateField, "The ETag should not be included in autogeneration."); ConcurrencyCheckAttribute concurrencyCheckAttribute = (ConcurrencyCheckAttribute)descriptor.Attributes[typeof(ConcurrencyCheckAttribute)]; Assert.IsNotNull(concurrencyCheckAttribute, "The ETag should have an ConcurrencyCheckAttribute."); }
public void OverwrittenTimestampMetadata() { // Create the DSD to register type descriptors DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TMPT_DomainService)); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(TMPT_MockEntity2)); PropertyDescriptor descriptor = properties["Timestamp"]; Assert.IsNotNull(descriptor, "There should be a property descriptor for Timestamp."); Assert.AreEqual(typeof(DateTime), descriptor.PropertyType, "The Timestamp type should be a DateTime."); TimestampAttribute timestampAttribute = (TimestampAttribute)descriptor.Attributes[typeof(TimestampAttribute)]; Assert.IsNotNull(timestampAttribute, "The Timestamp should have a TimestampAttribute."); EditableAttribute editableAttribute = (EditableAttribute)descriptor.Attributes[typeof(EditableAttribute)]; Assert.IsNotNull(editableAttribute, "The Timestamp should have an EditableAttribute."); Assert.IsTrue(editableAttribute.AllowEdit, "The Timestamp should allow editing."); Assert.IsTrue(editableAttribute.AllowInitialValue, "The Timestamp should allow an initial value."); DisplayAttribute displayAttribute = (DisplayAttribute)descriptor.Attributes[typeof(DisplayAttribute)]; Assert.IsNotNull(displayAttribute, "The Timestamp should have an DisplayAttribute."); Assert.AreEqual("T", displayAttribute.Name, "The Timestamp names should be equal."); }
public void OverwrittenRowKeyMetadata() { // Create the DSD to register type descriptors DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TMPT_DomainService)); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(TMPT_MockEntity2)); PropertyDescriptor descriptor = properties["RowKey"]; Assert.IsNotNull(descriptor, "There should be a property descriptor for RowKey."); Assert.AreEqual(typeof(string), descriptor.PropertyType, "The RowKey type should be a string."); KeyAttribute keyAttribute = (KeyAttribute)descriptor.Attributes[typeof(KeyAttribute)]; Assert.IsNotNull(keyAttribute, "The RowKey should have a KeyAttribute."); EditableAttribute editableAttribute = (EditableAttribute)descriptor.Attributes[typeof(EditableAttribute)]; Assert.IsNotNull(editableAttribute, "The RowKey should have an EditableAttribute."); Assert.IsTrue(editableAttribute.AllowEdit, "The RowKey should allow editing."); Assert.IsTrue(editableAttribute.AllowInitialValue, "The RowKey should allow an initial value."); DisplayAttribute displayAttribute = (DisplayAttribute)descriptor.Attributes[typeof(DisplayAttribute)]; Assert.IsNotNull(displayAttribute, "The RowKey should have an DisplayAttribute."); Assert.AreEqual("RK", displayAttribute.Name, "The RowKey names shoulds be equal."); }
public void DomainOperationEntry_All_Types() { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(DomainOperationEntryTestDomainService)); // Invoke DomainOperationEntry entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "InvokeMethod"); Assert.IsNotNull(entry, "Could not locate InvokeMethod"); Assert.IsNull(entry.AssociatedType, "Invoke should have no associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Invoke, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Invoke", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Invoke with entity entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "InvokeMethodEntity"); Assert.IsNotNull(entry, "Could not locate InvokeMethodEntity"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Invoke, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Invoke", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Query entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "GetEntities"); Assert.IsNotNull(entry, "Could not locate GetEntities"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Query, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Query", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Insert entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "InsertMethod"); Assert.IsNotNull(entry, "Could not locate InsertMethod"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Insert, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Insert", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Update entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "UpdateMethod"); Assert.IsNotNull(entry, "Could not locate InvokeMethod"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Update, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Update", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Custom Update entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "CustomMethod"); Assert.IsNotNull(entry, "Could not locate CustomMethod"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Custom, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Update", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); // Delete entry = description.DomainOperationEntries.SingleOrDefault(p => p.Name == "DeleteMethod"); Assert.IsNotNull(entry, "Could not locate DeleteMethod"); Assert.AreEqual(typeof(DomainOperationEntryTestEntity), entry.AssociatedType, "Wrong associated type"); Assert.AreEqual(typeof(DomainOperationEntryTestDomainService), entry.DomainServiceType, "Wrong domain service type"); Assert.AreEqual(DomainOperation.Delete, entry.Operation, "Wrong domain operation"); Assert.AreEqual("Delete", entry.OperationType, "Wrong operation type for this DomainOperationEntry"); }
public void GetDomainMethods_Sanity() { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(DomainMethod_ValidProvider_MultipleMethods)); // verify that GetDomainMethods with City type only returns methods that are associated with City IEnumerable <DomainOperationEntry> domainMethods = description.GetCustomMethods(typeof(City)); Assert.IsNotNull(domainMethods); Assert.AreEqual(4, domainMethods.Count()); Assert.IsNotNull(domainMethods.Single(m => m.Name == "ProcessCity")); Assert.IsNotNull(domainMethods.Single(m => m.Name == "AssignCityZone")); Assert.IsNotNull(domainMethods.Single(m => m.Name == "AssignCityZoneIfAuthorized")); Assert.IsNotNull(domainMethods.Single(m => m.Name == "AutoAssignCityZone")); Assert.IsNull(domainMethods.FirstOrDefault(m => m.Name == "ProcessCounty")); // verify that GetDomainMethods with Zip type returns one method domainMethods = description.GetCustomMethods(typeof(Zip)); Assert.AreEqual(2, domainMethods.Count()); Assert.IsNotNull(domainMethods.Single(m => m.Name == "ReassignZipCode")); // verify that GetDomainMethods with County type returns one method domainMethods = description.GetCustomMethods(typeof(County)); Assert.AreEqual(1, domainMethods.Count()); Assert.IsNotNull(domainMethods.Single(m => m.Name == "ProcessCounty")); // verify that GetDomainMethods return empty collection when passing in type that is not associated with any methods on the provider domainMethods = description.GetCustomMethods(typeof(State)); Assert.IsNotNull(domainMethods); Assert.AreEqual(0, domainMethods.Count()); }
public void TestDomainService_UpdateMemberToDefaultValue() { TestDomainServices.EF.Catalog service = ServerTestHelper.CreateInitializedDomainService <TestDomainServices.EF.Catalog>(DomainOperationType.Submit); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType()); // in the below, non RTO is simulated by leaving ReorderPoint as its default value in the // original instance AdventureWorksModel.Product currProduct = new AdventureWorksModel.Product { ProductID = 1, ReorderPoint = 0, Weight = 0 }; AdventureWorksModel.Product origProduct = new AdventureWorksModel.Product { ProductID = 1, Weight = 50.0M }; // verify expected test state - this test relies on the below attribute values PropertyDescriptor pd = TypeDescriptor.GetProperties(typeof(AdventureWorksModel.Product))["ReorderPoint"]; Assert.IsNull(pd.Attributes[typeof(RoundtripOriginalAttribute)]); pd = TypeDescriptor.GetProperties(typeof(AdventureWorksModel.Product))["Weight"]; Assert.IsNotNull(pd.Attributes[typeof(RoundtripOriginalAttribute)]); pd = TypeDescriptor.GetProperties(typeof(AdventureWorksModel.Product))["SafetyStockLevel"]; Assert.IsNotNull(pd.Attributes[typeof(ExcludeAttribute)]); ObjectContextExtensions.AttachAsModified(service.ObjectContext.Products, currProduct, origProduct); // verify the expected property modifications ObjectStateEntry stateEntry = service.ObjectContext.ObjectStateManager.GetObjectStateEntry(currProduct); string[] modifiedProperties = stateEntry.GetModifiedProperties().ToArray(); Assert.IsTrue(modifiedProperties.Contains("ReorderPoint")); // no RTO so this should be modified Assert.IsTrue(modifiedProperties.Contains("Weight")); // RTO so this is picked up by normal value comparison Assert.IsFalse(modifiedProperties.Contains("SafetyStockLevel")); // excluded member, so shouldn't be marked modified Assert.IsFalse(modifiedProperties.Contains("ProductID")); // key members shouldn't be marked modified }
/// <summary> /// Helper method performs a query operation against a given proxy instance. /// </summary> /// <param name="domainService">The type of <see cref="DomainService"/> to perform this query operation against.</param> /// <param name="context">The current context.</param> /// <param name="domainServiceInstances">The list of tracked <see cref="DomainService"/> instances that any newly created /// <see cref="DomainServices"/> will be added to.</param> /// <param name="queryName">The name of the query to invoke.</param> /// <param name="parameters">The query parameters.</param> /// <returns>The query results. May be null if there are no query results.</returns> /// <exception cref="ArgumentNullException">if <paramref name="context"/> is null.</exception> /// <exception cref="ArgumentNullException">if <paramref name="queryName"/> is null or an empty string.</exception> /// <exception cref="InvalidOperationException">if no match query operation exists on the <paramref name="context"/>.</exception> /// <exception cref="OperationException">if operation errors are thrown during execution of the query operation.</exception> public static IEnumerable Query(Type domainService, DomainServiceContext context, IList <DomainService> domainServiceInstances, string queryName, object[] parameters) { context = new DomainServiceContext(context, DomainOperationType.Query); DomainService service = CreateDomainServiceInstance(domainService, context, domainServiceInstances); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType()); DomainOperationEntry queryOperation = serviceDescription.GetQueryMethod(queryName); if (queryOperation == null) { string errorMessage = string.Format( CultureInfo.InvariantCulture, Resource.DomainServiceProxy_QueryOperationNotFound, queryName, domainService); throw new InvalidOperationException(errorMessage); } object[] parameterValues = parameters ?? Array.Empty <object>(); QueryDescription queryDescription = new QueryDescription(queryOperation, parameterValues); var actualMethod = s_queryGeneric.MakeGenericMethod(queryDescription.Method.AssociatedType); try { return((IEnumerable)actualMethod.Invoke(null, new object[] { service, queryDescription })); } catch (TargetInvocationException tie) when(tie.InnerException is object) { throw tie.InnerException; } }
public void InvalidProvider_DupMethodName() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(OnlineMethod_InvalidProvider_DupMethodName)); }, string.Format(CultureInfo.CurrentCulture, Resource.DomainOperationEntryOverload_NotSupported, "TestMethod")); }
public async Task DomainService_DirectQuery() { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Catalog)); TestDomainServices.EF.Catalog service = new TestDomainServices.EF.Catalog(); DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Query); service.Initialize(dsc); DomainOperationEntry queryOperation = description.GetQueryMethod("GetPurchaseOrders"); ServiceQuery serviceQuery = new ServiceQuery(); serviceQuery.QueryParts = new ServiceQueryPart[] { new ServiceQueryPart("where", "(it.Freight!=0)"), new ServiceQueryPart("take", "1") }; QueryResult <AdventureWorksModel.PurchaseOrder> result = await QueryProcessor.ProcessAsync <AdventureWorksModel.PurchaseOrder>(service, queryOperation, Array.Empty <object>(), serviceQuery); Assert.AreEqual(1, result.RootResults.Count()); }
public void ClientCodeGenerationDispatcher_Generate_Using_T4_Custom() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { typeof(T4DomainServiceClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, null); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.AreEqual(generator.GetType(), typeof(T4DomainServiceClientCodeGenerator), "dispatcher found " + generator.GetType() + " but should have found T4DomainServiceClientProxyGenerator"); DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(DispatcherDomainService)); string generatedCode = generator.GenerateCode(host, new DomainServiceDescription[] { dsd }, options); Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "expected T4 generator to generate code"); TestHelper.AssertGeneratedCodeContains(generatedCode, T4DomainServiceClientCodeGenerator.GeneratedBoilerPlate); TestHelper.AssertGeneratedCodeContains(generatedCode, "public class DispatcherEntity : Entity"); TestHelper.AssertNoErrorsOrWarnings(logger); } }
public void RequiresRoleAttribute_Authorize_MultipleAttributes_Denied() { // Create user in only role1, which should be denied because we require (1 or 2) AND (3 or 4) IPrincipal user = this.CreateIPrincipal("user1", "role1"); // Instantiate a new DomainService to use for an Invoke using (RequiresRoleTestService testDomainService = new RequiresRoleTestService()) { testDomainService.Initialize(new DomainServiceContext(new MockDataService(user), DomainOperationType.Invoke)); // Get a DomainServiceDescription for that same domain service DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(RequiresRoleTestService)); // Locate the invoke method DomainOperationEntry invokeEntry = description.DomainOperationEntries.Single(p => p.Name == "Method1"); // Ask the domain service to perform authorization. // The principal will be located via the mock data service created above. // Invokes do not expect an entity instance. AuthorizationResult result = testDomainService.IsAuthorized(invokeEntry, entity: null); Assert.AreNotSame(AuthorizationResult.Allowed, result, "Expected user in role1 to be denied against invoke requiring roles (1 or 2) && (3 or 4) in multiple attributes"); // Validate the formatted denial message includes the invoke we attempted string expectedMessage = String.Format(CultureInfo.CurrentCulture, Resource.AuthorizationAttribute_Default_Message, "Method1"); Assert.AreEqual(expectedMessage, result.ErrorMessage, "Expected default denial message plus name of the invoke method"); } }
public void ServerValidation_Query() { TestDomainServices.TestProvider_Scenarios service = ServerTestHelper.CreateInitializedDomainService <TestDomainServices.TestProvider_Scenarios>(DomainOperationType.Query); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType()); DomainOperationEntry method = serviceDescription.DomainOperationEntries.Single(p => p.Name == "QueryWithParamValidation"); QueryDescription qd = new QueryDescription(method, new object[] { -1, "ABC" }); int totalCount; IEnumerable <ValidationResult> validationErrors; service.Query(qd, out validationErrors, out totalCount); Assert.IsNotNull(validationErrors); Assert.AreEqual(2, validationErrors.Count()); ValidationResult error = validationErrors.ElementAt(0); Assert.AreEqual("The field a must be between 0 and 10.", error.ErrorMessage); Assert.AreEqual("a", error.MemberNames.Single()); error = validationErrors.ElementAt(1); Assert.AreEqual("The field b must be a string with a maximum length of 2.", error.ErrorMessage); Assert.AreEqual("b", error.MemberNames.Single()); }
public void ClientCodeGenerationDispatcher_Finds_Default_By_Name() { ConsoleLogger logger = new ConsoleLogger(); ClientCodeGenerationOptions options = new ClientCodeGenerationOptions() { Language = "C#" }; ICodeGenerationHost host = TestHelper.CreateMockCodeGenerationHost(logger, /*sharedTypeService*/ null); // Create a new dispatcher and call an internal extensibility point to add ourselves // into the MEF composition container using (ClientCodeGenerationDispatcher dispatcher = new ClientCodeGenerationDispatcher()) { string[] compositionAssemblies = new string[] { Assembly.GetExecutingAssembly().Location, typeof(T4DomainServiceClientCodeGenerator).Assembly.Location }; IDomainServiceClientCodeGenerator generator = dispatcher.FindCodeGenerator(host, options, compositionAssemblies, CodeDomClientCodeGenerator.GeneratorName); Assert.IsNotNull(generator, "the dispatcher did not find any code generator"); Assert.IsTrue(typeof(CodeDomClientCodeGenerator).IsAssignableFrom(generator.GetType()), "dispatcher found " + generator.GetType() + " but should have found CodeDomClientCodeGenerator"); DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(DispatcherDomainService)); string generatedCode = generator.GenerateCode(host, new DomainServiceDescription[] { dsd }, options); Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "expected code to have been generated"); Assert.IsTrue(generatedCode.Contains("public sealed partial class DispatcherDomainContext : DomainContext"), "Expected generated code to contain public sealed partial class DispatcherDomainContext : DomainContext"); } }
public async Task DomainService_CallSubmitDirectly() { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(DomainMethod_ValidProvider_MultipleMethods)); List <ChangeSetEntry> changeSetEntries = new List <ChangeSetEntry>(); ChangeSetEntry processCityOperation = new ChangeSetEntry(); processCityOperation.Entity = new City { Name = "Redmond", CountyName = "King", StateName = "WA" }; processCityOperation.DomainOperationEntry = description.GetCustomMethod(typeof(City), "ProcessCity"); processCityOperation.Operation = DomainOperation.Update; processCityOperation.EntityActions = new EntityActionCollection { { "ProcessCity", new object[] { new byte[] { byte.MaxValue, byte.MinValue, 123 } } } }; changeSetEntries.Add(processCityOperation); ChangeSet changeset = new ChangeSet(changeSetEntries); DomainMethod_ValidProvider_MultipleMethods myTestProvider = ServerTestHelper.CreateInitializedDomainService <DomainMethod_ValidProvider_MultipleMethods>(DomainOperationType.Submit); await myTestProvider.SubmitAsync(changeset, CancellationToken.None); // check that the domain services have invoked the domain method correctly by checking the internal variables set Assert.AreEqual <string>("ProcessCity_", myTestProvider.Invoked); Assert.AreEqual <int>(3, myTestProvider.InputData.Length); Assert.AreEqual <byte>(123, myTestProvider.InputData[2]); }
public void DomainService_DirectQuery() { DomainServiceDescription description = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Catalog)); TestDomainServices.EF.Catalog service = new TestDomainServices.EF.Catalog(); DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Query); service.Initialize(dsc); DomainOperationEntry queryOperation = description.GetQueryMethod("GetPurchaseOrders"); ServiceQuery serviceQuery = new ServiceQuery(); serviceQuery.QueryParts = new ServiceQueryPart[] { new ServiceQueryPart("where", "(it.Freight!=0)"), new ServiceQueryPart("take", "1") }; IEnumerable <ValidationResult> validationErrors; int totalCount; QueryResult <AdventureWorksModel.PurchaseOrder> result = QueryProcessor.Process <AdventureWorksModel.PurchaseOrder>(service, queryOperation, new object[0], serviceQuery, out validationErrors, out totalCount); Assert.AreEqual(1, result.RootResults.Count()); }
public void OtherArgsMustBeOfPredefinedTypes() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_MultipleEntities)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "county")); ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_ArgOfTypeObject)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "objArg")); ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_ArgOfTypeIntPtr)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "intPtrArg")); ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_ArgOfTypeUIntPtr)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "uintPtrArg")); ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_ArgOfComplexTypeIEnumerable)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "ienumerableArg")); ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_ArgOfComplexTypeList)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_ParamMustBeSimple, "ProcessCity", "listArg")); }
public void ParameterlessDomainMethodNotSupported() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_Parameterless)); }, Resource.InvalidCustomMethod_MethodCannotBeParameterless); }
public void FirstArgMustBeEntity() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_FirstArgNonEntity)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainMethod_ParamMustBeEntity, "name", "ProcessCity")); }
public void InvalidReturnType() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_InvalidReturnType)); }, string.Format(CultureInfo.CurrentCulture, Resource.InvalidDomainOperationEntry_NonQueryMustReturnVoid, "ProcessCity")); }
public void OverloadsNotSupported() { ExceptionHelper.ExpectException <InvalidOperationException>(delegate { DomainServiceDescription.GetDescription(typeof(DomainMethod_InvalidProvider_MethodOverloads)); }, string.Format(CultureInfo.CurrentCulture, Resource.DomainOperationEntryOverload_NotSupported, "ProcessCity")); }
/// <summary> /// Initializes a new instance of the <see cref="DomainServiceHost"/> class with /// the type of service and its base addresses specified. /// </summary> /// <param name="domainServiceType">The type of the <see cref="DomainService"/> to host.</param> /// <param name="baseAddresses"> /// An array of type <see cref="System.Uri"/> that contains the base addresses for /// the hosted service. /// </param> public DomainServiceHost(Type domainServiceType, params Uri[] baseAddresses) { if (domainServiceType == null) { throw new ArgumentNullException("domainServiceType"); } if (baseAddresses == null) { throw new ArgumentNullException("baseAddresses"); } EnableClientAccessAttribute att = (EnableClientAccessAttribute)TypeDescriptor.GetAttributes(domainServiceType)[typeof(EnableClientAccessAttribute)]; // Filter out all non-HTTP addresses. HashSet <string> allowedSchemes = DomainServiceHost._allowedSchemes; // Additionally filter out HTTP addresses if this DomainService requires a secure endpoint. if (att != null && att.RequiresSecureEndpoint) { allowedSchemes = DomainServiceHost._allowedSecureSchemes; } // Apply the filter. baseAddresses = baseAddresses.Where(addr => allowedSchemes.Contains(addr.Scheme)).ToArray(); this._domainServiceDescription = DomainServiceDescription.GetDescription(domainServiceType); this.InitializeDescription(domainServiceType, new UriSchemeKeyedCollection(baseAddresses)); }
public async Task Authorization_Custom_Authorization_On_Query() { CityDomainService cities = new CityDomainService(); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(typeof(CityDomainService)); DomainOperationEntry getZipsIfUser = serviceDescription.GetQueryMethod("GetZipsIfUser"); // The attribute permits only a user named mathew to access the query MockUser user = new MockUser("NotZipGuy"); MockDataService dataService = new MockDataService(user); cities.Initialize(new WcfDomainServiceContext(dataService, DomainOperationType.Query)); // not authenticated should be denied cleanly because there is no user name Exception expectedException = null; System.Collections.IEnumerable result; try { user.IsAuthenticated = false; result = (await cities.QueryAsync <Zip>(new QueryDescription(getZipsIfUser), CancellationToken.None)).Result; } catch (UnauthorizedAccessException e) { expectedException = e; } Assert.IsNotNull(expectedException); Assert.AreEqual("Only one user is authorized for this query, and it isn't you.", expectedException.Message, "Expected this custom authorization deny message for non-authenticated user."); // Authenticated, but still not the right user name -- should be denied cities = new CityDomainService(); expectedException = null; user = new MockUser("NotZipGuy", new string[] { "clerk" }); user.IsAuthenticated = true; dataService = new MockDataService(user); cities.Initialize(new WcfDomainServiceContext(dataService, DomainOperationType.Query)); try { result = (await cities.QueryAsync <Zip>(new QueryDescription(getZipsIfUser), CancellationToken.None)) .Result; } catch (UnauthorizedAccessException e) { expectedException = e; } Assert.IsNotNull(expectedException); Assert.AreEqual("Only one user is authorized for this query, and it isn't you.", expectedException.Message, "Expected this custom authorization deny message for authenticated user with wrong name."); // authenticated and in with the right name -- should be allowed cities = new CityDomainService(); user = new MockUser("ZipGuy"); user.IsAuthenticated = true; dataService = new MockDataService(user); cities.Initialize(new WcfDomainServiceContext(dataService, DomainOperationType.Query)); var queryResult = await cities.QueryAsync <Zip>(new QueryDescription(getZipsIfUser), CancellationToken.None); Assert.IsNotNull(queryResult.Result); Assert.IsNull(queryResult.ValidationErrors); Assert.IsTrue(queryResult.Result.OfType <Zip>().Any(), "Expected non-zero number of zip codes returned"); }