← Back to branch summary

~markmc/nova/flat-dhcp-without-bridge-iface

« back to all changes in this revision

Viewing changes to nova/tests/api/openstack/test_servers.py

  • Committer: Tarmac
  • Author(s): Alex Meade
  • Date: 2011-08-22 03:17:04 UTC
  • mfrom: (1450.6.17 servers-accessip)
  • Revision ID: tarmac-20110822031704-3m2u6o62ut0gqyzo
Adds accessIPv4 and accessIPv6 to servers requests and responses as per the current spec.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/api/openstack/test_servers.py
19
19
import datetime
20
20
import json
21
21
import unittest
 
22
from lxml import etree
22
23
from xml.dom import minidom
23
24
 
24
25
import webob
32
33
from nova.api.openstack import create_instance_helper
33
34
from nova.api.openstack import servers
34
35
from nova.api.openstack import wsgi
 
36
from nova.api.openstack import xmlutil
35
37
import nova.compute.api
36
38
from nova.compute import instance_types
37
39
from nova.compute import power_state
46
48
 
47
49
 
48
50
FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
 
51
NS = "{http://docs.openstack.org/compute/api/v1.1}"
 
52
ATOMNS = "{http://www.w3.org/2005/Atom}"
49
53
 
50
54
 
51
55
def fake_gen_uuid():
145
149
def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
146
150
                  public_addresses=None, host=None, power_state=0,
147
151
                  reservation_id="", uuid=FAKE_UUID, image_ref="10",
148
 
                  flavor_id="1", interfaces=None, name=None):
 
152
                  flavor_id="1", interfaces=None, name=None,
 
153
                  access_ipv4=None, access_ipv6=None):
149
154
    metadata = []
150
155
    metadata.append(InstanceMetadata(key='seq', value=id))
151
156
 
197
202
        "display_description": "",
198
203
        "locked": False,
199
204
        "metadata": metadata,
 
205
        "access_ip_v4": access_ipv4,
 
206
        "access_ip_v6": access_ipv6,
200
207
        "uuid": uuid,
201
208
        "virtual_interfaces": interfaces}
202
209
 
334
341
                "progress": 0,
335
342
                "name": "server1",
336
343
                "status": "BUILD",
 
344
                "accessIPv4": "",
 
345
                "accessIPv6": "",
337
346
                "hostId": '',
338
347
                "image": {
339
348
                    "id": "10",
431
440
                created="%(expected_created)s"
432
441
                hostId=""
433
442
                status="BUILD"
 
443
                accessIPv4=""
 
444
                accessIPv6=""
434
445
                progress="0">
435
446
            <atom:link href="%(server_href)s" rel="self"/>
436
447
            <atom:link href="%(server_bookmark)s" rel="bookmark"/>
496
507
                "progress": 100,
497
508
                "name": "server1",
498
509
                "status": "ACTIVE",
 
510
                "accessIPv4": "",
 
511
                "accessIPv6": "",
499
512
                "hostId": '',
500
513
                "image": {
501
514
                    "id": "10",
587
600
                "progress": 100,
588
601
                "name": "server1",
589
602
                "status": "ACTIVE",
 
603
                "accessIPv4": "",
 
604
                "accessIPv6": "",
590
605
                "hostId": '',
591
606
                "image": {
592
607
                    "id": "10",
1379
1394
                    'display_name': 'server_test',
1380
1395
                    'uuid': FAKE_UUID,
1381
1396
                    'instance_type': dict(inst_type),
 
1397
                    'access_ip_v4': '1.2.3.4',
 
1398
                    'access_ip_v6': 'fead::1234',
1382
1399
                    'image_ref': image_ref,
1383
1400
                    "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
1384
1401
                    "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
1579
1596
        res = req.get_response(fakes.wsgi_app())
1580
1597
        self.assertEqual(res.status_int, 400)
1581
1598
 
 
1599
    def test_create_instance_with_access_ip_v1_1(self):
 
1600
        self._setup_for_create_instance()
 
1601
 
 
1602
        # proper local hrefs must start with 'http://localhost/v1.1/'
 
1603
        image_href = 'http://localhost/v1.1/images/2'
 
1604
        flavor_ref = 'http://localhost/flavors/3'
 
1605
        access_ipv4 = '1.2.3.4'
 
1606
        access_ipv6 = 'fead::1234'
 
1607
        expected_flavor = {
 
1608
            "id": "3",
 
1609
            "links": [
 
1610
                {
 
1611
                    "rel": "bookmark",
 
1612
                    "href": 'http://localhost/flavors/3',
 
1613
                },
 
1614
            ],
 
1615
        }
 
1616
        expected_image = {
 
1617
            "id": "2",
 
1618
            "links": [
 
1619
                {
 
1620
                    "rel": "bookmark",
 
1621
                    "href": 'http://localhost/images/2',
 
1622
                },
 
1623
            ],
 
1624
        }
 
1625
        body = {
 
1626
            'server': {
 
1627
                'name': 'server_test',
 
1628
                'imageRef': image_href,
 
1629
                'flavorRef': flavor_ref,
 
1630
                'accessIPv4': access_ipv4,
 
1631
                'accessIPv6': access_ipv6,
 
1632
                'metadata': {
 
1633
                    'hello': 'world',
 
1634
                    'open': 'stack',
 
1635
                },
 
1636
                'personality': [
 
1637
                    {
 
1638
                        "path": "/etc/banner.txt",
 
1639
                        "contents": "MQ==",
 
1640
                    },
 
1641
                ],
 
1642
            },
 
1643
        }
 
1644
 
 
1645
        req = webob.Request.blank('/v1.1/servers')
 
1646
        req.method = 'POST'
 
1647
        req.body = json.dumps(body)
 
1648
        req.headers["content-type"] = "application/json"
 
1649
 
 
1650
        res = req.get_response(fakes.wsgi_app())
 
1651
 
 
1652
        self.assertEqual(res.status_int, 202)
 
1653
        server = json.loads(res.body)['server']
 
1654
        self.assertEqual(16, len(server['adminPass']))
 
1655
        self.assertEqual(1, server['id'])
 
1656
        self.assertEqual(0, server['progress'])
 
1657
        self.assertEqual('server_test', server['name'])
 
1658
        self.assertEqual(expected_flavor, server['flavor'])
 
1659
        self.assertEqual(expected_image, server['image'])
 
1660
        self.assertEqual(access_ipv4, server['accessIPv4'])
 
1661
        self.assertEqual(access_ipv6, server['accessIPv6'])
 
1662
 
1582
1663
    def test_create_instance_v1_1(self):
1583
1664
        self._setup_for_create_instance()
1584
1665
 
1636
1717
        self.assertEqual('server_test', server['name'])
1637
1718
        self.assertEqual(expected_flavor, server['flavor'])
1638
1719
        self.assertEqual(expected_image, server['image'])
 
1720
        self.assertEqual('1.2.3.4', server['accessIPv4'])
 
1721
        self.assertEqual('fead::1234', server['accessIPv6'])
1639
1722
 
1640
1723
    def test_create_instance_v1_1_invalid_flavor_href(self):
1641
1724
        self._setup_for_create_instance()
1879
1962
        res = req.get_response(fakes.wsgi_app())
1880
1963
        self.assertEqual(res.status_int, 400)
1881
1964
 
 
1965
    def test_update_server_all_attributes_v1_1(self):
 
1966
        self.stubs.Set(nova.db.api, 'instance_get',
 
1967
                return_server_with_attributes(name='server_test',
 
1968
                                              access_ipv4='0.0.0.0',
 
1969
                                              access_ipv6='beef::0123'))
 
1970
        req = webob.Request.blank('/v1.1/servers/1')
 
1971
        req.method = 'PUT'
 
1972
        req.content_type = 'application/json'
 
1973
        body = {'server': {
 
1974
                  'name': 'server_test',
 
1975
                  'accessIPv4': '0.0.0.0',
 
1976
                  'accessIPv6': 'beef::0123',
 
1977
               }}
 
1978
        req.body = json.dumps(body)
 
1979
        res = req.get_response(fakes.wsgi_app())
 
1980
        self.assertEqual(res.status_int, 200)
 
1981
        res_dict = json.loads(res.body)
 
1982
        self.assertEqual(res_dict['server']['id'], 1)
 
1983
        self.assertEqual(res_dict['server']['name'], 'server_test')
 
1984
        self.assertEqual(res_dict['server']['accessIPv4'], '0.0.0.0')
 
1985
        self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123')
 
1986
 
1882
1987
    def test_update_server_name_v1_1(self):
1883
1988
        self.stubs.Set(nova.db.api, 'instance_get',
1884
1989
                return_server_with_attributes(name='server_test'))
1892
1997
        self.assertEqual(res_dict['server']['id'], 1)
1893
1998
        self.assertEqual(res_dict['server']['name'], 'server_test')
1894
1999
 
 
2000
    def test_update_server_access_ipv4_v1_1(self):
 
2001
        self.stubs.Set(nova.db.api, 'instance_get',
 
2002
                return_server_with_attributes(access_ipv4='0.0.0.0'))
 
2003
        req = webob.Request.blank('/v1.1/servers/1')
 
2004
        req.method = 'PUT'
 
2005
        req.content_type = 'application/json'
 
2006
        req.body = json.dumps({'server': {'accessIPv4': '0.0.0.0'}})
 
2007
        res = req.get_response(fakes.wsgi_app())
 
2008
        self.assertEqual(res.status_int, 200)
 
2009
        res_dict = json.loads(res.body)
 
2010
        self.assertEqual(res_dict['server']['id'], 1)
 
2011
        self.assertEqual(res_dict['server']['accessIPv4'], '0.0.0.0')
 
2012
 
 
2013
    def test_update_server_access_ipv6_v1_1(self):
 
2014
        self.stubs.Set(nova.db.api, 'instance_get',
 
2015
                return_server_with_attributes(access_ipv6='beef::0123'))
 
2016
        req = webob.Request.blank('/v1.1/servers/1')
 
2017
        req.method = 'PUT'
 
2018
        req.content_type = 'application/json'
 
2019
        req.body = json.dumps({'server': {'accessIPv6': 'beef::0123'}})
 
2020
        res = req.get_response(fakes.wsgi_app())
 
2021
        self.assertEqual(res.status_int, 200)
 
2022
        res_dict = json.loads(res.body)
 
2023
        self.assertEqual(res_dict['server']['id'], 1)
 
2024
        self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123')
 
2025
 
1895
2026
    def test_update_server_adminPass_ignored_v1_1(self):
1896
2027
        inst_dict = dict(name='server_test', adminPass='bacon')
1897
2028
        self.body = json.dumps(dict(server=inst_dict))
2491
2622
        }
2492
2623
        self.assertEquals(request['body'], expected)
2493
2624
 
 
2625
    def test_access_ipv4(self):
 
2626
        serial_request = """
 
2627
<server xmlns="http://docs.openstack.org/compute/api/v1.1"
 
2628
        name="new-server-test"
 
2629
        imageRef="1"
 
2630
        flavorRef="2"
 
2631
        accessIPv4="1.2.3.4"/>"""
 
2632
        request = self.deserializer.deserialize(serial_request, 'create')
 
2633
        expected = {
 
2634
            "server": {
 
2635
                "name": "new-server-test",
 
2636
                "imageRef": "1",
 
2637
                "flavorRef": "2",
 
2638
                "accessIPv4": "1.2.3.4",
 
2639
            },
 
2640
        }
 
2641
        self.assertEquals(request['body'], expected)
 
2642
 
 
2643
    def test_access_ipv6(self):
 
2644
        serial_request = """
 
2645
<server xmlns="http://docs.openstack.org/compute/api/v1.1"
 
2646
        name="new-server-test"
 
2647
        imageRef="1"
 
2648
        flavorRef="2"
 
2649
        accessIPv6="fead::1234"/>"""
 
2650
        request = self.deserializer.deserialize(serial_request, 'create')
 
2651
        expected = {
 
2652
            "server": {
 
2653
                "name": "new-server-test",
 
2654
                "imageRef": "1",
 
2655
                "flavorRef": "2",
 
2656
                "accessIPv6": "fead::1234",
 
2657
            },
 
2658
        }
 
2659
        self.assertEquals(request['body'], expected)
 
2660
 
 
2661
    def test_access_ip(self):
 
2662
        serial_request = """
 
2663
<server xmlns="http://docs.openstack.org/compute/api/v1.1"
 
2664
        name="new-server-test"
 
2665
        imageRef="1"
 
2666
        flavorRef="2"
 
2667
        accessIPv4="1.2.3.4"
 
2668
        accessIPv6="fead::1234"/>"""
 
2669
        request = self.deserializer.deserialize(serial_request, 'create')
 
2670
        expected = {
 
2671
            "server": {
 
2672
                "name": "new-server-test",
 
2673
                "imageRef": "1",
 
2674
                "flavorRef": "2",
 
2675
                "accessIPv4": "1.2.3.4",
 
2676
                "accessIPv6": "fead::1234",
 
2677
            },
 
2678
        }
 
2679
        self.assertEquals(request['body'], expected)
 
2680
 
2494
2681
    def test_admin_pass(self):
2495
2682
        serial_request = """
2496
2683
<server xmlns="http://docs.openstack.org/compute/api/v1.1"
3039
3226
            "display_description": "",
3040
3227
            "locked": False,
3041
3228
            "metadata": [],
 
3229
            "accessIPv4": "1.2.3.4",
 
3230
            "accessIPv6": "fead::1234",
3042
3231
            #"address": ,
3043
3232
            #"floating_ips": [{"address":ip} for ip in public_addresses]}
3044
3233
            "uuid": "deadbeef-feed-edee-beef-d0ea7beefedd"}
3093
3282
                "progress": 0,
3094
3283
                "name": "test_server",
3095
3284
                "status": "BUILD",
 
3285
                "accessIPv4": "",
 
3286
                "accessIPv6": "",
3096
3287
                "hostId": '',
3097
3288
                "image": {
3098
3289
                    "id": "5",
3144
3335
                "progress": 100,
3145
3336
                "name": "test_server",
3146
3337
                "status": "ACTIVE",
 
3338
                "accessIPv4": "",
 
3339
                "accessIPv6": "",
3147
3340
                "hostId": '',
3148
3341
                "image": {
3149
3342
                    "id": "5",
3181
3374
        output = self.view_builder.build(self.instance, True)
3182
3375
        self.assertDictMatch(output, expected_server)
3183
3376
 
 
3377
    def test_build_server_detail_with_accessipv4(self):
 
3378
 
 
3379
        self.instance['access_ip_v4'] = '1.2.3.4'
 
3380
 
 
3381
        image_bookmark = "http://localhost/images/5"
 
3382
        flavor_bookmark = "http://localhost/flavors/1"
 
3383
        expected_server = {
 
3384
            "server": {
 
3385
                "id": 1,
 
3386
                "uuid": self.instance['uuid'],
 
3387
                "updated": "2010-11-11T11:00:00Z",
 
3388
                "created": "2010-10-10T12:00:00Z",
 
3389
                "progress": 0,
 
3390
                "name": "test_server",
 
3391
                "status": "BUILD",
 
3392
                "hostId": '',
 
3393
                "image": {
 
3394
                    "id": "5",
 
3395
                    "links": [
 
3396
                        {
 
3397
                            "rel": "bookmark",
 
3398
                            "href": image_bookmark,
 
3399
                        },
 
3400
                    ],
 
3401
                },
 
3402
                "flavor": {
 
3403
                    "id": "1",
 
3404
                    "links": [
 
3405
                                              {
 
3406
                            "rel": "bookmark",
 
3407
                            "href": flavor_bookmark,
 
3408
                        },
 
3409
                    ],
 
3410
                },
 
3411
                "addresses": {},
 
3412
                "metadata": {},
 
3413
                "accessIPv4": "1.2.3.4",
 
3414
                "accessIPv6": "",
 
3415
                "links": [
 
3416
                    {
 
3417
                        "rel": "self",
 
3418
                        "href": "http://localhost/v1.1/servers/1",
 
3419
                    },
 
3420
                    {
 
3421
                        "rel": "bookmark",
 
3422
                        "href": "http://localhost/servers/1",
 
3423
                    },
 
3424
                ],
 
3425
            }
 
3426
        }
 
3427
 
 
3428
        output = self.view_builder.build(self.instance, True)
 
3429
        self.assertDictMatch(output, expected_server)
 
3430
 
 
3431
    def test_build_server_detail_with_accessipv6(self):
 
3432
 
 
3433
        self.instance['access_ip_v6'] = 'fead::1234'
 
3434
 
 
3435
        image_bookmark = "http://localhost/images/5"
 
3436
        flavor_bookmark = "http://localhost/flavors/1"
 
3437
        expected_server = {
 
3438
            "server": {
 
3439
                "id": 1,
 
3440
                "uuid": self.instance['uuid'],
 
3441
                "updated": "2010-11-11T11:00:00Z",
 
3442
                "created": "2010-10-10T12:00:00Z",
 
3443
                "progress": 0,
 
3444
                "name": "test_server",
 
3445
                "status": "BUILD",
 
3446
                "hostId": '',
 
3447
                "image": {
 
3448
                    "id": "5",
 
3449
                    "links": [
 
3450
                        {
 
3451
                            "rel": "bookmark",
 
3452
                            "href": image_bookmark,
 
3453
                        },
 
3454
                    ],
 
3455
                },
 
3456
                "flavor": {
 
3457
                    "id": "1",
 
3458
                    "links": [
 
3459
                                              {
 
3460
                            "rel": "bookmark",
 
3461
                            "href": flavor_bookmark,
 
3462
                        },
 
3463
                    ],
 
3464
                },
 
3465
                "addresses": {},
 
3466
                "metadata": {},
 
3467
                "accessIPv4": "",
 
3468
                "accessIPv6": "fead::1234",
 
3469
                "links": [
 
3470
                    {
 
3471
                        "rel": "self",
 
3472
                        "href": "http://localhost/v1.1/servers/1",
 
3473
                    },
 
3474
                    {
 
3475
                        "rel": "bookmark",
 
3476
                        "href": "http://localhost/servers/1",
 
3477
                    },
 
3478
                ],
 
3479
            }
 
3480
        }
 
3481
 
 
3482
        output = self.view_builder.build(self.instance, True)
 
3483
        self.assertDictMatch(output, expected_server)
 
3484
 
3184
3485
    def test_build_server_detail_with_metadata(self):
3185
3486
 
3186
3487
        metadata = []
3199
3500
                "progress": 0,
3200
3501
                "name": "test_server",
3201
3502
                "status": "BUILD",
 
3503
                "accessIPv4": "",
 
3504
                "accessIPv6": "",
3202
3505
                "hostId": '',
3203
3506
                "image": {
3204
3507
                    "id": "5",
3265
3568
                "name": "test_server",
3266
3569
                "status": "BUILD",
3267
3570
                "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
 
3571
                "accessIPv4": "1.2.3.4",
 
3572
                "accessIPv6": "fead::1234",
3268
3573
                "image": {
3269
3574
                    "id": "5",
3270
3575
                    "links": [
3323
3628
        }
3324
3629
 
3325
3630
        output = serializer.serialize(fixture, 'show')
3326
 
        actual = minidom.parseString(output.replace("  ", ""))
 
3631
        print output
 
3632
        root = etree.XML(output)
 
3633
        xmlutil.validate_schema(root, 'server')
3327
3634
 
3328
3635
        expected_server_href = self.SERVER_HREF
3329
3636
        expected_server_bookmark = self.SERVER_BOOKMARK
3331
3638
        expected_flavor_bookmark = self.FLAVOR_BOOKMARK
3332
3639
        expected_now = self.TIMESTAMP
3333
3640
        expected_uuid = FAKE_UUID
3334
 
        expected = minidom.parseString("""
3335
 
        <server id="1"
3336
 
                uuid="%(expected_uuid)s"
3337
 
                xmlns="http://docs.openstack.org/compute/api/v1.1"
3338
 
                xmlns:atom="http://www.w3.org/2005/Atom"
3339
 
                name="test_server"
3340
 
                updated="%(expected_now)s"
3341
 
                created="%(expected_now)s"
3342
 
                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
3343
 
                status="BUILD"
3344
 
                progress="0">
3345
 
            <atom:link href="%(expected_server_href)s" rel="self"/>
3346
 
            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
3347
 
            <image id="5">
3348
 
                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
3349
 
            </image>
3350
 
            <flavor id="1">
3351
 
                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
3352
 
            </flavor>
3353
 
            <metadata>
3354
 
                <meta key="Open">
3355
 
                    Stack
3356
 
                </meta>
3357
 
                <meta key="Number">
3358
 
                    1
3359
 
                </meta>
3360
 
            </metadata>
3361
 
            <addresses>
3362
 
                <network id="network_one">
3363
 
                    <ip version="4" addr="67.23.10.138"/>
3364
 
                    <ip version="6" addr="::babe:67.23.10.138"/>
3365
 
                </network>
3366
 
                <network id="network_two">
3367
 
                    <ip version="4" addr="67.23.10.139"/>
3368
 
                    <ip version="6" addr="::babe:67.23.10.139"/>
3369
 
                </network>
3370
 
            </addresses>
3371
 
        </server>
3372
 
        """.replace("  ", "") % (locals()))
3373
 
 
3374
 
        self.assertEqual(expected.toxml(), actual.toxml())
 
3641
        server_dict = fixture['server']
 
3642
 
 
3643
        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
 
3644
                    'updated', 'progress', 'status', 'hostId',
 
3645
                    'accessIPv6']:
 
3646
            self.assertEqual(root.get(key), str(server_dict[key]))
 
3647
 
 
3648
        link_nodes = root.findall('{0}link'.format(ATOMNS))
 
3649
        self.assertEqual(len(link_nodes), 2)
 
3650
        for i, link in enumerate(server_dict['links']):
 
3651
            for key, value in link.items():
 
3652
                self.assertEqual(link_nodes[i].get(key), value)
 
3653
 
 
3654
        metadata_root = root.find('{0}metadata'.format(NS))
 
3655
        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
 
3656
        self.assertEqual(len(metadata_elems), 2)
 
3657
        for i, metadata_elem in enumerate(metadata_elems):
 
3658
            (meta_key, meta_value) = server_dict['metadata'].items()[i]
 
3659
            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
 
3660
            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
3661
 
 
3662
        image_root = root.find('{0}image'.format(NS))
 
3663
        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
 
3664
        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
 
3665
        self.assertEqual(len(link_nodes), 1)
 
3666
        for i, link in enumerate(server_dict['image']['links']):
 
3667
            for key, value in link.items():
 
3668
                self.assertEqual(link_nodes[i].get(key), value)
 
3669
 
 
3670
        flavor_root = root.find('{0}flavor'.format(NS))
 
3671
        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
 
3672
        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
 
3673
        self.assertEqual(len(link_nodes), 1)
 
3674
        for i, link in enumerate(server_dict['flavor']['links']):
 
3675
            for key, value in link.items():
 
3676
                self.assertEqual(link_nodes[i].get(key), value)
 
3677
 
 
3678
        addresses_root = root.find('{0}addresses'.format(NS))
 
3679
        addresses_dict = server_dict['addresses']
 
3680
        network_elems = addresses_root.findall('{0}network'.format(NS))
 
3681
        self.assertEqual(len(network_elems), 2)
 
3682
        for i, network_elem in enumerate(network_elems):
 
3683
            network = addresses_dict.items()[i]
 
3684
            self.assertEqual(str(network_elem.get('id')), str(network[0]))
 
3685
            ip_elems = network_elem.findall('{0}ip'.format(NS))
 
3686
            for z, ip_elem in enumerate(ip_elems):
 
3687
                ip = network[1][z]
 
3688
                self.assertEqual(str(ip_elem.get('version')),
 
3689
                                 str(ip['version']))
 
3690
                self.assertEqual(str(ip_elem.get('addr')),
 
3691
                                 str(ip['addr']))
3375
3692
 
3376
3693
    def test_create(self):
3377
3694
        serializer = servers.ServerXMLSerializer()
3385
3702
                "progress": 0,
3386
3703
                "name": "test_server",
3387
3704
                "status": "BUILD",
 
3705
                "accessIPv4": "1.2.3.4",
 
3706
                "accessIPv6": "fead::1234",
3388
3707
                "hostId": "e4d909c290d0fb1ca068ffaddf22cbd0",
3389
3708
                "adminPass": "test_password",
3390
3709
                "image": {
3445
3764
        }
3446
3765
 
3447
3766
        output = serializer.serialize(fixture, 'create')
3448
 
        actual = minidom.parseString(output.replace("  ", ""))
 
3767
        print output
 
3768
        root = etree.XML(output)
 
3769
        xmlutil.validate_schema(root, 'server')
3449
3770
 
3450
3771
        expected_server_href = self.SERVER_HREF
3451
3772
        expected_server_bookmark = self.SERVER_BOOKMARK
3453
3774
        expected_flavor_bookmark = self.FLAVOR_BOOKMARK
3454
3775
        expected_now = self.TIMESTAMP
3455
3776
        expected_uuid = FAKE_UUID
3456
 
        expected = minidom.parseString("""
3457
 
        <server id="1"
3458
 
                uuid="%(expected_uuid)s"
3459
 
                xmlns="http://docs.openstack.org/compute/api/v1.1"
3460
 
                xmlns:atom="http://www.w3.org/2005/Atom"
3461
 
                name="test_server"
3462
 
                updated="%(expected_now)s"
3463
 
                created="%(expected_now)s"
3464
 
                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
3465
 
                status="BUILD"
3466
 
                adminPass="test_password"
3467
 
                progress="0">
3468
 
            <atom:link href="%(expected_server_href)s" rel="self"/>
3469
 
            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
3470
 
            <image id="5">
3471
 
                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
3472
 
            </image>
3473
 
            <flavor id="1">
3474
 
                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
3475
 
            </flavor>
3476
 
            <metadata>
3477
 
                <meta key="Open">
3478
 
                    Stack
3479
 
                </meta>
3480
 
                <meta key="Number">
3481
 
                    1
3482
 
                </meta>
3483
 
            </metadata>
3484
 
            <addresses>
3485
 
                <network id="network_one">
3486
 
                    <ip version="4" addr="67.23.10.138"/>
3487
 
                    <ip version="6" addr="::babe:67.23.10.138"/>
3488
 
                </network>
3489
 
                <network id="network_two">
3490
 
                    <ip version="4" addr="67.23.10.139"/>
3491
 
                    <ip version="6" addr="::babe:67.23.10.139"/>
3492
 
                </network>
3493
 
            </addresses>
3494
 
        </server>
3495
 
        """.replace("  ", "") % (locals()))
3496
 
 
3497
 
        self.assertEqual(expected.toxml(), actual.toxml())
 
3777
        server_dict = fixture['server']
 
3778
 
 
3779
        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
 
3780
                    'updated', 'progress', 'status', 'hostId',
 
3781
                    'accessIPv6', 'adminPass']:
 
3782
            self.assertEqual(root.get(key), str(server_dict[key]))
 
3783
 
 
3784
        link_nodes = root.findall('{0}link'.format(ATOMNS))
 
3785
        self.assertEqual(len(link_nodes), 2)
 
3786
        for i, link in enumerate(server_dict['links']):
 
3787
            for key, value in link.items():
 
3788
                self.assertEqual(link_nodes[i].get(key), value)
 
3789
 
 
3790
        metadata_root = root.find('{0}metadata'.format(NS))
 
3791
        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
 
3792
        self.assertEqual(len(metadata_elems), 2)
 
3793
        for i, metadata_elem in enumerate(metadata_elems):
 
3794
            (meta_key, meta_value) = server_dict['metadata'].items()[i]
 
3795
            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
 
3796
            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
3797
 
 
3798
        image_root = root.find('{0}image'.format(NS))
 
3799
        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
 
3800
        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
 
3801
        self.assertEqual(len(link_nodes), 1)
 
3802
        for i, link in enumerate(server_dict['image']['links']):
 
3803
            for key, value in link.items():
 
3804
                self.assertEqual(link_nodes[i].get(key), value)
 
3805
 
 
3806
        flavor_root = root.find('{0}flavor'.format(NS))
 
3807
        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
 
3808
        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
 
3809
        self.assertEqual(len(link_nodes), 1)
 
3810
        for i, link in enumerate(server_dict['flavor']['links']):
 
3811
            for key, value in link.items():
 
3812
                self.assertEqual(link_nodes[i].get(key), value)
 
3813
 
 
3814
        addresses_root = root.find('{0}addresses'.format(NS))
 
3815
        addresses_dict = server_dict['addresses']
 
3816
        network_elems = addresses_root.findall('{0}network'.format(NS))
 
3817
        self.assertEqual(len(network_elems), 2)
 
3818
        for i, network_elem in enumerate(network_elems):
 
3819
            network = addresses_dict.items()[i]
 
3820
            self.assertEqual(str(network_elem.get('id')), str(network[0]))
 
3821
            ip_elems = network_elem.findall('{0}ip'.format(NS))
 
3822
            for z, ip_elem in enumerate(ip_elems):
 
3823
                ip = network[1][z]
 
3824
                self.assertEqual(str(ip_elem.get('version')),
 
3825
                                 str(ip['version']))
 
3826
                self.assertEqual(str(ip_elem.get('addr')),
 
3827
                                 str(ip['addr']))
3498
3828
 
3499
3829
    def test_index(self):
3500
3830
        serializer = servers.ServerXMLSerializer()
3535
3865
        ]}
3536
3866
 
3537
3867
        output = serializer.serialize(fixture, 'index')
3538
 
        actual = minidom.parseString(output.replace("  ", ""))
3539
 
 
3540
 
        expected = minidom.parseString("""
3541
 
        <servers xmlns="http://docs.openstack.org/compute/api/v1.1"
3542
 
                 xmlns:atom="http://www.w3.org/2005/Atom">
3543
 
        <server id="1" name="test_server">
3544
 
            <atom:link href="%(expected_server_href)s" rel="self"/>
3545
 
            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
3546
 
        </server>
3547
 
        <server id="2" name="test_server_2">
3548
 
            <atom:link href="%(expected_server_href_2)s" rel="self"/>
3549
 
            <atom:link href="%(expected_server_bookmark_2)s" rel="bookmark"/>
3550
 
        </server>
3551
 
        </servers>
3552
 
        """.replace("  ", "") % (locals()))
3553
 
 
3554
 
        self.assertEqual(expected.toxml(), actual.toxml())
 
3868
        print output
 
3869
        root = etree.XML(output)
 
3870
        xmlutil.validate_schema(root, 'servers_index')
 
3871
        server_elems = root.findall('{0}server'.format(NS))
 
3872
        self.assertEqual(len(server_elems), 2)
 
3873
        for i, server_elem in enumerate(server_elems):
 
3874
            server_dict = fixture['servers'][i]
 
3875
            for key in ['name', 'id']:
 
3876
                self.assertEqual(server_elem.get(key), str(server_dict[key]))
 
3877
 
 
3878
            link_nodes = server_elem.findall('{0}link'.format(ATOMNS))
 
3879
            self.assertEqual(len(link_nodes), 2)
 
3880
            for i, link in enumerate(server_dict['links']):
 
3881
                for key, value in link.items():
 
3882
                    self.assertEqual(link_nodes[i].get(key), value)
3555
3883
 
3556
3884
    def test_detail(self):
3557
3885
        serializer = servers.ServerXMLSerializer()
3574
3902
                "progress": 0,
3575
3903
                "name": "test_server",
3576
3904
                "status": "BUILD",
 
3905
                "accessIPv4": "1.2.3.4",
 
3906
                "accessIPv6": "fead::1234",
3577
3907
                "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
3578
3908
                "image": {
3579
3909
                    "id": "5",
3627
3957
                "progress": 100,
3628
3958
                "name": "test_server_2",
3629
3959
                "status": "ACTIVE",
 
3960
                "accessIPv4": "1.2.3.4",
 
3961
                "accessIPv6": "fead::1234",
3630
3962
                "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
3631
3963
                "image": {
3632
3964
                    "id": "5",
3675
4007
        ]}
3676
4008
 
3677
4009
        output = serializer.serialize(fixture, 'detail')
3678
 
        actual = minidom.parseString(output.replace("  ", ""))
3679
 
 
3680
 
        expected = minidom.parseString("""
3681
 
        <servers xmlns="http://docs.openstack.org/compute/api/v1.1"
3682
 
                 xmlns:atom="http://www.w3.org/2005/Atom">
3683
 
        <server id="1"
3684
 
                uuid="%(expected_uuid)s"
3685
 
                name="test_server"
3686
 
                updated="%(expected_now)s"
3687
 
                created="%(expected_now)s"
3688
 
                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
3689
 
                status="BUILD"
3690
 
                progress="0">
3691
 
            <atom:link href="%(expected_server_href)s" rel="self"/>
3692
 
            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
3693
 
            <image id="5">
3694
 
                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
3695
 
            </image>
3696
 
            <flavor id="1">
3697
 
                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
3698
 
            </flavor>
3699
 
            <metadata>
3700
 
                <meta key="Number">
3701
 
                    1
3702
 
                </meta>
3703
 
            </metadata>
3704
 
            <addresses>
3705
 
                <network id="network_one">
3706
 
                    <ip version="4" addr="67.23.10.138"/>
3707
 
                    <ip version="6" addr="::babe:67.23.10.138"/>
3708
 
                </network>
3709
 
            </addresses>
3710
 
        </server>
3711
 
        <server id="2"
3712
 
                uuid="%(expected_uuid)s"
3713
 
                name="test_server_2"
3714
 
                updated="%(expected_now)s"
3715
 
                created="%(expected_now)s"
3716
 
                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
3717
 
                status="ACTIVE"
3718
 
                progress="100">
3719
 
            <atom:link href="%(expected_server_href_2)s" rel="self"/>
3720
 
            <atom:link href="%(expected_server_bookmark_2)s" rel="bookmark"/>
3721
 
            <image id="5">
3722
 
                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
3723
 
            </image>
3724
 
            <flavor id="1">
3725
 
                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
3726
 
            </flavor>
3727
 
            <metadata>
3728
 
                <meta key="Number">
3729
 
                    2
3730
 
                </meta>
3731
 
            </metadata>
3732
 
            <addresses>
3733
 
                <network id="network_one">
3734
 
                    <ip version="4" addr="67.23.10.138"/>
3735
 
                    <ip version="6" addr="::babe:67.23.10.138"/>
3736
 
                </network>
3737
 
            </addresses>
3738
 
        </server>
3739
 
        </servers>
3740
 
        """.replace("  ", "") % (locals()))
3741
 
 
3742
 
        self.assertEqual(expected.toxml(), actual.toxml())
 
4010
        print output
 
4011
        root = etree.XML(output)
 
4012
        xmlutil.validate_schema(root, 'servers')
 
4013
        server_elems = root.findall('{0}server'.format(NS))
 
4014
        self.assertEqual(len(server_elems), 2)
 
4015
        for i, server_elem in enumerate(server_elems):
 
4016
            server_dict = fixture['servers'][i]
 
4017
 
 
4018
            for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
 
4019
                        'updated', 'progress', 'status', 'hostId',
 
4020
                        'accessIPv6']:
 
4021
                self.assertEqual(server_elem.get(key), str(server_dict[key]))
 
4022
 
 
4023
            link_nodes = server_elem.findall('{0}link'.format(ATOMNS))
 
4024
            self.assertEqual(len(link_nodes), 2)
 
4025
            for i, link in enumerate(server_dict['links']):
 
4026
                for key, value in link.items():
 
4027
                    self.assertEqual(link_nodes[i].get(key), value)
 
4028
 
 
4029
            metadata_root = server_elem.find('{0}metadata'.format(NS))
 
4030
            metadata_elems = metadata_root.findall('{0}meta'.format(NS))
 
4031
            for i, metadata_elem in enumerate(metadata_elems):
 
4032
                (meta_key, meta_value) = server_dict['metadata'].items()[i]
 
4033
                self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
 
4034
                self.assertEqual(str(metadata_elem.text).strip(),
 
4035
                                 str(meta_value))
 
4036
 
 
4037
            image_root = server_elem.find('{0}image'.format(NS))
 
4038
            self.assertEqual(image_root.get('id'), server_dict['image']['id'])
 
4039
            link_nodes = image_root.findall('{0}link'.format(ATOMNS))
 
4040
            self.assertEqual(len(link_nodes), 1)
 
4041
            for i, link in enumerate(server_dict['image']['links']):
 
4042
                for key, value in link.items():
 
4043
                    self.assertEqual(link_nodes[i].get(key), value)
 
4044
 
 
4045
            flavor_root = server_elem.find('{0}flavor'.format(NS))
 
4046
            self.assertEqual(flavor_root.get('id'),
 
4047
                             server_dict['flavor']['id'])
 
4048
            link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
 
4049
            self.assertEqual(len(link_nodes), 1)
 
4050
            for i, link in enumerate(server_dict['flavor']['links']):
 
4051
                for key, value in link.items():
 
4052
                    self.assertEqual(link_nodes[i].get(key), value)
 
4053
 
 
4054
            addresses_root = server_elem.find('{0}addresses'.format(NS))
 
4055
            addresses_dict = server_dict['addresses']
 
4056
            network_elems = addresses_root.findall('{0}network'.format(NS))
 
4057
            for i, network_elem in enumerate(network_elems):
 
4058
                network = addresses_dict.items()[i]
 
4059
                self.assertEqual(str(network_elem.get('id')), str(network[0]))
 
4060
                ip_elems = network_elem.findall('{0}ip'.format(NS))
 
4061
                for z, ip_elem in enumerate(ip_elems):
 
4062
                    ip = network[1][z]
 
4063
                    self.assertEqual(str(ip_elem.get('version')),
 
4064
                                     str(ip['version']))
 
4065
                    self.assertEqual(str(ip_elem.get('addr')),
 
4066
                                     str(ip['addr']))
3743
4067
 
3744
4068
    def test_update(self):
3745
4069
        serializer = servers.ServerXMLSerializer()
3754
4078
                "name": "test_server",
3755
4079
                "status": "BUILD",
3756
4080
                "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
 
4081
                "accessIPv4": "1.2.3.4",
 
4082
                "accessIPv6": "fead::1234",
3757
4083
                "image": {
3758
4084
                    "id": "5",
3759
4085
                    "links": [
3812
4138
        }
3813
4139
 
3814
4140
        output = serializer.serialize(fixture, 'update')
3815
 
        actual = minidom.parseString(output.replace("  ", ""))
 
4141
        print output
 
4142
        root = etree.XML(output)
 
4143
        xmlutil.validate_schema(root, 'server')
3816
4144
 
3817
4145
        expected_server_href = self.SERVER_HREF
3818
4146
        expected_server_bookmark = self.SERVER_BOOKMARK
3820
4148
        expected_flavor_bookmark = self.FLAVOR_BOOKMARK
3821
4149
        expected_now = self.TIMESTAMP
3822
4150
        expected_uuid = FAKE_UUID
3823
 
        expected = minidom.parseString("""
3824
 
        <server id="1"
3825
 
                uuid="%(expected_uuid)s"
3826
 
                xmlns="http://docs.openstack.org/compute/api/v1.1"
3827
 
                xmlns:atom="http://www.w3.org/2005/Atom"
3828
 
                name="test_server"
3829
 
                updated="%(expected_now)s"
3830
 
                created="%(expected_now)s"
3831
 
                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
3832
 
                status="BUILD"
3833
 
                progress="0">
3834
 
            <atom:link href="%(expected_server_href)s" rel="self"/>
3835
 
            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
3836
 
            <image id="5">
3837
 
                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
3838
 
            </image>
3839
 
            <flavor id="1">
3840
 
                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
3841
 
            </flavor>
3842
 
            <metadata>
3843
 
                <meta key="Open">
3844
 
                    Stack
3845
 
                </meta>
3846
 
                <meta key="Number">
3847
 
                    1
3848
 
                </meta>
3849
 
            </metadata>
3850
 
            <addresses>
3851
 
                <network id="network_one">
3852
 
                    <ip version="4" addr="67.23.10.138"/>
3853
 
                    <ip version="6" addr="::babe:67.23.10.138"/>
3854
 
                </network>
3855
 
                <network id="network_two">
3856
 
                    <ip version="4" addr="67.23.10.139"/>
3857
 
                    <ip version="6" addr="::babe:67.23.10.139"/>
3858
 
                </network>
3859
 
            </addresses>
3860
 
        </server>
3861
 
        """.replace("  ", "") % (locals()))
3862
 
 
3863
 
        self.assertEqual(expected.toxml(), actual.toxml())
 
4151
        server_dict = fixture['server']
 
4152
 
 
4153
        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
 
4154
                    'updated', 'progress', 'status', 'hostId',
 
4155
                    'accessIPv6']:
 
4156
            self.assertEqual(root.get(key), str(server_dict[key]))
 
4157
 
 
4158
        link_nodes = root.findall('{0}link'.format(ATOMNS))
 
4159
        self.assertEqual(len(link_nodes), 2)
 
4160
        for i, link in enumerate(server_dict['links']):
 
4161
            for key, value in link.items():
 
4162
                self.assertEqual(link_nodes[i].get(key), value)
 
4163
 
 
4164
        metadata_root = root.find('{0}metadata'.format(NS))
 
4165
        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
 
4166
        self.assertEqual(len(metadata_elems), 2)
 
4167
        for i, metadata_elem in enumerate(metadata_elems):
 
4168
            (meta_key, meta_value) = server_dict['metadata'].items()[i]
 
4169
            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
 
4170
            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
4171
 
 
4172
        image_root = root.find('{0}image'.format(NS))
 
4173
        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
 
4174
        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
 
4175
        self.assertEqual(len(link_nodes), 1)
 
4176
        for i, link in enumerate(server_dict['image']['links']):
 
4177
            for key, value in link.items():
 
4178
                self.assertEqual(link_nodes[i].get(key), value)
 
4179
 
 
4180
        flavor_root = root.find('{0}flavor'.format(NS))
 
4181
        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
 
4182
        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
 
4183
        self.assertEqual(len(link_nodes), 1)
 
4184
        for i, link in enumerate(server_dict['flavor']['links']):
 
4185
            for key, value in link.items():
 
4186
                self.assertEqual(link_nodes[i].get(key), value)
 
4187
 
 
4188
        addresses_root = root.find('{0}addresses'.format(NS))
 
4189
        addresses_dict = server_dict['addresses']
 
4190
        network_elems = addresses_root.findall('{0}network'.format(NS))
 
4191
        self.assertEqual(len(network_elems), 2)
 
4192
        for i, network_elem in enumerate(network_elems):
 
4193
            network = addresses_dict.items()[i]
 
4194
            self.assertEqual(str(network_elem.get('id')), str(network[0]))
 
4195
            ip_elems = network_elem.findall('{0}ip'.format(NS))
 
4196
            for z, ip_elem in enumerate(ip_elems):
 
4197
                ip = network[1][z]
 
4198
                self.assertEqual(str(ip_elem.get('version')),
 
4199
                                 str(ip['version']))
 
4200
                self.assertEqual(str(ip_elem.get('addr')),
 
4201
                                 str(ip['addr']))