Ejemplo n.º 1
0
 def setUp(self):
     self.flavor1 = FlavorFactory()
     self.flavor2 = FlavorFactory(deleted=True)
     self.flavor3 = FlavorFactory()
     self.project1 = 'project1'
     self.project2 = 'project2'
     self.project3 = 'project3'
     self.projects = [self.project1, self.project2]
     self.flavor4 = FlavorFactory(public=False)
     self.flavor5 = FlavorFactory(public=False)
     self.flavor6 = FlavorFactory(public=False)
     self.flavor7 = FlavorFactory(public=False)
     self.flavor8 = FlavorFactory()
     self.flavoraccess1 = FlavorAccessFactory(project=self.project1,
                                              flavor=self.flavor4)
     self.flavoraccess2 = FlavorAccessFactory(project=self.project1,
                                              flavor=self.flavor5)
     self.flavoraccess3 = FlavorAccessFactory(project=self.project2,
                                              flavor=self.flavor6)
     self.flavoraccess4 = FlavorAccessFactory(project=self.project3,
                                              flavor=self.flavor7)
     self.flavoraccess5 = FlavorAccessFactory(project=self.project1,
                                              flavor=self.flavor8)
     self.compute_path = get_service_path(cyclades_services, 'compute',
                                          version='v2.0')
Ejemplo n.º 2
0
    def test_not_allowed(self):
        self.view_path = join_urls(get_service_path(
            pithos_settings.pithos_services, 'pithos_ui'), 'view')
        self.view_url = join_urls(self.view_path, self.user, get_random_name(),
                                  get_random_name())

        r = self.delete(self.view_url)
        self.assertEqual(r.status_code, 405)
        self.assertTrue('Allow' in r)
        self.assertEqual(sorted(r['Allow'].split(', ')),  ['GET', 'HEAD'])

        r = self.post(self.view_url)
        self.assertEqual(r.status_code, 405)
        self.assertTrue('Allow' in r)
        self.assertEqual(sorted(r['Allow'].split(', ')),  ['GET', 'HEAD'])

        r = self.put(self.view_url)
        self.assertEqual(r.status_code, 405)
        self.assertTrue('Allow' in r)
        self.assertEqual(sorted(r['Allow'].split(', ')),  ['GET', 'HEAD'])

        r = self.copy(self.view_url)
        self.assertEqual(r.status_code, 405)
        self.assertTrue('Allow' in r)
        self.assertEqual(sorted(r['Allow'].split(', ')),  ['GET', 'HEAD'])

        r = self.move(self.view_url)
        self.assertEqual(r.status_code, 405)
        self.assertTrue('Allow' in r)
        self.assertEqual(sorted(r['Allow'].split(', ')),  ['GET', 'HEAD'])
Ejemplo n.º 3
0
 def test_catch_wrong_identity_paths(self, *args):
     path = get_service_path(astakos_services, 'identity', 'v2.0')
     path = join_urls(BASE_HOST, path, 'nonexistent')
     response = self.client.get(path)
     self.assertEqual(response.status_code, 400)
     try:
         error = json.loads(response.content)
     except ValueError:
         self.assertTrue(False)
Ejemplo n.º 4
0
Archivo: api.py Proyecto: jbd/synnefo
 def test_catch_wrong_account_paths(self, *args):
     path = get_service_path(astakos_services, "account", "v1.0")
     path = join_urls(BASE_HOST, path, "nonexistent")
     response = self.client.get(path)
     self.assertEqual(response.status_code, 400)
     try:
         error = json.loads(response.content)
     except ValueError:
         self.assertTrue(False)
Ejemplo n.º 5
0
 def test_catch_wrong_api_paths(self, *args):
     path = get_service_path(cyclades_services,
                             'compute', version='v2.0')
     response = self.client.get(join_urls(path, 'nonexistent'))
     self.assertEqual(response.status_code, 400)
     try:
         error = json.loads(response.content)
     except ValueError:
         self.assertTrue(False)
Ejemplo n.º 6
0
 def test_api_version(self):
     """Check API version."""
     path = get_service_path(cyclades_services,
                             'compute', version='v2.0')
     with astakos_user('user'):
         response = self.client.get(path.rstrip('/') + '/')
     self.assertEqual(response.status_code, 200)
     api_version = json.loads(response.content)['version']
     self.assertEqual(api_version['id'], 'v2.0')
     self.assertEqual(api_version['status'], 'CURRENT')
Ejemplo n.º 7
0
    def setUp(self):
        PithosAPITest.setUp(self)
        self.cname = self.create_container()[0]
        self.oname, self.odata = self.upload_object(self.cname,
                                                    'φωτογραφία.JPG')[:-1]

        self.view_path = join_urls(get_service_path(
            pithos_settings.pithos_services, 'pithos_ui'), 'view')
        self.view_url = join_urls(self.view_path, self.user, self.cname,
                                  self.oname)
        self.api_url = join_urls(self.pithos_path, self.user, self.cname,
                                 self.oname)
Ejemplo n.º 8
0
    def setUp(self):

        self.volumes_path = get_service_path(cyclades_services, 'volume',
                                             version='v2.0') + '/volumes'
        self.snapshots_path = get_service_path(cyclades_services, 'volume',
                                             version='v2.0') + '/snapshots'

        # Volume types
        self.archip_vt = mf.VolumeTypeFactory(name="archipelago",
                                              disk_template="ext_archipelago")
        self.file_vt = mf.VolumeTypeFactory(name="file", disk_template="file")

        # Common arguments
        self.userid = "test_user"
        self.size = 1
        self.kwargs = {"user_id": self.userid, }

        # VMs
        self.archip_vm = mf.VirtualMachineFactory(
            userid=self.userid, flavor__volume_type=self.archip_vt)
        self.file_vm = mf.VirtualMachineFactory(
            userid=self.userid, flavor__volume_type=self.file_vt)
Ejemplo n.º 9
0
def extend_with_root_redirects(patterns_obj, filled_services, service_type,
                               base_path, with_slash=True):
    """
    Append additional redirect url entries for `/` and `/<base_path>` paths.

    `/` redirects to `/<base_path>` and `/<base_path>` to the resolved service
    type url.

    This is used in synnefo components root urlpatterns to append sane default
    redirects to the chosen service url.

    """
    service_path = get_service_path(filled_services, service_type)
    if with_slash:
        service_path = service_path.rstrip('/') + '/'

    root_url_entry = None
    if base_path and base_path != '/':
        # redirect slash to /<base_path>/
        root_url_entry = url('^$', 'redirect_to',
                             {'url': join_urls('/', base_path.rstrip('/'),
                                               '/')})

    base_path_pattern = prefix_pattern(base_path) + '$'
    base_path_pattern_no_slash = prefix_pattern(base_path).rstrip('/') + '$'

    # redirect /<base_path> and /<base_path>/ to service_path public endpoint
    base_url_entry = url(base_path_pattern, 'redirect_to', {'url':
                                                            service_path})
    base_url_entry_no_slash = url(base_path_pattern_no_slash,
                                  'redirect_to', {'url': service_path})
    # urls order matter. Setting base_url_entry first allows us to avoid
    # redirect loops when base_path is empty or `/`
    patterns_obj += patterns('django.views.generic.simple',
                             base_url_entry, base_url_entry_no_slash)
    if root_url_entry:
        # register root entry only for non root base_path deployments
        patterns_obj += patterns('django.views.generic.simple', root_url_entry)
Ejemplo n.º 10
0
    def setUp(self):
        self.client = PithosTestClient()

        # Override default block size to spead up tests
        pithos_settings.BACKEND_BLOCK_SIZE = TEST_BLOCK_SIZE
        pithos_settings.BACKEND_HASH_ALGORITHM = TEST_HASH_ALGORITHM

        self.user = '******'
        self.pithos_path = join_urls(get_service_path(
            pithos_settings.pithos_services, 'object-store'))

        # patch astakosclient.AstakosClient.validate_token
        mock_validate_token = self.create_patch(
            'astakosclient.AstakosClient.validate_token')
        mock_validate_token.return_value = {
            'access': {
                'user': {'id': smart_unicode(self.user, encoding='utf-8')}}}

        # patch astakosclient.AstakosClient.get_token
        mock_get_token = self.create_patch(
            'astakosclient.AstakosClient.get_token')
        mock_get_token.return_value = {'access_token': 'valid_token'}

        # patch astakosclient.AstakosClient.api_oa2_auth
        mock_api_oauth2_auth = self.create_patch(
            'astakosclient.AstakosClient.oauth2_url',
            new_callable=PropertyMock)
        mock_api_oauth2_auth.return_value = '/astakos/oauth2/'

        mock_service_get_quotas = self.create_patch(
            'astakosclient.AstakosClient.service_get_quotas')
        mock_service_get_quotas.return_value = {
            self.user: {
                "system": {
                    "pithos.diskspace": {
                        "usage": 0,
                        "limit": 1073741824,  # 1GB
                        "pending": 0}}}}
Ejemplo n.º 11
0
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json
import urllib

from mock import patch
from functools import wraps
from copy import deepcopy
from decimal import Decimal
from snf_django.utils.testing import BaseAPITest
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

PLANKTON_URL = get_service_path(cyclades_services, 'image', version='v1.0')
IMAGES_URL = join_urls(PLANKTON_URL, "images/")


def assert_backend_closed(func):
    @wraps(func)
    def wrapper(self, backend):
        result = func(self, backend)
        if backend.called is True:
            backend.return_value.close.assert_called_once_with()
        return result

    return wrapper


@patch("synnefo.plankton.backend.get_pithos_backend")
Ejemplo n.º 12
0
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from snf_django.utils.testing import BaseAPITest
import json
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls
from ipaddr import IPv4Network
import json
import synnefo.db.models_factory as mf

NETWORK_URL = get_service_path(cyclades_services, 'network', version='v2.0')
SUBNETS_URL = join_urls(NETWORK_URL, "subnets/")


class SubnetTest(BaseAPITest):
    def test_list_subnets(self):
        """Test list subnets without data"""
        response = self.get(SUBNETS_URL)
        self.assertSuccess(response)
        subnets = json.loads(response.content)
        self.assertEqual(subnets, {'subnets': []})

    def test_list_subnets_data(self):
        """Test list subnets with data"""
        test_net = mf.NetworkFactory()
        test_subnet_ipv4 = mf.IPv4SubnetFactory(network=test_net)
Ejemplo n.º 13
0
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from snf_django.utils.testing import BaseAPITest
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls

COMPUTE_URL = get_service_path(cyclades_services, 'compute',
                               version='v2.0')
EXTENSIONS_URL = join_urls(COMPUTE_URL, "extensions/")


class ExtensionsAPITest(BaseAPITest):
    def test_list(self):
        response = self.get(EXTENSIONS_URL, "user")
        self.assertSuccess(response)
        extensions = json.loads(response.content)["extensions"]
        self.assertEqual(extensions, [])

    def test_get(self):
        response = self.get(join_urls(EXTENSIONS_URL, "SNF"), "user")
        self.assertEqual(response.status_code, 404)
        response = self.get(join_urls(EXTENSIONS_URL, "SNF_asfas_da"), "user")
        self.assertEqual(response.status_code, 404)
Ejemplo n.º 14
0
 def __init__(self, *args, **kwargs):
     super(ComputeAPITest, self).__init__(*args, **kwargs)
     self.compute_path = get_service_path(cyclades_services, 'compute',
                                          version='v2.0')
Ejemplo n.º 15
0
from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata,
                               Network, BackendNetwork, NetworkInterface,
                               BridgePoolTable, MacPrefixPoolTable, Backend)
from synnefo.db.pools import EmptyPool

from snf_django.lib.astakos import get_user
from synnefo.plankton.utils import image_backend
from synnefo.settings import MAX_CIDR_BLOCK

from synnefo.cyclades_settings import cyclades_services, BASE_HOST
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

COMPUTE_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "compute", version="v2.0"))
SERVERS_URL = join_urls(COMPUTE_URL, "servers/")
NETWORKS_URL = join_urls(COMPUTE_URL, "networks/")
FLAVORS_URL = join_urls(COMPUTE_URL, "flavors/")
IMAGES_URL = join_urls(COMPUTE_URL, "images/")
PLANKTON_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "image", version="v1.0"))
IMAGES_PLANKTON_URL = join_urls(PLANKTON_URL, "images/")


log = getLogger('synnefo.api')


def random_password():
    """Generates a random password
Ejemplo n.º 16
0
def extend_endpoint_with_slash(patterns_obj, filled_services, service_type,
                               version=None):
    path = get_service_path(filled_services, service_type, version)
    extend_path_with_slash(patterns_obj, path)
Ejemplo n.º 17
0
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from snf_django.lib.api import faults
from snf_django.utils.testing import BaseAPITest
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls

from mock import patch
from functools import wraps

compute_path = get_service_path(cyclades_services, 'compute',
                                version='v2.0')
IMAGES_URL = join_urls(compute_path, "images/")


def assert_backend_closed(func):
    """Decorator for ensuring that PlanktonBackend is returned to pool."""
    @wraps(func)
    def wrapper(self, backend):
        result = func(self, backend)
        if backend.called is True:
            backend.return_value.close.asssert_called
        return result
    return wrapper


@patch('synnefo.plankton.backend.PlanktonBackend')
Ejemplo n.º 18
0
Archivo: api.py Proyecto: grnet/synnefo
import sys
import json

from django.conf import settings
from django.utils.importlib import import_module
from django.test.utils import override_settings
from mock import patch, Mock
from snf_django.utils.testing import BaseAPITest, mocked_quotaholder
from synnefo.db.models_factory import (VolumeFactory, VolumeTypeFactory,
                                       VirtualMachineFactory)
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls
from copy import deepcopy

VOLUME_URL = get_service_path(cyclades_services, 'volume',
                              version='v2.0')
VOLUMES_URL = join_urls(VOLUME_URL, "volumes")
SNAPSHOTS_URL = join_urls(VOLUME_URL, "snapshots")


@patch("synnefo.logic.rapi_pool.GanetiRapiClient")
class VolumeAPITest(BaseAPITest):
    @override_settings(CYCLADES_DETACHABLE_DISK_TEMPLATES=("ext_vlmc",))
    def test_create_volume(self, mrapi):
        vm = VirtualMachineFactory(
            operstate="ACTIVE",
            flavor__volume_type__disk_template="ext_vlmc")
        vt = VolumeTypeFactory(disk_template="ext_vlmc")
        user = vm.userid
        _data = {"display_name": "test_vol",
                 "size": 2,
Ejemplo n.º 19
0
def extend_endpoint_with_slash(patterns_obj,
                               filled_services,
                               service_type,
                               version=None):
    path = get_service_path(filled_services, service_type, version)
    extend_path_with_slash(patterns_obj, path)
Ejemplo n.º 20
0
from snf_django.lib.api import faults
from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata,
                               Network, NetworkInterface, SecurityGroup,
                               BridgePoolTable, MacPrefixPoolTable, IPAddress,
                               IPPoolTable)
from synnefo.plankton.backend import PlanktonBackend
from synnefo.webproject.memory_cache import MemoryCache

from synnefo.cyclades_settings import cyclades_services, BASE_HOST
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

COMPUTE_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "compute", version="v2.0"))
SERVERS_URL = join_urls(COMPUTE_URL, "servers/")
FLAVORS_URL = join_urls(COMPUTE_URL, "flavors/")
IMAGES_URL = join_urls(COMPUTE_URL, "images/")
PLANKTON_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "image", version="v1.0"))
IMAGES_PLANKTON_URL = join_urls(PLANKTON_URL, "images/")

NETWORK_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "network", version="v2.0"))
NETWORKS_URL = join_urls(NETWORK_URL, "networks/")
PORTS_URL = join_urls(NETWORK_URL, "ports/")
SUBNETS_URL = join_urls(NETWORK_URL, "subnets/")
FLOATING_IPS_URL = join_urls(NETWORK_URL, "floatingips/")
Ejemplo n.º 21
0
 def setUp(self, *args, **kwargs):
     super(VMAPITest, self).setUp(*args, **kwargs)
     self.api_path = get_service_path(cyclades_services,
                                      'vmapi',
                                      version='v1.0')
Ejemplo n.º 22
0
 def setUp(self, *args, **kwargs):
     super(PlanktonAPITest, self).setUp(*args, **kwargs)
     self.api_path = get_service_path(cyclades_services,
                                      'image',
                                      version='v1.0')
Ejemplo n.º 23
0
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.utils import simplejson as json
from django.conf import settings
from snf_django.utils.testing import BaseAPITest, mocked_quotaholder, \
    with_settings
from synnefo.db.models import IPAddress, Network, Subnet, IPPoolTable
from synnefo.db import models_factory as mf

from mock import patch, Mock

from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

network_path = get_service_path(cyclades_services, "network", version="v2.0")
URL = join_urls(network_path, "floatingips")
NETWORKS_URL = join_urls(network_path, "networks")
SERVERS_URL = join_urls(network_path, "servers")

floating_ips = IPAddress.objects.filter(floating_ip=True)


class FloatingIPAPITest(BaseAPITest):
    def setUp(self):
        self.pool = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
                                                public=True,
                                                subnet__cidr="192.168.2.0/24",
                                                subnet__gateway="192.168.2.1")

    def test_no_floating_ip(self):
Ejemplo n.º 24
0
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from mock import patch, Mock
from snf_django.utils.testing import BaseAPITest, mocked_quotaholder
from synnefo.db.models_factory import (VolumeFactory, VolumeTypeFactory,
                                       VirtualMachineFactory)
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls
from copy import deepcopy

VOLUME_URL = get_service_path(cyclades_services, 'volume', version='v2.0')
VOLUMES_URL = join_urls(VOLUME_URL, "volumes")


@patch("synnefo.logic.rapi_pool.GanetiRapiClient")
class VolumeAPITest(BaseAPITest):
    def test_create_volume(self, mrapi):
        vm = VirtualMachineFactory(
            operstate="ACTIVE", flavor__volume_type__disk_template="ext_vlmc")
        user = vm.userid
        _data = {"display_name": "test_vol", "size": 2, "server_id": vm.id}

        # Test Success
        mrapi().ModifyInstance.return_value = 42
        with mocked_quotaholder():
            r = self.post(VOLUMES_URL, user, json.dumps({"volume": _data}),
Ejemplo n.º 25
0
#
# The views and conclusions contained in the software and
# documentation are those of the authors and should not be
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.i

from django.conf import settings
from snf_django.utils.testing import BaseAPITest, override_settings
from django.utils import simplejson as json
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls
from mock import patch
import synnefo.db.models_factory as dbmf

NETWORK_URL = get_service_path(cyclades_services, 'network',
                               version='v2.0')
PORTS_URL = join_urls(NETWORK_URL, "ports/")


class PortTest(BaseAPITest):
    def test_get_ports(self):
        url = join_urls(PORTS_URL)
        response = self.get(url)
        self.assertEqual(response.status_code, 200)
        ports = json.loads(response.content)
        self.assertEqual(ports, {"ports": []})

    def test_get_port_unfound(self):
        url = join_urls(PORTS_URL, "123")
        response = self.get(url)
        self.assertEqual(response.status_code, 404)
Ejemplo n.º 26
0
        server_id = int(server_id)
    except (TypeError, ValueError):
        raise faults.BadRequest("Invalid server id: %s" % server_id)
    try:
        return get_vm(server_id,
                      user_id,
                      for_update=for_update,
                      non_deleted=non_deleted,
                      non_suspended=True)
    except faults.ItemNotFound:
        raise exception("Server %s not found" % server_id)


VOLUME_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "volume", version="v2.0"))

VOLUMES_URL = join_urls(VOLUME_URL, "volumes/")
SNAPSHOTS_URL = join_urls(VOLUME_URL, "snapshots/")


def volume_to_links(volume_id):
    href = join_urls(VOLUMES_URL, str(volume_id))
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]


def snapshot_to_links(snapshot_id):
    href = join_urls(SNAPSHOTS_URL, str(snapshot_id))
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]

Ejemplo n.º 27
0
Archivo: util.py Proyecto: jbd/synnefo
    VirtualMachineMetadata,
    Network,
    NetworkInterface,
    SecurityGroup,
    BridgePoolTable,
    MacPrefixPoolTable,
    IPAddress,
    IPPoolTable,
)
from synnefo.plankton.utils import image_backend

from synnefo.cyclades_settings import cyclades_services, BASE_HOST
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

COMPUTE_URL = join_urls(BASE_HOST, get_service_path(cyclades_services, "compute", version="v2.0"))
SERVERS_URL = join_urls(COMPUTE_URL, "servers/")
FLAVORS_URL = join_urls(COMPUTE_URL, "flavors/")
IMAGES_URL = join_urls(COMPUTE_URL, "images/")
PLANKTON_URL = join_urls(BASE_HOST, get_service_path(cyclades_services, "image", version="v1.0"))
IMAGES_PLANKTON_URL = join_urls(PLANKTON_URL, "images/")

NETWORK_URL = join_urls(BASE_HOST, get_service_path(cyclades_services, "network", version="v2.0"))
NETWORKS_URL = join_urls(NETWORK_URL, "networks/")
PORTS_URL = join_urls(NETWORK_URL, "ports/")
SUBNETS_URL = join_urls(NETWORK_URL, "subnets/")
FLOATING_IPS_URL = join_urls(NETWORK_URL, "floatingips/")

PITHOSMAP_PREFIX = "pithosmap://"

log = getLogger("synnefo.api")
Ejemplo n.º 28
0
 def setUp(self, *args, **kwargs):
     super(VMAPITest, self).setUp(*args, **kwargs)
     self.api_path = get_service_path(cyclades_services, 'vmapi',
                                      version='v1.0')
Ejemplo n.º 29
0
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from snf_django.utils.testing import BaseAPITest, override_settings
from django.utils import simplejson as json
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls
import synnefo.db.models_factory as dbmf
from synnefo.db.models import Network, QuotaHolderSerial
from django.conf import settings

NETWORK_URL = get_service_path(cyclades_services, "network", version="v2.0")
NETWORKS_URL = join_urls(NETWORK_URL, "networks/")


class NetworkTest(BaseAPITest):
    def test_list_networks(self):
        response = self.get(NETWORKS_URL)
        self.assertSuccess(response)
        networks = json.loads(response.content)
        self.assertEqual(networks, {"networks": []})

    def test_invalid_create(self):
        """Test invalid flavor"""
        request = {"network": {}}
        response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
        self.assertBadRequest(response)
Ejemplo n.º 30
0
 def setUp(self, *args, **kwargs):
     super(ComputeAPITest, self).setUp(*args, **kwargs)
     self.compute_path = get_service_path(cyclades_services, 'compute',
                                          version='v2.0')
Ejemplo n.º 31
0
 def setUp(self, *args, **kwargs):
     super(PlanktonAPITest, self).setUp(*args, **kwargs)
     self.api_path = get_service_path(cyclades_services, 'image',
                                          version='v1.0')
Ejemplo n.º 32
0
 def setUp(self):
     self.flavor1 = FlavorFactory()
     self.flavor2 = FlavorFactory(deleted=True)
     self.flavor3 = FlavorFactory()
     self.compute_path = get_service_path(cyclades_services, 'compute',
                                          version='v2.0')
Ejemplo n.º 33
0
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from snf_django.lib.api import faults
from snf_django.utils.testing import BaseAPITest
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls

from mock import patch
from functools import wraps

compute_path = get_service_path(cyclades_services, 'compute', version='v2.0')
IMAGES_URL = join_urls(compute_path, "images/")


def assert_backend_closed(func):
    """Decorator for ensuring that PlanktonBackend is returned to pool."""
    @wraps(func)
    def wrapper(self, backend):
        result = func(self, backend)
        if backend.called is True:
            backend.return_value.close.asssert_called
        return result

    return wrapper

Ejemplo n.º 34
0
from django.utils import simplejson as json
from django.conf import settings
from snf_django.utils.testing import BaseAPITest, mocked_quotaholder, \
    with_settings
from synnefo.db.models import IPAddress, Network, Subnet, IPPoolTable
from synnefo.db import models_factory as mf

from mock import patch, Mock

from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls


network_path = get_service_path(cyclades_services, "network", version="v2.0")
URL = join_urls(network_path, "floatingips")
NETWORKS_URL = join_urls(network_path, "networks")
SERVERS_URL = join_urls(network_path, "servers")


floating_ips = IPAddress.objects.filter(floating_ip=True)


class FloatingIPAPITest(BaseAPITest):
    def setUp(self):
        self.pool = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
                                                public=True,
                                                subnet__cidr="192.168.2.0/24",
                                                subnet__gateway="192.168.2.1")
Ejemplo n.º 35
0
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json
import urllib

from mock import patch
from functools import wraps
from copy import deepcopy
from decimal import Decimal
from snf_django.utils.testing import BaseAPITest
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls

PLANKTON_URL = get_service_path(cyclades_services, 'image',
                                version='v1.0')
IMAGES_URL = join_urls(PLANKTON_URL, "images/")


def assert_backend_closed(func):
    @wraps(func)
    def wrapper(self, backend):
        result = func(self, backend)
        if backend.called is True:
            backend.return_value.close.assert_called_once_with()
        return result
    return wrapper


@patch("synnefo.plankton.backend.get_pithos_backend")
class PlanktonTest(BaseAPITest):
Ejemplo n.º 36
0
def get_server(user_id, server_id, for_update=False, non_deleted=False,
               exception=faults.ItemNotFound):
    try:
        server_id = int(server_id)
    except (TypeError, ValueError):
        raise faults.BadRequest("Invalid server id: %s" % server_id)
    try:
        return get_vm(server_id, user_id, for_update=for_update,
                      non_deleted=non_deleted, non_suspended=True)
    except faults.ItemNotFound:
        raise exception("Server %s not found" % server_id)


VOLUME_URL = \
    join_urls(BASE_HOST,
              get_service_path(cyclades_services, "volume", version="v2.0"))

VOLUMES_URL = join_urls(VOLUME_URL, "volumes/")
SNAPSHOTS_URL = join_urls(VOLUME_URL, "snapshots/")


def volume_to_links(volume_id):
    href = join_urls(VOLUMES_URL, str(volume_id))
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]


def snapshot_to_links(snapshot_id):
    href = join_urls(SNAPSHOTS_URL, str(snapshot_id))
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]

Ejemplo n.º 37
0
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and
# documentation are those of the authors and should not be
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.

import json

from snf_django.utils.testing import BaseAPITest
from synnefo.lib.services import get_service_path
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib import join_urls

COMPUTE_URL = get_service_path(cyclades_services, 'compute',
                               version='v2.0')
EXTENSIONS_URL = join_urls(COMPUTE_URL, "extensions/")


class ExtensionsAPITest(BaseAPITest):
    def test_list(self):
        response = self.get(EXTENSIONS_URL, "user")
        self.assertSuccess(response)
        extensions = json.loads(response.content)["extensions"]
        self.assertEqual(extensions, [])

    def test_get(self):
        response = self.get(join_urls(EXTENSIONS_URL, "SNF"), "user")
        self.assertEqual(response.status_code, 404)
        response = self.get(join_urls(EXTENSIONS_URL, "SNF_asfas_da"), "user")
        self.assertEqual(response.status_code, 404)