~ubuntu-branches/ubuntu/saucy/heat/saucy-updates

« back to all changes in this revision

Viewing changes to heat/tests/test_parser.py

• browse files at revision 1.1.3
• compare with another revision
• download diff
• download tarball
• view history from revision 1.1.3

Show diffs side-by-side

added

removed

heat/tests/test_parser.py

14

14

 

15

15

import json

16

16

import time

17

 

import uuid

18

17

 

19

 

from heat.common import context

20

18

from heat.engine import environment

21

19

from heat.common import exception

22

20

from heat.common import template_format

27

25

from heat.engine import scheduler

28

26

from heat.engine import template

29

27

 

 

28

from heat.tests.fakes import FakeKeystoneClient

30

29

from heat.tests.common import HeatTestCase

 

30

from heat.tests.utils import dummy_context

31

31

from heat.tests.utils import setup_dummy_db

32

32

from heat.tests.v1_1 import fakes

33

33

from heat.tests.utils import stack_delete_after

121

121

 

122

122

 

123

123

class TemplateTest(HeatTestCase):

 

124

 

 

125

    def setUp(self):

 

126

        super(TemplateTest, self).setUp()

 

127

        self.ctx = dummy_context()

 

128

 

124

129

    def test_defaults(self):

125

130

        empty = parser.Template({})

126

131

        try:

199

204

 

200

205

    def test_param_ref_missing(self):

201

206

        tmpl = {'Parameters': {'foo': {'Type': 'String', 'Required': True}}}

 

207

        tmpl = parser.Template(tmpl)

202

208

        params = parameters.Parameters('test', tmpl, validate_value=False)

203

209

        snippet = {"Ref": "foo"}

204

210

        self.assertRaises(exception.UserParameterMissing,

390

396

 

391

397

    def test_get_azs_with_stack(self):

392

398

        snippet = {"Fn::GetAZs": ""}

393

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}))

 

399

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}))

394

400

        self.m.StubOutWithMock(clients.OpenStackClients, 'nova')

395

401

        fc = fakes.FakeClient()

396

402

        clients.OpenStackClients.nova().MultipleTimes().AndReturn(fc)

462

468

        deletion_policy_snippet = {'Fn::ResourceFacade': 'DeletionPolicy'}

463

469

        update_policy_snippet = {'Fn::ResourceFacade': 'UpdatePolicy'}

464

470

 

465

 

        class DummyClass:

 

471

        class DummyClass(object):

466

472

            pass

467

473

        parent_resource = DummyClass()

468

474

        parent_resource.metadata = '{"foo": "bar"}'

469

475

        parent_resource.t = {'DeletionPolicy': 'Retain',

470

476

                             'UpdatePolicy': '{"foo": "bar"}'}

471

 

        stack = parser.Stack(None, 'test_stack',

 

477

        stack = parser.Stack(self.ctx, 'test_stack',

472

478

                             parser.Template({}),

473

479

                             parent_resource=parent_resource)

474

480

        self.assertEqual(

483

489

 

484

490

    def test_resource_facade_invalid_arg(self):

485

491

        snippet = {'Fn::ResourceFacade': 'wibble'}

486

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}))

 

492

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}))

487

493

        self.assertRaises(ValueError,

488

494

                          parser.Template.resolve_resource_facade,

489

495

                          snippet,

492

498

    def test_resource_facade_missing_key(self):

493

499

        snippet = {'Fn::ResourceFacade': 'DeletionPolicy'}

494

500

 

495

 

        class DummyClass:

 

501

        class DummyClass(object):

496

502

            pass

497

503

        parent_resource = DummyClass()

498

504

        parent_resource.metadata = '{"foo": "bar"}'

499

505

        parent_resource.t = {}

500

 

        stack = parser.Stack(None, 'test_stack',

 

506

        stack = parser.Stack(self.ctx, 'test_stack',

501

507

                             parser.Template({}),

502

508

                             parent_resource=parent_resource)

503

509

        self.assertRaises(KeyError,

513

519

        self.username = 'parser_stack_test_user'

514

520

 

515

521

        setup_dummy_db()

516

 

        self.ctx = context.get_admin_context()

517

 

        self.m.StubOutWithMock(self.ctx, 'user')

518

 

        self.ctx.user = self.username

519

 

        self.ctx.tenant_id = 'test_tenant'

 

522

        self.ctx = dummy_context()

520

523

 

521

524

        resource._register_class('GenericResourceType',

522

525

                                 generic_rsrc.GenericResource)

526

529

        self.m.ReplayAll()

527

530

 

528

531

    def test_state_defaults(self):

529

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}))

 

532

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}))

530

533

        self.assertEqual(stack.state, (None, None))

531

534

        self.assertEqual(stack.status_reason, '')

532

535

 

 

536

    def test_no_auth_token(self):

 

537

        ctx = dummy_context()

 

538

        ctx.auth_token = None

 

539

        self.m.StubOutWithMock(clients.OpenStackClients, 'keystone')

 

540

        clients.OpenStackClients.keystone().AndReturn(FakeKeystoneClient())

 

541

 

 

542

        self.m.ReplayAll()

 

543

        stack = parser.Stack(ctx, 'test_stack', parser.Template({}))

 

544

        self.assertEqual('abcd1234', stack.clients.auth_token)

 

545

 

 

546

        self.m.VerifyAll()

 

547

 

533

548

    def test_state(self):

534

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}),

 

549

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}),

535

550

                             action=parser.Stack.CREATE,

536

551

                             status=parser.Stack.IN_PROGRESS)

537

552

        self.assertEqual(stack.state,

544

559

                         (parser.Stack.DELETE, parser.Stack.COMPLETE))

545

560

 

546

561

    def test_state_bad(self):

547

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}),

 

562

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}),

548

563

                             action=parser.Stack.CREATE,

549

564

                             status=parser.Stack.IN_PROGRESS)

550

565

        self.assertEqual(stack.state,

555

570

                          parser.Stack.CREATE, 'oops', 'test')

556

571

 

557

572

    def test_status_reason(self):

558

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}),

 

573

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}),

559

574

                             status_reason='quux')

560

575

        self.assertEqual(stack.status_reason, 'quux')

561

576

        stack.state_set(parser.Stack.CREATE, parser.Stack.IN_PROGRESS,

608

623

 

609

624

    @stack_delete_after

610

625

    def test_set_param_id(self):

611

 

        dummy_stackid = 'STACKABCD1234'

612

 

        self.m.StubOutWithMock(uuid, 'uuid4')

613

 

        uuid.uuid4().AndReturn(dummy_stackid)

614

 

        self.m.ReplayAll()

615

626

        self.stack = parser.Stack(self.ctx, 'param_arn_test',

616

627

                                  parser.Template({}))

617

 

        exp_prefix = 'arn:openstack:heat::test_tenant:stacks/param_arn_test/'

 

628

        exp_prefix = ('arn:openstack:heat::test_tenant_id'

 

629

                      ':stacks/param_arn_test/')

618

630

        self.assertEqual(self.stack.parameters['AWS::StackId'],

619

631

                         exp_prefix + 'None')

620

632

        self.stack.store()

621

633

        identifier = self.stack.identifier()

622

634

        self.assertEqual(self.stack.parameters['AWS::StackId'],

623

 

                         exp_prefix + dummy_stackid)

 

635

                         exp_prefix + self.stack.id)

624

636

        self.assertEqual(self.stack.parameters['AWS::StackId'],

625

637

                         identifier.arn())

626

638

        self.m.VerifyAll()

699

711

    def test_suspend_fail(self):

700

712

        tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}}

701

713

        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_suspend')

702

 

        exc = exception.ResourceFailure(Exception('foo'))

 

714

        exc = Exception('foo')

703

715

        generic_rsrc.GenericResource.handle_suspend().AndRaise(exc)

704

716

        self.m.ReplayAll()

705

717

 

723

735

    def test_resume_fail(self):

724

736

        tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}}

725

737

        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_resume')

726

 

        exc = exception.ResourceFailure(Exception('foo'))

727

 

        generic_rsrc.GenericResource.handle_resume().AndRaise(exc)

 

738

        generic_rsrc.GenericResource.handle_resume().AndRaise(Exception('foo'))

728

739

        self.m.ReplayAll()

729

740

 

730

741

        self.stack = parser.Stack(self.ctx, 'resume_test_fail',

1022

1033

        # key/property in update_allowed_keys/update_allowed_properties

1023

1034

 

1024

1035

        # make the update fail deleting the existing resource

1025

 

        self.m.StubOutWithMock(resource.Resource, 'destroy')

1026

 

        exc = exception.ResourceFailure(Exception())

1027

 

        resource.Resource.destroy().AndRaise(exc)

 

1036

        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_delete')

 

1037

        generic_rsrc.GenericResource.handle_delete().AndRaise(Exception)

1028

1038

        self.m.ReplayAll()

1029

1039

 

1030

1040

        self.stack.update(updated_stack)

1222

1232

                                     template.Template(tmpl2))

1223

1233

 

1224

1234

        # patch in a dummy delete making the destroy fail

1225

 

        self.m.StubOutWithMock(resource.Resource, 'delete')

1226

 

        exc = exception.ResourceFailure(Exception())

1227

 

        resource.Resource.delete().AndRaise(exc)

 

1235

        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_delete')

 

1236

        generic_rsrc.GenericResource.handle_delete().AndRaise(Exception)

1228

1237

        self.m.ReplayAll()

1229

1238

 

1230

1239

        self.stack.update(updated_stack)

1466

1475

        self.m.StubOutWithMock(scheduler.DependencyTaskGroup, '__call__')

1467

1476

        self.m.StubOutWithMock(scheduler, 'wallclock')

1468

1477

 

1469

 

        stack = parser.Stack(None, 's', parser.Template({}))

 

1478

        stack = parser.Stack(self.ctx, 's', parser.Template({}))

1470

1479

 

1471

1480

        def dummy_task():

1472

1481

            while True:

1489

1498

        self.m.VerifyAll()

1490

1499

 

1491

1500

    def test_stack_name_valid(self):

1492

 

        stack = parser.Stack(None, 's', parser.Template({}))

1493

 

        stack = parser.Stack(None, 'stack123', parser.Template({}))

1494

 

        stack = parser.Stack(None, 'test.stack', parser.Template({}))

1495

 

        stack = parser.Stack(None, 'test_stack', parser.Template({}))

1496

 

        stack = parser.Stack(None, 'TEST', parser.Template({}))

1497

 

        stack = parser.Stack(None, 'test-stack', parser.Template({}))

 

1501

        stack = parser.Stack(self.ctx, 's', parser.Template({}))

 

1502

        stack = parser.Stack(self.ctx, 'stack123', parser.Template({}))

 

1503

        stack = parser.Stack(self.ctx, 'test.stack', parser.Template({}))

 

1504

        stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}))

 

1505

        stack = parser.Stack(self.ctx, 'TEST', parser.Template({}))

 

1506

        stack = parser.Stack(self.ctx, 'test-stack', parser.Template({}))

1498

1507

 

1499

1508

    def test_stack_name_invalid(self):

1500

 

        self.assertRaises(ValueError, parser.Stack, None, '_foo',

1501

 

                          parser.Template({}))

1502

 

        self.assertRaises(ValueError, parser.Stack, None, '1bad',

1503

 

                          parser.Template({}))

1504

 

        self.assertRaises(ValueError, parser.Stack, None, '.kcats',

1505

 

                          parser.Template({}))

1506

 

        self.assertRaises(ValueError, parser.Stack, None, 'test stack',

1507

 

                          parser.Template({}))

1508

 

        self.assertRaises(ValueError, parser.Stack, None, ' teststack',

1509

 

                          parser.Template({}))

1510

 

        self.assertRaises(ValueError, parser.Stack, None, '^-^',

1511

 

                          parser.Template({}))

1512

 

        self.assertRaises(ValueError, parser.Stack, None, '\"stack\"',

1513

 

                          parser.Template({}))

1514

 

        self.assertRaises(ValueError, parser.Stack, None, '1234',

1515

 

                          parser.Template({}))

1516

 

        self.assertRaises(ValueError, parser.Stack, None, 'cat|dog',

1517

 

                          parser.Template({}))

1518

 

        self.assertRaises(ValueError, parser.Stack, None, '$(foo)',

1519

 

                          parser.Template({}))

1520

 

        self.assertRaises(ValueError, parser.Stack, None, 'test/stack',

1521

 

                          parser.Template({}))

1522

 

        self.assertRaises(ValueError, parser.Stack, None, 'test\stack',

1523

 

                          parser.Template({}))

1524

 

        self.assertRaises(ValueError, parser.Stack, None, 'test::stack',

1525

 

                          parser.Template({}))

1526

 

        self.assertRaises(ValueError, parser.Stack, None, 'test;stack',

1527

 

                          parser.Template({}))

1528

 

        self.assertRaises(ValueError, parser.Stack, None, 'test~stack',

1529

 

                          parser.Template({}))

1530

 

        self.assertRaises(ValueError, parser.Stack, None, '#test',

 

1509

        self.assertRaises(ValueError, parser.Stack, self.ctx, '_foo',

 

1510

                          parser.Template({}))

 

1511

        self.assertRaises(ValueError, parser.Stack, self.ctx, '1bad',

 

1512

                          parser.Template({}))

 

1513

        self.assertRaises(ValueError, parser.Stack, self.ctx, '.kcats',

 

1514

                          parser.Template({}))

 

1515

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test stack',

 

1516

                          parser.Template({}))

 

1517

        self.assertRaises(ValueError, parser.Stack, self.ctx, ' teststack',

 

1518

                          parser.Template({}))

 

1519

        self.assertRaises(ValueError, parser.Stack, self.ctx, '^-^',

 

1520

                          parser.Template({}))

 

1521

        self.assertRaises(ValueError, parser.Stack, self.ctx, '\"stack\"',

 

1522

                          parser.Template({}))

 

1523

        self.assertRaises(ValueError, parser.Stack, self.ctx, '1234',

 

1524

                          parser.Template({}))

 

1525

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'cat|dog',

 

1526

                          parser.Template({}))

 

1527

        self.assertRaises(ValueError, parser.Stack, self.ctx, '$(foo)',

 

1528

                          parser.Template({}))

 

1529

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test/stack',

 

1530

                          parser.Template({}))

 

1531

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test\stack',

 

1532

                          parser.Template({}))

 

1533

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test::stack',

 

1534

                          parser.Template({}))

 

1535

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test;stack',

 

1536

                          parser.Template({}))

 

1537

        self.assertRaises(ValueError, parser.Stack, self.ctx, 'test~stack',

 

1538

                          parser.Template({}))

 

1539

        self.assertRaises(ValueError, parser.Stack, self.ctx, '#test',

1531

1540

                          parser.Template({}))

1532

1541

 

1533

1542

    @stack_delete_after

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1