Esempio n. 1
0
 def test_addinterfaces_invalid(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[6])
     v.create()
     with self.assertRaises(AttributeError) as e:
         v.add_interfaces("asdfg")
     self.assertEqual("'str' object has no attribute 'name'",
                      str(e.exception))
     v.delete()
Esempio n. 2
0
 def test_addinterfaces_repeated(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[8])
     v.create()
     fc1 = Fc(switch=self.switch, name=self.fc_name[7])
     pc = PortChannel(self.switch, self.pc_id[5])
     pc.create()
     v.add_interfaces([fc1, fc1, fc1, fc1])
     self.assertEqual(fc1.name, v.interfaces[0].name)
     pc.delete()
     v.delete()
Esempio n. 3
0
 def test_addinterfaces_nonexistingvsan(self):
     i = self.vsan_id[7]
     v = Vsan(switch=self.switch, id=i)
     if v.id is not None:
         v.delete()
     with self.assertRaises(VsanNotPresent) as e:
         v.add_interfaces([Fc(switch=self.switch, name=self.fc_name[6])])
     self.assertEqual(
         "VsanNotPresent: Vsan " + str(i) +
         " is not present on the switch.", str(e.exception))
 def test_interfaces_read(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[0])
     v.create()
     fc = [
         Fc(switch=self.switch, name=self.fc_name[0]),
         Fc(switch=self.switch, name=self.fc_name[1])
     ]
     v.add_interfaces(fc)
     self.assertEqual(self.fc_name[0], v.interfaces[0].name)
     self.assertEqual(self.fc_name[1], v.interfaces[1].name)
     v.delete()
Esempio n. 5
0
 def test_addinterfaces_portchannelnotpresent(self):
     i = self.vsan_id[9]
     v = Vsan(switch=self.switch, id=i)
     v.create()
     pc = PortChannel(self.switch, self.pc_id[6])
     with self.assertRaises(CLIError) as e:
         v.add_interfaces([pc])
     self.assertEqual(
         'The command " vsan database ; vsan ' + str(i) +
         ' interface port-channel' + str(self.pc_id[6]) +
         ' " gave the error " Invalid range ".', str(e.exception))
     v.delete()
Esempio n. 6
0
 def test_addinterfaces_type_error(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[0])
     v.create()
     fc = Fc(switch=self.switch, name=self.fc_name[0])
     with self.assertRaises(TypeError) as e:
         v.add_interfaces(fc)
     self.assertEqual("'Fc' object is not iterable", str(e.exception))
     pc = PortChannel(self.switch, self.pc_id[0])
     with self.assertRaises(TypeError) as e:
         v.add_interfaces(pc)
     self.assertEqual("'PortChannel' object is not iterable",
                      str(e.exception))
     v.delete()
Esempio n. 7
0
 def test_addinterfaces_fc_invalid(self):
     i = self.vsan_id[5]
     v = Vsan(switch=self.switch, id=i)
     v.create()
     for name in self.invalid_fc:
         with self.assertRaises(CLIError) as e:
             fc = Fc(switch=self.switch, name=name)
             v.add_interfaces([fc])
         self.assertEqual(
             'The command " vsan database ; vsan ' + str(i) +
             ' interface ' + str(name) +
             ' " gave the error " Invalid interface format ".',
             str(e.exception))
     v.delete()
Esempio n. 8
0
 def test_addinterfaces_splitlist(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[3])
     v.create()
     fc1 = Fc(switch=self.switch, name=self.fc_name[2])
     fc2 = Fc(switch=self.switch, name=self.fc_name[3])
     pc = PortChannel(self.switch, self.pc_id[2])
     pc.create()
     v.add_interfaces([fc1])
     v.add_interfaces([fc2])
     v.add_interfaces([pc])
     self.assertEqual(fc1.name, v.interfaces[0].name)
     self.assertEqual(fc2.name, v.interfaces[1].name)
     self.assertEqual(pc.name, v.interfaces[2].name)
     pc.delete()
     v.delete()
Esempio n. 9
0
 def test_addinterfaces(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[1])
     v.create()
     fc = Fc(switch=self.switch, name=self.fc_name[1])
     v.add_interfaces([fc])
     self.assertEqual(fc.name, v.interfaces[0].name)
     v.delete()
     v = Vsan(switch=self.switch, id=self.vsan_id[2])
     v.create()
     pc = PortChannel(self.switch, self.pc_id[1])
     pc.create()
     v.add_interfaces([pc])
     self.assertEqual(pc.name, v.interfaces[0].name)
     pc.delete()
     v.delete()
Esempio n. 10
0
 def test_addinterfaces_list(self):
     v = Vsan(switch=self.switch, id=self.vsan_id[4])
     v.create()
     fc1 = Fc(switch=self.switch, name=self.fc_name[4])
     fc2 = Fc(switch=self.switch, name=self.fc_name[5])
     pc4 = PortChannel(self.switch, self.pc_id[3])
     pc5 = PortChannel(self.switch, self.pc_id[4])
     pc4.create()
     pc5.create()
     l = [fc1, fc2, pc4, pc5]
     v.add_interfaces(l)
     self.assertEqual(fc1.name, v.interfaces[0].name)
     self.assertEqual(fc2.name, v.interfaces[1].name)
     self.assertEqual(pc4.name, v.interfaces[2].name)
     self.assertEqual(pc5.name, v.interfaces[3].name)
     pc4.delete()
     pc5.delete()
     v.delete()
Esempio n. 11
0
class TestVsanAddInterfaces(unittest.TestCase):
    def __init__(self, testName, sw):
        super().__init__(testName)
        self.switch = sw

    def setUp(self) -> None:
        log.debug(self.switch.version)
        log.debug(self.switch.ipaddr)
        self.vsandb = self.switch.vsans
        while True:
            self.id = get_random_id()
            if self.id not in self.vsandb.keys():
                break
        self.v = Vsan(switch=self.switch, id=self.id)
        self.fc = self.vsandb[1].interfaces[1]  ## fc interface from vsan 1
        self.interfaces = self.switch.interfaces
        while True:
            self.pc_id = get_random_id(1, 256)
            if "port-channel" + str(self.pc_id) not in self.interfaces.keys():
                break
        self.pc = PortChannel(self.switch, self.pc_id)
        self.invalid_fc = Fc(
            self.switch,
            "fc48/48")  ## matches fc pattern but is not present on switch

    def test_addinterfaces_type_error(self):
        self.v.create()
        with self.assertRaises(TypeError) as e:
            self.v.add_interfaces(self.fc)
        self.assertIn("object is not iterable", str(e.exception))
        self.v.delete()

    def test_addinterfaces(self):
        self.v.create()
        self.pc.create()
        self.v.add_interfaces([self.fc, self.pc])
        self.assertEqual(self.fc.name, self.v.interfaces[0].name)
        self.assertEqual(self.pc.name, self.v.interfaces[1].name)
        self.pc.delete()
        self.v.delete()

    def test_addinterfaces_fc_invalid(self):
        self.v.create()
        with self.assertRaises(CLIError) as e:
            self.v.add_interfaces([self.invalid_fc])
        self.assertIn("Invalid interface format", str(e.exception))
        self.v.delete()

    def test_addinterfaces_invalid(self):
        self.v.create()
        with self.assertRaises(AttributeError) as e:
            self.v.add_interfaces("asdfg")
        self.assertEqual("'str' object has no attribute 'name'",
                         str(e.exception))
        self.v.delete()

    def test_addinterfaces_nonexistingvsan(self):
        with self.assertRaises(VsanNotPresent) as e:
            self.v.add_interfaces([self.fc])
        self.assertEqual(
            "VsanNotPresent: Vsan " + str(self.id) +
            " is not present on the switch.",
            str(e.exception),
        )

    def test_addinterfaces_repeated(self):
        self.v.create()
        self.pc.create()
        self.v.add_interfaces(
            [self.fc, self.fc,
             self.pc])  ## self.fc even though repeated will not be added
        self.assertEqual(self.fc.name, self.v.interfaces[0].name)
        self.assertEqual(2, len(self.v.interfaces))
        self.pc.delete()
        self.v.delete()

    def test_addinterfaces_portchannelnotpresent(self):
        self.v.create()
        with self.assertRaises(CLIError) as e:
            self.v.add_interfaces([self.pc])
        self.assertRegex(
            str(e.exception),
            ".*The command.*vsan database ; vsan " + str(self.id) +
            " interface port-channel" + str(self.pc.id) +
            ".*gave the error.*Invalid range .*",
        )
        self.v.delete()

    def tearDown(self) -> None:
        if self.v.id is not None:
            self.v.delete()
        if self.pc.channel_mode is not None:
            self.pc.delete()
        self.vsandb[1].add_interfaces([self.fc])
        self.assertEqual(self.vsandb.keys(), self.switch.vsans.keys())
Esempio n. 12
0
v = Vsan(sw, 2)

# Creating vsan
v.create()

# Creating Fc object for interface fc1/3
int13 = Fc(sw, "fc1/3")

# Instantiating PortChannel object 1
pc1 = PortChannel(sw, 1)

# Creating port channel
pc1.create()

# Adding interfaces to vsan 2
v.add_interfaces([int13, pc1])

# Instantiating DeviceAlias object
d = DeviceAlias(sw)
new = {"da1": "60:66:61:01:0e:00:01:ff"}

# Adding new device alias
d.create(new)

# Instantiate zone object
z = Zone(sw, "zone1", v.id)

# Create new zone
z.create()

# Configuring fcalias
 def tearDown(self):
     v = Vsan(switch=self.switch, id=1)
     for i in self.fc_name:
         v.add_interfaces([Fc(switch=self.switch, name=i)])