def test_parse_with_aliases(self):
"""Test if a set of aliases is created after parsing"""
aliases = {
'label': 'tag',
'label2': 'tag',
'newdate': 'from_date',
'from_date': 'tag',
'notfound': 'backend_token'
}
parser = BackendCommandArgumentParser(from_date=True, aliases=aliases)
args = ['--tag', 'test', '--from-date', '2015-01-01']
parsed_args = parser.parse(*args)
expected_dt = datetime.datetime(2015,
1,
1,
0,
0,
tzinfo=dateutil.tz.tzutc())
self.assertIsInstance(parsed_args, argparse.Namespace)
self.assertEqual(parsed_args.tag, 'test')
self.assertEqual(parsed_args.from_date, expected_dt)
# Check aliases
self.assertEqual(parsed_args.label, 'test')
self.assertEqual(parsed_args.label2, 'test')
self.assertEqual(parsed_args.newdate, expected_dt)
self.assertNotIn('notfound', parsed_args)
def test_incompatible_fetch_archive_and_no_archive(self):
"""Test if fetch-archive and no-archive arguments are incompatible"""
args = ['--fetch-archive', '--no-archive']
parser = BackendCommandArgumentParser(archive=True)
with self.assertRaises(AttributeError):
_ = parser.parse(*args)
def test_fetch_archive_needs_category(self):
"""Test if fetch-archive needs a category"""
args = ['--fetch-archive']
parser = BackendCommandArgumentParser(archive=True)
with self.assertRaises(AttributeError):
_ = parser.parse(*args)
def test_parse_default_args(self):
"""Test if the default configured arguments are parsed"""
args = ['--tag', 'test']
parser = BackendCommandArgumentParser()
parsed_args = parser.parse(*args)
self.assertIsInstance(parsed_args, argparse.Namespace)
self.assertEqual(parsed_args.tag, 'test')
def test_incompatible_date_and_offset(self):
"""Test if date and offset arguments are incompatible"""
with self.assertRaises(AttributeError):
_ = BackendCommandArgumentParser(from_date=True, offset=True)
with self.assertRaises(AttributeError):
_ = BackendCommandArgumentParser(to_date=True, offset=True)
with self.assertRaises(AttributeError):
_ = BackendCommandArgumentParser(from_date=True,
to_date=True,
offset=True)
def test_parse_auth_args(self):
"""Test if the authtentication arguments are parsed"""
args = ['-u', 'jsmith', '-p', '1234', '-t', 'abcd']
parser = BackendCommandArgumentParser(basic_auth=True, token_auth=True)
parsed_args = parser.parse(*args)
self.assertIsInstance(parsed_args, argparse.Namespace)
self.assertEqual(parsed_args.user, 'jsmith')
self.assertEqual(parsed_args.password, '1234')
self.assertEqual(parsed_args.api_token, 'abcd')
def test_parse_cache_args(self):
"""Test if the authtentication arguments are parsed"""
args = ['--cache-path', '/tmp/cache', '--clean-cache', '--fetch-cache']
parser = BackendCommandArgumentParser(cache=True)
parsed_args = parser.parse(*args)
self.assertIsInstance(parsed_args, argparse.Namespace)
self.assertEqual(parsed_args.cache_path, '/tmp/cache')
self.assertEqual(parsed_args.clean_cache, True)
self.assertEqual(parsed_args.fetch_cache, True)
self.assertEqual(parsed_args.no_cache, False)
def test_parse_offset_arg(self):
"""Test if offset parameter is parsed"""
parser = BackendCommandArgumentParser(offset=True)
# Check default value
args = []
parsed_args = parser.parse(*args)
self.assertEqual(parsed_args.offset, 0)
# Check argument
args = ['--offset', '88']
parsed_args = parser.parse(*args)
self.assertEqual(parsed_args.offset, 88)
def setup_cmd_parser():
parser = BackendCommandArgumentParser(from_date=True,
archive=False)
parser.parser.add_argument('origin')
parser.parser.add_argument('--subtype', dest='subtype')
return parser
def setup_cmd_parser():
parser = BackendCommandArgumentParser(from_date=True,
basic_auth=True,
token_auth=True,
cache=True)
parser.parser.add_argument('origin')
return parser
def test_parse_date_args(self):
"""Test if date parameters are parsed"""
parser = BackendCommandArgumentParser(from_date=True, to_date=True)
# Check default value
args = []
parsed_args = parser.parse(*args)
self.assertEqual(parsed_args.from_date, DEFAULT_DATETIME)
self.assertEqual(parsed_args.to_date, None)
# Check argument 'from-date'
args = ['--from-date', '2015-01-01']
parsed_args = parser.parse(*args)
expected = datetime.datetime(2015,
1,
1,
0,
0,
tzinfo=dateutil.tz.tzutc())
self.assertEqual(parsed_args.from_date, expected)
self.assertEqual(parsed_args.to_date, None)
# Invalid 'from-date'
args = ['--from-date', 'asdf']
with self.assertRaises(InvalidDateError):
parsed_args = parser.parse(*args)
# Check argument 'to-date'
args = ['--to-date', '2016-01-01']
parsed_args = parser.parse(*args)
expected_dt = datetime.datetime(2016,
1,
1,
0,
0,
tzinfo=dateutil.tz.tzutc())
self.assertEqual(parsed_args.from_date, DEFAULT_DATETIME)
self.assertEqual(parsed_args.to_date, expected_dt)
# Invalid 'to-date'
args = ['--to-date', 'asdf']
with self.assertRaises(InvalidDateError):
parsed_args = parser.parse(*args)
# Check both arguments
args = ['--from-date', '2015-01-01', '--to-date', '2016-01-01']
parsed_args = parser.parse(*args)
self.assertEqual(parsed_args.from_date, expected)
self.assertEqual(parsed_args.to_date, expected_dt)
def test_parse_archive_args(self):
"""Test if achiving arguments are parsed"""
args = ['--archive-path', '/tmp/archive',
'--fetch-archive',
'--archived-since', '2016-01-01',
'--category', 'mocked']
parser = BackendCommandArgumentParser(archive=True)
parsed_args = parser.parse(*args)
expected_dt = datetime.datetime(2016, 1, 1, 0, 0,
tzinfo=dateutil.tz.tzutc())
self.assertIsInstance(parsed_args, argparse.Namespace)
self.assertEqual(parsed_args.archive_path, '/tmp/archive')
self.assertEqual(parsed_args.fetch_archive, True)
self.assertEqual(parsed_args.no_archive, False)
self.assertEqual(parsed_args.archived_since, expected_dt)
def setup_cmd_parser():
"""Returns the MozillaClub argument parser."""
parser = BackendCommandArgumentParser(cache=True)
# Required arguments
parser.parser.add_argument('url', nargs='?',
default=MOZILLA_CLUB_URL,
help="MozillaClub URL")
return parser
def setup_cmd_parser():
"""Returns the Kitsune argument parser."""
parser = BackendCommandArgumentParser(offset=True, cache=True)
# Required arguments
parser.parser.add_argument(
'url',
nargs='?',
default="https://support.mozilla.org",
help="Kitsune URL (default: https://support.mozilla.org)")
return parser
def setup_cmd_parser():
"""Returns the Launchpad argument parser."""
parser = BackendCommandArgumentParser(from_date=True,
cache=False,
token_auth=True)
# Optional arguments
group = parser.parser.add_argument_group('Crates.io arguments')
group.add_argument('--sleep-time',
dest='sleep_time',
help="Sleep time in case of connection lost")
group.add_argument('--category',
default=CRATES_CATEGORY,
choices=(CRATES_CATEGORY, SUMMARY_CATEGORY),
help="category of items to fecth")
return parser
def setup_cmd_parser():
"""Returns the ReMo argument parser."""
parser = BackendCommandArgumentParser(offset=True, cache=True)
# ReMo options
group = parser.parser.add_argument_group('ReMo arguments')
group.add_argument(
'--category',
default='events',
help="category could be events, activities or users")
# Required arguments
parser.parser.add_argument(
'url',
nargs='?',
default="https://reps.mozilla.org",
help="ReMo URL (default: https://reps.mozilla.org)")
return parser
def setup_cmd_parser(cls):
"""Returns the Gitee argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND,
from_date=True,
to_date=True,
token_auth=False,
archive=True,
ssl_verify=True)
# Gitee options
group = parser.parser.add_argument_group('Gitee arguments')
group.add_argument('--sleep-for-rate', dest='sleep_for_rate',
action='store_true',
help="sleep for getting more rate")
group.add_argument('--min-rate-to-sleep', dest='min_rate_to_sleep',
default=MIN_RATE_LIMIT, type=int,
help="sleep until reset when the rate limit reaches this value")
# Gitee token(s)
group.add_argument('-t', '--api-token', dest='api_token',
nargs='+',
default=[],
help="list of Gitee API tokens")
# Generic client options
group.add_argument('--max-items', dest='max_items',
default=MAX_CATEGORY_ITEMS_PER_PAGE, type=int,
help="Max number of category items per query.")
group.add_argument('--max-retries', dest='max_retries',
default=MAX_RETRIES, type=int,
help="number of API call retries")
group.add_argument('--sleep-time', dest='sleep_time',
default=DEFAULT_SLEEP_TIME, type=int,
help="sleeping time between API call retries")
# Positional arguments
parser.parser.add_argument('owner',
help="Gitee owner")
parser.parser.add_argument('repository',
help="Gitee repository")
return parser
def test_remove_empty_category(self):
"""Test whether category argument is removed when no value is given"""
args = []
parser = BackendCommandArgumentParser(archive=True)
parsed_args = parser.parse(*args)
with self.assertRaises(AttributeError):
_ = parsed_args.category
# An empty string is parsed
args = ['--category', '']
parser = BackendCommandArgumentParser(archive=True)
parsed_args = parser.parse(*args)
self.assertEqual(parsed_args.category, '')
def setup_cmd_parser():
"""Returns the Graal argument parser."""
parser = BackendCommandArgumentParser(from_date=True, to_date=True)
# Optional arguments
group = parser.parser.add_argument_group('Git arguments')
group.add_argument('--branches', dest='branches',
nargs='+', type=str, default=None,
help="Fetch commits only from these branches")
group.add_argument('--latest-items', dest='latest_items',
action='store_true',
help="Fetch latest commits added to the repository")
group.add_argument('--worktree-path', dest='worktreepath',
default=DEFAULT_WORKTREE_PATH,
help="Path where to save the working tree")
group.add_argument('--in-paths', dest='in_paths',
nargs='+', type=str, default=None,
help="Target paths of the analysis")
group.add_argument('--out-paths', dest='out_paths',
nargs='+', type=str, default=None,
help="Paths to be excluded from the analysis")
group.add_argument('--entrypoint', dest='entrypoint',
type=str, default=None,
help="Entrypoint of the analysis")
group.add_argument('--details', dest='details',
action='store_true', default=False,
help="include details")
# Required arguments
parser.parser.add_argument('uri',
help="URI of the Git log repository")
parser.parser.add_argument('--git-path', dest='git_path',
help="Path where the Git repository will be cloned")
return parser
def test_argument_parser(self):
"""Test if an argument parser object is created on initialization"""
parser = BackendCommandArgumentParser()
self.assertIsInstance(parser.parser, argparse.ArgumentParser)
