Synnefo

from mock import patch, Mock

from functools import partial

FloatingIPPoolFactory = partial(NetworkFactory, public=True, deleted=False,

                                floating_ip_pool=True)

        # Also send a notification to remove the NIC and assert that FIP is in

        # use until notification from ganeti arrives

        request = {"removeFloatingIp": {"address": ip.ipv4}}

        with patch('synnefo.logic.rapi_pool.GanetiRapiClient') as c:

            c().ModifyInstance.return_value = 10

            response = self.post(url, vm.userid, json.dumps(request),

        net = ip.network

        # Can not remove network with floating IPs

        with mocked_quotaholder():

                                   net.userid)

        self.assertFault(response, 421, "networkInUse")

        # But we can with only deleted Floating Ips

        ip.deleted = True

        ip.save()

        with mocked_quotaholder():

                                   net.userid)

        self.assertSuccess(response)

class FloatingIPPoolsAPITest(BaseAPITest):

        self.vm = vm

    def test_bad_request(self):

        response = self.post(url, self.vm.userid, json.dumps({}), "json")

        self.assertBadRequest(response)

        response = self.post(url, self.vm.userid,

    @patch('synnefo.logic.rapi_pool.GanetiRapiClient')

    def test_add_floating_ip(self, mock):

        # Not exists

        request = {"addFloatingIp": {"address": "10.0.0.1"}}

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertItemNotFound(response)

    @patch('synnefo.logic.rapi_pool.GanetiRapiClient')

    def test_remove_floating_ip(self, mock):

        # Not exists

        request = {"removeFloatingIp": {"address": "10.0.0.1"}}

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertItemNotFound(response)

class ComputeAPITest(BaseAPITest):

        self.compute_path = get_service_path(cyclades_services, 'compute',

                                             version='v2.0')

    def myget(self, path, *args, **kwargs):

        path = join_urls(self.compute_path, path)

        return self.get(path, *args, **kwargs)

        net = mfactory.NetworkFactory(state='PENDING', subnet='10.0.0.0/31',

                                      userid=user)

        request = {'add': {'serverRef': vm.id}}

                               net.userid, json.dumps(request), 'json')

        # Test that returns BuildInProgress

        self.assertEqual(response.status_code, 409)

    def test_remove_nic(self, mrapi):

        user = 'userr'

        net = mfactory.NetworkFactory(state='ACTIVE', userid=user)

        nic = mfactory.NetworkInterfaceFactory(machine=vm, network=net)

        mrapi().ModifyInstance.return_value = 1

class ComputeAPITest(BaseAPITest):

        self.compute_path = get_service_path(cyclades_services, 'compute',

                                             version='v2.0')

        self.vm3 = mfactory.VirtualMachineFactory(deleted=True,

                                                  userid=self.user1)

        self.vm4 = mfactory.VirtualMachineFactory(userid=self.user2)

    def test_server_list_1(self):

        """Test if the expected list of servers is returned."""

        mrapi().CreateInstance.return_value = 12

        with override_settings(settings, DEFAULT_INSTANCE_NETWORKS=[]):

            with mocked_quotaholder():

                                       json.dumps(self.request), 'json')

        self.assertEqual(response.status_code, 202)

        mrapi().CreateInstance.assert_called_once()

                DEFAULT_INSTANCE_NETWORKS=["public", bnet1.network.id,

                                           bnet2.network.id]):

            with mocked_quotaholder():

                                       json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        name, args, kwargs = mrapi().CreateInstance.mock_calls[0]

        with override_settings(settings,

                DEFAULT_INSTANCE_NETWORKS=[bnet2.network.id]):

            with mocked_quotaholder():

                                       json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        name, args, kwargs = mrapi().CreateInstance.mock_calls[1]

        # test invalid network in DEFAULT_INSTANCE_NETWORKS

        with override_settings(settings, DEFAULT_INSTANCE_NETWORKS=[42]):

                                   json.dumps(request), 'json')

        self.assertFault(response, 500, "internalServerError")

        request = deepcopy(self.request)

        request["server"]["networks"] = [self.network.id]

        with override_settings(settings, DEFAULT_INSTANCE_NETWORKS=["public"]):

                                    json.dumps(request), 'json')

        self.assertFault(response, 403, "forbidden")

        # test wrong user

        request["server"]["networks"] = [bnet3.network.id]

        with override_settings(settings, DEFAULT_INSTANCE_NETWORKS=["public"]):

            with mocked_quotaholder():

                                       json.dumps(request), 'json')

        self.assertItemNotFound(response)

        with override_settings(settings,

                DEFAULT_INSTANCE_NETWORKS=[bnet3.network.id]):

            with mocked_quotaholder():

                                     json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        api_server = json.loads(response.content)['server']

        request = deepcopy(self.request)

        request["server"]["flavorRef"] = 42

        with mocked_quotaholder():

                                   json.dumps(request), 'json')

        self.assertItemNotFound(response)

    def test_delete_server(self, mrapi):

        vm = mfactory.VirtualMachineFactory()

        mrapi().DeleteInstance.return_value = 12

        self.assertEqual(response.status_code, 204)

        mrapi().DeleteInstance.assert_called_once()

        vm = mfactory.VirtualMachineFactory(operstate="BUILD")

        request = {'start': {}}

        with mocked_quotaholder():

                                   vm.userid, json.dumps(request), 'json')

        self.assertEqual(response.status_code, 409)

        self.assertFalse(mrapi.mock_calls)

        """Test building in progress"""

        vm = mfactory.VirtualMachineFactory()

        mrapi().DeleteInstance.return_value = 2

                                 vm.userid)

        self.assertSuccess(response)

        mrapi().RemoveInstance.assert_called_once()

        # Check building VM

        vm = self.get_vm(flavor=flavor, operstate="BUILD")

        request = {'resize': {'flavorRef': flavor.id}}

                             vm.userid, json.dumps(request), 'json')

        self.assertFault(response, 409, "buildInProgress")

        # Check same Flavor

        vm = self.get_vm(flavor=flavor, operstate="STOPPED")

        request = {'resize': {'flavorRef': flavor.id}}

                             vm.userid, json.dumps(request), 'json')

        self.assertBadRequest(response)

        # Check flavor with different disk

        flavor3 = mfactory.FlavorFactory(disk=2048)

        vm = self.get_vm(flavor=flavor2, operstate="STOPPED")

        request = {'resize': {'flavorRef': flavor3.id}}

                             vm.userid, json.dumps(request), 'json')

        self.assertBadRequest(response)

        flavor2 = mfactory.FlavorFactory(disk_template="foo")

        flavor3 = mfactory.FlavorFactory(disk_template="baz")

        vm = self.get_vm(flavor=flavor2, operstate="STOPPED")

        request = {'resize': {'flavorRef': flavor3.id}}

                             vm.userid, json.dumps(request), 'json')

        self.assertBadRequest(response)

        # Check success

                                         cpu=4, ram=2048)

        request = {'resize': {'flavorRef': flavor4.id}}

        mrapi().ModifyInstance.return_value = 42

                             vm.userid, json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        vm = VirtualMachine.objects.get(id=vm.id)

        vm.save()

        for action in VirtualMachine.ACTIONS:

            request = {action[0]: ""}

                                 vm.userid, json.dumps(request), 'json')

            self.assertBadRequest(response)

        # however you can destroy

        mrapi().DeleteInstance.return_value = 42

        self.assertSuccess(response)

    def get_vm(self, flavor, operstate):

        data = json.dumps({'console': {'type': 'vnc'}})

        with override_settings(settings, TEST=True):

                                   vm.userid, data, 'json')

        self.assertEqual(response.status_code, 200)

        reply = json.loads(response.content)

            db_vm = VirtualMachine.objects.get(id=vm.id)

            self.assertEqual(db_vm.operstate, vm.operstate)

        # Test intermediate states

        for status in ["queued", "waiting", "running"]:

            msg = self.create_msg(operation='OP_INSTANCE_SET_PARAMS',

                                  instance=vm.backend_vm_id,

    def test_get_servers_from_db(self):

        """Test getting a dictionary from each server to its operstate"""

        vm1 = self.get_vm('STARTED')

        vm2 = self.get_vm('DESTROYED', deleted=True)

        vm3 = self.get_vm('STOPPED')

                    {vm1.id: VMState(state='STARTED', cpu=2, ram=1024, nics=[]),

                     vm3.id: VMState(state='STOPPED', cpu=2, ram=1024, nics=[])}

                    )