Ejemplo n.º 1
0
        /// <summary>
        /// Select all tests in the TreeView that are tagged by the tagExpression
        /// </summary>
        /// <param name="root">Root node of the TreeView</param>
        /// <param name="tagExpression">Tag expression</param>
        /// <param name="browser">Browser running the tests</param>
        public void SelectTaggedTests(TreeNode root, string tagExpression, BrowserVersions browser)
        {
            if (root == null)
            {
                throw new ArgumentNullException("root", "Root cannot be null!");
            }

            EnsureLoaded();

            // Get the tests that should be tagged
            bool selectAllTests            = string.IsNullOrEmpty(tagExpression);
            IList <MethodInfo> taggedTests = null;

            if (!selectAllTests)
            {
                taggedTests = GetTestsByTag(tagExpression, browser);
            }

            // Select the nodes
            foreach (TreeNode classNode in root.ChildNodes)
            {
                foreach (TreeNode methodNode in classNode.ChildNodes)
                {
                    MethodInfo testCase = GetTestCase(classNode.Value, methodNode.Value);
                    bool       selected = selectAllTests || taggedTests.Contains(testCase);
                    methodNode.Checked = selected;
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Evaluate an expression
        /// </summary>
        /// <returns>Test methods described by the expression</returns>
        public List <MethodInfo> Evaluate(
            string tagExpression,
            BrowserVersions browser,
            List <MethodInfo> testMethods,
            Dictionary <MethodInfo, BrowserVersions> testFailures,
            Dictionary <string, List <MethodInfo> > tags)
        {
            if (tagExpression == null)
            {
                throw new ArgumentNullException("tagExpression", "tagExpression cannot be null!");
            }
            else if (tagExpression.Length == 0)
            {
                throw new ArgumentException("tagExpression cannot be empty!", "tagExpression");
            }

            _tagExpression = tagExpression;
            _browser       = browser;
            _testFailures  = testFailures;
            _testMethods   = testMethods;
            _tags          = tags;
            _position      = 0;

            List <MethodInfo> expression = ReadExpression();

            if (_position >= 0 && _position < _tagExpression.Length)
            {
                throw new FormatException(string.Format("Expected end of tag expression \"{0}\" at position {1}!", _tagExpression, _position));
            }
            return(expression);
        }
Ejemplo n.º 3
0
        internal void OnLoadCompleteInternal()
        {
            // Only auto-select or auto-run on the first request
            if (!_aspNetService.GetIsPostBack(this))
            {
                // Get query string values
                QueryStringParameters queryParams = new QueryStringParameters();
                queryParams.LoadFromQueryString(_aspNetService.GetQueryString(this));

                BrowserVersions browser = BrowserUtility.GetBrowser(_aspNetService.GetBrowserName(this), _aspNetService.GetBrowserMajorVersion(this));

                LogDetail = queryParams.LogDetail;
                this.WriteLogToDiskCheckBox.Checked = queryParams.WriteLog;
                this.ShowConsoleCheckBox.Checked    = queryParams.ShowConsole;

                // Auto-select tests with a given tag
                if (!String.IsNullOrEmpty(queryParams.Tag))
                {
                    _testcaseManager.SelectTaggedTests(this.TestCasesTreeView, queryParams.Tag, browser);
                }
                else if (queryParams.Run)
                {
                    _testcaseManager.SelectAllTests(this.TestCasesTreeView, browser);
                }

                // Optionally remove unselected tests
                if (queryParams.Filter)
                {
                    _testcaseManager.FilterIgnoredTests(this.TestCasesTreeView);
                }

                // Auto-run the selected tests (or all tests if none are selected)
                if (queryParams.Run)
                {
                    RunTestCases();
                }
            }

            // Change UI depending if showing console or not.
            if (this.ShowConsoleCheckBox.Checked)
            {
                this.TestsPanel.CssClass = "tests";
                this.FooterPanel.Visible = true;
            }
            else
            {
                this.TestsPanel.CssClass = "testsNoConsole";
                this.FooterPanel.Visible = false;
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// WebTestFailureTag attribute used to associate test cases with failures
        /// in specific sets of browsers so they can be properly tracked.
        /// </summary>
        /// <param name="browsers">Browsers the test cases fail in</param>
        /// <param name="description">Description of the failure</param>
        public WebTestFailureTagAttribute(BrowserVersions browsers, string description)
        {
            if (description == null)
            {
                throw new ArgumentNullException("description", "Description cannot be null!");
            }
            else if (description.Length == 0)
            {
                throw new ArgumentException("Description cannot be empty!", "description");
            }

            _browsers    = browsers;
            _description = description;
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Ignore any tests that fail in the given browsers
        /// </summary>
        /// <param name="root">Root node of the TreeView</param>
        /// <param name="browsers">Browsers to skip failures</param>
        public void IgnoreFailures(TreeNode root, BrowserVersions browsers)
        {
            if (root == null)
            {
                throw new ArgumentNullException("root", "Root cannot be null!");
            }

            EnsureLoaded();

            // Select the nodes
            foreach (TreeNode @class in root.ChildNodes)
            {
                foreach (TreeNode method in @class.ChildNodes)
                {
                    MethodInfo      testCase = GetTestCase(@class.Value, method.Value);
                    BrowserVersions failures;
                    if (this._testFailures.TryGetValue(testCase, out failures) && ((browsers & failures) > 0))
                    {
                        method.Checked = false;
                    }
                }
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Get the test methods that correspond to a tag expression
        /// </summary>
        /// <param name="tagExpression">Tag expression</param>
        /// <param name="browser">Browser running the tests</param>
        /// <returns>Test methods for the tag expression</returns>
        public IList <MethodInfo> GetTestsByTag(string tagExpression, BrowserVersions browser)
        {
            if (tagExpression == null)
            {
                throw new ArgumentNullException("tagExpression", "Tag expression cannot be null!");
            }
            else if (tagExpression.Length == 0)
            {
                throw new ArgumentException("Tag expression cannot be empty!", "tagExpression");
            }

            EnsureLoaded();

            // Try to use the cached methods
            List <MethodInfo> methods;
            string            cacheKey = string.Format("{0} + {1}", tagExpression, browser);

            if (_cachedTagExpressions.TryGetValue(cacheKey, out methods))
            {
                return(methods);
            }

            // Evaluate the tag
            WebTestTagExpressionEvaluator webTestTagExpressionEvaluator = new WebTestTagExpressionEvaluator();

            methods = webTestTagExpressionEvaluator.Evaluate(
                tagExpression,
                browser,
                _testMethods,
                _testFailures,
                _tags);

            // Cache the expression and return it
            _cachedTagExpressions.Add(cacheKey, methods);
            return(methods);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Load the test cases
        /// </summary>
        private void EnsureLoaded()
        {
            // Make sure we only load this once and ignore simultaneous requests
            lock (_syncRoot)
            {
                // If it's already been loaded, ignore subsequent loads
                if (_appCodeAssembly != null)
                {
                    return;
                }

                Type[] testTypes = GetTestTypes(out _appCodeAssembly);

                _testClasses        = new List <Type>();
                _testClassesByName  = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase);
                _testMethods        = new List <MethodInfo>();
                _testMethodsByClass = new Dictionary <Type, List <MethodInfo> >();
                foreach (Type type in testTypes)
                {
                    // Add the type
                    _testClasses.Add(type);
                    _testClassesByName.Add(type.FullName, type);

                    // Add the methods associated with the type
                    List <MethodInfo> methodsForType = new List <MethodInfo>();
                    _testMethodsByClass.Add(type, methodsForType);
                    foreach (MethodInfo method in type.GetMethods())
                    {
                        if (!method.IsDefined(typeof(WebTestMethodAttribute), true))
                        {
                            continue;
                        }

                        _testMethods.Add(method);
                        methodsForType.Add(method);
                    }
                }

                // Sort the list of types alphabetically
                _testClasses.Sort(delegate(Type a, Type b)
                {
                    return(string.CompareOrdinal(
                               a != null ? a.FullName : null,
                               b != null ? b.FullName : null));
                });

                // Compute the tags and known failures lookups
                _tags = new Dictionary <string, List <MethodInfo> >(StringComparer.OrdinalIgnoreCase);
                _cachedTagExpressions = new Dictionary <string, List <MethodInfo> >(StringComparer.OrdinalIgnoreCase);
                _testFailures         = new Dictionary <MethodInfo, BrowserVersions>();

                // Compute the tags for each class
                Dictionary <Type, List <string> >  classTags     = new Dictionary <Type, List <string> >();
                Dictionary <Type, BrowserVersions> classFailures = new Dictionary <Type, BrowserVersions>();
                foreach (Type type in _testClasses)
                {
                    // Add the tags
                    List <string> tagsForClass = new List <string>();
                    classTags.Add(type, tagsForClass);

                    // Include the class name as one of it's tags so they can
                    // be easily isolated during development without adding addtional
                    // temporary tags
                    tagsForClass.Add(type.FullName);

                    foreach (Attribute attribute in type.GetCustomAttributes(typeof(WebTestTagAttribute), true))
                    {
                        WebTestTagAttribute testTag = attribute as WebTestTagAttribute;
                        if (testTag != null)
                        {
                            tagsForClass.Add(testTag.Tag);
                        }
                    }

                    // Add the known failures
                    BrowserVersions failures = BrowserVersions.None;
                    foreach (Attribute attribute in type.GetCustomAttributes(typeof(WebTestFailureTagAttribute), true))
                    {
                        WebTestFailureTagAttribute failureTag = attribute as WebTestFailureTagAttribute;
                        if (failureTag != null)
                        {
                            failures |= failureTag.Browsers;
                        }
                    }
                    classFailures.Add(type, failures);
                }

                // Compute the tags and known failures for each method
                foreach (MethodInfo method in _testMethods)
                {
                    // Start the list of tags with all those declared on its type
                    List <string> methodTags = new List <string>(classTags[method.ReflectedType]);

                    // Include the method's name and full name as one of it's tags so they can
                    // be easily isolated during development without adding addtional
                    // temporary tags.  Also include Class.Method as well to make it easy to
                    // isolate common tests.
                    methodTags.Add(method.Name);
                    methodTags.Add(string.Format("{0}.{1}", method.ReflectedType.FullName, method.Name));

                    // Add the tags declared on the method
                    foreach (Attribute attribute in method.GetCustomAttributes(typeof(WebTestTagAttribute), true))
                    {
                        WebTestTagAttribute testTag = attribute as WebTestTagAttribute;
                        if (testTag != null)
                        {
                            methodTags.Add(testTag.Tag);
                        }
                    }

                    // Associate this method with each of its tags
                    foreach (string tag in methodTags)
                    {
                        List <MethodInfo> methods;
                        if (!_tags.TryGetValue(tag, out methods))
                        {
                            methods = new List <MethodInfo>();
                            _tags.Add(tag, methods);
                        }
                        methods.Add(method);
                    }

                    // Add the known failures on the method and class
                    BrowserVersions failures = classFailures[method.ReflectedType];
                    foreach (Attribute attribute in method.GetCustomAttributes(typeof(WebTestFailureTagAttribute), true))
                    {
                        WebTestFailureTagAttribute failureTag = attribute as WebTestFailureTagAttribute;
                        if (failureTag != null)
                        {
                            failures |= failureTag.Browsers;
                        }
                    }
                    _testFailures.Add(method, failures);
                }
            }
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Ignore any tests that fail in the given browsers
 /// </summary>
 /// <param name="tree">TreeView</param>
 /// <param name="browsers">Browsers to skip failures</param>
 public void IgnoreFailures(TreeView tree, BrowserVersions browsers)
 {
     IgnoreFailures(GetTreeRoot(tree), browsers);
 }
Ejemplo n.º 9
0
 /// <summary>
 /// Select all tests in the TreeView that are tagged by the tagExpression
 /// </summary>
 /// <param name="tree">TreeView</param>
 /// <param name="tagExpression">Tag expression</param>
 /// <param name="browser">Browser running the tests</param>
 public void SelectTaggedTests(TreeView tree, string tagExpression, BrowserVersions browser)
 {
     SelectTaggedTests(GetTreeRoot(tree), tagExpression, browser);
 }
Ejemplo n.º 10
0
 /// <summary>
 /// Select all the tests in the TreeView
 /// </summary>
 /// <param name="root">Root node of the TreeView</param>
 /// <param name="browser">Browser running the tests</param>
 public void SelectAllTests(TreeNode root, BrowserVersions browser)
 {
     SelectTaggedTests(root, null, browser);
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Select all the tests in the TreeView
 /// </summary>
 /// <param name="tree">TreeView</param>
 /// <param name="browser">Browser running the tests</param>
 public void SelectAllTests(TreeView tree, BrowserVersions browser)
 {
     SelectAllTests(GetTreeRoot(tree), browser);
 }