class UnitsDisplayTests(unittest.TestCase):
def setUp(self):
super(UnitsDisplayTests, self).setUp()
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False, output=self.recorder, record_tags=True)
def test_display_modules_zero_count(self):
# Test
units_display.display_modules(self.prompt, [], 10)
# Verify
self.assertEqual(['too-few'], self.prompt.get_write_tags())
def test_display_modules_over_threshold(self):
# Test
copied_modules = self._generate_copied_modules(10)
units_display.display_modules(self.prompt, copied_modules, 5)
# Verify
self.assertEqual(['too-many'], self.prompt.get_write_tags())
self.assertTrue('10' in self.recorder.lines[0])
def test_display_modules_show_modules(self):
# Test
copied_modules = self._generate_copied_modules(2)
# Reverse here so we can check the sort takes place in the method
copied_modules.sort(key=lambda x : x['unit_key']['author'], reverse=True)
units_display.display_modules(self.prompt, copied_modules, 10)
# Verify
expected_tags = ['just-enough', 'module', 'module'] # header + one line for each module
self.assertEqual(expected_tags, self.prompt.get_write_tags())
self.assertTrue('Modules' in self.recorder.lines[0])
# Verify the sorting was done
self.assertTrue('0' in self.recorder.lines[1])
self.assertTrue('1' in self.recorder.lines[2])
def _generate_copied_modules(self, count):
"""
Returns a list of the given size representing modules as they would be handed to
the display method.
"""
modules = []
for i in range(0, count):
unit_key = {
'author' : 'author-%s' % i,
'name' : 'name-%s' % i,
'version' : 'version-%s' % i,
}
modules.append({'type_id' : constants.TYPE_PUPPET_MODULE,
'unit_key' : unit_key})
return modules
def setUp(self):
super(UnitsDisplayTests, self).setUp()
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False,
output=self.recorder,
record_tags=True)
def setUp(self):
super(PulpClientTests, self).setUp()
self.config = SafeConfigParser()
config_filename = os.path.join(DATA_DIR, 'test-override-client.conf')
self.config = Config(config_filename)
self.server_mock = mock.Mock()
self.pulp_connection = PulpConnection('',
server_wrapper=self.server_mock)
self.bindings = Bindings(self.pulp_connection)
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False,
output=self.recorder,
record_tags=True)
self.logger = logging.getLogger('pulp')
self.exception_handler = ExceptionHandler(self.prompt, self.config)
self.context = ClientContext(self.bindings, self.config, self.logger,
self.prompt, self.exception_handler)
self.cli = PulpCli(self.context)
self.context.cli = self.cli
def _create_prompt(config):
"""
@return: prompt instance to pass throughout the UI
@rtype: PulpPrompt
"""
enable_color = config.parse_bool(config['output']['enable_color'])
if config.parse_bool(config['output']['wrap_to_terminal']):
wrap = WIDTH_TERMINAL
else:
wrap = int(config['output']['wrap_width'])
prompt = PulpPrompt(enable_color=enable_color, wrap_width=wrap)
return prompt
def setUp(self):
TestCase.setUp(self)
self.config = SafeConfigParser()
path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'data',
'client.conf')
self.config = Config(path)
self.server_mock = mock.Mock()
self.pulp_connection = \
PulpConnection('', server_wrapper=self.server_mock)
self.bindings = Bindings(self.pulp_connection)
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False,
output=self.recorder,
record_tags=True)
self.logger = logging.getLogger('pulp')
self.exception_handler = ExceptionHandler(self.prompt, self.config)
self.context = ClientContext(self.bindings, self.config, self.logger,
self.prompt, self.exception_handler)
self.cli = PulpCli(self.context)
self.context.cli = self.cli
def setUp(self):
super(UnitsDisplayTests, self).setUp()
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False, output=self.recorder, record_tags=True)
def setUp(self):
super(ExtensionLoaderTests, self).setUp()
self.prompt = PulpPrompt()
self.cli = PulpCli(self.prompt)
self.context = ClientContext(None, None, None, self.prompt, None, cli=self.cli)
class UnitsDisplayTests(unittest.TestCase):
def setUp(self):
super(UnitsDisplayTests, self).setUp()
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False, output=self.recorder, record_tags=True)
def test_display_units_zero_count(self):
# Test
units_display.display_units(self.prompt, [], 10)
# Verify
self.assertEqual(['too-few'], self.prompt.get_write_tags())
def test_display_units_over_threshold(self):
# Test
copied_modules = self._generate_errata(7)
units_display.display_units(self.prompt, copied_modules, 2)
# Verify
expected_tags = ['summary', 'count-entry']
self.assertEqual(expected_tags, self.prompt.get_write_tags())
self.assertTrue('7' in self.recorder.lines[1])
def test_display_units_mixed(self):
# Setup
units = self._generate_packages(1, TYPE_ID_RPM) + \
self._generate_packages(1, TYPE_ID_SRPM) + \
self._generate_errata(1) + \
self._generate_distributions(1) + \
self._generate_drpms(1) + \
self._generate_package_category(1) + \
self._generate_package_groups(1)
# Test
units_display.display_units(self.prompt, units, 100)
# Verify
expected_tags = ['header']
for i in sorted([TYPE_ID_DISTRO, TYPE_ID_DRPM, TYPE_ID_ERRATA, TYPE_ID_PKG_CATEGORY,
TYPE_ID_PKG_GROUP, TYPE_ID_RPM, TYPE_ID_SRPM]):
expected_tags.append('type-header-%s' % i)
expected_tags.append('unit-entry-%s' % i)
self.assertEqual(expected_tags, self.prompt.get_write_tags())
def test_display_units_sort_units(self):
# Setup
units = self._generate_packages(10, TYPE_ID_RPM) # will be in descending order
# Test
units_display.display_units(self.prompt, units, 100)
# Verify they were written out in ascending order
for i in range(1, 10):
self.assertTrue(str(i) in self.recorder.lines[i + 1])
def test_display_distribution(self):
# Setup
units = self._generate_distributions(1)
# Test
units_display.display_units(self.prompt, units, 100)
# ensure that only the "id" of a distribution is being displayed
self.assertEqual(self.recorder.lines[1].strip(), units[0]['unit_key']['id'])
# -- utilities ------------------------------------------------------------------------------------------
def _generate_packages(self, count, type_id):
packages = []
for i in range(count, 0, -1):
unit_key = {
'name' : 'name-%s' % i,
'epoch' : 'epoch-%s' % i,
'version' : 'version-%s' % i,
'release' : 'release-%s' % i,
'arch' : 'arch-%s' % i,
}
packages.append({'type_id' : type_id, 'unit_key' : unit_key})
return packages
def _generate_drpms(self, count):
drpms = []
for i in range(count, 0, -1):
unit_key = {
'epoch' : 'epoch-%s' % i,
'version' : 'version-%s' % i,
'release' : 'release-%s' % i,
'filename' : 'filename-%s' % i,
}
drpms.append({'type_id' : TYPE_ID_DRPM, 'unit_key' : unit_key})
return drpms
def _generate_distributions(self, count):
distros = []
for i in range(count, 0, -1):
unit_args = {
'version' : 'version-%s' % i,
'arch' : 'arch-%s' % i,
'variant' : 'variant-%s' % i,
'family' : 'family-%s' % i,
}
distro = models.Distribution(metadata={}, **unit_args)
distros.append({'type_id' : TYPE_ID_DISTRO, 'unit_key' : distro.unit_key})
return distros
def _generate_errata(self, count):
errata = []
for i in range(count, 0, -1):
unit_key = {'id' : 'id-%s' % i}
errata.append({'type_id' : TYPE_ID_ERRATA, 'unit_key' : unit_key})
return errata
def _generate_package_groups(self, count):
groups = []
for i in range(count, 0, -1):
unit_key = {'id' : 'id-%s' % i}
groups.append({'type_id' : TYPE_ID_PKG_GROUP, 'unit_key' : unit_key})
return groups
def _generate_package_category(self, count):
categories = []
for i in range(count, 0, -1):
unit_key = {'id' : 'id-%s' % i}
categories.append({'type_id' : TYPE_ID_PKG_CATEGORY, 'unit_key' : unit_key})
return categories
class UnitsDisplayTests(unittest.TestCase):
def setUp(self):
super(UnitsDisplayTests, self).setUp()
# Disabling color makes it easier to grep results since the character codes aren't there
self.recorder = okaara.prompt.Recorder()
self.prompt = PulpPrompt(enable_color=False,
output=self.recorder,
record_tags=True)
def test_display_modules_zero_count(self):
# Test
units_display.display_modules(self.prompt, [], 10)
# Verify
self.assertEqual(['too-few'], self.prompt.get_write_tags())
def test_display_modules_over_threshold(self):
# Test
copied_modules = self._generate_copied_modules(10)
units_display.display_modules(self.prompt, copied_modules, 5)
# Verify
self.assertEqual(['too-many'], self.prompt.get_write_tags())
self.assertTrue('10' in self.recorder.lines[0])
def test_display_modules_show_modules(self):
# Test
copied_modules = self._generate_copied_modules(2)
# Reverse here so we can check the sort takes place in the method
copied_modules.sort(key=lambda x: x['unit_key']['author'],
reverse=True)
units_display.display_modules(self.prompt, copied_modules, 10)
# Verify
expected_tags = ['just-enough', 'module',
'module'] # header + one line for each module
self.assertEqual(expected_tags, self.prompt.get_write_tags())
self.assertTrue('Modules' in self.recorder.lines[0])
# Verify the sorting was done
self.assertTrue('0' in self.recorder.lines[1])
self.assertTrue('1' in self.recorder.lines[2])
def _generate_copied_modules(self, count):
"""
Returns a list of the given size representing modules as they would be handed to
the display method.
"""
modules = []
for i in range(0, count):
unit_key = {
'author': 'author-%s' % i,
'name': 'name-%s' % i,
'version': 'version-%s' % i,
}
modules.append({
'type_id': constants.TYPE_PUPPET_MODULE,
'unit_key': unit_key
})
return modules
