File: test_objects.py

package info (click to toggle)
python-os-xenapi 0.3.4-4
  • links: PTS, VCS
  • area: main
  • in suites: bookworm, bullseye
  • size: 1,012 kB
  • sloc: python: 8,137; sh: 2,154; makefile: 45
file content (127 lines) | stat: -rw-r--r-- 4,363 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
# -*- coding: utf-8 -*-

# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

"""
test_os_xenapi
----------------------------------

Tests for `os_xenapi objects` module.
"""

import mock

from os_xenapi.client import objects
from os_xenapi.tests import base


class XenAPISessionObjectTestCase(base.TestCase):
    def setUp(self):
        super(XenAPISessionObjectTestCase, self).setUp()
        self.session = mock.Mock()
        self.obj = objects.XenAPISessionObject(self.session, "FAKE")

    def test_call_method_via_attr(self):
        self.session.call_xenapi.return_value = "asdf"
        result = self.obj.get_X("ref")
        self.assertEqual(result, "asdf")
        self.session.call_xenapi.assert_called_once_with("FAKE.get_X", "ref")


class ObjectsTestCase(base.TestCase):
    def setUp(self):
        super(ObjectsTestCase, self).setUp()
        self.session = mock.Mock()

    def test_VM(self):
        vm = objects.VM(self.session)
        vm.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("VM.get_X", "ref")

    def test_SR(self):
        sr = objects.SR(self.session)
        sr.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("SR.get_X", "ref")

    def test_VDI(self):
        vdi = objects.VDI(self.session)
        vdi.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("VDI.get_X", "ref")

    def test_VIF(self):
        vdi = objects.VIF(self.session)
        vdi.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("VIF.get_X", "ref")

    def test_VBD(self):
        vbd = objects.VBD(self.session)
        vbd.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("VBD.get_X", "ref")

    def test_PBD(self):
        pbd = objects.PBD(self.session)
        pbd.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("PBD.get_X", "ref")

    def test_PIF(self):
        pif = objects.PIF(self.session)
        pif.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("PIF.get_X", "ref")

    def test_VLAN(self):
        vlan = objects.VLAN(self.session)
        vlan.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("VLAN.get_X", "ref")

    def test_host(self):
        host = objects.Host(self.session)
        host.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("host.get_X", "ref")

    def test_network(self):
        network = objects.Network(self.session)
        network.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("network.get_X",
                                                         "ref")

    def test_pool(self):
        pool = objects.Pool(self.session)
        pool.get_X("ref")
        self.session.call_xenapi.assert_called_once_with("pool.get_X", "ref")


class VBDTestCase(base.TestCase):
    def setUp(self):
        super(VBDTestCase, self).setUp()
        self.session = mock.Mock()
        self.session.VBD = objects.VBD(self.session)
        self.utils = mock.Mock()

    def test_plug(self):
        self.session.VBD.plug("vbd_ref", "vm_ref")
        self.session.call_xenapi.assert_called_once_with("VBD.plug", "vbd_ref")

    def test_unplug(self):
        self.session.VBD.unplug("vbd_ref", "vm_ref")
        self.session.call_xenapi.assert_called_once_with("VBD.unplug",
                                                         "vbd_ref")

    @mock.patch.object(objects, 'synchronized')
    def test_vbd_plug_check_synchronized(self, mock_synchronized):
        self.session.VBD.plug("vbd_ref", "vm_ref")
        mock_synchronized.assert_called_once_with("vbd-vm_ref")

    @mock.patch.object(objects, 'synchronized')
    def test_vbd_unplug_check_synchronized(self, mock_synchronized):
        self.session.VBD.unplug("vbd_ref", "vm_ref")
        mock_synchronized.assert_called_once_with("vbd-vm_ref")