Esempio n. 1
0
        public void DefinitionsShouldHave_ParentHostCapabilityAttribute_v12()
        {
            if (!M2RegressionRuntime.IsV12)
            {
                return;
            }

            var passed = true;

            // definitions must have a relationship attt

            var defTypesWithoutRelationships = AllDefinitionTypes.Where(d => AllDefinitionRelationships.All(r => r.DefinitionType != d));

            Trace.WriteLine("Cheking ParentHostCapability attr presence for all definitions");

            TraceUtils.WithScope(trace =>
            {
                foreach (var def in defTypesWithoutRelationships)
                {
                    Trace.WriteLine(string.Format("missing relationship for definition:[{0}]", def.Name));
                }
            });

            if (defTypesWithoutRelationships.Any())
            {
                passed = false;
            }

            if (defTypesWithoutRelationships.Any())
            {
                Trace.WriteLine("[FALSE] Missing definition relationships detected");
            }
            else
            {
                Trace.WriteLine("[TRUE] Missing definition relationships detected");
            }

            Assert.IsTrue(passed);
        }
Esempio n. 2
0
        public void DefinitionsShouldHaveAddXXX_DefinitionSyntax_v12()
        {
            if (!M2RegressionRuntime.IsV12)
            {
                return;
            }

            var passed = true;
            var showOnlyFalseOutput = true;

            var allCount    = AllDefinitionTypes.Count;
            var missesCount = 0;

            // add definitions should have AddXXX() methods

            // - must be generic
            // - typed model node
            // - definitions type as a second param
            // - overload with typed node call back
            // - allback with typed model node

            // AddField<TModelNode>(this TModelNode model, FieldDefinition definition)
            // where TModelNode : ModelNode, IFieldHostModelNode, new()

            // AddField<TModelNode>(this TModelNode model, FieldDefinition definition, Action<FieldModelNode> action)
            // where TModelNode : ModelNode, IFieldHostModelNode, new()

            Trace.WriteLine("Checking AddXXX() method specs");
            Trace.WriteLine("");

            TraceUtils.WithScope(trace =>
            {
                foreach (var defType in AllDefinitionTypes.OrderBy(d => d.Name))
                {
                    var isRootDef = (defType.GetCustomAttributes(typeof(ParentHostCapabilityAttribute))
                                     .FirstOrDefault() as ParentHostCapabilityAttribute).IsRoot;

                    var isSelfHostDefinition = (defType.GetCustomAttributes(typeof(SelfHostCapabilityAttribute)).Any());

                    if (isRootDef)
                    {
                        trace.WriteLine(string.Format("Skipping root def"));
                        continue;
                    }

                    var completedtype = true;

                    var pureDefName = defType.Name.Replace("Definition", string.Empty);

                    var shouldCheckArrayOverload = defType.GetCustomAttributes(typeof(ExpectArrayExtensionMethod), false).Any();
                    var shouldCheckAddHostMethod = defType.GetCustomAttributes(typeof(ExpectAddHostExtensionMethod), false).Any();

                    var targetModelNodeTypeName = string.Format("{0}ModelNode", pureDefName);
                    var modelNodelType          = AllModelNodeTypes.FirstOrDefault(n => n.Name == targetModelNodeTypeName);

                    trace.WriteLine(defType.Name);

                    if (modelNodelType == null)
                    {
                        trace.WriteLine(string.Format("[FALSE] Missing model node: [{0}]", targetModelNodeTypeName));
                    }

                    trace.WithTraceIndent(addXXXTrace =>
                    {
                        if (!showOnlyFalseOutput)
                        {
                            trace.WriteLine("Checking AddXXX() method");
                        }

                        var relationships = AllDefinitionRelationships.FirstOrDefault(r => r.DefinitionType == defType);

                        var addXXXMethodName = string.Format("Add{0}", pureDefName);
                        var addXXXArrayDefinitionMethodName = string.Format("Add{0}s", pureDefName);

                        var addXXXHostMethodName = string.Format("AddHost{0}", pureDefName);

                        var lastChar = pureDefName[pureDefName.Length - 1];

                        switch (lastChar)
                        {
                        case 'y':
                            {
                                addXXXArrayDefinitionMethodName  = string.Format("Add{0}", pureDefName);
                                addXXXArrayDefinitionMethodName  = addXXXArrayDefinitionMethodName.Substring(0, addXXXArrayDefinitionMethodName.Length - 1);
                                addXXXArrayDefinitionMethodName += "ies";
                            }
                            ;
                            break;

                        case 'x':
                        case 'e':
                            {
                                addXXXArrayDefinitionMethodName  = string.Format("Add{0}", pureDefName);
                                addXXXArrayDefinitionMethodName += "s";
                            } break;

                        case 's':
                            {
                                addXXXArrayDefinitionMethodName  = string.Format("Add{0}", pureDefName);
                                addXXXArrayDefinitionMethodName += "es";
                            } break;
                        }

                        // host

                        Func <MethodInfo, bool> addHostMethodPlainSpec = (m) =>
                        {
                            // public static TModelNode AddAlternateUrl<TModelNode>(this TModelNode model, AlternateUrlDefinition definition)
                            // where TModelNode : ModelNode, IWebApplicationHostModelNode, new()

                            return(m.Name == addXXXHostMethodName &&
                                   m.IsGenericMethod

                                   && (m.GetParameters().Count() == 2) &&
                                   m.ReturnType.Name == "TModelNode"

                                   && m.GetGenericArguments()[0].Name == "TModelNode" &&
                                   m.GetGenericArguments()[0].BaseType == typeof(ModelNode)

                                   && m.GetParameters()[1].ParameterType == defType
                                   );
                        };

                        Func <MethodInfo, bool> addHostMethodWithCallbackSpec = (m) =>
                        {
                            // public static TModelNode AddAlternateUrl<TModelNode>(this TModelNode model, AlternateUrlDefinition definition,
                            // Action<ContentTypeModelNode> action)
                            // where TModelNode : ModelNode, IWebApplicationHostModelNode, new()

                            var callbackType      = typeof(Action <>);
                            var typedCallbackType = callbackType.MakeGenericType(modelNodelType);

                            Func <MethodInfo, bool> selfHostCallbackCheck = (method => true);
                            selfHostCallbackCheck = (method) => method.GetParameters()[2].ParameterType == typedCallbackType;

                            return(m.Name == addXXXHostMethodName &&
                                   m.IsGenericMethod

                                   && (m.GetParameters().Count() == 3)

                                   && m.ReturnType.Name == "TModelNode"

                                   && m.GetGenericArguments()[0].Name == "TModelNode" &&
                                   m.GetGenericArguments()[0].BaseType == typeof(ModelNode)

                                   && m.GetParameters()[1].ParameterType == defType &&
                                   selfHostCallbackCheck(m));
                        };



                        // add

                        Func <MethodInfo, bool> addMethodPlainSpec = (m) =>
                        {
                            // public static TModelNode AddAlternateUrl<TModelNode>(this TModelNode model, AlternateUrlDefinition definition)
                            // where TModelNode : ModelNode, IWebApplicationHostModelNode, new()

                            return(m.Name == addXXXMethodName &&
                                   m.IsGenericMethod

                                   && (m.GetParameters().Count() == 2) &&
                                   m.ReturnType.Name == "TModelNode"

                                   && m.GetGenericArguments()[0].Name == "TModelNode" &&
                                   m.GetGenericArguments()[0].BaseType == typeof(ModelNode)

                                   && m.GetParameters()[1].ParameterType == defType
                                   );
                        };

                        Func <MethodInfo, bool> addMethodWithCallbackSpec = (m) =>
                        {
                            // public static TModelNode AddAlternateUrl<TModelNode>(this TModelNode model, AlternateUrlDefinition definition,
                            // Action<ContentTypeModelNode> action)
                            // where TModelNode : ModelNode, IWebApplicationHostModelNode, new()

                            var callbackType      = typeof(Action <>);
                            var typedCallbackType = callbackType.MakeGenericType(modelNodelType);

                            Func <MethodInfo, bool> selfHostCallbackCheck = (method => true);

                            if (isSelfHostDefinition)
                            {
                                selfHostCallbackCheck = (method) =>
                                {
                                    // self return
                                    // callback has the same type as TModelNode
                                    // that works for ResetRoleInheritance/BreakRoleInheritance as they 'pass' the current object further to the chain

                                    // public static TModelNode AddResetRoleInheritance<TModelNode>(this TModelNode model, ResetRoleInheritanceDefinition definition)
                                    // where TModelNode : ModelNode, ISecurableObjectHostModelNode, new()

                                    return(typeof(Action <>).MakeGenericType(method.GetParameters()[0].ParameterType) == method.GetParameters()[2].ParameterType);
                                };
                            }
                            else
                            {
                                selfHostCallbackCheck = (method) => method.GetParameters()[2].ParameterType == typedCallbackType;
                            }

                            return(m.Name == addXXXMethodName &&
                                   m.IsGenericMethod

                                   && (m.GetParameters().Count() == 3)

                                   && m.ReturnType.Name == "TModelNode"

                                   && m.GetGenericArguments()[0].Name == "TModelNode" &&
                                   m.GetGenericArguments()[0].BaseType == typeof(ModelNode)

                                   && m.GetParameters()[1].ParameterType == defType &&
                                   selfHostCallbackCheck(m));
                        };

                        Func <MethodInfo, bool> addMethodWithArraySpec = (m) =>
                        {
                            //  public static TModelNode AddAlternateUrls<TModelNode>(this TModelNode model, IEnumerable<AlternateUrlDefinition> definitions)
                            //  where TModelNode : ModelNode, IWebApplicationHostModelNode, new()

                            var arrayType           = typeof(IEnumerable <>);
                            var arrayDefinitionType = arrayType.MakeGenericType(defType);

                            return(m.Name == addXXXArrayDefinitionMethodName &&
                                   m.IsGenericMethod &&
                                   (m.GetParameters().Count() == 2) &&
                                   m.ReturnType.Name == "TModelNode"

                                   && m.GetGenericArguments()[0].Name == "TModelNode" &&
                                   m.GetGenericArguments()[0].BaseType == typeof(ModelNode)

                                   && m.GetParameters()[1].ParameterType == arrayDefinitionType
                                   );
                        };


                        var addMethodPlain             = AllExtensionMethods.FirstOrDefault(addMethodPlainSpec);
                        var addMethodPlainWithCallBack = AllExtensionMethods.FirstOrDefault(addMethodWithCallbackSpec);

                        if (addMethodPlain == null)
                        {
                            passed        = false;
                            completedtype = false;

                            addXXXTrace.WriteLine("[FALSE] AddXXX()");
                        }
                        else
                        {
                            var missedRelationshipModelNodeTypes = GetUnsupportedRelationshipModelNodeTypes(addMethodPlainWithCallBack, relationships);

                            if (missedRelationshipModelNodeTypes.Any())
                            {
                                passed        = false;
                                completedtype = false;

                                addXXXTrace.WriteLine(string.Format(
                                                          "[FALSE] AddXXX() misses relationships: [{0}]",
                                                          string.Join(",", missedRelationshipModelNodeTypes)));
                            }
                        }

                        if (addMethodPlainWithCallBack == null)
                        {
                            passed        = false;
                            completedtype = false;

                            addXXXTrace.WriteLine("[FALSE] AddXXX(callback)");
                        }
                        else
                        {
                            var missedRelationshipModelNodeTypes = GetUnsupportedRelationshipModelNodeTypes(addMethodPlainWithCallBack, relationships);

                            if (missedRelationshipModelNodeTypes.Any())
                            {
                                passed        = false;
                                completedtype = false;

                                addXXXTrace.WriteLine(string.Format(
                                                          "[FALSE] AddXXX(callback) misses relationships: [{0}]",
                                                          string.Join(",", missedRelationshipModelNodeTypes)));
                            }
                        }

                        if (shouldCheckArrayOverload)
                        {
                            var addMethodWithArraySupport = AllExtensionMethods.FirstOrDefault(addMethodWithArraySpec);

                            if (addMethodWithArraySupport == null)
                            {
                                passed        = false;
                                completedtype = false;

                                addXXXTrace.WriteLine("[FALSE] AddXXXs()");
                            }
                            else
                            {
                                var missedRelationshipModelNodeTypes = GetUnsupportedRelationshipModelNodeTypes(addMethodWithArraySupport, relationships);

                                if (missedRelationshipModelNodeTypes.Any())
                                {
                                    passed        = false;
                                    completedtype = false;

                                    addXXXTrace.WriteLine(string.Format(
                                                              "[FALSE] AddXXXs() misses relationships: [{0}]",
                                                              string.Join(",", missedRelationshipModelNodeTypes)));
                                }
                            }
                        }


                        if (shouldCheckAddHostMethod)
                        {
                            var addHostMethodPlain             = AllExtensionMethods.FirstOrDefault(addHostMethodPlainSpec);
                            var addHostMethodPlainWithCallBack = AllExtensionMethods.FirstOrDefault(addHostMethodWithCallbackSpec);

                            if (addHostMethodPlain == null)
                            {
                                passed        = false;
                                completedtype = false;

                                addXXXTrace.WriteLine("[FALSE] AddHostXXX()");
                            }
                            else
                            {
                                var missedRelationshipModelNodeTypes = GetUnsupportedRelationshipModelNodeTypes(addHostMethodPlain, relationships);

                                if (missedRelationshipModelNodeTypes.Any())
                                {
                                    passed        = false;
                                    completedtype = false;

                                    addXXXTrace.WriteLine(string.Format(
                                                              "[FALSE] AddHostXXX() misses relationships: [{0}]",
                                                              string.Join(",", missedRelationshipModelNodeTypes)));
                                }
                            }

                            if (addHostMethodPlainWithCallBack == null)
                            {
                                passed        = false;
                                completedtype = false;

                                addXXXTrace.WriteLine("[FALSE] AddHostXXX(callback)");
                            }
                            else
                            {
                                var missedRelationshipModelNodeTypes = GetUnsupportedRelationshipModelNodeTypes(addHostMethodPlainWithCallBack, relationships);

                                if (missedRelationshipModelNodeTypes.Any())
                                {
                                    passed        = false;
                                    completedtype = false;

                                    addXXXTrace.WriteLine(string.Format(
                                                              "[FALSE] AddHostXXX(callback) misses relationships: [{0}]",
                                                              string.Join(",", missedRelationshipModelNodeTypes)));
                                }
                            }
                        }
                    });

                    if (!showOnlyFalseOutput)
                    {
                        trace.WriteLine("");
                    }

                    if (!completedtype)
                    {
                        missesCount++;
                    }
                }
            });

            Trace.WriteLine("");
            Trace.WriteLine(string.Format("{0}/{1}", missesCount, allCount));

            Assert.IsTrue(passed);
        }