org.sonar.plugins.web.checks.AbstractCheckTester.java Source code

Introduction

Here is the source code for org.sonar.plugins.web.checks.AbstractCheckTester.java

Source

/*
 * Sonar Web Plugin
 * Copyright (C) 2010 Matthijs Galesloot
 * dev@sonar.codehaus.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.sonar.plugins.web.checks;

import static junit.framework.Assert.assertNotNull;

import java.io.Reader;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.sonar.api.profiles.ProfileDefinition;
import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.profiles.XMLProfileParser;
import org.sonar.api.resources.File;
import org.sonar.api.rules.ActiveRule;
import org.sonar.api.rules.ActiveRuleParam;
import org.sonar.api.rules.AnnotationRuleParser;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
import org.sonar.api.rules.RuleQuery;
import org.sonar.api.utils.SonarException;
import org.sonar.api.utils.ValidationMessages;
import org.sonar.plugins.web.AbstractWebPluginTester;
import org.sonar.plugins.web.analyzers.PageCountLines;
import org.sonar.plugins.web.lex.PageLexer;
import org.sonar.plugins.web.node.Node;
import org.sonar.plugins.web.rules.DefaultWebProfile;
import org.sonar.plugins.web.rules.StrutsProfile;
import org.sonar.plugins.web.visitor.PageScanner;
import org.sonar.plugins.web.visitor.WebSourceCode;

public abstract class AbstractCheckTester extends AbstractWebPluginTester {

    private Rule getRule(String ruleKey, Class<? extends AbstractPageCheck> checkClass) {

        AnnotationRuleParser parser = new AnnotationRuleParser();
        List<Rule> rules = parser.parse("Web", Arrays.asList(new Class[] { checkClass }));
        for (Rule rule : rules) {
            if (rule.getKey().equals(ruleKey)) {
                return rule;
            }
        }
        return null;
    }

    public WebSourceCode parseAndCheck(Reader reader, Class<? extends AbstractPageCheck> checkClass,
            String... params) {

        return parseAndCheck(reader, null, null, checkClass, params);
    }

    public WebSourceCode parseAndCheck(Reader reader, java.io.File file, String code,
            Class<? extends AbstractPageCheck> checkClass, String... params) {

        AbstractPageCheck check = instantiateCheck(checkClass, params);

        PageLexer lexer = new PageLexer();
        List<Node> nodeList = lexer.parse(reader);
        WebSourceCode webSourceCode = new WebSourceCode(new File("test"));

        PageScanner pageScanner = new PageScanner();
        pageScanner.addVisitor(new PageCountLines());
        pageScanner.addVisitor(check);
        pageScanner.scan(nodeList, webSourceCode);
        return webSourceCode;
    }

    protected AbstractPageCheck instantiateCheck(Class<? extends AbstractPageCheck> checkClass, String... params) {
        try {
            AbstractPageCheck check = checkClass.newInstance();

            Rule rule = getRule(checkClass.getSimpleName(), checkClass);
            assertNotNull("Could not find rule", rule);
            check.setRule(rule);
            configureDefaultParams(check, rule);

            for (int i = 0; i < params.length / 2; i++) {
                BeanUtils.setProperty(check, params[i * 2], params[i * 2 + 1]);
                assertNotNull(BeanUtils.getProperty(check, params[i * 2]));
            }
            return check;
        } catch (IllegalAccessException e) {
            throw new SonarException(e);
        } catch (InstantiationException e) {
            throw new SonarException(e);
        } catch (InvocationTargetException e) {
            throw new SonarException(e);
        } catch (NoSuchMethodException e) {
            throw new SonarException(e);
        }
    }

    private static final class WebRuleFinder implements RuleFinder {

        private final Rule rule;

        public WebRuleFinder(Rule rule) {
            this.rule = rule;
        }

        public Rule findByKey(String repositoryKey, String key) {
            if (rule.getKey().equals(key)) {
                return rule;
            } else {
                return null;
            }
        }

        public Rule find(RuleQuery query) {
            return rule;
        }

        public Collection<Rule> findAll(RuleQuery query) {
            return new ArrayList<Rule>();
        }

        public Rule findById(int ruleId) {
            return null;
        }
    }

    private void configureDefaultParams(AbstractPageCheck check, Rule rule) {
        WebRuleFinder ruleFinder = new WebRuleFinder(rule);
        ValidationMessages validationMessages = ValidationMessages.create();
        ProfileDefinition profileDefinition;
        if (rule.getKey().equals("OGNLExpressionCheck")) {
            profileDefinition = new StrutsProfile(new XMLProfileParser(ruleFinder), ruleFinder);
        } else {
            profileDefinition = new DefaultWebProfile(new XMLProfileParser(ruleFinder));
        }
        RulesProfile rulesProfile = profileDefinition.createProfile(validationMessages);

        ActiveRule activeRule = rulesProfile.getActiveRule(rule);

        assertNotNull("Could not find activeRule", activeRule);

        try {
            if (activeRule.getActiveRuleParams() != null) {
                for (ActiveRuleParam param : activeRule.getActiveRuleParams()) {
                    Object value = PropertyUtils.getProperty(check, param.getRuleParam().getKey());
                    if (value instanceof Integer) {
                        value = Integer.parseInt(param.getValue());
                    } else {
                        value = param.getValue();
                    }
                    PropertyUtils.setProperty(check, param.getRuleParam().getKey(), value);
                }
            }
        } catch (IllegalAccessException e) {
            throw new SonarException(e);
        } catch (InvocationTargetException e) {
            throw new SonarException(e);
        } catch (NoSuchMethodException e) {
            throw new SonarException(e);
        }
    }
}