"""

SoftLayer.tests.CLI.formatting_table_tests

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

:license: MIT, see LICENSE for more details.

"""

from rich.console import Console

from SoftLayer.CLI import exceptions

from SoftLayer.CLI import formatting

from SoftLayer import testing

class TestTable(testing.TestCase):

def test_table_with_duplicated_columns(self):

self.assertRaises(exceptions.CLIHalt, formatting.Table, ['col', 'col'])

def test_boolean_table(self):

table = formatting.Table(["column1"], title="Test Title")

self.assertFalse(table)

table.add_row(["entry1"])

self.assertTrue(table)

def test_key_value_table(self):

expected = """┌───────────┬─────────────────────────┐

│ Key │ Value │

├───────────┼─────────────────────────┤

│ First │ One │

│ Sub Table │ ┌─────────┬───────────┐ │

│ │ │ Sub Key │ Sub Value │ │

│ │ ├─────────┼───────────┤ │

│ │ │ Second │ Two │ │

│ │ └─────────┴───────────┘ │

└───────────┴─────────────────────────┘

"""

table = formatting.KeyValueTable(["Key", "Value"])

table.add_row(["First", "One"])

sub_table = formatting.KeyValueTable(["Sub Key", "Sub Value"])

sub_table.add_row(["Second", "Two"])

table.add_row(["Sub Table", sub_table])

console = Console()

with console.capture() as capture:

to_print = formatting.format_output(table)

console.print(to_print)

result = capture.get()

self.assertEqual(expected, result)

def test_key_value_table_empty(self):

expected = """┌────────┬───────┐

│ name │ value │

├────────┼───────┤

│ table2 │ - │

└────────┴───────┘

"""

table1 = formatting.KeyValueTable(["name", "value"])

table2 = formatting.Table(["one", "two", "three"])

table1.add_row(["table2", table2])

result = formatting.format_output(table1, "table")

console = Console()

with console.capture() as capture:

to_print = formatting.format_output(table1)

console.print(to_print)

result = capture.get()

self.assertEqual(expected, result)

def test_unrenderable_recovery_table(self):

expected = """│ Sub Table │ [<rich.table.Table object at"""

table = formatting.KeyValueTable(["Key", "Value"])

table.add_row(["First", "One"])

sub_table = formatting.KeyValueTable(["Sub Key", "Sub Value"])

sub_table.add_row(["Second", "Two"])

# You can't have a list of tables, that isn't handled very well.

listable = [sub_table]

table.add_row(["Sub Table", listable])

console = Console()

with console.capture() as capture:

to_print = formatting.format_output(table)

console.print(to_print)

result = capture.get()

print(result)

self.assertIn(expected, result)

class IterToTableTests(testing.TestCase):

def test_format_api_dict(self):

result = formatting._format_dict({'key': 'value'})

self.assertIsInstance(result, formatting.Table)

self.assertEqual(result.columns, ['name', 'value'])

self.assertEqual(result.rows, [['key', 'value']])

def test_format_api_list(self):

result = formatting._format_list([{'key': 'value'}])

self.assertIsInstance(result, formatting.Table)

self.assertEqual(result.columns, ['key'])

self.assertEqual(result.rows, [['value']])

def test_format_api_list_non_objects(self):

result = formatting._format_list(['a', 'b', 'c'])

self.assertIsInstance(result, formatting.Table)

self.assertEqual(result.columns, ['value'])

self.assertEqual(result.rows, [['a'], ['b'], ['c']])

def test_format_api_list_with_none_value(self):

result = formatting._format_list([{'key': [None, 'value']}, None])

self.assertIsInstance(result, formatting.Table)

self.assertEqual(result.columns, ['key'])

def test_format_api_list_with_empty_array(self):

result = formatting.iter_to_table([{'id': 130224450, 'activeTickets': []}])

self.assertIsInstance(result, formatting.Table)

self.assertIn('id', result.columns)

self.assertIn('activeTickets', result.columns)

formatted = formatting.format_output(result, "table")

# No good ways to test whats actually in a Rich.Table without going through the hassel of

# printing it out. As long as this didn't throw and exception it should be fine.

self.assertEqual(formatted.row_count, 1)