def test_filter_bears_ci_mode(self):
sys.argv.append('--ci')
with bear_test_module():
languages = []
res_1 = filter_relevant_bears(
languages, self.printer, self.arg_parser, {})
res_2 = []
with generate_files(context_filenames,
context_file_contents,
self.project_dir):
with simulate_console_inputs("Yes") as generator:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
# Make sure there was no prompt
self.assertEqual(generator.last_input, -1)
# The NonOptionalSettingBear is not selected due to non-optional
# setting value in non-interactive mode.
additional_bears_by_lang = {
"All": []
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
def test_filter_relevant_bears_with_non_optional_settings(self):
sys.argv.append('--no-filter-by-capabilities')
with bear_test_module():
languages = []
res_1 = filter_relevant_bears(
languages, self.printer, self.arg_parser, {})
# results with extracted information
res_2 = []
with generate_files(context_filenames,
context_file_contents,
self.project_dir):
with simulate_console_inputs("Yes") as generator:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
self.assertEqual(generator.last_input, 0)
# Comparing both the scenarios
additional_bears_by_lang = {
"All": ["NonOptionalSettingBear"]
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
# Simulating the situation when user rejects the bear
res_2 = []
with generate_files(context_filenames,
context_file_contents,
self.project_dir):
with simulate_console_inputs(
"Some random text which will not be accepted",
"No") as generator:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
self.assertEqual(generator.last_input, 1)
# This time there will be no additional bears
additional_bears_by_lang = {
"All": []
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
def test_filter_relevant_bears_with_non_optional_settings(self):
sys.argv.append('--no-filter-by-capabilities')
with bear_test_module():
languages = []
res_1 = filter_relevant_bears(
languages, self.printer, self.arg_parser, {})
# results with extracted information
res_2 = []
with generate_files(context_filenames,
context_file_contents,
self.project_dir):
with simulate_console_inputs("Yes") as generator:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
self.assertEqual(generator.last_input, 0)
# Comparing both the scenarios
additional_bears_by_lang = {
"All": ["NonOptionalSettingBear"]
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
# Simulating the situation when user rejects the bear
res_2 = []
with generate_files(context_filenames,
context_file_contents,
self.project_dir):
with simulate_console_inputs(
"Some random text which will not be accepted",
"No") as generator:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
self.assertEqual(generator.last_input, 1)
# This time there will be no additional bears
additional_bears_by_lang = {
"All": []
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
def test_filter_relevant_bears_with_capabilities(self):
# Clear the IMPORTANT_BEARS_LIST
import coala_quickstart.generation.Bears as Bears
Bears.IMPORTANT_BEARS_LIST = {}
with bear_test_module():
languages = []
capability_to_select = 'Smell'
cap_number = (
sorted(ALL_CAPABILITIES).index(capability_to_select) + 1)
res = []
with simulate_console_inputs('1000', str(cap_number)) as generator:
res = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
{})
# 1000 was not a valid option, so there will be two prompts
self.assertEqual(generator.last_input, 1)
expected_results = {
"All": set(["SmellCapabilityBear"])
}
for lang, lang_bears in expected_results.items():
for bear in lang_bears:
res_bears = [b.name for b in res[lang]]
self.assertIn(bear, res_bears)
def test_filter_relevant_bears_green_mode(self):
from argparse import Namespace
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
self.arg_parser.parse_args = unittest.mock.MagicMock(
return_value=Namespace(green_mode=True))
res = filter_relevant_bears([('Python', 70), ('C', 20)],
self.printer,
self.arg_parser,
{})
all_bears = get_filtered_bears(['Python', 'C'])[0]
bears = all_bears['cli']
important_bears = []
for bear_set in list(IMPORTANT_BEAR_LIST.values()):
for bear in bear_set:
important_bears.append(bear)
bear_objs = []
for bear in bears:
if bear.__name__ in important_bears:
bear_objs.append(bear)
bear_obj_dict = dict()
for key in ['Python', 'C', 'All']:
bear_obj_dict[key] = set()
for bear in IMPORTANT_BEAR_LIST[key]:
if bear in GREEN_MODE_INCOMPATIBLE_BEAR_LIST:
continue
bear_obj_dict[key].update([x for x in bear_objs if (
x.__name__ == bear)])
self.maxDiff = None
self.assertEqual(res, bear_obj_dict)
def test_allow_complete_section_mode_with_ignore_globs(self):
project_dir = "/repo"
project_files = ['/repo/hello.html']
ignore_globs = ["/repo/style.css"]
used_languages = list(get_used_languages(project_files))
relevant_bears = filter_relevant_bears(
used_languages, self.printer, self.arg_parser, {})
res = generate_settings(
project_dir, project_files, ignore_globs, relevant_bears, {}, True)
bears_list = res["all.HTML"]["bears"].value.replace(" ", "").split(",")
files_list = res["all.HTML"]["files"].value.replace(" ", "").split(",")
self.assertEqual(
['HTMLLintBear', 'coalaBear', 'BootLintBear',
'LicenseCheckBear', 'SpaceConsistencyBear', 'KeywordBear',
'LineLengthBear', 'DuplicateFileBear'].sort(),
bears_list.sort())
ignore_file = str(os.path.normpath(self.path_leaf(
str(res["all"]["ignore"]))))
self.assertEqual(['**.html'], files_list)
self.assertEqual('style.css', ignore_file)
def test_filter_relevant_bears_simple(self):
res = filter_relevant_bears([('Python', 70), ('C', 20)], self.printer,
self.arg_parser, {})
self.assertIn("C", res)
self.assertIn("Python", res)
self.assertTrue(len(res["C"]) > 0)
self.assertTrue(len(res["Python"]) > 0)
def main():
arg_parser = _get_arg_parser()
args = arg_parser.parse_args()
printer = ConsolePrinter()
log_printer = LogPrinter(printer)
project_dir = os.getcwd()
if not args.non_interactive:
print_welcome_message(printer)
project_dir = ask_question("What is your project directory?",
default=project_dir,
typecast=valid_path)
project_files, ignore_globs = get_project_files(log_printer, printer,
project_dir)
used_languages = list(get_used_languages(project_files))
print_used_languages(printer, used_languages)
relevant_bears = filter_relevant_bears(used_languages, arg_parser)
print_relevant_bears(printer, relevant_bears)
if args.non_interactive:
unusable_bears = get_non_optional_settings_bears(relevant_bears)
remove_unusable_bears(relevant_bears, unusable_bears)
print_relevant_bears(printer, relevant_bears, 'usable')
settings = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears)
write_coafile(printer, project_dir, settings)
def test_filter_relevant_bears_green_mode(self):
from argparse import Namespace
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
self.arg_parser.parse_args = unittest.mock.MagicMock(
return_value=Namespace(green_mode=True))
res = filter_relevant_bears([('Python', 70), ('C', 20)],
self.printer,
self.arg_parser,
{})
all_bears = get_filtered_bears(['Python', 'C'])[0]
bears = all_bears['cli']
important_bears = []
for bear_set in list(IMPORTANT_BEAR_LIST.values()):
for bear in bear_set:
important_bears.append(bear)
bear_objs = []
for bear in bears:
if bear.__name__ in important_bears:
bear_objs.append(bear)
bear_obj_dict = dict()
for key in ['Python', 'C', 'All']:
bear_obj_dict[key] = set()
for bear in IMPORTANT_BEAR_LIST[key]:
if bear in GREEN_MODE_INCOMPATIBLE_BEAR_LIST:
continue
bear_obj_dict[key].update([x for x in bear_objs if (
x.__name__ == bear)])
self.maxDiff = None
self.assertEqual(res, bear_obj_dict)
def test_filter_relevant_bears_with_capabilities(self):
# Clear the IMPORTANT_BEARS_LIST
import coala_quickstart.generation.Bears as Bears
Bears.IMPORTANT_BEARS_LIST = {}
with bear_test_module():
languages = []
capability_to_select = 'Smell'
cap_number = (
sorted(ALL_CAPABILITIES).index(capability_to_select) + 1)
res = []
with simulate_console_inputs('1000', str(cap_number)) as generator:
res = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
{})
# 1000 was not a valid option, so there will be two prompts
self.assertEqual(generator.last_input, 1)
expected_results = {
"All": set(["SmellCapabilityBear"])
}
for lang, lang_bears in expected_results.items():
for bear in lang_bears:
res_bears = [b.name for b in res[lang]]
self.assertIn(bear, res_bears)
def test_filter_relevant_bears_gruntfile_present(self):
# Reset the IMPORTANT_BEARS_LIST
import coala_quickstart.generation.Bears as Bears
Bears.IMPORTANT_BEARS_LIST = {
"JavaScript": "DoesNotExistBear",
"Python": "DoesNotExistAsWellBear"
}
sys.argv.append('--no-filter-by-capabilities')
with bear_test_module():
languages = [('JavaScript', 70), ('Python', 20)]
res = {}
with generate_files(["Gruntfile.js"],
[gruntfile],
self.project_dir) as gen_files:
extracted_info = collect_info(self.project_dir)
res = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
expected_results = {
"JavaScript": set(["SomeLinterBear"]),
}
for lang, lang_bears in expected_results.items():
for bear in lang_bears:
res_bears = [b.name for b in res[lang]]
self.assertIn(bear, res_bears)
def test_print_relevant_bears(self):
with retrieve_stdout() as custom_stdout:
print_relevant_bears(
self.printer,
filter_relevant_bears([('Python', 70), ('Unknown', 30)],
self.printer, self.arg_parser, {}))
self.assertIn("PycodestyleBear", custom_stdout.getvalue())
def test_filter_relevant_bears_gruntfile_present(self):
# Reset the IMPORTANT_BEARS_LIST
import coala_quickstart.generation.Bears as Bears
Bears.IMPORTANT_BEARS_LIST = {
"JavaScript": "DoesNotExistBear",
"Python": "DoesNotExistAsWellBear"
}
sys.argv.append('--no-filter-by-capabilities')
with bear_test_module():
languages = [('JavaScript', 70), ('Python', 20)]
res = {}
with generate_files(["Gruntfile.js"], [gruntfile],
self.project_dir) as gen_files:
extracted_info = collect_info(self.project_dir)
res = filter_relevant_bears(languages, self.printer,
self.arg_parser, extracted_info)
expected_results = {
"JavaScript": set(["SomeLinterBear"]),
}
for lang, lang_bears in expected_results.items():
for bear in lang_bears:
res_bears = [b.name for b in res[lang]]
self.assertIn(bear, res_bears)
def test_filter_relevant_bears_simple(self):
res = filter_relevant_bears([('Python', 70), ('C', 20)],
self.printer,
self.arg_parser,
{})
self.assertIn("C", res)
self.assertIn("Python", res)
self.assertTrue(len(res["C"]) > 0)
self.assertTrue(len(res["Python"]) > 0)
def test_filter_relevant_bears_with_extracted_info(self):
# results without extracted information
languages = [('JavaScript', 70), ('Ruby', 20)]
res_1 = filter_relevant_bears(
languages, self.printer, self.arg_parser, {})
for lang, _ in languages:
self.assertIn(lang, res_1)
self.assertTrue(len(res_1[lang]) > 0)
# results with extracted information
res_2 = []
# FIXME: Create and use Test bears with
# ``TestUtilites.bear_test_module`` instead of running
# tests on actual bears in coala-bears package.
with generate_files(context_filenames,
context_file_contents,
self.project_dir) as gen_files:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
for lang, _ in languages:
self.assertIn(lang, res_2)
self.assertTrue(len(res_2[lang]) > 0)
# Comparing both the scenarios
# The following dict has list of bears that have their requirements
# caputred by `ProjectDependencyInfo` from the dependency files
# but are not part of the `IMPORTANT_BEARS_LIST` in Constants.py
additional_bears_by_lang = {
"JavaScript": ["ESLintBear", "HappinessLintBear"],
"Ruby": [],
"All": []
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
def test_filter_relevant_bears_with_extracted_info(self):
# results without extracted information
languages = [('JavaScript', 70), ('Ruby', 20)]
res_1 = filter_relevant_bears(
languages, self.printer, self.arg_parser, {})
for lang, _ in languages:
self.assertIn(lang, res_1)
self.assertTrue(len(res_1[lang]) > 0)
# results with extracted information
res_2 = []
# FIXME: Create and use Test bears with
# ``TestUtilites.bear_test_module`` instead of running
# tests on actual bears in coala-bears package.
with generate_files(context_filenames,
context_file_contents,
self.project_dir) as gen_files:
extracted_info = collect_info(self.project_dir)
res_2 = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
extracted_info)
for lang, _ in languages:
self.assertIn(lang, res_2)
self.assertTrue(len(res_2[lang]) > 0)
# Comparing both the scenarios
# The following dict has list of bears that have their requirements
# caputred by `ProjectDependencyInfo` from the dependency files
# but are not part of the `IMPORTANT_BEARS_LIST` in Constants.py
additional_bears_by_lang = {
"JavaScript": ["ESLintBear", "HappinessLintBear"],
"Ruby": [],
"All": []
}
for lang in res_1:
additional_bears = [bear.name for bear in res_2[lang]
if bear not in res_1[lang]]
for bear in additional_bears_by_lang[lang]:
self.assertIn(bear, additional_bears)
def test_bears_no_filter_by_capability_mode(self):
languages = []
with bear_test_module():
# Results without filtering
sys.argv.append('--no-filter-by-capabilities')
res = []
with simulate_console_inputs() as generator:
res = filter_relevant_bears(languages, self.printer,
self.arg_parser, {})
self.assertEqual(generator.last_input, -1)
self.assertEqual(res, {"All": set()})
def main():
arg_parser = _get_arg_parser()
args = arg_parser.parse_args()
logging.basicConfig(stream=sys.stdout)
printer = ConsolePrinter()
logging.getLogger(__name__)
fpc = None
project_dir = os.getcwd()
if args.green_mode:
args.non_interactive = None
args.no_filter_by_capabilities = None
args.incomplete_sections = None
if not args.non_interactive and not args.green_mode:
fpc = FilePathCompleter()
fpc.activate()
print_welcome_message(printer)
printer.print(PROJECT_DIR_HELP)
project_dir = ask_question('What is your project directory?',
default=project_dir,
typecast=valid_path)
fpc.deactivate()
project_files, ignore_globs = get_project_files(None, printer, project_dir,
fpc, args.non_interactive)
used_languages = list(get_used_languages(project_files))
print_used_languages(printer, used_languages)
extracted_information = collect_info(project_dir)
relevant_bears = filter_relevant_bears(used_languages, printer, arg_parser,
extracted_information)
if args.green_mode:
collect_bear_settings(relevant_bears)
print_relevant_bears(printer, relevant_bears)
if args.non_interactive and not args.incomplete_sections:
unusable_bears = get_non_optional_settings_bears(relevant_bears)
remove_unusable_bears(relevant_bears, unusable_bears)
print_relevant_bears(printer, relevant_bears, 'usable')
settings = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears, extracted_information,
args.incomplete_sections)
write_coafile(printer, project_dir, settings)
def test_bears_no_filter_by_capability_mode(self):
languages = []
with bear_test_module():
# Results without filtering
sys.argv.append('--no-filter-by-capabilities')
res = []
with simulate_console_inputs() as generator:
res = filter_relevant_bears(languages,
self.printer,
self.arg_parser,
{})
self.assertEqual(generator.last_input, -1)
self.assertEqual(res, {"All": set()})
def test_filter_relevant_bears_green_mode(self):
from argparse import Namespace
invalid_bears = ['DocGrammarBear', 'DocumentationStyleBear']
self.arg_parser.parse_args = unittest.mock.MagicMock(
return_value=Namespace(green_mode=True))
res = filter_relevant_bears([('Python', 70), ('C', 20)], self.printer,
self.arg_parser, {})
for lang in res:
result = list(
filter(
lambda x: next((False for bear in invalid_bears
if bear in str(x)), True),
list(res[lang])))
to_compare = list(
filter(lambda x: lang in x.LANGUAGES, get_all_bears()))
self.assertCountEqual(result, to_compare)
def main():
printer = ConsolePrinter()
log_printer = LogPrinter(printer)
print_welcome_message(printer)
project_dir = ask_question("What is your project directory?",
default=os.getcwd(),
typecast=valid_path)
project_files, ignore_globs = get_project_files(log_printer, printer,
project_dir)
used_languages = list(get_used_languages(project_files))
print_used_languages(printer, used_languages)
relevant_bears = filter_relevant_bears(used_languages)
print_relevant_bears(printer, relevant_bears)
settings = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears)
write_coafile(printer, project_dir, settings)
def test_allow_complete_section_mode(self):
project_dir = "/repo"
project_files = ['/repo/hello.html']
ignore_globs = []
used_languages = list(get_used_languages(project_files))
relevant_bears = filter_relevant_bears(used_languages)
res = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears, True)
bears_list = res["HTML"]["bears"].value.replace(" ", "").split(",")
files_list = res["HTML"]["files"].value.replace(" ", "").split(",")
self.assertEqual([
'HTMLLintBear', 'coalaBear', 'BootLintBear', 'LicenseCheckBear',
'SpaceConsistencyBear', 'KeywordBear', 'LineLengthBear',
'DuplicateFileBear'
].sort(), bears_list.sort())
self.assertEqual(['**.html'], files_list)
def main():
global MAX_ARGS_GREEN_MODE, MAX_VALUES_GREEN_MODE
arg_parser = _get_arg_parser()
args = arg_parser.parse_args()
logging.basicConfig(stream=sys.stdout)
printer = ConsolePrinter()
logging.getLogger(__name__)
fpc = None
project_dir = os.getcwd()
if args.green_mode:
args.no_filter_by_capabilities = None
args.incomplete_sections = None
if args.max_args:
MAX_ARGS_GREEN_MODE = args.max_args
if args.max_values:
MAX_VALUES_GREEN_MODE = args.max_values
if not args.green_mode and (args.max_args or args.max_values):
logging.warning(' --max-args and --max-values can be used '
'only with --green-mode. The arguments will '
'be ignored.')
if not args.non_interactive and not args.green_mode:
fpc = FilePathCompleter()
fpc.activate()
print_welcome_message(printer)
printer.print(PROJECT_DIR_HELP)
project_dir = ask_question('What is your project directory?',
default=project_dir,
typecast=valid_path)
fpc.deactivate()
project_files, ignore_globs = get_project_files(None, printer, project_dir,
fpc, args.non_interactive)
used_languages = list(get_used_languages(project_files))
used_languages = ask_to_select_languages(used_languages, printer,
args.non_interactive)
extracted_information = collect_info(project_dir)
relevant_bears = filter_relevant_bears(used_languages, printer, arg_parser,
extracted_information)
if args.green_mode:
bear_settings_obj = collect_bear_settings(relevant_bears)
green_mode(
project_dir,
ignore_globs,
relevant_bears,
bear_settings_obj,
MAX_ARGS_GREEN_MODE,
MAX_VALUES_GREEN_MODE,
project_files,
printer,
)
exit()
print_relevant_bears(printer, relevant_bears)
if args.non_interactive and not args.incomplete_sections:
unusable_bears = get_non_optional_settings_bears(relevant_bears)
remove_unusable_bears(relevant_bears, unusable_bears)
print_relevant_bears(printer, relevant_bears, 'usable')
settings = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears, extracted_information,
args.incomplete_sections)
write_coafile(printer, project_dir, settings)
def test_print_relevant_bears(self):
with retrieve_stdout() as custom_stdout:
print_relevant_bears(self.printer, filter_relevant_bears(
[('Python', 70), ('Unknown', 30)], self.printer,
self.arg_parser, {}))
self.assertIn("PycodestyleBear", custom_stdout.getvalue())
def main():
global MAX_ARGS_GREEN_MODE, MAX_VALUES_GREEN_MODE
arg_parser = _get_arg_parser()
args = arg_parser.parse_args()
logging.basicConfig(stream=sys.stdout)
printer = ConsolePrinter()
logging.getLogger(__name__)
fpc = None
project_dir = os.getcwd()
if args.green_mode:
args.no_filter_by_capabilities = None
args.incomplete_sections = None
if args.max_args:
MAX_ARGS_GREEN_MODE = args.max_args
if args.max_values:
MAX_VALUES_GREEN_MODE = args.max_values
if not args.green_mode and (args.max_args or args.max_values):
logging.warning(' --max-args and --max-values can be used '
'only with --green-mode. The arguments will '
'be ignored.')
if not args.non_interactive and not args.green_mode:
fpc = FilePathCompleter()
fpc.activate()
print_welcome_message(printer)
printer.print(PROJECT_DIR_HELP)
project_dir = ask_question(
'What is your project directory?',
default=project_dir,
typecast=valid_path)
fpc.deactivate()
project_files, ignore_globs = get_project_files(
None,
printer,
project_dir,
fpc,
args.non_interactive)
used_languages = list(get_used_languages(project_files))
used_languages = ask_to_select_languages(used_languages, printer,
args.non_interactive)
extracted_information = collect_info(project_dir)
relevant_bears = filter_relevant_bears(
used_languages, printer, arg_parser, extracted_information)
if args.green_mode:
bear_settings_obj = collect_bear_settings(relevant_bears)
green_mode(
project_dir, ignore_globs, relevant_bears, bear_settings_obj,
MAX_ARGS_GREEN_MODE,
MAX_VALUES_GREEN_MODE,
project_files,
printer,
)
exit()
print_relevant_bears(printer, relevant_bears)
if args.non_interactive and not args.incomplete_sections:
unusable_bears = get_non_optional_settings_bears(relevant_bears)
remove_unusable_bears(relevant_bears, unusable_bears)
print_relevant_bears(printer, relevant_bears, 'usable')
settings = generate_settings(
project_dir,
project_files,
ignore_globs,
relevant_bears,
extracted_information,
args.incomplete_sections)
write_coafile(printer, project_dir, settings)
def test_filter_relevant_bears(self):
res = filter_relevant_bears([('Python', 70), ('C', 20)])
self.assertIn("C", res)
self.assertIn("Python", res)
self.assertTrue(len(res["C"]) > 0)
self.assertTrue(len(res["Python"]) > 0)
