示例#1
0
 def setUp(self):
     array_test, list_test = 'arrayParsing_test', 'listParsing_test'
     text_test, global_test = 'textParsing_test', 'global_test'
     array_error_test, array_error_test2 = 'arrayParsing_error_test', 'arrayParsing_error2_test'
     my_template = "{{hostname}}\n{{VLAN_error}}\n{{VLAN_error2}}\n{{VLAN}}\n{{VLAN!((VLAN!104:Name)):Gateway}}"
     self.workbook = dict()
     self.workbook['VLAN'] = ArrayParsing(
         get_sheet_test(array_test + '.xlsx'))
     self.workbook['VLAN_error'] = ArrayParsing(
         get_sheet_test(array_error_test + '.xlsx'))
     self.workbook['VLAN_error2'] = ArrayParsing(
         get_sheet_test(array_error_test2 + '.xlsx'))
     self.workbook[list_test] = ListParsing(
         get_sheet_test(list_test + '.xlsx'))
     self.workbook[text_test] = TextParsing(
         get_sheet_test(text_test + '.xlsx'))
     self.workbook['Global'] = ArrayParsing(
         get_sheet_test(global_test + '.xlsx'))
     self.equipment = Equipment('HOST1', my_template, self.workbook)
     self.equipment.unresolved = 1
     self.equipment.resolved = 2
示例#2
0
def main(excel_file, template_file, directory):
    wb = get_excel_workbook(excel_file)
    sheet_names = wb.sheet_names()
    workbook = dict()
    template = open_file(template_file)

    for sheet in sheet_names:
        xl_sheet = wb.sheet_by_name(sheet)
        if (xl_sheet.cell(0, 0).value == 'Function' and
                xl_sheet.cell(0, 1).value == 'Variable' and
                xl_sheet.cell(0, 2).value == 'Value'):
            workbook[sheet] = ListParsing(xl_sheet)
        elif xl_sheet.cell(0, 0).value == 'Text':
            workbook[sheet] = TextParsing(xl_sheet)
        elif sheet == 'Interfaces':
            workbook[sheet] = Interface(xl_sheet)
        else:
            workbook[sheet] = ArrayParsing(xl_sheet)

    if not directory:
        directory = os.path.dirname(template_file)
    is_directory = False
    version_number = 1
    while is_directory is False:
        directory_name = ''.join(['scripts-', os.path.splitext(os.path.basename(excel_file))[0], '-v',
                                  str(version_number)])
        if os.path.isdir(os.path.join(directory, directory_name)) is False:
            directory = os.path.join(directory, directory_name)
            os.mkdir(directory)
            is_directory = True
        version_number += 1
    list_of_equipments = list()
    for hostname in workbook['Global'].get_all_indexes():
        equipment = Equipment(hostname, template, workbook)
        list_of_equipments.append(equipment)
        equipment.save_script_as(directory, hostname)
示例#3
0
 def setUp(self):
     self.sheet = ListParsing(get_sheet_test('listParsing_test.xlsx'))
示例#4
0
class ListParsingTests(TestCase):
    def setUp(self):
        self.sheet = ListParsing(get_sheet_test('listParsing_test.xlsx'))

    def test_get_value_by_bag_and_key(self):
        values = list()
        self.assertListEqual(
            self.sheet.get_value_by_bag_and_key('Administrative', 'Code Site'),
            values)

    def test_get_value_by_bag_and_key_and_index(self):
        expected = '45'
        got = self.sheet.get_value_by_bag_and_key_and_index(
            'Administrative', 'Num Site', 1)
        self.assertEqual(expected, got)

    def test_get_value_by_bag_and_key_and_index_failed(self):
        try:
            expected = IndexError
            got = self.sheet.get_value_by_bag_and_key_and_index(
                'Administrative', 'Num Site', 5)
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_param_by_index_failed(self):
        try:
            expected = KeyError
            got = self.sheet.get_value_by_bag_and_key('invalid_bag',
                                                      'invalid_key')
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_set_value_by_bag_and_key(self):
        bag, key, updated_value = 'DNS', 'DNS Server', '1.1.1.1'
        expected = list()
        expected.append(updated_value)
        self.sheet.set_value_by_bag_and_key(bag, key, 1, updated_value)
        got = self.sheet.get_value_by_bag_and_key(bag, key)
        self.assertListEqual(expected, got)

    def test_set_value_by_bag_and_key_failed(self):
        try:
            bag, key, updated_value = '000', 'Gateway', '1.1.1.1'
            expected = KeyError
            got = self.sheet.set_value_by_bag_and_key(bag, key, 0,
                                                      updated_value)
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_all_keys_by_bag(self):
        expected = ['Radius Server 1', 'Radius Server 2']
        got = sorted(self.sheet.get_all_keys_by_bag('Authentication'))
        self.assertListEqual(expected, got)

    def test_get_all_keys_by_bag_failed(self):
        try:
            expected = KeyError('invalid_bag')
            got = self.sheet.get_all_keys_by_bag('invalid_bag')
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_all_keys(self):
        expected = [
            'Code Site', 'Num Site', 'AS Number', 'DNS Domain-name',
            'DNS Server', 'DNS Server 2', 'DHCP Relay 1', 'DHCP Relay 2',
            '123', 'Radius Server 1', 'Radius Server 2'
        ]
        expected = sorted(expected)
        got = sorted(self.sheet.get_all_keys())
        self.assertListEqual(expected, got)

    def test_get_value_by_key(self):
        expected = list()
        expected.append('65845')
        got = self.sheet.get_value_by_key('AS Number')
        self.assertListEqual(expected, got)

    def test_get_value_by_key_failed(self):
        try:
            expected = KeyError
            got = self.sheet.get_value_by_key('invalid_key')
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_set_value_by_key(self):
        key, index, updated_value = 'Radius Server 1', 1, '1.1.1.1'
        expected = list()
        expected.append(updated_value)
        self.sheet.set_value_by_key(key, index, updated_value)
        got = self.sheet.get_value_by_key(key)
        self.assertListEqual(expected, got)

    def test_set_value_by_key_failed(self):
        try:
            expected = KeyError
            got = self.sheet.set_value_by_key('invalid_key', 1, '1.1.1.1')
            self.assertRaises(expected, got)
        except KeyError:
            pass
 def setUp(self):
     self.sheet = ListParsing(get_sheet_test("listParsing_test.xlsx"))
class ListParsingTests(TestCase):
    def setUp(self):
        self.sheet = ListParsing(get_sheet_test("listParsing_test.xlsx"))

    def test_get_value_by_bag_and_key(self):
        values = list()
        self.assertListEqual(self.sheet.get_value_by_bag_and_key("Administrative", "Code Site"), values)

    def test_get_value_by_bag_and_key_and_index(self):
        expected = "45"
        got = self.sheet.get_value_by_bag_and_key_and_index("Administrative", "Num Site", 1)
        self.assertEqual(expected, got)

    def test_get_value_by_bag_and_key_and_index_failed(self):
        try:
            expected = IndexError
            got = self.sheet.get_value_by_bag_and_key_and_index("Administrative", "Num Site", 5)
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_param_by_index_failed(self):
        try:
            expected = KeyError
            got = self.sheet.get_value_by_bag_and_key("invalid_bag", "invalid_key")
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_set_value_by_bag_and_key(self):
        bag, key, updated_value = "DNS", "DNS Server", "1.1.1.1"
        expected = list()
        expected.append(updated_value)
        self.sheet.set_value_by_bag_and_key(bag, key, 1, updated_value)
        got = self.sheet.get_value_by_bag_and_key(bag, key)
        self.assertListEqual(expected, got)

    def test_set_value_by_bag_and_key_failed(self):
        try:
            bag, key, updated_value = "000", "Gateway", "1.1.1.1"
            expected = KeyError
            got = self.sheet.set_value_by_bag_and_key(bag, key, 0, updated_value)
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_all_keys_by_bag(self):
        expected = ["Radius Server 1", "Radius Server 2"]
        got = sorted(self.sheet.get_all_keys_by_bag("Authentication"))
        self.assertListEqual(expected, got)

    def test_get_all_keys_by_bag_failed(self):
        try:
            expected = KeyError("invalid_bag")
            got = self.sheet.get_all_keys_by_bag("invalid_bag")
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_get_all_keys(self):
        expected = [
            "Code Site",
            "Num Site",
            "AS Number",
            "DNS Domain-name",
            "DNS Server",
            "DNS Server 2",
            "DHCP Relay 1",
            "DHCP Relay 2",
            "123",
            "Radius Server 1",
            "Radius Server 2",
        ]
        expected = sorted(expected)
        got = sorted(self.sheet.get_all_keys())
        self.assertListEqual(expected, got)

    def test_get_value_by_key(self):
        expected = list()
        expected.append("65845")
        got = self.sheet.get_value_by_key("AS Number")
        self.assertListEqual(expected, got)

    def test_get_value_by_key_failed(self):
        try:
            expected = KeyError
            got = self.sheet.get_value_by_key("invalid_key")
            self.assertRaises(expected, got)
        except KeyError:
            pass

    def test_set_value_by_key(self):
        key, index, updated_value = "Radius Server 1", 1, "1.1.1.1"
        expected = list()
        expected.append(updated_value)
        self.sheet.set_value_by_key(key, index, updated_value)
        got = self.sheet.get_value_by_key(key)
        self.assertListEqual(expected, got)

    def test_set_value_by_key_failed(self):
        try:
            expected = KeyError
            got = self.sheet.set_value_by_key("invalid_key", 1, "1.1.1.1")
            self.assertRaises(expected, got)
        except KeyError:
            pass