public void InitializInsertRestrictionsTypeWithRecordSuccess() { // Assert IEdmRecordExpression primitiveExampleValue = new EdmRecordExpression( new EdmPropertyConstructor("Description", new EdmStringConstant("example desc")), new EdmPropertyConstructor("Value", new EdmStringConstant("example value"))); IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Insertable", new EdmBooleanConstant(false)), new EdmPropertyConstructor("NonInsertableProperties", new EdmCollectionExpression(new EdmPathExpression("abc/xyz"))), new EdmPropertyConstructor("NonInsertableNavigationProperties", new EdmCollectionExpression(new EdmNavigationPropertyPathExpression("abc"), new EdmNavigationPropertyPathExpression("RelatedEvents"))), new EdmPropertyConstructor("MaxLevels", new EdmIntegerConstant(8)), new EdmPropertyConstructor("CustomQueryOptions", new EdmCollectionExpression( new EdmRecordExpression( new EdmPropertyConstructor("Name", new EdmStringConstant("primitive name")), new EdmPropertyConstructor("Description", new EdmStringConstant("primitive desc")), new EdmPropertyConstructor("DocumentationURL", new EdmStringConstant("http://any3")), new EdmPropertyConstructor("Required", new EdmBooleanConstant(true)), new EdmPropertyConstructor("ExampleValues", new EdmCollectionExpression(primitiveExampleValue))))) // QueryOptions // Permission // CustomHeaders ); // Act InsertRestrictionsType insert = new InsertRestrictionsType(); insert.Initialize(record); // Assert VerifyInsertRestrictions(insert); }
public void InitializReadRestrictionsTypeWithRecordSuccess() { // Assert IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Readable", new EdmBooleanConstant(false)), new EdmPropertyConstructor("CustomQueryOptions", new EdmCollectionExpression( new EdmRecordExpression(new EdmPropertyConstructor("Name", new EdmStringConstant("root query name"))))), // Root Permission // Root CustomHeaders new EdmPropertyConstructor("ReadByKeyRestrictions", new EdmRecordExpression( new EdmPropertyConstructor("Readable", new EdmBooleanConstant(true)), new EdmPropertyConstructor("CustomHeaders", new EdmCollectionExpression( new EdmRecordExpression(new EdmPropertyConstructor("Name", new EdmStringConstant("by key head name"))))) // ByKey Permission // ByKey CustomQueryOptions )) ); // Act ReadRestrictionsType read = new ReadRestrictionsType(); read.Initialize(record); // Assert VerifyReadRestrictions(read); }
public static IEdmExpression CreatePermission(params string[] scopeNames) { var restriction = new EdmRecordExpression( CreatePermissionProperty(scopeNames)); return(restriction); }
public void InitializeSecuritySchemeWithRecordSuccess() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Authorization", new EdmStringConstant("DelegatedWork")), new EdmPropertyConstructor("RequiredScopes", new EdmCollectionExpression( new EdmStringConstant("User.ReadAll"), new EdmStringConstant("User.WriteAll")))); SecurityScheme securityScheme = new SecurityScheme(); Assert.Null(securityScheme.Authorization); Assert.Null(securityScheme.RequiredScopes); // Act securityScheme.Initialize(record); // Assert Assert.NotNull(securityScheme.Authorization); Assert.Equal("DelegatedWork", securityScheme.Authorization); Assert.NotNull(securityScheme.RequiredScopes); Assert.Equal(2, securityScheme.RequiredScopes.Count); Assert.Equal(new[] { "User.ReadAll", "User.WriteAll" }, securityScheme.RequiredScopes); }
public void GetCollectionForRecordWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmCollectionExpression( new EdmRecordExpression( new EdmPropertyConstructor("Scope", new EdmStringConstant("scope1")), new EdmPropertyConstructor("RestrictedProperties", new EdmStringConstant("restrictedProperties1"))), new EdmRecordExpression( new EdmPropertyConstructor("Scope", new EdmStringConstant("scope2")), new EdmPropertyConstructor("RestrictedProperties", new EdmStringConstant("restrictedProperties2")))))); // Act IList <ScopeType> actual = record.GetCollection <ScopeType>("prop"); // Assert Assert.NotNull(actual); Assert.Equal(2, actual.Count); for (int i = 1; i <= actual.Count; i++) { Assert.Equal("scope" + i, actual[i - 1].Scope); Assert.Equal("restrictedProperties" + i, actual[i - 1].RestrictedProperties); } }
public void InitializeDeleteRestrictionsTypeWithRecordSuccess() { // Assert IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Deletable", new EdmBooleanConstant(false)), new EdmPropertyConstructor("NonDeletableNavigationProperties", new EdmCollectionExpression(new EdmNavigationPropertyPathExpression("abc"), new EdmNavigationPropertyPathExpression("RelatedEvents"))), new EdmPropertyConstructor("MaxLevels", new EdmIntegerConstant(42)), new EdmPropertyConstructor("Permissions", new EdmCollectionExpression( new EdmRecordExpression( new EdmPropertyConstructor("SchemeName", new EdmStringConstant("schemeName"))))), new EdmPropertyConstructor("CustomQueryOptions", new EdmCollectionExpression( new EdmRecordExpression( new EdmPropertyConstructor("Name", new EdmStringConstant("odata-debug")), new EdmPropertyConstructor("DocumentationURL", new EdmStringConstant("https://debug.html"))))) // CustomHeaders ); // Act DeleteRestrictionsType delete = new DeleteRestrictionsType(); delete.Initialize(record); // Assert VerifyDeleteRestrictionsType(delete); }
private static void AddComplexPropertyCommunityAlternateKey(EdmModel model, EdmEntityType entity) { // Alternate key 1 -> Code List <IEdmExpression> propertyRefs = new List <IEdmExpression>(); IEdmRecordExpression propertyRef = new EdmRecordExpression( new EdmPropertyConstructor("Alias", new EdmStringConstant("Code")), new EdmPropertyConstructor("Name", new EdmPropertyPathExpression("Code"))); propertyRefs.Add(propertyRef); EdmRecordExpression alternateKey1 = new EdmRecordExpression(new EdmPropertyConstructor("Key", new EdmCollectionExpression(propertyRefs))); // Alternate key 2 -> City & Street propertyRefs = new List <IEdmExpression>(); propertyRef = new EdmRecordExpression( new EdmPropertyConstructor("Alias", new EdmStringConstant("City")), new EdmPropertyConstructor("Name", new EdmPropertyPathExpression("Location/City"))); propertyRefs.Add(propertyRef); propertyRef = new EdmRecordExpression( new EdmPropertyConstructor("Alias", new EdmStringConstant("Street")), new EdmPropertyConstructor("Name", new EdmPropertyPathExpression("Location/Street"))); propertyRefs.Add(propertyRef); EdmRecordExpression alternateKey2 = new EdmRecordExpression(new EdmPropertyConstructor("Key", new EdmCollectionExpression(propertyRefs))); IEdmTerm coreAlternateTerm = AlternateKeysVocabularyModel.Instance.FindDeclaredTerm("OData.Community.Keys.V1.AlternateKeys"); Assert.NotNull(coreAlternateTerm); var annotation = new EdmVocabularyAnnotation(entity, coreAlternateTerm, new EdmCollectionExpression(alternateKey1, alternateKey2)); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.SetVocabularyAnnotation(annotation); }
public void InitializeOAuth2AuthCodeWithRecordSuccess() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("TokenUrl", new EdmStringConstant("http://tokenUrl")), new EdmPropertyConstructor("AuthorizationUrl", new EdmStringConstant("http://authorizationUrl"))); OAuth2AuthCode authCode = new OAuth2AuthCode(); Assert.Null(authCode.Name); Assert.Null(authCode.Description); Assert.Null(authCode.Scopes); Assert.Null(authCode.AuthorizationUrl); Assert.Null(authCode.TokenUrl); // Act authCode.Initialize(record); // Assert Assert.Null(authCode.Name); Assert.Null(authCode.Description); Assert.Null(authCode.Scopes); Assert.Equal("http://authorizationUrl", authCode.AuthorizationUrl); Assert.Equal("http://tokenUrl", authCode.TokenUrl); }
public void InitializNavigationRestrictionsTypeWithRecordSuccess() { // Assert EdmModel model = new EdmModel(); IEdmEnumType navigationType = model.FindType("Org.OData.Capabilities.V1.NavigationType") as IEdmEnumType; Assert.NotNull(navigationType); IEdmRecordExpression restriction1 = new EdmRecordExpression( new EdmPropertyConstructor("NavigationProperty", new EdmNavigationPropertyPathExpression("abc")), new EdmPropertyConstructor("Navigability", new EdmEnumMemberExpression(navigationType.Members.First(c => c.Name == "Single"))), new EdmPropertyConstructor("SkipSupported", new EdmBooleanConstant(false))); IEdmRecordExpression restriction2 = new EdmRecordExpression( new EdmPropertyConstructor("NavigationProperty", new EdmNavigationPropertyPathExpression("xyz")), new EdmPropertyConstructor("Navigability", new EdmEnumMemberExpression(navigationType.Members.First(c => c.Name == "None"))), new EdmPropertyConstructor("OptimisticConcurrencyControl", new EdmBooleanConstant(true))); IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Navigability", new EdmEnumMemberExpression(navigationType.Members.First(c => c.Name == "Recursive"))), new EdmPropertyConstructor("RestrictedProperties", new EdmCollectionExpression(restriction1, restriction2)) ); // Act NavigationRestrictionsType navigation = new NavigationRestrictionsType(); navigation.Initialize(record); // Assert VerifyNavigationRestrictions(navigation); }
public void InitializSearchRestrictionsTypeWithRecordSuccess() { // Assert EdmModel model = new EdmModel(); IEdmEnumType searchExpressions = model.FindType("Org.OData.Capabilities.V1.SearchExpressions") as IEdmEnumType; Assert.NotNull(searchExpressions); IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(false)), new EdmPropertyConstructor("UnsupportedExpressions", new EdmEnumMemberExpression( searchExpressions.Members.First(c => c.Name == "AND"), searchExpressions.Members.First(c => c.Name == "OR"))) ); // Act SearchRestrictionsType search = new SearchRestrictionsType(); search.Initialize(record); // Assert Assert.False(search.Searchable); Assert.NotNull(search.UnsupportedExpressions); Assert.Equal(SearchExpressions.AND | SearchExpressions.OR, search.UnsupportedExpressions.Value); }
public static void SetSearchRestrictionsCapabilitiesAnnotation(this EdmModel model, IEdmEntitySet entitySet, bool searchable, CapabilitiesSearchExpressions unsupported) { if (model == null) { throw new ArgumentNullException("model"); } if (entitySet == null) { throw new ArgumentNullException("entitySet"); } var target = entitySet; var term = SearchRestrictionsTerm; var name = new EdmEnumTypeReference(SearchExpressionsType, false).ToStringLiteral((long)unsupported); var properties = new IEdmPropertyConstructor[] { new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(searchable)), new EdmPropertyConstructor("UnsupportedExpressions", new EdmEnumMemberReferenceExpression(SearchExpressionsType.Members.Single(m => m.Name == name))), }; var record = new EdmRecordExpression(properties); var annotation = new EdmAnnotation(target, term, record); annotation.SetSerializationLocation(model, entitySet.ToSerializationLocation()); model.AddVocabularyAnnotation(annotation); }
public void ValueTerm_Record_OnEntityType() { this.SetupModels(); IEdmEntityType person = this.baseModel.FindEntityType("NS1.Person"); IEdmValueTerm termStringValue = this.longDefinitionModel.FindValueTerm("bar.StringValue"); var record = new EdmRecordExpression( new EdmPropertyConstructor("p1", new EdmStringConstant("s1")), new EdmPropertyConstructor("p2", new EdmIntegerConstant(2))); this.CreateAndAttachValueAnnotation(person, termStringValue, record); string expectedCsdl = @"<Schema Namespace=""NS1"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""Person""> <Key> <PropertyRef Name=""Name"" /> </Key> <Property Name=""Name"" Type=""Edm.String"" Nullable=""false"" /> <Property Name=""Birthday"" Type=""Edm.DateTimeOffset"" Nullable=""false"" /> </EntityType> <Annotations Target=""NS1.Person""> <Annotation Term=""bar.StringValue""> <Record> <PropertyValue Property=""p1"" String=""s1"" /> <PropertyValue Property=""p2"" Int=""2"" /> </Record> </Annotation> </Annotations> </Schema>"; this.SerializeAndVerifyAgainst(this.baseModel, expectedCsdl); }
public void InitializeApiKeyWithRecordSuccess() { // Arrange EdmModel model = new EdmModel(); IEdmType edmType = model.FindType("Org.OData.Authorization.V1.KeyLocation"); IEdmEnumType enumType = edmType as IEdmEnumType; IEdmEnumMember enumMember = enumType.Members.FirstOrDefault(c => c.Name == "Header"); Assert.NotNull(enumMember); IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Name", new EdmStringConstant("DelegatedWork")), new EdmPropertyConstructor("Description", new EdmStringConstant("Description of the authorization scheme")), new EdmPropertyConstructor("KeyName", new EdmStringConstant("keyName")), new EdmPropertyConstructor("Location", new EdmEnumMemberExpression(enumMember))); ApiKey apiKey = new ApiKey(); Assert.Null(apiKey.Name); Assert.Null(apiKey.Description); Assert.Null(apiKey.Location); Assert.Null(apiKey.KeyName); // Act apiKey.Initialize(record); // Assert Assert.Equal("DelegatedWork", apiKey.Name); Assert.Equal("Description of the authorization scheme", apiKey.Description); Assert.Equal("keyName", apiKey.KeyName); Assert.Equal(KeyLocation.Header, apiKey.Location); }
public void InitializeOAuth2PasswordWithRecordSuccess() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("RefreshUrl", new EdmStringConstant("http://refreshUrl")), new EdmPropertyConstructor("TokenUrl", new EdmStringConstant("http://tokenUrl"))); OAuth2Password password = new OAuth2Password(); Assert.Null(password.Name); Assert.Null(password.Description); Assert.Null(password.Scopes); Assert.Null(password.RefreshUrl); Assert.Null(password.TokenUrl); // Act password.Initialize(record); // Assert Assert.Null(password.Name); Assert.Null(password.Description); Assert.Null(password.Scopes); Assert.Equal("http://refreshUrl", password.RefreshUrl); Assert.Equal("http://tokenUrl", password.TokenUrl); }
public void EdmRecordExpression() { var e = new EdmRecordExpression(EdmCoreModel.Instance.GetBoolean(true).AsStructured(), new EdmPropertyConstructor("p1", new EdmStringConstant("qwerty")), new EdmPropertyConstructor("p2", new EdmStringConstant("qwerty2"))); Assert.AreEqual(EdmExpressionKind.Record, e.ExpressionKind, "e.ExpressionKind"); Assert.AreEqual("Edm.Boolean", e.DeclaredType.FullName(), "e.DeclaredType"); Assert.IsTrue(e.IsBad(), "e is bad because it has a bad declared type"); Assert.AreEqual(1, e.Errors().Count(), "Expression has errors"); e = new EdmRecordExpression(); Assert.IsNull(e.DeclaredType, "e.DeclaredType"); Assert.AreEqual(0, e.Properties.Count(), "e.Properties.Count()"); Assert.IsFalse(e.IsBad(), "e is good"); Assert.AreEqual(0, e.Errors().Count(), "Expression has no errors"); e = new EdmRecordExpression(new EdmEntityTypeReference(new EdmEntityType("", ""), false), new EdmPropertyConstructor("p1", new EdmStringConstant("qwerty")), new EdmPropertyConstructor("p2", new EdmStringConstant("qwerty2"))); Assert.IsFalse(e.IsBad(), "e is good"); Assert.AreEqual(0, e.Errors().Count(), "Expression has no errors"); e = new EdmRecordExpression((IEdmStructuredTypeReference)null); Assert.IsNull(e.DeclaredType, "e.DeclaredType"); Assert.AreEqual(0, e.Properties.Count(), "e.Properties.Count()"); Assert.IsFalse(e.IsBad(), "e is good"); Assert.AreEqual(0, e.Errors().Count(), "Expression has no errors"); this.VerifyThrowsException(typeof(ArgumentNullException), () => new EdmPropertyConstructor(null, new EdmStringConstant("qwerty"))); this.VerifyThrowsException(typeof(ArgumentNullException), () => new EdmPropertyConstructor("p1", null)); }
public void InitializeHttpWithRecordSuccess() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Name", new EdmStringConstant("HttpWork")), new EdmPropertyConstructor("Description", new EdmStringConstant("Description of the scheme")), new EdmPropertyConstructor("Scheme", new EdmStringConstant("Authorization scheme")), new EdmPropertyConstructor("BearerFormat", new EdmStringConstant("Format of the bearer token"))); Http http = new Http(); Assert.Null(http.Name); Assert.Null(http.Description); Assert.Null(http.Scheme); Assert.Null(http.BearerFormat); // Act http.Initialize(record); // Assert Assert.Equal("HttpWork", http.Name); Assert.Equal("Description of the scheme", http.Description); Assert.Equal("Authorization scheme", http.Scheme); Assert.Equal("Format of the bearer token", http.BearerFormat); }
private static void AddSelectTerm <T>(EdmModel model) { EdmComplexType complexType = new EdmComplexType("NS", "SelectType"); complexType.AddStructuralProperty("DefaultSelect", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true)))); complexType.AddStructuralProperty("DefaultHidden", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true)))); model.AddElement(complexType); EdmTerm term = new EdmTerm("NS", "MyTerm", new EdmComplexTypeReference(complexType, true)); model.AddElement(term); Type type = typeof(T); string name = type.Name; var entityType = model.SchemaElements.OfType <IEdmEntityType>().FirstOrDefault(c => c.Name == name); if (entityType == null) { return; } IList <string> defaultSelects = new List <string>(); IList <string> defaultHiddens = new List <string>(); var properties = type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); foreach (var property in properties) { var attrs = property.GetCustomAttributes(typeof(DefaultSelectAttribute), false); if (attrs != null && attrs.Any()) { defaultSelects.Add(property.Name); continue; } attrs = property.GetCustomAttributes(typeof(DefaultHiddenAttribute), false); if (attrs != null && attrs.Any()) { defaultHiddens.Add(property.Name); continue; } } if (defaultSelects.Any() && defaultHiddens.Any()) { List <IEdmPropertyConstructor> edmPropertiesConstructors = new List <IEdmPropertyConstructor> { new EdmPropertyConstructor("DefaultSelect", new EdmCollectionExpression( defaultSelects.Select(e => new EdmPropertyPathExpression(e)))), new EdmPropertyConstructor("DefaultHidden", new EdmCollectionExpression( defaultHiddens.Select(e => new EdmPropertyPathExpression(e)))), }; IEdmRecordExpression record = new EdmRecordExpression(edmPropertiesConstructors); EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(entityType, term, record); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.SetVocabularyAnnotation(annotation); } }
public void InitializeCollectionPropertyRestrictionsTypeWithRecordSuccess() { // Assert IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("CollectionProperty", new EdmPropertyPathExpression("abc/xyz")), new EdmPropertyConstructor("FilterFunctions", new EdmCollectionExpression(new EdmStringConstant("div"))), new EdmPropertyConstructor("FilterRestrictions", new EdmRecordExpression(new EdmPropertyConstructor("Filterable", new EdmBooleanConstant(true)))), new EdmPropertyConstructor("SearchRestrictions", new EdmRecordExpression(new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(false)))), new EdmPropertyConstructor("SortRestrictions", new EdmRecordExpression(new EdmPropertyConstructor("Sortable", new EdmBooleanConstant(false)))), new EdmPropertyConstructor("TopSupported", new EdmBooleanConstant(true)), new EdmPropertyConstructor("Deletable", new EdmBooleanConstant(false)) // SkipSupported // SelectSupport // Insertable // Updatable ); // Act CollectionPropertyRestrictionsType collectionPropertyRestrictions = new CollectionPropertyRestrictionsType(); collectionPropertyRestrictions.Initialize(record); // Assert Assert.Null(collectionPropertyRestrictions.SkipSupported); Assert.Null(collectionPropertyRestrictions.SelectSupport); Assert.Null(collectionPropertyRestrictions.Insertable); Assert.Null(collectionPropertyRestrictions.Updatable); Assert.Equal("abc/xyz", collectionPropertyRestrictions.CollectionProperty); Assert.NotNull(collectionPropertyRestrictions.FilterFunctions); string function = Assert.Single(collectionPropertyRestrictions.FilterFunctions); Assert.Equal("div", function); Assert.NotNull(collectionPropertyRestrictions.FilterRestrictions); Assert.NotNull(collectionPropertyRestrictions.FilterRestrictions.Filterable); Assert.True(collectionPropertyRestrictions.FilterRestrictions.Filterable.Value); Assert.NotNull(collectionPropertyRestrictions.SearchRestrictions); Assert.NotNull(collectionPropertyRestrictions.SearchRestrictions.Searchable); Assert.False(collectionPropertyRestrictions.SearchRestrictions.Searchable.Value); Assert.NotNull(collectionPropertyRestrictions.SortRestrictions); Assert.NotNull(collectionPropertyRestrictions.SortRestrictions.Sortable); Assert.False(collectionPropertyRestrictions.SortRestrictions.Sortable.Value); Assert.NotNull(collectionPropertyRestrictions.TopSupported); Assert.True(collectionPropertyRestrictions.TopSupported.Value); Assert.NotNull(collectionPropertyRestrictions.Deletable); Assert.False(collectionPropertyRestrictions.Deletable.Value); }
public void GetStringWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmStringConstant("test"))); // Act string actual = record.GetString("prop"); // Assert Assert.NotNull(actual); Assert.Equal("test", actual); }
public void GetPropertyPathWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmPropertyPathExpression("abc/xyz"))); // Act string actual = record.GetPropertyPath("prop"); // Assert Assert.NotNull(actual); Assert.Equal("abc/xyz", actual); }
public void GetBooleanWorks(bool expected) { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmBooleanConstant(expected))); // Act bool?actual = record.GetBoolean("prop"); // Assert Assert.NotNull(actual); Assert.Equal(expected, actual.Value); }
public void GetIntegerWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmIntegerConstant(42))); // Act long?actual = record.GetInteger("prop"); // Assert Assert.NotNull(actual); Assert.Equal(42, actual.Value); }
public void CreateAuthorizationThrowsForOAuthAuthorizationRecord() { // Arrange & Act IEdmStructuredTypeReference structuredTypeRef = GetType("Org.OData.Authorization.V1.OAuthAuthorization"); IEdmRecordExpression record = new EdmRecordExpression(structuredTypeRef, new EdmPropertyConstructor("Name", new EdmStringConstant("temp"))); Action test = () => OData.Vocabulary.Authorization.Authorization.CreateAuthorization(record); // Assert OpenApiException exception = Assert.Throws <OpenApiException>(test); Assert.Equal(String.Format(SRResource.AuthorizationRecordTypeNameNotCorrect, structuredTypeRef.FullName()), exception.Message); }
public static IEdmPropertyConstructor CreatePermissionProperty(params string[] scopeNames) { var scopes = scopeNames.Select(scope => new EdmRecordExpression( new EdmPropertyConstructor("Scope", new EdmStringConstant(scope)), new EdmPropertyConstructor("RestrictedProperties", new EdmStringConstant("*")))); var permission = new EdmRecordExpression( new EdmPropertyConstructor("SchemeName", new EdmStringConstant("AuthScheme")), new EdmPropertyConstructor("Scopes", new EdmCollectionExpression(scopes))); var property = new EdmPropertyConstructor("Permissions", new EdmCollectionExpression(permission)); return(property); }
public void GetCollectionForStringWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmCollectionExpression( new EdmStringConstant("abc"), new EdmStringConstant("xyz")))); // Act IList <string> actual = record.GetCollection("prop"); // Assert Assert.NotNull(actual); Assert.Equal(2, actual.Count); Assert.Equal(new[] { "abc", "xyz" }, actual); }
public void InitializeDeepInsertSupportTypeWithRecordSuccess() { // Assert IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("Supported", new EdmBooleanConstant(false)), new EdmPropertyConstructor("ContentIDSupported", new EdmBooleanConstant(true))); // Act DeepInsertSupportType deepInsert = new DeepInsertSupportType(); deepInsert.Initialize(record); // Assert VerifyDeepInsertSupportType(deepInsert); }
public void GetEnumWorks() { // Arrange IEdmEnumType enumType = new EdmEnumType("NS", "Color"); EdmEnumMember member = new EdmEnumMember(enumType, "Red", new EdmEnumMemberValue(2)); IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmEnumMemberExpression(member))); // Act Color?actual = record.GetEnum <Color>("prop"); // Assert Assert.NotNull(actual); Assert.Equal(Color.Red, actual.Value); }
public void CreateAuthorizationReturnsOpenIDConnect(Type type) { // Arrange & Act string qualifiedName = AuthorizationConstants.Namespace + "." + type.Name; IEdmRecordExpression record = new EdmRecordExpression(GetType(qualifiedName), new EdmPropertyConstructor("Name", new EdmStringConstant("temp"))); // Assert var authorization = OData.Vocabulary.Authorization.Authorization.CreateAuthorization(record); Assert.NotNull(authorization); Assert.Equal(type, authorization.GetType()); Assert.Equal("temp", authorization.Name); Assert.Null(authorization.Description); }
private static void SetVocabularyAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target, IList <IEdmPropertyConstructor> properties, string qualifiedName) { Contract.Assert(model != null); Contract.Assert(target != null); IEdmTerm term = model.FindTerm(qualifiedName); if (term != null) { IEdmRecordExpression record = new EdmRecordExpression(properties); EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(target, term, record); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.SetVocabularyAnnotation(annotation); } }
public void GetRecordWorks() { // Arrange IEdmRecordExpression record = new EdmRecordExpression( new EdmPropertyConstructor("prop", new EdmRecordExpression( new EdmPropertyConstructor("Scope", new EdmStringConstant("scope name")), new EdmPropertyConstructor("RestrictedProperties", new EdmStringConstant("*"))))); // Act ScopeType actual = record.GetRecord <ScopeType>("prop"); // Assert Assert.NotNull(actual); Assert.Equal("scope name", actual.Scope); Assert.Equal("*", actual.RestrictedProperties); }