def test_with_urls(self):
with_urls_args = ['--with-urls']
args = self.parser.parse_args(with_urls_args)
output_fields = get_output_fields(args)
self.assertNotEquals(output_fields, list(DEFAULT_OUTPUT_FIELDS))
self.assertIn('URL', output_fields)
def test_with_empty_args(self):
empty_args = []
args = self.parser.parse_args(empty_args)
table = create_licenses_table(args)
self.assertIn('l', table.align.values())
self.assertFalse(table.border)
self.assertTrue(table.header)
self.assertEqual('+', table.junction_char)
self.assertEqual(RULE_FRAME, table.hrules)
output_fields = get_output_fields(args)
self.assertEqual(output_fields, list(DEFAULT_OUTPUT_FIELDS))
self.assertNotIn('Author', output_fields)
self.assertNotIn('URL', output_fields)
pkg_name_columns = self._create_pkg_name_columns(table)
for sys_pkg in SYSTEM_PACKAGES:
self.assertNotIn(sys_pkg, pkg_name_columns)
sortby = get_sortby(args)
self.assertEqual('Name', sortby)
output_string = create_output_string(args)
self.assertNotIn('<table>', output_string)
def test_with_description(self):
with_description_args = ['--with-description']
args = self.parser.parse_args(with_description_args)
output_fields = get_output_fields(args)
self.assertNotEquals(output_fields, list(DEFAULT_OUTPUT_FIELDS))
self.assertIn('Description', output_fields)
def test_with_authors(self):
with_authors_args = ['--with-authors']
args = self.parser.parse_args(with_authors_args)
output_fields = get_output_fields(args)
self.assertNotEqual(output_fields, list(DEFAULT_OUTPUT_FIELDS))
self.assertIn('Author', output_fields)
output_string = create_output_string(args)
self.assertIn('Author', output_string)
def test_from_classifier(self):
from_classifier_args = ['--from=classifier']
args = self.parser.parse_args(from_classifier_args)
table = create_licenses_table(args)
output_fields = get_output_fields(args)
self.assertIn('License', output_fields)
license_columns = self._create_license_columns(table)
license_notation_as_classifier = 'MIT License'
self.assertIn(license_notation_as_classifier, license_columns)
def test_from_meta(self):
from_args = ['--from=meta']
args = self.parser.parse_args(from_args)
output_fields = get_output_fields(args)
self.assertIn('License', output_fields)
table = create_licenses_table(args, output_fields)
license_columns = self._create_license_columns(table, output_fields)
license_notation_as_meta = 'MIT'
self.assertIn(license_notation_as_meta, license_columns)
def test_from_mixed(self):
from_classifier_args = ['--from=mixed']
args = self.parser.parse_args(from_classifier_args)
table = create_licenses_table(args)
output_fields = get_output_fields(args)
self.assertIn('License', output_fields)
license_columns = self._create_license_columns(table)
# Depending on the condition "MIT" or "BSD" etc.
license_notation_as_classifier = 'MIT License'
self.assertIn(license_notation_as_classifier, license_columns)
def test_with_license_file(self):
with_license_file_args = ['--with-license-file']
args = self.parser.parse_args(with_license_file_args)
output_fields = get_output_fields(args)
self.assertNotEqual(output_fields, list(DEFAULT_OUTPUT_FIELDS))
self.assertIn('LicenseFile', output_fields)
self.assertIn('LicenseText', output_fields)
output_string = create_output_string(args)
self.assertIn('LicenseFile', output_string)
self.assertIn('LicenseText', output_string)
def test_from_all(self):
from_args = ['--from=all']
args = self.parser.parse_args(from_args)
output_fields = get_output_fields(args)
table = create_licenses_table(args, output_fields)
self.assertIn('License-Metadata', output_fields)
self.assertIn('License-Classifier', output_fields)
index_license_meta = output_fields.index('License-Metadata')
license_meta = []
for row in table._rows:
license_meta.append(row[index_license_meta])
index_license_classifier = output_fields.index('License-Classifier')
license_classifier = []
for row in table._rows:
license_classifier.append(row[index_license_classifier])
for license in ('BSD', 'MIT', 'Apache 2.0'):
self.assertIn(license, license_meta)
for license in ('BSD License', 'MIT License',
'Apache Software License'):
self.assertIn(license, license_classifier)
