source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube, open source software quality management tool.
   3  * Copyright (C) 2008-2013 SonarSource
   4  * mailto:contact AT sonarsource DOT com
   5  *
   6  * SonarQube is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * SonarQube is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 package org.sonar.plugins.core.issue.ignore.pattern;
  22
  23 import org.junit.Rule;
  24 import org.junit.Test;
  25 import org.junit.rules.ExpectedException;
  26 import org.sonar.api.utils.SonarException;
  27
  28 import java.util.List;
  29
  30 import static org.fest.assertions.Assertions.assertThat;
  31
  32 public class PatternDecoderTest {
  33
  34   private PatternDecoder decoder = new PatternDecoder();
  35
  36   @Rule
  37   public ExpectedException thrown = ExpectedException.none();
  38
  39   @Test
  40   public void shouldReadString() {
  41     String patternsList = "# a comment followed by a blank line\n\n" +
  42       "# suppress all violations\n" +
  43       "*;*;*\n\n" +
  44       "# exclude a Java file\n" +
  45       "com.foo.Bar;*;*\n\n" +
  46       "# exclude a Java package\n" +
  47       "com.foo.*;*;*\n\n" +
  48       "# exclude a specific rule\n" +
  49       "*;checkstyle:IllegalRegexp;*\n\n" +
  50       "# exclude a specific rule on a specific file\n" +
  51       "com.foo.Bar;checkstyle:IllegalRegexp;*\n";
  52     List<Pattern> patterns = decoder.decode(patternsList);
  53
  54     assertThat(patterns).hasSize(5);
  55   }
  56
  57   @Test
  58   public void shouldCheckFormatOfResource() {
  59     assertThat(decoder.isResource("")).isFalse();
  60     assertThat(decoder.isResource("*")).isTrue();
  61     assertThat(decoder.isResource("com.foo.*")).isTrue();
  62   }
  63
  64   @Test
  65   public void shouldCheckFormatOfRule() {
  66     assertThat(decoder.isRule("")).isFalse();
  67     assertThat(decoder.isRule("*")).isTrue();
  68     assertThat(decoder.isRule("com.foo.*")).isTrue();
  69   }
  70
  71   @Test
  72   public void shouldCheckFormatOfLinesRange() {
  73     assertThat(decoder.isLinesRange("")).isFalse();
  74     assertThat(decoder.isLinesRange("   ")).isFalse();
  75     assertThat(decoder.isLinesRange("12")).isFalse();
  76     assertThat(decoder.isLinesRange("12,212")).isFalse();
  77
  78     assertThat(decoder.isLinesRange("*")).isTrue();
  79     assertThat(decoder.isLinesRange("[]")).isTrue();
  80     assertThat(decoder.isLinesRange("[13]")).isTrue();
  81     assertThat(decoder.isLinesRange("[13,24]")).isTrue();
  82     assertThat(decoder.isLinesRange("[13,24,25-500]")).isTrue();
  83     assertThat(decoder.isLinesRange("[24-65]")).isTrue();
  84     assertThat(decoder.isLinesRange("[13,24-65,84-89,122]")).isTrue();
  85   }
  86
  87   @Test
  88   public void shouldReadStarPatterns() {
  89     Pattern pattern = decoder.decodeLine("*;*;*");
  90
  91     assertThat(pattern.getResourcePattern().toString()).isEqualTo("*");
  92     assertThat(pattern.getRulePattern().toString()).isEqualTo("*");
  93     assertThat(pattern.isCheckLines()).isFalse();
  94   }
  95
  96   @Test
  97   public void shouldReadLineIds() {
  98     Pattern pattern = decoder.decodeLine("*;*;[10,25,98]");
  99
 100     assertThat(pattern.isCheckLines()).isTrue();
 101     assertThat(pattern.getAllLines()).containsOnly(10, 25, 98);
 102   }
 103
 104   @Test
 105   public void shouldReadRangeOfLineIds() {
 106     Pattern pattern = decoder.decodeLine("*;*;[10-12,25,97-100]");
 107
 108     assertThat(pattern.isCheckLines()).isTrue();
 109     assertThat(pattern.getAllLines()).containsOnly(10, 11, 12, 25, 97, 98, 99, 100);
 110   }
 111
 112   @Test
 113   public void shouldNotExcludeLines() {
 114     // [] is different than *
 115     // - all violations are excluded on *
 116     // * no violations are excluded on []
 117     Pattern pattern = decoder.decodeLine("*;*;[]");
 118
 119     assertThat(pattern.isCheckLines()).isTrue();
 120     assertThat(pattern.getAllLines()).isEmpty();
 121   }
 122
 123   @Test
 124   public void shouldReadBlockPattern() {
 125     Pattern pattern = decoder.decodeLine("SONAR-OFF;SONAR-ON");
 126
 127     assertThat(pattern.getResourcePattern()).isNull();
 128     assertThat(pattern.getBeginBlockRegexp()).isEqualTo("SONAR-OFF");
 129     assertThat(pattern.getEndBlockRegexp()).isEqualTo("SONAR-ON");
 130   }
 131
 132   @Test
 133   public void shouldReadAllFilePattern() {
 134     Pattern pattern = decoder.decodeLine("SONAR-ALL-OFF");
 135
 136     assertThat(pattern.getResourcePattern()).isNull();
 137     assertThat(pattern.getAllFileRegexp()).isEqualTo("SONAR-ALL-OFF");
 138   }
 139
 140   @Test
 141   public void shouldFailToReadUncorrectLine1() {
 142     thrown.expect(SonarException.class);
 143     thrown.expectMessage("Invalid format. The following line has more than 3 fields separated by comma");
 144
 145     decoder.decode(";;;;");
 146   }
 147
 148   @Test
 149   public void shouldFailToReadUncorrectLine3() {
 150     thrown.expect(SonarException.class);
 151     thrown.expectMessage("Invalid format. The first field does not define a resource pattern");
 152
 153     decoder.decode(";*;*");
 154   }
 155
 156   @Test
 157   public void shouldFailToReadUncorrectLine4() {
 158     thrown.expect(SonarException.class);
 159     thrown.expectMessage("Invalid format. The second field does not define a rule pattern");
 160
 161     decoder.decode("*;;*");
 162   }
 163
 164   @Test
 165   public void shouldFailToReadUncorrectLine5() {
 166     thrown.expect(SonarException.class);
 167     thrown.expectMessage("Invalid format. The third field does not define a range of lines");
 168
 169     decoder.decode("*;*;blabla");
 170   }
 171
 172   @Test
 173   public void shouldFailToReadUncorrectLine6() {
 174     thrown.expect(SonarException.class);
 175     thrown.expectMessage("Invalid format. The first field does not define a regular expression");
 176
 177     decoder.decode(";ON");
 178   }
 179
 180   @Test
 181   public void shouldFailToReadUncorrectLine7() {
 182     thrown.expect(SonarException.class);
 183     thrown.expectMessage("Invalid format. The second field does not define a regular expression");
 184
 185     decoder.decode("OFF;");
 186   }
 187 }