foo();
    bar();
    return 0;
}
"""


def get_testdirectory_name(test_directory):
    return os.path.join(os.path.dirname(__file__), 'test_files',
                        test_directory)


CPPCleanBearTest = verify_local_bear(CPPCleanBear,
                                     valid_files=(good_file, ),
                                     invalid_files=(
                                         bad_file,
                                         test_include_paths_file,
                                     ),
                                     tempfile_kwargs={'suffix': '.cpp'})

CPPCleanBearValidIncludeMultiplePathTest = verify_local_bear(
    CPPCleanBear,
    valid_files=(test_include_paths_file, ),
    invalid_files=(),
    settings={
        'include_paths':
        escape(get_testdirectory_name('headers1'), '\\') + ',' +
        escape(get_testdirectory_name('headers2'), '\\')
    },
    tempfile_kwargs={'suffix': '.cpp'})
Exemplo n.º 2
0
from bears.ruby.RubySyntaxBear import RubySyntaxBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """
class HelloWorld
    def initialize(name)
        @name = name.capitalize
    end
    def sayHi
        puts "Hello #{@name}!"
    end
end
"""


bad_file = """
class HelloWorld
    def initialize(name)
        @name = name.capitalize
    end
    def sayHi
        x = 1 # unused variables invoke a warning
        puts "Hello #{@name}!"
    end
"""


RubySyntaxBearTest = verify_local_bear(RubySyntaxBear, valid_files=(good_file,), invalid_files=(bad_file,))
done
"""

trigger_sc2060 = """
#!/usr/bin/env sh
tr -cd [:digit:]
"""

good_zero_byte = ''
good_only_eol = '\n'
good_only_eol_eol = '\n\n'
good_only_comment = '# this is a bash comment'

invalid_file_list = (invalid_file, trigger_sc2164, trigger_sc2060,)
ShellCheckBearTest = verify_local_bear(ShellCheckBear,
                                       valid_files=(valid_file,),
                                       invalid_files=invalid_file_list,
                                       )

small_files = (good_zero_byte, good_only_eol, good_only_eol_eol,
               good_only_comment,)
SmallFileTest = verify_local_bear(ShellCheckBear,
                                  valid_files=small_files,
                                  invalid_files=(),
                                  )

IgnoreSC2164Test = verify_local_bear(ShellCheckBear,
                                     valid_files=(trigger_sc2164,),
                                     invalid_files=(),
                                     settings={
                                         'shellcheck_ignore': ['SC2164']},
                                     )
Exemplo n.º 4
0
bad_file_undef = """
console.log(a)
"""

bad_file_ifelse = """
var a = 1
if (a) {
  console.log(a)
}
else {
  console.log(0)
}
"""

bad_file_func_name = """
function my_function (a) {
  return a
}
"""

JSStandardBearTest = verify_local_bear(JSStandardBear,
                                       valid_files=(good_file,),
                                       invalid_files=(bad_file_indent,
                                                      bad_file_quote,
                                                      bad_file_semicolon,
                                                      bad_file_infix,
                                                      bad_file_undef,
                                                      bad_file_ifelse,
                                                      bad_file_func_name,))
'''


bad_file = '''
"""
example module level docstring
"""

def hello():
    print("hello world")

'''

PyDocStyleBearTest = verify_local_bear(
    PyDocStyleBear,
    valid_files=(good_file,),
    invalid_files=(bad_file,),
    tempfile_kwargs={'suffix': '.py'})

PyDocStyleBearIgnoreAllTest = verify_local_bear(
    PyDocStyleBear,
    valid_files=(good_file, bad_file,),
    invalid_files=(),
    settings={'pydocstyle_ignore': 'D400, D200, D103, D212'},
    tempfile_kwargs={'suffix': '.py'})

# Checks if an invalid file yields results when only some errors are ignored.
PyDocStyleBearIgnoreSomeTest = verify_local_bear(
    PyDocStyleBear,
    valid_files=(good_file,),
    invalid_files=(bad_file,),
long_length_test_file = """<?php
/**
 * PHP_CodeSniffer tokenizes PHP code and detects violations of a defined set \
of coding.This is to test that the absoluteLineLength is violated or not.

 * PHP version 5
 *
 * @category PHP
 * @package  Your_Package
 * @author   John Snow <*****@*****.**>
 * @license  https://licence.txt LICENSE
 * @link     http://somelink
 */
>
"""


PHPCodeSnifferBearTest = verify_local_bear(
    PHPCodeSnifferBear,
    valid_files=(good_file,),
    invalid_files=(bad_file,),
    tempfile_kwargs={'suffix': '.php'})


PHPCodeSnifferBearLineLengthTest = verify_local_bear(
    PHPCodeSnifferBear,
    valid_files=(long_length_test_file,),
    invalid_files=(),
    settings={'max_line_length': '160'},
    tempfile_kwargs={'suffix': '.php'})
from bears.shell.ShellCheckBear import ShellCheckBear
from coalib.testing.LocalBearTestHelper import verify_local_bear


valid_file = """
#!/usr/bin/env sh
echo "Path is $PATH"
echo "$P"
"""

invalid_file = """
#!/usr/bin/env sh
echo 'Path is $PATH'
echo $P
X = 24
X+=2    # += operator is supported by bash and not by sh
echo $X
"""


ShellCheckBearTest = verify_local_bear(ShellCheckBear,
                                       valid_files=(valid_file,),
                                       invalid_files=(invalid_file,))
Exemplo n.º 8
0
'''

bad_file = '''
import something



def hello():
    print("hello world")
'''

file_with_very_long_line = ('def ' + 'h' * 1000 + '():\n' +
                            '    print("hello")')

PycodestyleBearTest = verify_local_bear(PycodestyleBear,
                                        valid_files=(good_file, ),
                                        invalid_files=(bad_file, ))

PycodestyleBearNoIgnoreTest = verify_local_bear(
    PycodestyleBear,
    valid_files=(good_file, ),
    invalid_files=(bad_file, ),
    settings={'pycodestyle_ignore': ''})

PycodestyleBearConfigIgnoreTest = verify_local_bear(
    PycodestyleBear,
    valid_files=(good_file, bad_file),
    invalid_files=[],
    settings={'pycodestyle_ignore': 'E303'})

PycodestyleBearConfigSelectTest = verify_local_bear(
Exemplo n.º 9
0
dtd_file = os.path.join(os.path.dirname(__file__), 'test_files', 'note.dtd')

schema_file = os.path.join(os.path.dirname(__file__), 'test_files', 'note.xsd')

valid_xml_path = load_testdata('note.xml')
valid_xml_url = load_testdata('concept-valid.xml')
invalid_xml_schema = load_testdata('xsd-error.xml')
invalid_xml_dtd = load_testdata('dtd-error.xml')
invalid_xml_url = load_testdata('concept-invalid.xml')

dtd_url = 'http://docs.oasis-open.org/dita/v1.0.1/dtd/concept.dtd'

XMLBearCorrectedTest = verify_local_bear(XMLBear,
                                         valid_files=(valid_xml_file,
                                                      valid_xml_chars),
                                         invalid_files=(invalid_xml_file,
                                                        invalid_xml_chars),
                                         tempfile_kwargs={'suffix': '.xml'})

XMLBearSchemaTest = verify_local_bear(XMLBear,
                                      valid_files=(valid_xml_path, ),
                                      invalid_files=(invalid_xml_schema, ),
                                      settings={'xml_schema': schema_file},
                                      tempfile_kwargs={'suffix': '.xml'})

XMLBearDTDPathTest = verify_local_bear(XMLBear,
                                       valid_files=(valid_xml_path, ),
                                       invalid_files=(invalid_xml_dtd, ),
                                       settings={'xml_dtd': dtd_file},
                                       tempfile_kwargs={'suffix': '.xml'})
Exemplo n.º 10
0
from tests.test_bears.LineCountTestBear import LineCountTestBear
from coala_utils.ContextManagers import prepare_file
from coalib.results.Result import Result
from coalib.results.RESULT_SEVERITY import RESULT_SEVERITY
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting
from coalib.testing.LocalBearTestHelper import verify_local_bear, execute_bear
from coalib.testing.LocalBearTestHelper import LocalBearTestHelper as Helper
from coalib.bearlib.aspects import (
    AspectList,
    get as get_aspect,
)

files = ('Everything is invalid/valid/raises error', )
invalidTest = verify_local_bear(TestBear,
                                valid_files=(),
                                invalid_files=files,
                                settings={'result': True})
validTest = verify_local_bear(TestBear, valid_files=files, invalid_files=())
min_files = ('This is valid.', )
max_files = ('This is particularly an invalid file', )
AspectTest = verify_local_bear(
    AspectsGeneralTestBear,
    valid_files=min_files,
    invalid_files=max_files,
    aspects=AspectList([
        get_aspect('LineLength')('Unknown', max_line_length=20),
    ]),
)
PriorityAspectsTest = verify_local_bear(
    AspectsGeneralTestBear,
    valid_files=min_files,
Exemplo n.º 11
0
from bears.general.KeywordBear import KeywordBear
from coalib.results.HiddenResult import HiddenResult
from coalib.results.SourceRange import SourceRange
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting
from coalib.testing.LocalBearTestHelper import verify_local_bear, execute_bear

test_file = """
test line fix me
to do
error fixme
"""

KeywordBearTest = verify_local_bear(KeywordBear,
                                    valid_files=(test_file, ),
                                    invalid_files=('test line todo',
                                                   'test line warNING'),
                                    settings={'keywords': 'todo, warning'})


class KeywordBearDiffTest(unittest.TestCase):
    def setUp(self):
        self.section = Section('')
        self.section.append(Setting('language', 'python3'))
        self.section.append(Setting('keywords', 'TODO'))
        self.uut = KeywordBear(self.section, Queue())

        self.annotation_bear_result_type = namedtuple('result', ['contents'])
        self.dep_results = {
            'AnnotationBear': HiddenResult('AnnotationBear', {'comments': ()})
        }
function b(object, key) {
  return object["key"];
}"""

bad_quotes = """const a = () => 'Foo bar';"""

bad_parentheses = """function b(){
"""

good_parentheses = """function b() {}
"""

bad_indent = """if (x) {
x = 0
}"""

good_indent = """if (x) {
  x = 0;
}"""

PrettierLintBear = verify_local_bear(PrettierLintBear,
                                     valid_files=(good_quotes,
                                                  good_file,
                                                  good_parentheses,
                                                  good_indent,),
                                     invalid_files=(bad_file,
                                                    bad_quotes,
                                                    bad_parentheses,
                                                    bad_indent,))
import platform
import unittest

from bears.natural_language.SpellCheckBear import SpellCheckBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = 'This is correct spelling.'

bad_file = 'tihs si surly som incoreclt speling.'

SpellCheckLintBearTest = unittest.skipIf(
    platform.system() == 'Windows', "SpellCheckBear doesn't work on windows")(
        verify_local_bear(SpellCheckBear,
                          valid_files=(good_file, ),
                          invalid_files=(bad_file, )))
Exemplo n.º 14
0
bad_file = """function findTitle(title) {
    let titleElement = 'hello';
    return title;
}
let t = findTitle('mytitle');
t.innerHTML = 'New title';
"""

tslint_config_dir = os.path.join(os.path.dirname(__file__), 'test_files')

tslintconfig = os.path.join(tslint_config_dir, 'tslint.json')

tslintconfig_single = os.path.join(tslint_config_dir, 'tslint-single.json')

TSLintDoubleQuotesTest = verify_local_bear(TSLintBear,
                                           valid_files=(good_file, ),
                                           invalid_files=(bad_file, ),
                                           settings={
                                               'tslint_config': tslintconfig,
                                               'rules_dir': tslint_config_dir,
                                           },
                                           tempfile_kwargs={'suffix': '.ts'})

TSLintSingleQuotesTest = verify_local_bear(
    TSLintBear,
    valid_files=(bad_file, ),
    invalid_files=(good_file, ),
    settings={'tslint_config': tslintconfig_single},
    tempfile_kwargs={'suffix': '.ts'})
Exemplo n.º 15
0
if(TRUE){
x=1  # inline comments
}else{
x=2;print("Oh no... ask the right bracket to go away!")}
"""


bad_file_3 = """x=(1+1+1+1+1+1+1+1+1)
if(TRUE){
x=1  # inline comments
}else{x=2;print("Oh no... ask the right bracket to go away!")}
"""


FormatRBearTest = verify_local_bear(FormatRBear, valid_files=(good_file_1,), invalid_files=(bad_file_1,))


FormatRBearRArrowToEqualTest = verify_local_bear(
    FormatRBear, valid_files=(good_file_2,), invalid_files=(bad_file_1,), settings={"r_use_arrows": "true"}
)


FormatRBearRKeepCommentsTest = verify_local_bear(
    FormatRBear, valid_files=(good_file_3,), invalid_files=(good_file_1,), settings={"r_keep_comments": "false"}
)


FormatRBearRBraceToNewlineTest = verify_local_bear(
    FormatRBear, valid_files=(good_file_4,), invalid_files=(bad_file_1,), settings={"r_braces_on_next_line": "true"}
)
Exemplo n.º 16
0
}
"""

bad_file = """
printNumber(num aNumber) {
  print('The number is $aNumber.')
}

main() {
  var answer = 42;          // The meaning of life.
  printNumber(answer)
}
"""

DartLintBearTest = verify_local_bear(DartLintBear,
                                     valid_files=(good_file, ),
                                     invalid_files=(bad_file, ),
                                     tempfile_kwargs={'suffix': '.dart'})


@generate_skip_decorator(DartLintBear)
class DartLintBearConfigTest(LocalBearTestHelper):

    DART_VALUE_ERROR_RE = ('ValueError: DartLintBear only supports '
                           '`use_spaces=True` and `indent_size=2`')

    def test_config_failure_use_spaces(self):
        section = Section('name')
        section.append(Setting('use_spaces', False))
        bear = DartLintBear(section, Queue())

        with self.assertRaisesRegex(AssertionError, self.DART_VALUE_ERROR_RE):
Exemplo n.º 17
0
from coalib.testing.LocalBearTestHelper import verify_local_bear

test_file = """
int main() {
    return 0;
}
"""

test_file2 = ('int main() {\n' +
              '    int x;\n' +
              '    x = 3;' * 100 + '\n'
              '    return 0;\n' +
              '}\n')

CPPLintBearTest = verify_local_bear(CPPLintBear,
                                    valid_files=(),
                                    invalid_files=(test_file,),
                                    tempfile_kwargs={'suffix': '.cpp'})

CPPLintBearIgnoreConfigTest = verify_local_bear(
    CPPLintBear,
    valid_files=(test_file,),
    invalid_files=(),
    settings={'cpplint_ignore': 'legal/copyright'},
    tempfile_kwargs={'suffix': '.cpp'})

CPPLintBearLineLengthConfigTest = verify_local_bear(
    CPPLintBear,
    valid_files=(),
    invalid_files=(test_file,),
    settings={'cpplint_ignore': 'legal/copyright',
              'max_line_length': '13'},
from bears.c_languages.ClangBear import ClangBear
from coalib.testing.LocalBearTestHelper import verify_local_bear


ClangBearTest = verify_local_bear(
    ClangBear,
    ('int main() {}', ),
    ('bad things, this is no C code',  # Has no fixit
     # Has a fixit and no range
     'struct { int f0; } x = { f0 :1 };',
     'int main() {int *b; return b}'),  # Has a fixit and a range
    'test.c')


ClangBearIgnoreTest = verify_local_bear(
    ClangBear,
    # Should ignore the warning, valid!
    ('struct { int f0; } x = { f0 :1 };',),
    (),
    'test.c',
    settings={'clang_cli_options': '-w'})
from bears.configfiles.DockerfileLintBear import DockerfileLintBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """
FROM ubuntu:14.04
MAINTAINER coala
LABEL Name coala-docker
LABEL Version 0.1

# Install basic tools
RUN apt-get -y -qq update
RUN apt-get -y -qq upgrade
EXPOSE 5432
CMD ["/bin/bash", "coala"]
"""


bad_file = """
FROM ubuntu:14.04

# Install basic tools
apt-get -y -qq update
apt-get -y -qq upgrade
"""


DockerfileLintBearTest = verify_local_bear(DockerfileLintBear,
                                           valid_files=(good_file,),
                                           invalid_files=(bad_file,))
Exemplo n.º 20
0
from bears.shell.ShellCheckBear import ShellCheckBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

valid_file = """
#!/usr/bin/env sh
echo "Path is $PATH"
echo "$P"
"""

invalid_file = """
#!/usr/bin/env sh
echo 'Path is $PATH'
echo $P
X = 24
X+=2    # += operator is supported by bash and not by sh
echo $X
"""

ShellCheckBearTest = verify_local_bear(ShellCheckBear,
                                       valid_files=(valid_file, ),
                                       invalid_files=(invalid_file, ))
Exemplo n.º 21
0
use strict;
use warnings;
use vars qw/ $VERSION /;

$VERSION = '1.00';

exit 1 if !print "Hello, world!\n";
"""


bad_file = """
#!/usr/bin/perl

print "Hello World\n";
"""


conf_file = os.path.abspath(os.path.join(
    os.path.dirname(os.path.realpath(__file__)),
    'testfiles', '.perlcriticrc'))

PerlCriticBearTest = verify_local_bear(PerlCriticBear,
                                       valid_files=(good_file,),
                                       invalid_files=(bad_file,))

PerlCriticBearConfigTest = verify_local_bear(
    PerlCriticBear,
    valid_files=(good_file, bad_file),
    invalid_files=(),
    settings={'perlcritic_profile': conf_file})
Exemplo n.º 22
0
    print("hello world")

'''

bad_file = '''
"""
example module level docstring
"""

def hello():
    print("hello world")

'''

PyDocStyleBearTest = verify_local_bear(PyDocStyleBear,
                                       valid_files=(good_file, ),
                                       invalid_files=(bad_file, ),
                                       tempfile_kwargs={'suffix': '.py'})

PyDocStyleBearIgnoreAllTest = verify_local_bear(
    PyDocStyleBear,
    valid_files=(
        good_file,
        bad_file,
    ),
    invalid_files=(),
    settings={'pydocstyle_ignore': 'D400, D200, D103, D212'},
    tempfile_kwargs={'suffix': '.py'})

# Checks if an invalid file yields results when only some errors are ignored.
PyDocStyleBearIgnoreSomeTest = verify_local_bear(
    PyDocStyleBear,
Exemplo n.º 23
0
from bears.go.GofmtBear import GofmtBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

GofmtBear = verify_local_bear(
    GofmtBear,
    ('package main\n\nfunc main() {\n\treturn 1\n}',),
    ('package main\nfunc main() {\n\treturn 1\n}',))
Exemplo n.º 24
0
                           confidence=90)
    ])


# The following test will ignore some error codes, so "good" and "bad" doesn't
# reflect the actual code quality.

good_files = ('good_file.py', 'assert.py')

bad_files = ('exec-py2.py', 'httpoxy_cgihandler.py', 'jinja2_templating.py',
             'skip.py')
skipped_error_codes = ['B105', 'B106', 'B107', 'B404', 'B606', 'B607', 'B101']

BanditBearSkipErrorCodesTest1 = verify_local_bear(
    BanditBear,
    valid_files=tuple(load_testfile(file) for file in good_files),
    invalid_files=tuple(load_testfile(file) for file in bad_files),
    settings={'bandit_skipped_tests': ','.join(skipped_error_codes)},
    tempfile_kwargs={'suffix': '.py'})

good_files = ('good_file.py', )
bad_files = ('exec-py2.py', 'httpoxy_cgihandler.py', 'jinja2_templating.py',
             'skip.py', 'assert.py')

BanditBearSkipErrorCodesTest2 = verify_local_bear(
    BanditBear,
    valid_files=tuple(load_testfile(file) for file in good_files),
    invalid_files=tuple(load_testfile(file) for file in bad_files),
    settings={'bandit_skipped_tests': ''},
    tempfile_kwargs={'suffix': '.py'})
class theGangster

  wasItAGoodDay : () ->
    yes
"""


invalid_file = """
# Coffeelint is buggy here and will generate an error with invalid CSV on this
var test
"""


CoffeeLintBearTest = verify_local_bear(CoffeeLintBear,
                                       valid_files=(good_file,),
                                       invalid_files=(warning_file,
                                                      error_file,
                                                      invalid_file))


CoffeeLintBearUseEnglishOperatorTest = verify_local_bear(
    CoffeeLintBear,
    valid_files=(good_file_use_english_operator,),
    invalid_files=(bad_file_use_english_operator,),
    settings={'allow_bitwise_operators': 'false',
              'consistent_line_endings_style': 'unix'})


CoffeeLintBearTabWidthTest = verify_local_bear(
    CoffeeLintBear,
    valid_files=(good_file_tab_width,),
from bears.css.CSSAutoPrefixBear import CSSAutoPrefixBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """
.example {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
}
"""

bad_file = """
.example {
    display: flex;
}
"""

CSSAutoPrefixBear = verify_local_bear(CSSAutoPrefixBear,
                                      valid_files=(good_file, ),
                                      invalid_files=(bad_file, ))
from bears.natural_language.LanguageToolBear import LanguageToolBear
from coalib.testing.BearTestHelper import generate_skip_decorator
from coalib.testing.LocalBearTestHelper import verify_local_bear

try:
    import language_check
    import guess_language
    language_check
    guess_language
except ImportError as err:
    raise SkipTest(str(err))

LanguageToolBearTest = verify_local_bear(
    LanguageToolBear,
    valid_files=('A correct English sentence sounds nice to everyone.',
                 'Ein korrekter englischer Satz klingt für alle gut.'),
    invalid_files=('  ',
                   'asdgaasdfgahsadf',
                   '"quoted"'))


LanguageToolBearLanguageTest = verify_local_bear(
    LanguageToolBear,
    valid_files=('A correct English sentence sounds nice to everyone.',),
    invalid_files=('Ein korrekter englischer Satz klingt für alle gut.',),
    settings={'language': 'en-US'})


LanguageToolBearDisableRulesTest = verify_local_bear(
    LanguageToolBear,
    valid_files=('Line without unnecessary spaces at the start.',
import os

from bears.cmake.CMakeLintBear import CMakeLintBear
from coalib.testing.LocalBearTestHelper import verify_local_bear


good_file = 'project(FooBar C)\nset(VERSION 0)\n'

bad_file_mixes_case = 'ProJeCt(FooBar C)\nseT(VERSION 0)\n'


conf_file = os.path.join(os.path.dirname(__file__),
                         'test_files',
                         'cmake_config.txt')


CMakeLintBearTest = verify_local_bear(
    CMakeLintBear,
    valid_files=(good_file,),
    invalid_files=(bad_file_mixes_case,),
    tempfile_kwargs={'suffix': '.cmake'})


CMakeLintBearConfigTest = verify_local_bear(
    CMakeLintBear,
    valid_files=(good_file, bad_file_mixes_case),
    invalid_files=(),
    tempfile_kwargs={'suffix': '.cmake'},
    settings={'cmakelint_config': conf_file})
Exemplo n.º 29
0
}
'''

good_file2 = '''
$value: 5px;

.foo {
  padding: $value;
}

.bar {
  margin: $value;
}

.new-class {
  display: block;
}
'''


SCSSLintBearTest = verify_local_bear(SCSSLintBear,
                                     valid_files=(good_file, good_file2),
                                     invalid_files=(bad_file, bad_file2))


SCSSLintBearChainedClassesTest = verify_local_bear(
    SCSSLintBear,
    valid_files=(bad_file2, good_file2),
    invalid_files=(bad_file,),
    settings={'allow_chained_classes': True})
Exemplo n.º 30
0
bad_file = """class lowerCamelCase {
  var x: Int
}
"""

long_class_file = """class LongClass {
  var x: Int
  var y: Int
  var z: Int
}
"""

TailorBearWithoutConfig = verify_local_bear(TailorBear,
                                            valid_files=(good_file,),
                                            invalid_files=(bad_file,),
                                            tempfile_kwargs={
                                                'suffix': '.swift'})

TailorBearWithConfig = verify_local_bear(TailorBear,
                                         valid_files=(bad_file,),
                                         invalid_files=(),
                                         settings={
                                             'tailor_config': tailorconfig},
                                         tempfile_kwargs={'suffix': '.swift'})

TailorBearWithSetting = verify_local_bear(TailorBear,
                                          valid_files=(),
                                          invalid_files=(long_class_file,),
                                          settings={
                                              'max_class_length': 2},
Exemplo n.º 31
0
ignorepkg_file = """package main
import (
  "io"
  "log"
  "os"
)
func main() {
  f, _ := os.Open("foo")
  log.Println("opened file")
  io.Copy(os.Stdout, f)
}"""

GoErrCheckBearTest = verify_local_bear(GoErrCheckBear,
                                       valid_files=(
                                           good_file, assert_file, blank_file),
                                       invalid_files=(bad_file,),
                                       tempfile_kwargs={'suffix': '.go'})

GoErrCheckBearWithIgnoreTest = verify_local_bear(GoErrCheckBear,
                                                 valid_files=(
                                                     good_file,
                                                     assert_file,
                                                     blank_file),
                                                 invalid_files=(bad_file,),
                                                 settings={
                                                     'ignore':
                                                     "'[rR]ead|[wW]rite'"},
                                                 tempfile_kwargs={'suffix':
                                                                  '.go'})
GoErrCheckBearWithIgnorePkgTest = verify_local_bear(GoErrCheckBear,
Exemplo n.º 32
0
"""


def get_testfile_path(filename):
    return os.path.join(os.path.dirname(__file__),
                        'dockerfile_lint_test_files',
                        filename)


default_rule = get_testfile_path('default_rule.yaml')

sample_rule = get_testfile_path('sample_rule.yaml')


DockerfileLintBearTest = verify_local_bear(DockerfileLintBear,
                                           valid_files=(good_file,),
                                           invalid_files=(bad_file,))

DockerfileLintBearDefaultRuleTest = verify_local_bear(
    DockerfileLintBear,
    valid_files=(good_file2,),
    invalid_files=(bad_file2,),
    settings={'dockerfile_lint_rule_file':
              default_rule})

DockerfileLintBearCustomRuleTest = verify_local_bear(
    DockerfileLintBear,
    valid_files=(good_file3,),
    invalid_files=(bad_file3,),
    settings={'dockerfile_lint_rule_file':
              sample_rule})
Exemplo n.º 33
0
from bears.julia.JuliaLintBear import JuliaLintBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """
a = 2
println(2)
"""

bad_file = """
println(hello)
"""

JuliaLintBearTest = verify_local_bear(JuliaLintBear,
                                      valid_files=(good_file,),
                                      invalid_files=(bad_file,),
                                      tempfile_kwargs={'suffix': '.jl'},
                                      timeout=45)
Exemplo n.º 34
0
from bears.markdown.MarkdownBear import MarkdownBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

test_file1 = """1. abc
1. def
"""

test_file2 = """1. abc
2. def
"""

test_file3 = """1. abcdefghijklm
2. nopqrstuvwxyz
"""

MarkdownBearTest = verify_local_bear(MarkdownBear,
                                     valid_files=(test_file2, ),
                                     invalid_files=(test_file1, ))

MarkdownBearConfigsTest = verify_local_bear(MarkdownBear,
                                            valid_files=(test_file1, ),
                                            invalid_files=(test_file2, ),
                                            settings={'list_increment': False})

MarkdownBearMaxLineLengthSettingTest = verify_local_bear(
    MarkdownBear,
    valid_files=(test_file2, ),
    invalid_files=(test_file3, ),
    settings={'max_line_length': 10})
Exemplo n.º 35
0
            filename='default')

    def test_exception_empty_file(self):
        self.check_results(
            self.uut,
            [],
            [Result.from_values('JSONFormatBear',
                                'This file is empty.',
                                file='default')],
            filename='default')


JSONFormatBearTest = verify_local_bear(JSONFormatBear,
                                       valid_files=(test_file1, test_file2),
                                       invalid_files=(test_file3,
                                                      unicode_file,
                                                      '',
                                                      'random stuff',
                                                      '{"a":5,"b":5}'))


JSONFormatBearSortTest = verify_local_bear(JSONFormatBear,
                                           valid_files=(test_file1,),
                                           invalid_files=(test_file2,),
                                           settings={'json_sort': 'true'})


JSONFormatBearTabWidthTest = verify_local_bear(JSONFormatBear,
                                               valid_files=(test_file3,),
                                               invalid_files=(test_file2,),
                                               settings={
Exemplo n.º 36
0
from bears.rest.RSTcheckBear import RSTcheckBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

rst_syntax_good = '====\ntest\n====\n'
rst_syntax_bad = '====\ntest\n===\n'

python_block_good = '====\nTest\n====\n.. code-block:: python\n\n    print()'
python_block_bad = '====\nTest\n====\n.. code-block:: python\n\n    print(\n'

RSTcheckBearTest_ignore_no_code_block = verify_local_bear(
                RSTcheckBear,
                (rst_syntax_good, python_block_good),
                (rst_syntax_bad, python_block_bad),
                )
RSTcheckBearTest_ignore_python_code_block = verify_local_bear(
                RSTcheckBear,
                (rst_syntax_good, python_block_bad, python_block_good),
                (rst_syntax_bad,),
                settings={'code_block_language_ignore': 'python'})
Exemplo n.º 37
0
import unittest
from unittest.mock import patch

from bears.natural_language.AlexBear import AlexBear
from coalib.testing.BearTestHelper import generate_skip_decorator
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = 'Their network looks good.'

bad_file = 'His network looks good.'


AlexBearTest = verify_local_bear(AlexBear,
                                 valid_files=(good_file,),
                                 invalid_files=(bad_file,))


@generate_skip_decorator(AlexBear)
@patch('bears.natural_language.AlexBear.subprocess.check_output')
class AlexBearPrereqTest(unittest.TestCase):

    def test_unverified_alex_installed(self, check_output_mock):
        check_output_mock.side_effect = OSError
        self.assertIn('The `alex` package could not be verified',
                      AlexBear.check_prerequisites())

    def test_wrong_alex_installed(self, check_output_mock):
        check_output_mock.return_value = b'Unexpected output from package'
        self.assertIn("The `alex` package that's been installed seems to "
                      'be incorrect',
                      AlexBear.check_prerequisites())
Exemplo n.º 38
0

if(TRUE){
x=1  # inline comments
}else{
x=2;print("Oh no... ask the right bracket to go away!")}
"""

bad_file_3 = """x=(1+1+1+1+1+1+1+1+1)
if(TRUE){
x=1  # inline comments
}else{x=2;print("Oh no... ask the right bracket to go away!")}
"""

FormatRBearTest = verify_local_bear(FormatRBear,
                                    valid_files=(good_file_1, ),
                                    invalid_files=(bad_file_1, ))

FormatRBearRArrowToEqualTest = verify_local_bear(
    FormatRBear,
    valid_files=(good_file_2, ),
    invalid_files=(bad_file_1, ),
    settings={'r_use_arrows': 'true'})

FormatRBearRKeepCommentsTest = verify_local_bear(
    FormatRBear,
    valid_files=(good_file_3, ),
    invalid_files=(good_file_1, ),
    settings={'r_keep_comments': 'false'})

FormatRBearRBraceToNewlineTest = verify_local_bear(
Exemplo n.º 39
0
from bears.r.RLintBear import RLintBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """
fun <- function(one){
  one_plus_one <- one + 1
  four <- matrix(1:10, nrow = 2)
  print(one_plus_one, four)
}"""


bad_file = """
fun = function(one)
{
    one.plus.one <- one + 1
    four <-  matrix(1:10,nrow =2)
    print(one_plus_one , four)
}
"""


RLintBearTest = verify_local_bear(RLintBear,
                                  invalid_files=(bad_file,),
                                  valid_files=(good_file,),
                                  tempfile_kwargs={'suffix': '.R'})
Exemplo n.º 40
0
  int test() {
    String s = null;
    return s.length();
  }
}
"""


class JavaPMDBearPrerequisiteTest(TestCase):
    def test_check_prerequisites(self):
        with mock.patch('bears.java.JavaPMDBear.which') as mock_which:
            mock_which.side_effect = [None, None, None]
            self.assertEqual(JavaPMDBear.check_prerequisites(),
                             'bash is not installed.')

            mock_which.side_effect = ['path/to/bash', None, None]
            self.assertEqual(JavaPMDBear.check_prerequisites(),
                             ('PMD is missing. Make sure to install it from '
                              '<https://pmd.github.io/>'))

            mock_which.side_effect = [
                'path/to/bash', 'path/to/pmd', 'path/to/run'
            ]
            self.assertEqual(JavaPMDBear.check_prerequisites(), True)


JavaPMDBearTest = verify_local_bear(JavaPMDBear,
                                    valid_files=(good_file, ),
                                    invalid_files=(bad_file, ),
                                    tempfile_kwargs={'suffix': '.java'})
Exemplo n.º 41
0
test_file1 = """
def simple():
    pass
"""


test_file2 = """
class class1():
    pass
"""

test_file3 = 'def f():\n' + ('    assert True\n' * 50)


RadonBearDefaultsTest = verify_local_bear(
    RadonBear,
    valid_files=(test_file1, test_file2),
    invalid_files=(test_file3,))


RadonBearNoReportsTest = verify_local_bear(
    RadonBear,
    valid_files=(test_file1, test_file2, test_file3),
    invalid_files=(),
    settings={'radon_ranks_info': '',
              'radon_ranks_normal': '',
              'radon_ranks_major': ''})


RadonBearReportsTest = verify_local_bear(
    RadonBear,
    valid_files=(),
Exemplo n.º 42
0
ignorepkg_file = """package main
import (
  "io"
  "log"
  "os"
)
func main() {
  f, _ := os.Open("foo")
  log.Println("opened file")
  io.Copy(os.Stdout, f)
}"""

GoErrCheckBearTest = verify_local_bear(GoErrCheckBear,
                                       valid_files=(good_file, assert_file,
                                                    blank_file),
                                       invalid_files=(bad_file, ),
                                       tempfile_kwargs={'suffix': '.go'})

GoErrCheckBearWithIgnoreTest = verify_local_bear(
    GoErrCheckBear,
    valid_files=(good_file, assert_file, blank_file),
    invalid_files=(bad_file, ),
    settings={'ignore': "'[rR]ead|[wW]rite'"},
    tempfile_kwargs={'suffix': '.go'})
GoErrCheckBearWithIgnorePkgTest = verify_local_bear(
    GoErrCheckBear,
    valid_files=(good_file, assert_file, blank_file),
    invalid_files=(ignorepkg_file, ),
    settings={'ignorepkg': "'io'"},
    tempfile_kwargs={'suffix': '.go'})
Exemplo n.º 43
0

bad_file = """
printNumber(num aNumber) {
  print('The number is $aNumber.')
}

main() {
  var answer = 42;          // The meaning of life.
  printNumber(answer)
}
"""


DartLintBearTest = verify_local_bear(DartLintBear,
                                     valid_files=(good_file,),
                                     invalid_files=(bad_file,),
                                     tempfile_kwargs={'suffix': '.dart'})


@generate_skip_decorator(DartLintBear)
class DartLintBearConfigTest(LocalBearTestHelper):

    DART_VALUE_ERROR_RE = ('ValueError: DartLintBear only supports '
                           '`use_spaces=True` and `indent_size=2`')

    def test_config_failure_use_spaces(self):
        section = Section('name')
        section.append(Setting('use_spaces', False))
        bear = DartLintBear(section, Queue())

        with self.assertRaisesRegex(AssertionError, self.DART_VALUE_ERROR_RE):
  wasItAGoodDay : () ->
    yes
"""

invalid_file = """
# Coffeelint is buggy here and will generate an error with invalid CSV on this
var test
"""

infinite_line_length_file = """# File to check long line length support
""" + 'number   = 42; ' * 1000 + """number   = 42
console.log number
"""

CoffeeLintBearTest = verify_local_bear(CoffeeLintBear,
                                       valid_files=(good_file, ),
                                       invalid_files=(warning_file, error_file,
                                                      invalid_file))

CoffeeLintBearUseEnglishOperatorTest = verify_local_bear(
    CoffeeLintBear,
    valid_files=(good_file_use_english_operator, ),
    invalid_files=(bad_file_use_english_operator, ),
    settings={
        'allow_bitwise_operators': 'false',
        'consistent_line_endings_style': 'unix'
    })

CoffeeLintBearTabWidthTest = verify_local_bear(
    CoffeeLintBear,
    valid_files=(good_file_tab_width, ),
    invalid_files=(good_file, ),
Exemplo n.º 45
0
        # actually parsing a complete C file.
        ClangRange = namedtuple('ClangRange', 'start end')
        ClangPosition = namedtuple('ClangPosition', 'file line column')
        ClangFile = namedtuple('ClangFile', 'name')
        file = ClangFile('t.c')
        start = ClangPosition(file, 1, 2)
        end = ClangPosition(file, 3, 4)

        uut = sourcerange_from_clang_range(ClangRange(start, end))
        compare = SourceRange.from_values('t.c', 1, 2, 3, 4)
        self.assertEqual(uut, compare)


ClangBearTest = verify_local_bear(
    ClangBear,
    ('int main() {}', ),
    ('bad things, this is no C code',  # Has no fixit
     # Has a fixit and no range
     'struct { int f0; } x = { f0 :1 };',
     'int main() {int *b; return b}'),  # Has a fixit and a range
    'test.c')


ClangBearIgnoreTest = verify_local_bear(
    ClangBear,
    # Should ignore the warning, valid!
    ('struct { int f0; } x = { f0 :1 };',),
    (),
    'test.c',
    settings={'clang_cli_options': '-w'})
Exemplo n.º 46
0
test_file10 = """
int main()
{
    return 0;
}"""


test_file11 = ('int\nmain ()\n' +
               '{\n' +
               ' ' * 1000 + 'return 0;\n' +
               '}')

GNUIndentBearTest = verify_local_bear(
    GNUIndentBear,
    valid_files=(test_file1,),
    invalid_files=(test_file2, test_file3, test_file4),
    settings={'use_spaces': 'true', 'max_line_length': '79'})


GNUIndentBearWithTabTest = verify_local_bear(
    GNUIndentBear,
    valid_files=(test_file3,),
    invalid_files=(test_file1, test_file2, test_file4),
    settings={'use_spaces': 'nope', 'max_line_length': '79'})


GNUIndentBearWidthTest = verify_local_bear(
    GNUIndentBear,
    valid_files=(test_file2,),
    invalid_files=(test_file1, test_file3, test_file4),
from bears.js.HappinessLintBear import HappinessLintBear
from coalib.testing.LocalBearTestHelper import verify_local_bear


good_file = """
var x = 2;
if (6 > 7 !== true) console.log('done');
console.log(x);
"""

bad_file = """
if (options.quiet !== true)
  console.log('done')
var x=2
"""

HappinessLintBear = verify_local_bear(HappinessLintBear,
                                      valid_files=(good_file,),
                                      invalid_files=(bad_file,))
Exemplo n.º 48
0
                                   line=2,
                                   column=5)
            ],
            filename='default')

    def test_exception_empty_file(self):
        self.check_results(self.uut, [], [
            Result.from_values(
                'JSONFormatBear', 'This file is empty.', file='default')
        ],
                           filename='default')


JSONFormatBearTest = verify_local_bear(JSONFormatBear,
                                       valid_files=(test_file1, test_file2),
                                       invalid_files=(test_file3, unicode_file,
                                                      '', 'random stuff',
                                                      '{"a":5,"b":5}'))

JSONFormatBearSortTest = verify_local_bear(JSONFormatBear,
                                           valid_files=(test_file1, ),
                                           invalid_files=(test_file2, ),
                                           settings={'json_sort': 'true'})

JSONFormatBearTabWidthTest = verify_local_bear(JSONFormatBear,
                                               valid_files=(test_file3, ),
                                               invalid_files=(test_file2, ),
                                               settings={'indent_size': '3'})

JSONFormatBearUnicodeTest = verify_local_bear(
    JSONFormatBear,
Exemplo n.º 49
0
                            'jshintconfig.json')


settings = {
    'max_statements': 'False',
    'max_parameters': 10,
    'allow_unused_variables': 'True',
    'shadow': 'False',
    'allow_last_semicolon': 'True',
    'es_version': 3,
    'allow_latedef': 'no_func',
    'javascript_strictness': 'False'}


JSHintBearTest = verify_local_bear(JSHintBear,
                                   valid_files=(),
                                   invalid_files=(test_file1, test_file2,
                                                  test_file3))


JSHintBearConfigFileTest = verify_local_bear(
    JSHintBear,
    valid_files=(test_file1,),
    invalid_files=(test_file2,),
    settings={'jshint_config': jshintconfig})


JSHintBearCoafileTest = verify_local_bear(
    JSHintBear,
    invalid_files=(),
    valid_files=(test_file3, ),
    settings=settings)
Exemplo n.º 50
0
test_file = """
test
too
er
e
"""

invalid_general_file = 'C' * (79 + 1)

invalid_VB_file = 'C' * (65535 + 1)


LineLengthBearTest = verify_local_bear(LineLengthBear,
                                       valid_files=(test_file,),
                                       invalid_files=('testa',
                                                      'test line'),
                                       settings={'max_line_length': '4'})


LineLengthBearIgnoreRegexTest = verify_local_bear(
    LineLengthBear,
    valid_files=(test_file,
                 'http://a.domain.de',
                 'ftp://a.domain.de',
                 'hi there ftp://!'),
    invalid_files=('http not a link',),
    settings={
        'max_line_length': '4',
        'ignore_length_regex': 'http://, https://, ftp://'})
Exemplo n.º 51
0
                            'False. Consider using autoescape=True to '
                            'mitigate XSS vulnerabilities.',
                            get_testfile_path('jinja2_templating.py'), 15,
                            end_line=16, severity=RESULT_SEVERITY.MAJOR,
                            confidence=90)])

# The following test will ignore some error codes, so "good" and "bad" doesn't
# reflect the actual code quality.
good_files = ('good_file.py', 'assert.py')
bad_files = ('exec-py2.py', 'httpoxy_cgihandler.py', 'jinja2_templating.py',
             'skip.py')
skipped_error_codes = ['B105', 'B106', 'B107', 'B404', 'B606', 'B607', 'B101']

BanditBearSkipErrorCodesTest1 = verify_local_bear(
    BanditBear,
    valid_files=tuple(load_testfile(file) for file in good_files),
    invalid_files=tuple(load_testfile(file) for file in bad_files),
    settings={'bandit_skipped_tests': ','.join(skipped_error_codes)},
    tempfile_kwargs={'suffix': '.py'})


good_files = ('good_file.py',)
bad_files = ('exec-py2.py', 'httpoxy_cgihandler.py', 'jinja2_templating.py',
             'skip.py', 'assert.py')

BanditBearSkipErrorCodesTest2 = verify_local_bear(
    BanditBear,
    valid_files=tuple(load_testfile(file) for file in good_files),
    invalid_files=tuple(load_testfile(file) for file in bad_files),
    settings={'bandit_skipped_tests': ''},
    tempfile_kwargs={'suffix': '.py'})
Exemplo n.º 52
0
from tests.test_bears.TestBearDep import (TestDepBearBDependsA,
                                          TestDepBearCDependsB,
                                          TestDepBearDependsAAndAA)
from coalib.bearlib.abstractions.Linter import linter
from tests.test_bears.LineCountTestBear import LineCountTestBear
from coala_utils.ContextManagers import prepare_file
from coalib.results.Result import Result
from coalib.results.RESULT_SEVERITY import RESULT_SEVERITY
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting
from coalib.testing.LocalBearTestHelper import verify_local_bear, execute_bear
from coalib.testing.LocalBearTestHelper import LocalBearTestHelper as Helper

files = ('Everything is invalid/valid/raises error', )
invalidTest = verify_local_bear(TestBear,
                                valid_files=(),
                                invalid_files=files,
                                settings={'result': True})
validTest = verify_local_bear(TestBear, valid_files=files, invalid_files=())


class LocalBearCheckResultsTest(Helper):
    def setUp(self):
        section = Section('')
        section.append(Setting('result', 'a, b'))
        self.uut = TestBear(section, Queue())

    def test_order_ignored(self):
        self.check_results(self.uut, ['a', 'b'], ['b', 'a'], check_order=False)

    def test_require_order(self):
        with self.assertRaises(AssertionError):
Exemplo n.º 53
0
from bears.matlab.MatlabIndentationBear import MatlabIndentationBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

MatlabIndentationBearTest = verify_local_bear(
    MatlabIndentationBear,
    valid_files=("if a ~= b\n  a\nendif\n", "if a ~= b\n  a\nendif\n", "if a ~= b\n  a\n  \nelse\n  a\nendif\n"),
    invalid_files=(
        "  A",
        "if a ~= b\na\nendif\n",
        "if a ~= b\n a\nendif\n",
        "if a ~= b\n a\nendif\n",
        "if a ~= b\n  a\n  else\n  a\nendif\n",
    ),
)
bad_max_line_length = """---
receipt: Oz-Ware This line-length is beyond 50 chars
..."""

config_file = """
extends:
    default
rules:
    colons:
      max-spaces-after: -1
    indentation: disable
    empty-lines: disable
"""

YAMLLintBear1Test = verify_local_bear(YAMLLintBear,
                                      valid_files=(),
                                      invalid_files=(test_file, ))

with prepare_file(config_file,
                  filename=None,
                  force_linebreaks=True,
                  create_tempfile=True) as (conf_lines, conf_file):
    YAMLLintBear2Test = verify_local_bear(
        YAMLLintBear,
        valid_files=(test_file, ),
        invalid_files=(),
        settings={'yamllint_config': conf_file})

YAMLLintBear3Test = verify_local_bear(YAMLLintBear,
                                      valid_files=(
                                          no_start_yaml_file,
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(x)  # <-- here everything is fine\n"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 0
}
"""

PEP8NotebookBearTest = \
    verify_local_bear(PEP8NotebookBear,
                      valid_files=(good_file,),
                      invalid_files=(bad_file,)
                      )

PEP8NotebookBearWithoutTrailingNewlineTest = \
    verify_local_bear(PEP8NotebookBear,
                      valid_files=(good_file[:-1],),
                      invalid_files=(bad_file[:-1],),
                      force_linebreaks=False,
                      )
import unittest
from queue import Queue
from coalib.settings.Section import Section
from bears.jinja2.Jinja2Bear import Jinja2Bear
from coalib.testing.LocalBearTestHelper import verify_local_bear, execute_bear

Jinja2BearVariableSpacingTest = verify_local_bear(
    Jinja2Bear,
    valid_files=(r'foo {{ var }}', r'foo {{ var1|filter }} bar {{ var2 }}'),
    invalid_files=(r'foo {{var }}', r'foo {{ var}} bar', r'{{  var }}',
                   r'{{ good_var }} foo {{bad_var }}'))

Jinja2BearCustomVariableSpacingTest = verify_local_bear(
    Jinja2Bear,
    valid_files=(r'foo {{var}}', r'foo {{var1|filter}} bar {{var2}}'),
    invalid_files=(r'foo {{ var }}', r'foo {{ var}} bar', r'{{  var }}'),
    settings={'variable_spacing': '0'})


class Jinja2BearSpacingDiffTest(unittest.TestCase):
    def setUp(self):
        self.uut = Jinja2Bear(Section(''), Queue())

    def test_variable_spacing(self):
        content = (r'foo {{var }} bar', )
        with execute_bear(self.uut, 'F', content) as result:
            self.assertEqual(
                result[0].diffs['F'].unified_diff, '--- \n'
                '+++ \n'
                '@@ -1 +1 @@\n'
                '-foo {{var }} bar\n'
Exemplo n.º 57
0
import unittest
from queue import Queue
from coalib.settings.Section import Section
from bears.jinja2.Jinja2Bear import Jinja2Bear
from coalib.testing.LocalBearTestHelper import verify_local_bear, execute_bear


Jinja2BearVariableSpacingTest = verify_local_bear(
    Jinja2Bear,
    valid_files=(r'foo {{ var }}',
                 r'foo {{ var1|filter }} bar {{ var2 }}'),
    invalid_files=(r'foo {{var }}',
                   r'foo {{ var}} bar',
                   r'{{  var }}',
                   r'{{ good_var }} foo {{bad_var }}'))

Jinja2BearCustomVariableSpacingTest = verify_local_bear(
    Jinja2Bear,
    valid_files=(r'foo {{var}}',
                 r'foo {{var1|filter}} bar {{var2}}'),
    invalid_files=(r'foo {{ var }}',
                   r'foo {{ var}} bar',
                   r'{{  var }}'),
    settings={'variable_spacing': '0'})


class Jinja2BearSpacingDiffTest(unittest.TestCase):

    def setUp(self):
        self.uut = Jinja2Bear(Section(''), Queue())
Exemplo n.º 58
0
    </head>
    <body>

        <button>No type set</button>
        <div>
          <div class="panel-body">
            <p>Something</p>
          </div>
        </div>

        <div id="qunit"></div>
        <ol id="bootlint">
          <li data-lint="Found one or more `<button>`s
           missing a `type` attribute."></li>
        </ol>
    </body>
</html>
"""
# There's a missing type in <button> tag, missing DOCTYPE
# and panel has no body.

BootLintBearTest = verify_local_bear(BootLintBear,
                                     valid_files=(good_file,),
                                     invalid_files=(bad_file,))

BootLintBearDisableTest = verify_local_bear(
    BootLintBear,
    valid_files=(good_file, bad_file),
    invalid_files=(),
    settings={'bootlint_ignore': 'W001,W007,E001,E023'})
Exemplo n.º 59
0
from bears.ruby.RuboCopBear import RuboCopBear
from coalib.testing.LocalBearTestHelper import verify_local_bear

good_file = """def good_name
  test if something
end
"""

bad_file = """def badName
  test if something
end
"""


RuboCopBearTest = verify_local_bear(RuboCopBear,
                                    invalid_files=(bad_file,),
                                    valid_files=(good_file,))

# Testing Config
rubocop_config = os.path.join(os.path.dirname(__file__),
                              'test_files',
                              'rubocop_config.yaml')


# bad file becomes good and vice-versa
RuboCopBearConfigFileTest = verify_local_bear(
                                RuboCopBear,
                                valid_files=(bad_file,),
                                invalid_files=(good_file,),
                                settings={'rubocop_config': rubocop_config})
dtd_file_path = get_testfile_path('note.dtd')
schema_file_path = get_testfile_path('note.xsd')
relaxng_file_path = get_testfile_path('note.rng')

valid_xml_path = load_testdata('note.xml')
valid_xml_url = load_testdata('concept-valid.xml')
invalid_xml_schema = load_testdata('xsd-error.xml')
invalid_xml_dtd = load_testdata('dtd-error.xml')
invalid_xml_relaxng = load_testdata('rng-error.xml')
invalid_xml_url = load_testdata('concept-invalid.xml')

dtd_url = 'http://docs.oasis-open.org/dita/v1.0.1/dtd/concept.dtd'

XMLBearCorrectedTest = verify_local_bear(XMLBear,
                                         valid_files=(valid_xml_file,
                                                      valid_xml_chars),
                                         invalid_files=(invalid_xml_file,
                                                        invalid_xml_chars),
                                         tempfile_kwargs={'suffix': '.xml'})

XMLBearSchemaTest = verify_local_bear(
    XMLBear,
    valid_files=(valid_xml_path, ),
    invalid_files=(invalid_xml_schema, ),
    settings={'xml_schema': escape(schema_file_path, '\\')},
    tempfile_kwargs={'suffix': '.xml'})

XMLBearDTDPathTest = verify_local_bear(
    XMLBear,
    valid_files=(valid_xml_path, ),
    invalid_files=(invalid_xml_dtd, ),
    settings={'xml_dtd': escape(dtd_file_path, '\\')},