Esempio n. 1
0
        public void FromExpression_CanGetMetadataFromBasicSubtype()
        {
            var subInstance1 = new SubType();
            var subInstance2 = new SubType();

            var baseType = typeof(BaseType);
            var subType  = typeof(SubType);

            // instance property of the subtype as is
            {
                var instancePropertyExpressions = subInstance2.InstancePropertyExpressions().ToList();
                var baseInstanceProperty        = baseType.GetProperty(nameof(BaseType.InstanceProperty), BindingFlags.Instance | BindingFlags.Public);

                var actual = SettingMetadata.FromExpression(instancePropertyExpressions.Last());

                Assert.AreEqual(subType, actual.Type);
                Assert.AreSame(subInstance2, actual.TypeInstance);
                Assert.AreEqual(subType.Name, actual.TypeName);
                Assert.AreEqual(baseInstanceProperty.ToString(), actual.Member.ToString());
                Assert.AreEqual(nameof(BaseType.InstanceProperty), actual.MemberName);

                AssertDefault(actual);
            }

            // static property of the subtype as is
            {
                var staticPropertyExpressions = subInstance2.StaticPropertyExpressions().ToList();
                var baseStaticProperty        = typeof(BaseType).GetProperty(nameof(BaseType.StaticProperty), BindingFlags.Static | BindingFlags.Public);

                var actual = SettingMetadata.FromExpression(staticPropertyExpressions.Last());

                Assert.AreEqual(baseType, actual.Type);
                Assert.IsNull(actual.TypeInstance);
                Assert.AreEqual(baseType.Name, actual.TypeName);
                Assert.AreEqual(baseStaticProperty, actual.Member);
                Assert.AreEqual(nameof(BaseType.StaticProperty), actual.MemberName);

                AssertDefault(actual);
            }

            // non-public instance field of the subtype as is
//            {
//                var instanceFieldExpressions = subInstance2.InstanceFieldExpressions().ToList();
//                var baseInstanceField = typeof(BaseType).GetField("_instanceField", BindingFlags.Instance | BindingFlags.NonPublic);
//
//                var actual = SettingMetadata.FromExpression(instanceFieldExpressions.Last(), nonPublic: true);
//
//                Assert.AreSame(subInstance2, actual.TypeInstance);
//                Assert.AreEqual(baseInstanceField, actual.Member);
//                Assert.AreEqual("_instanceField", actual.MemberName);
//
//                AssertDefault(actual);
//            }

            // static field of the subtype as is
            {
                var staticFieldExpressions = subInstance2.StaticFieldExpressions().ToList();
                var baseStaticField        = typeof(BaseType).GetField("_staticField", BindingFlags.Static | BindingFlags.NonPublic);

                var actual = SettingMetadata.FromExpression(staticFieldExpressions.Last());

                Assert.IsNull(actual.TypeInstance);
                Assert.AreEqual(baseStaticField, actual.Member);
                Assert.AreEqual("_staticField", actual.MemberName);

                AssertDefault(actual);
            }


            void AssertDefault(SettingMetadata actual)
            {
                // These cases are common to all tests.

                Assert.IsNull(actual.ResourcePrefix);
                Assert.AreEqual(Namespace, actual.Scope);

                Assert.IsTrue(actual.Validations.Empty());
                Assert.IsNull(actual.DefaultValue);
                Assert.IsNull(actual.ResourceProviderName);
                //Assert.AreEqual(SettingNameStrength.Inherit, actual.Strength);
                //Assert.AreEqual(PrefixHandling.Inherit, actual.PrefixHandling);
            }
        }