~lutostag/ubuntu/trusty/maas/1.5.4+keystone

« back to all changes in this revision

Viewing changes to src/metadataserver/tests/test_api.py

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

Show diffs side-by-side

added

removed

src/metadataserver/tests/test_api.py

16

16

import httplib

17

17

from io import BytesIO

18

18

import json

 

19

import os.path

 

20

import random

 

21

import tarfile

19

22

 

20

23

from django.conf import settings

21

24

from django.core.exceptions import PermissionDenied

34

37

from maasserver.testing.factory import factory

35

38

from maasserver.testing.oauthclient import OAuthAuthenticatedClient

36

39

from maastesting.djangotestcase import DjangoTestCase

 

40

from maastesting.matchers import ContainsAll

37

41

from metadataserver import api

38

42

from metadataserver.api import (

39

43

    check_version,

50

54

    NodeKey,

51

55

    NodeUserData,

52

56

    )

 

57

from metadataserver.models.commissioningscript import ARCHIVE_PREFIX

53

58

from metadataserver.nodeinituser import get_node_init_user

54

59

from mock import Mock

55

60

from netaddr import IPNetwork

160

165

            'status': 'OK',

161

166

        }

162

167

        params.update(kwargs)

163

 

        for name, content in files.items():

164

 

            params[name] = BytesIO(content)

165

 

            params[name].name = name

 

168

        params.update({

 

169

            name: factory.make_file_upload(name, content)

 

170

            for name, content in files.items()

 

171

        })

166

172

        url = reverse('metadata-version', args=[version])

167

173

        return client.post(url, params)

168

174

 

182

188

        # The test is that we get here without exception.

183

189

        pass

184

190

 

185

 

    def test_version_index_shows_meta_data(self):

 

191

    def test_version_index_shows_unconditional_entries(self):

186

192

        client = self.make_node_client()

187

193

        url = reverse('metadata-version', args=['latest'])

188

194

        items = client.get(url).content.splitlines()

189

 

        self.assertIn('meta-data', items)

 

195

        self.assertThat(items, ContainsAll([

 

196

            'meta-data',

 

197

            'maas-commissioning-scripts',

 

198

            ]))

190

199

 

191

200

    def test_version_index_does_not_show_user_data_if_not_available(self):

192

201

        client = self.make_node_client()

326

335

            '\n'.join(keys),

327

336

            response.content.decode('ascii'))

328

337

 

 

338

    def test_commissioning_scripts(self):

 

339

        script = factory.make_commissioning_script()

 

340

        response = self.make_node_client().get(

 

341

            reverse('commissioning-scripts', args=['latest']))

 

342

        self.assertEqual(

 

343

            httplib.OK, response.status_code,

 

344

            "Unexpected response %d: %s"

 

345

            % (response.status_code, response.content))

 

346

        self.assertIn(

 

347

            response['Content-Type'],

 

348

            {

 

349

                'application/tar',

 

350

                'application/x-gtar',

 

351

                'application/x-tar',

 

352

                'application/x-tgz',

 

353

            })

 

354

        archive = tarfile.open(fileobj=BytesIO(response.content))

 

355

        self.assertIn(

 

356

            os.path.join(ARCHIVE_PREFIX, script.name),

 

357

            archive.getnames())

 

358

 

329

359

    def test_other_user_than_node_cannot_signal_commissioning_result(self):

330

360

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

331

361

        client = OAuthAuthenticatedClient(factory.make_user())

373

403

        self.assertEqual(

374

404

            NODE_STATUS.COMMISSIONING, reload_object(node).status)

375

405

 

 

406

    def test_signaling_stores_script_result(self):

 

407

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

 

408

        client = self.make_node_client(node=node)

 

409

        script_result = random.randint(0, 10)

 

410

        filename = factory.getRandomString()

 

411

        response = self.call_signal(

 

412

            client, script_result=script_result,

 

413

            files={filename: factory.getRandomString().encode('ascii')})

 

414

        self.assertEqual(httplib.OK, response.status_code, response.content)

 

415

        result = NodeCommissionResult.objects.get(node=node)

 

416

        self.assertEqual(script_result, result.script_result)

 

417

 

 

418

    def test_signaling_stores_empty_script_result(self):

 

419

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

 

420

        client = self.make_node_client(node=node)

 

421

        response = self.call_signal(

 

422

            client, script_result=random.randint(0, 10),

 

423

            files={factory.getRandomString(): ''.encode('ascii')})

 

424

        self.assertEqual(httplib.OK, response.status_code, response.content)

 

425

        result = NodeCommissionResult.objects.get(node=node)

 

426

        self.assertEqual('', result.data)

 

427

 

376

428

    def test_signaling_WORKING_keeps_owner(self):

377

429

        user = factory.make_user()

378

430

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

455

507

            for status in statuses}

456

508

        for status, node in nodes.items():

457

509

            client = self.make_node_client(node=node)

 

510

            script_result = random.randint(0, 10)

458

511

            self.call_signal(

459

512

                client, status=status,

 

513

                script_result=script_result,

460

514

                files={filename: factory.getRandomString().encode('ascii')})

461

515

        self.assertEqual(

462

516

            {status: filename for status in statuses},

468

522

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

469

523

        client = self.make_node_client(node=node)

470

524

        text = factory.getRandomString().encode('ascii')

471

 

        response = self.call_signal(client, files={'file.txt': text})

 

525

        script_result = random.randint(0, 10)

 

526

        response = self.call_signal(

 

527

            client, script_result=script_result, files={'file.txt': text})

472

528

        self.assertEqual(httplib.OK, response.status_code)

473

529

        self.assertEqual(

474

530

            text, NodeCommissionResult.objects.get_data(node, 'file.txt'))

477

533

        unicode_text = '<\u2621>'

478

534

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

479

535

        client = self.make_node_client(node=node)

 

536

        script_result = random.randint(0, 10)

480

537

        response = self.call_signal(

481

 

            client, files={'file.txt': unicode_text.encode('utf-8')})

 

538

            client, script_result=script_result,

 

539

            files={'file.txt': unicode_text.encode('utf-8')})

482

540

        self.assertEqual(httplib.OK, response.status_code)

483

541

        self.assertEqual(

484

542

            unicode_text,

491

549

            for counter in range(3)}

492

550

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

493

551

        client = self.make_node_client(node=node)

494

 

        response = self.call_signal(client, files=contents)

 

552

        script_result = random.randint(0, 10)

 

553

        response = self.call_signal(

 

554

            client, script_result=script_result, files=contents)

495

555

        self.assertEqual(httplib.OK, response.status_code)

496

556

        self.assertEqual(

497

557

            contents,

508

568

        contents = factory.getRandomString(size_limit, spaces=True)

509

569

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)

510

570

        client = self.make_node_client(node=node)

 

571

        script_result = random.randint(0, 10)

511

572

        response = self.call_signal(

512

 

            client, files={'output.txt': contents.encode('utf-8')})

 

573

            client, script_result=script_result,

 

574

            files={'output.txt': contents.encode('utf-8')})

513

575

        self.assertEqual(httplib.OK, response.status_code)

514

576

        stored_data = NodeCommissionResult.objects.get_data(

515

577

            node, 'output.txt')

519

581

        node = factory.make_node(status=NODE_STATUS.COMMISSIONING, memory=512)

520

582

        client = self.make_node_client(node=node)

521

583

        xmlbytes = "<t\xe9st/>".encode("utf-8")

522

 

        response = self.call_signal(client, files={'01-lshw.out': xmlbytes})

 

584

        script_result = random.randint(0, 10)

 

585

        response = self.call_signal(

 

586

            client, script_result=script_result,

 

587

            files={'00-maas-01-lshw.out': xmlbytes})

523

588

        self.assertEqual(httplib.OK, response.status_code)

524

589

        node = reload_object(node)

525

590

        self.assertEqual(xmlbytes, node.hardware_details)

727

792

        ud_url = reverse('enlist-metadata-user-data', args=['latest'])

728

793

        fake_preseed = factory.getRandomString()

729

794

        self.patch(

730

 

            api, "get_enlist_userdata", Mock(return_value= fake_preseed))

 

795

            api, "get_enlist_userdata", Mock(return_value=fake_preseed))

731

796

        response = self.client.get(ud_url)

732

797

        self.assertEqual(

733

798

            (httplib.OK, "text/plain", fake_preseed),

• Older »

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