private static void AssertNoMethodsMatching(Func <MethodBase, MemberPolicy?, bool> matcher)
        {
            var policy  = new DefaultApiPolicyFactory().CreateSafeDefaultPolicy();
            var matched = new HashSet <string>();

            var filter = new ApiFilter(policy);

            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                foreach (var type in GetExportedTypesSafe(assembly))
                {
                    foreach (var method in type.GetMethods())
                    {
                        if (type.Namespace == null)
                        {
                            continue;
                        }

                        var result = filter.Filter(type.Namespace, type.Name, ApiFilterTypeKind.External, method.Name);
                        if (result.Kind != ApiFilterResultKind.Allowed)
                        {
                            continue;
                        }

                        if (matcher(method, result.MemberRule))
                        {
                            matched.Add(DescribeMethod(method));
                        }
                    }
                }
            }

            Assert.Empty(matched);
        }
Exemple #2
0
        private static IEnumerable <(MethodBase method, MemberPolicy?rule)> GetAllAllowedMethods()
        {
            var policy = new DefaultApiPolicyFactory().CreateSafeDefaultPolicy();

            var filter = new ApiFilter(policy);

            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                foreach (var type in GetExportedTypesSafe(assembly))
                {
                    foreach (var method in type.GetMethods())
                    {
                        if (type.Namespace == null)
                        {
                            continue;
                        }

                        var result = filter.Filter(type.Namespace, type.Name, ApiFilterTypeKind.External, method.Name);
                        if (result.Kind != ApiFilterResultKind.Allowed)
                        {
                            continue;
                        }

                        yield return(method, result.MemberRule);
                    }
                }
            }
        }
        public void CreateSafeDefaultPolicy_DoesNotReferenceNonExistentTypesOrMembers_InLatestNet()
        {
            // Not in latest .NET
            var legacyTypeFullNames = new HashSet <string> {
                "System.AppDomainManager"
            };

            var policy = new DefaultApiPolicyFactory().CreateSafeDefaultPolicy();

            var missing    = new HashSet <string>();
            var assemblies = AppDomain.CurrentDomain.GetAssemblies();

            foreach (var namespacePolicy in policy.Namespaces)
            {
                foreach (var typePolicy in namespacePolicy.Value.Types)
                {
                    var typeFullName = namespacePolicy.Key + "." + typePolicy.Key;
                    if (legacyTypeFullNames.Contains(typeFullName))
                    {
                        continue;
                    }

                    var type = assemblies
                               .Select(a => a.GetType(typeFullName, throwOnError: false))
                               .FirstOrDefault(t => t != null);
                    if (type == null)
                    {
                        missing.Add("Type: " + typeFullName);
                        continue;
                    }

                    foreach (var memberPolicy in typePolicy.Value.Members)
                    {
                        var memberName = memberPolicy.Key;
                        if (type.GetMember(memberName) == null)
                        {
                            missing.Add($"Member: {typeFullName}.{memberName}");
                        }
                    }
                }
            }

            Assert.Empty(missing);
        }