~ubuntu-branches/ubuntu/precise/python-quantumclient/precise : revision 1

1

# vim: tabstop=4 shiftwidth=4 softtabstop=4

2

3

4

5

#

6

# Licensed under the Apache License, Version 2.0 (the "License"); you may

7

# not use this file except in compliance with the License. You may obtain

8

# a copy of the License at

9

#

10

# http://www.apache.org/licenses/LICENSE-2.0

11

#

12

# Unless required by applicable law or agreed to in writing, software

13

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

14

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

15

# License for the specific language governing permissions and limitations

16

# under the License.

17

# @author: Tyler Smith, Cisco Systems

18

19

import logging

20

import unittest

21

import re

22

23

from quantum.common.serializer import Serializer

24

from quantum.client import Client

25

26

LOG = logging.getLogger('quantum.tests.test_api')

27

28

# Set a couple tenants to use for testing

29

TENANT_1 = 'totore'

30

TENANT_2 = 'totore2'

31

32

33

class ServerStub():

34

"""This class stubs a basic server for the API client to talk to"""

35

36

class Response(object):

37

"""This class stubs a basic response to send the API client"""

38

def __init__(self, content=None, status=None):

39

self.content = content

40

self.status = status

41

42

def read(self):

43

return self.content

44

45

def status(self):

46

return self.status

47

48

# To test error codes, set the host to 10.0.0.1, and the port to the code

49

def __init__(self, host, port=9696, key_file="", cert_file=""):

50

self.host = host

51

self.port = port

52

self.key_file = key_file

53

self.cert_file = cert_file

54

55

def request(self, method, action, body, headers):

56

self.method = method

57

self.action = action

58

self.body = body

59

60

def status(self, status=None):

61

return status or 200

62

63

def getresponse(self):

64

res = self.Response(status=self.status())

65

66

# If the host is 10.0.0.1, return the port as an error code

67

if self.host == "10.0.0.1":

68

res.status = self.port

69

return res

70

71

# Extract important information from the action string to assure sanity

72

match = re.search('tenants/(.+?)/(.+)\.(json|xml)$', self.action)

73

74

tenant = match.group(1)

75

path = match.group(2)

76

format = match.group(3)

77

78

data = {'data': {'method': self.method, 'action': self.action,

79

'body': self.body, 'tenant': tenant, 'path': path,

80

'format': format, 'key_file': self.key_file,

81

'cert_file': self.cert_file}}

82

83

# Serialize it to the proper format so the API client can handle it

84

if data['data']['format'] == 'json':

85

res.content = Serializer().serialize(data, "application/json")

86

else:

87

res.content = Serializer().serialize(data, "application/xml")

88

return res

89

90

91

class APITest(unittest.TestCase):

92

93

def setUp(self):

94

""" Setups a test environment for the API client """

95

HOST = '127.0.0.1'

96

PORT = 9696

97

USE_SSL = False

98

99

self.client = Client(HOST, PORT, USE_SSL, TENANT_1, 'json', ServerStub)

100

101

def _assert_sanity(self, call, status, method, path, data=[], params={}):

102

""" Perform common assertions to test the sanity of client requests """

103

104

# Handle an error case first

105

if status != 200:

106

(self.client.host, self.client.port) = ("10.0.0.1", status)

107

self.assertRaises(Exception, call, *data, **params)

108

return

109

110

# Make the call, then get the data from the root node and assert it

111

data = call(*data, **params)['data']

112

113

self.assertEqual(data['method'], method)

114

self.assertEqual(data['format'], params['format'])

115

self.assertEqual(data['tenant'], params['tenant'])

116

self.assertEqual(data['path'], path)

117

118

return data

119

120

def _test_list_networks(self, tenant=TENANT_1, format='json', status=200):

121

LOG.debug("_test_list_networks - tenant:%s "\

122

"- format:%s - START", format, tenant)

123

124

self._assert_sanity(self.client.list_networks,

125

status,

126

"GET",

127

"networks",

128

data=[],

129

params={'tenant': tenant, 'format': format})

130

131

LOG.debug("_test_list_networks - tenant:%s "\

132

"- format:%s - END", format, tenant)

133

134

def _test_show_network_details(self,

135

tenant=TENANT_1, format='json', status=200):

136

LOG.debug("_test_show_network_details - tenant:%s "\

137

"- format:%s - START", format, tenant)

138

139

self._assert_sanity(self.client.show_network_details,

140

status,

141

"GET",

142

"networks/001",

143

data=["001"],

144

params={'tenant': tenant, 'format': format})

145

146

LOG.debug("_test_show_network_details - tenant:%s "\

147

"- format:%s - END", format, tenant)

148

149

def _test_create_network(self, tenant=TENANT_1, format='json', status=200):

150

LOG.debug("_test_create_network - tenant:%s "\

151

"- format:%s - START", format, tenant)

152

153

self._assert_sanity(self.client.create_network,

154

status,

155

"POST",

156

"networks",

157

data=[{'network': {'net-name': 'testNetwork'}}],

158

params={'tenant': tenant, 'format': format})

159

160

LOG.debug("_test_create_network - tenant:%s "\

161

"- format:%s - END", format, tenant)

162

163

def _test_update_network(self, tenant=TENANT_1, format='json', status=200):

164

LOG.debug("_test_update_network - tenant:%s "\

165

"- format:%s - START", format, tenant)

166

167

self._assert_sanity(self.client.update_network,

168

status,

169

"PUT",

170

"networks/001",

171

data=["001",

172

{'network': {'net-name': 'newName'}}],

173

params={'tenant': tenant, 'format': format})

174

175

LOG.debug("_test_update_network - tenant:%s "\

176

"- format:%s - END", format, tenant)

177

178

def _test_delete_network(self, tenant=TENANT_1, format='json', status=200):

179

LOG.debug("_test_delete_network - tenant:%s "\

180

"- format:%s - START", format, tenant)

181

182

self._assert_sanity(self.client.delete_network,

183

status,

184

"DELETE",

185

"networks/001",

186

data=["001"],

187

params={'tenant': tenant, 'format': format})

188

189

LOG.debug("_test_delete_network - tenant:%s "\

190

"- format:%s - END", format, tenant)

191

192

def _test_list_ports(self, tenant=TENANT_1, format='json', status=200):

193

LOG.debug("_test_list_ports - tenant:%s "\

194

"- format:%s - START", format, tenant)

195

196

self._assert_sanity(self.client.list_ports,

197

status,

198

"GET",

199

"networks/001/ports",

200

data=["001"],

201

params={'tenant': tenant, 'format': format})

202

203

LOG.debug("_test_list_ports - tenant:%s "\

204

"- format:%s - END", format, tenant)

205

206

def _test_show_port_details(self,

207

tenant=TENANT_1, format='json', status=200):

208

LOG.debug("_test_show_port_details - tenant:%s "\

209

"- format:%s - START", format, tenant)

210

211

self._assert_sanity(self.client.show_port_details,

212

status,

213

"GET",

214

"networks/001/ports/001",

215

data=["001", "001"],

216

params={'tenant': tenant, 'format': format})

217

218

LOG.debug("_test_show_port_details - tenant:%s "\

219

"- format:%s - END", format, tenant)

220

221

def _test_create_port(self, tenant=TENANT_1, format='json', status=200):

222

LOG.debug("_test_create_port - tenant:%s "\

223

"- format:%s - START", format, tenant)

224

225

self._assert_sanity(self.client.create_port,

226

status,

227

"POST",

228

"networks/001/ports",

229

data=["001"],

230

params={'tenant': tenant, 'format': format})

231

232

LOG.debug("_test_create_port - tenant:%s "\

233

"- format:%s - END", format, tenant)

234

235

def _test_delete_port(self, tenant=TENANT_1, format='json', status=200):

236

LOG.debug("_test_delete_port - tenant:%s "\

237

"- format:%s - START", format, tenant)

238

239

self._assert_sanity(self.client.delete_port,

240

status,

241

"DELETE",

242

"networks/001/ports/001",

243

data=["001", "001"],

244

params={'tenant': tenant, 'format': format})

245

246

LOG.debug("_test_delete_port - tenant:%s "\

247

"- format:%s - END", format, tenant)

248

249

def _test_update_port(self, tenant=TENANT_1, format='json', status=200):

250

LOG.debug("_test_update_port - tenant:%s "\

251

"- format:%s - START", format, tenant)

252

253

self._assert_sanity(self.client.update_port,

254

status,

255

"PUT",

256

"networks/001/ports/001",

257

data=["001", "001",

258

{'port': {'state': 'ACTIVE'}}],

259

params={'tenant': tenant, 'format': format})

260

261

LOG.debug("_test_update_port - tenant:%s "\

262

"- format:%s - END", format, tenant)

263

264

def _test_show_port_attachment(self,

265

tenant=TENANT_1, format='json', status=200):

266

LOG.debug("_test_show_port_attachment - tenant:%s "\

267

"- format:%s - START", format, tenant)

268

269

self._assert_sanity(self.client.show_port_attachment,

270

status,

271

"GET",

272

"networks/001/ports/001/attachment",

273

data=["001", "001"],

274

params={'tenant': tenant, 'format': format})

275

276

LOG.debug("_test_show_port_attachment - tenant:%s "\

277

"- format:%s - END", format, tenant)

278

279

def _test_attach_resource(self, tenant=TENANT_1,

280

format='json', status=200):

281

LOG.debug("_test_attach_resource - tenant:%s "\

282

"- format:%s - START", format, tenant)

283

284

self._assert_sanity(self.client.attach_resource,

285

status,

286

"PUT",

287

"networks/001/ports/001/attachment",

288

data=["001", "001",

289

{'resource': {'id': '1234'}}],

290

params={'tenant': tenant, 'format': format})

291

292

LOG.debug("_test_attach_resource - tenant:%s "\

293

"- format:%s - END", format, tenant)

294

295

def _test_detach_resource(self, tenant=TENANT_1,

296

format='json', status=200):

297

LOG.debug("_test_detach_resource - tenant:%s "\

298

"- format:%s - START", format, tenant)

299

300

self._assert_sanity(self.client.detach_resource,

301

status,

302

"DELETE",

303

"networks/001/ports/001/attachment",

304

data=["001", "001"],

305

params={'tenant': tenant, 'format': format})

306

307

LOG.debug("_test_detach_resource - tenant:%s "\

308

"- format:%s - END", format, tenant)

309

310

def _test_ssl_certificates(self, tenant=TENANT_1,

311

format='json', status=200):

312

LOG.debug("_test_ssl_certificates - tenant:%s "\

313

"- format:%s - START", format, tenant)

314

315

# Set SSL, and our cert file

316

self.client.use_ssl = True

317

cert_file = "/fake.cert"

318

self.client.key_file = self.client.cert_file = cert_file

319

320

data = self._assert_sanity(self.client.list_networks,

321

status,

322

"GET",

323

"networks",

324

data=[],

325

params={'tenant': tenant, 'format': format})

326

327

self.assertEquals(data["key_file"], cert_file)

328

self.assertEquals(data["cert_file"], cert_file)

329

330

LOG.debug("_test_ssl_certificates - tenant:%s "\

331

"- format:%s - END", format, tenant)

332

333

def test_list_networks_json(self):

334

self._test_list_networks(format='json')

335

336

def test_list_networks_xml(self):

337

self._test_list_networks(format='xml')

338

339

def test_list_networks_alt_tenant(self):

340

self._test_list_networks(tenant=TENANT_2)

341

342

def test_list_networks_error_470(self):

343

self._test_list_networks(status=470)

344

345

def test_list_networks_error_401(self):

346

self._test_list_networks(status=401)

347

348

def test_show_network_details_json(self):

349

self._test_show_network_details(format='json')

350

351

def test_show_network_details_xml(self):

352

self._test_show_network_details(format='xml')

353

354

def test_show_network_details_alt_tenant(self):

355

self._test_show_network_details(tenant=TENANT_2)

356

357

def test_show_network_details_error_470(self):

358

self._test_show_network_details(status=470)

359

360

def test_show_network_details_error_401(self):

361

self._test_show_network_details(status=401)

362

363

def test_show_network_details_error_420(self):

364

self._test_show_network_details(status=420)

365

366

def test_create_network_json(self):

367

self._test_create_network(format='json')

368

369

def test_create_network_xml(self):

370

self._test_create_network(format='xml')

371

372

def test_create_network_alt_tenant(self):

373

self._test_create_network(tenant=TENANT_2)

374

375

def test_create_network_error_470(self):

376

self._test_create_network(status=470)

377

378

def test_create_network_error_401(self):

379

self._test_create_network(status=401)

380

381

def test_create_network_error_400(self):

382

self._test_create_network(status=400)

383

384

def test_create_network_error_422(self):

385

self._test_create_network(status=422)

386

387

def test_update_network_json(self):

388

self._test_update_network(format='json')

389

390

def test_update_network_xml(self):

391

self._test_update_network(format='xml')

392

393

def test_update_network_alt_tenant(self):

394

self._test_update_network(tenant=TENANT_2)

395

396

def test_update_network_error_470(self):

397

self._test_update_network(status=470)

398

399

def test_update_network_error_401(self):

400

self._test_update_network(status=401)

401

402

def test_update_network_error_400(self):

403

self._test_update_network(status=400)

404

405

def test_update_network_error_420(self):

406

self._test_update_network(status=420)

407

408

def test_update_network_error_422(self):

409

self._test_update_network(status=422)

410

411

def test_delete_network_json(self):

412

self._test_delete_network(format='json')

413

414

def test_delete_network_xml(self):

415

self._test_delete_network(format='xml')

416

417

def test_delete_network_alt_tenant(self):

418

self._test_delete_network(tenant=TENANT_2)

419

420

def test_delete_network_error_470(self):

421

self._test_delete_network(status=470)

422

423

def test_delete_network_error_401(self):

424

self._test_delete_network(status=401)

425

426

def test_delete_network_error_420(self):

427

self._test_delete_network(status=420)

428

429

def test_delete_network_error_421(self):

430

self._test_delete_network(status=421)

431

432

def test_list_ports_json(self):

433

self._test_list_ports(format='json')

434

435

def test_list_ports_xml(self):

436

self._test_list_ports(format='xml')

437

438

def test_list_ports_alt_tenant(self):

439

self._test_list_ports(tenant=TENANT_2)

440

441

def test_list_ports_error_470(self):

442

self._test_list_ports(status=470)

443

444

def test_list_ports_error_401(self):

445

self._test_list_ports(status=401)

446

447

def test_list_ports_error_420(self):

448

self._test_list_ports(status=420)

449

450

def test_show_port_details_json(self):

451

self._test_list_ports(format='json')

452

453

def test_show_port_details_xml(self):

454

self._test_list_ports(format='xml')

455

456

def test_show_port_details_alt_tenant(self):

457

self._test_list_ports(tenant=TENANT_2)

458

459

def test_show_port_details_error_470(self):

460

self._test_show_port_details(status=470)

461

462

def test_show_port_details_error_401(self):

463

self._test_show_port_details(status=401)

464

465

def test_show_port_details_error_420(self):

466

self._test_show_port_details(status=420)

467

468

def test_show_port_details_error_430(self):

469

self._test_show_port_details(status=430)

470

471

def test_create_port_json(self):

472

self._test_create_port(format='json')

473

474

def test_create_port_xml(self):

475

self._test_create_port(format='xml')

476

477

def test_create_port_alt_tenant(self):

478

self._test_create_port(tenant=TENANT_2)

479

480

def test_create_port_error_470(self):

481

self._test_create_port(status=470)

482

483

def test_create_port_error_401(self):

484

self._test_create_port(status=401)

485

486

def test_create_port_error_400(self):

487

self._test_create_port(status=400)

488

489

def test_create_port_error_420(self):

490

self._test_create_port(status=420)

491

492

def test_create_port_error_430(self):

493

self._test_create_port(status=430)

494

495

def test_create_port_error_431(self):

496

self._test_create_port(status=431)

497

498

def test_delete_port_json(self):

499

self._test_delete_port(format='json')

500

501

def test_delete_port_xml(self):

502

self._test_delete_port(format='xml')

503

504

def test_delete_port_alt_tenant(self):

505

self._test_delete_port(tenant=TENANT_2)

506

507

def test_delete_port_error_470(self):

508

self._test_delete_port(status=470)

509

510

def test_delete_port_error_401(self):

511

self._test_delete_port(status=401)

512

513

def test_delete_port_error_420(self):

514

self._test_delete_port(status=420)

515

516

def test_delete_port_error_430(self):

517

self._test_delete_port(status=430)

518

519

def test_delete_port_error_432(self):

520

self._test_delete_port(status=432)

521

522

def test_update_port_json(self):

523

self._test_update_port(format='json')

524

525

def test_update_port_xml(self):

526

self._test_update_port(format='xml')

527

528

def test_update_port_alt_tenant(self):

529

self._test_update_port(tenant=TENANT_2)

530

531

def test_update_port_error_470(self):

532

self._test_update_port(status=470)

533

534

def test_update_port_error_401(self):

535

self._test_update_port(status=401)

536

537

def test_update_port_error_400(self):

538

self._test_update_port(status=400)

539

540

def test_update_port_error_420(self):

541

self._test_update_port(status=420)

542

543

def test_update_port_error_430(self):

544

self._test_update_port(status=430)

545

546

def test_update_port_error_431(self):

547

self._test_update_port(status=431)

548

549

def test_show_port_attachment_json(self):

550

self._test_show_port_attachment(format='json')

551

552

def test_show_port_attachment_xml(self):

553

self._test_show_port_attachment(format='xml')

554

555

def test_show_port_attachment_alt_tenant(self):

556

self._test_show_port_attachment(tenant=TENANT_2)

557

558

def test_show_port_attachment_error_470(self):

559

self._test_show_port_attachment(status=470)

560

561

def test_show_port_attachment_error_401(self):

562

self._test_show_port_attachment(status=401)

563

564

def test_show_port_attachment_error_400(self):

565

self._test_show_port_attachment(status=400)

566

567

def test_show_port_attachment_error_420(self):

568

self._test_show_port_attachment(status=420)

569

570

def test_show_port_attachment_error_430(self):

571

self._test_show_port_attachment(status=430)

572

573

def test_attach_resource_json(self):

574

self._test_attach_resource(format='json')

575

576

def test_attach_resource_xml(self):

577

self._test_attach_resource(format='xml')

578

579

def test_attach_resource_alt_tenant(self):

580

self._test_attach_resource(tenant=TENANT_2)

581

582

def test_attach_resource_error_470(self):

583

self._test_attach_resource(status=470)

584

585

def test_attach_resource_error_401(self):

586

self._test_attach_resource(status=401)

587

588

def test_attach_resource_error_400(self):

589

self._test_attach_resource(status=400)

590

591

def test_attach_resource_error_420(self):

592

self._test_attach_resource(status=420)

593

594

def test_attach_resource_error_430(self):

595

self._test_attach_resource(status=430)

596

597

def test_attach_resource_error_432(self):

598

self._test_attach_resource(status=432)

599

600

def test_attach_resource_error_440(self):

601

self._test_attach_resource(status=440)

602

603

def test_detach_resource_json(self):

604

self._test_detach_resource(format='json')

605

606

def test_detach_resource_xml(self):

607

self._test_detach_resource(format='xml')

608

609

def test_detach_resource_alt_tenant(self):

610

self._test_detach_resource(tenant=TENANT_2)

611

612

def test_detach_resource_error_470(self):

613

self._test_detach_resource(status=470)

614

615

def test_detach_resource_error_401(self):

616

self._test_detach_resource(status=401)

617

618

def test_detach_resource_error_420(self):

619

self._test_detach_resource(status=420)

620

621

def test_detach_resource_error_430(self):

622

self._test_detach_resource(status=430)

623

624

def test_ssl_certificates(self):

625

self._test_ssl_certificates()