~bzr-pqm/bzr/bzr.dev

_expected_rev_v8 = """<revision committer="Martin Pool <mbp@sourcefrog.net>" format="8" inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41" revision_id="mbp@sourcefrog.net-20050905080035-e0439293f8b6b9f9" timestamp="1125907235.212" timezone="36000">

152

<message>- start splitting code for xml (de)serialization away from objects

153

preparatory to supporting multiple formats by a single library

154

</message>

155

156

<revision_ref revision_id="mbp@sourcefrog.net-20050905063503-43948f59fa127d92" />

157

</parents>

158

</revision>

159

"""

160

161

_expected_inv_v8 = """<inventory format="8" revision_id="rev_outer">

162

163

164

165

166

</inventory>

167

"""

168

169

_revision_utf8_v5 = """<revision committer="Erik Bågfors <erik@foo.net>"

170

inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"

171

revision_id="erik@bågfors-02"

172

timestamp="1125907235.212"

173

timezone="36000">

174

<message>Include µnicode characters

175

</message>

176

177

<revision_ref revision_id="erik@bågfors-01"/>

178

</parents>

179

</revision>

180

"""

181

182

_inventory_utf8_v5 = """<inventory file_id="TREé_ROOT" format="5"

183

revision_id="erik@bågfors-02">

184

<file file_id="bår-01"

185

name="bår" parent_id="TREé_ROOT"

186

revision="erik@bågfors-01"/>

187

<directory name="sµbdir"

188

file_id="sµbdir-01"

189

parent_id="TREé_ROOT"

190

revision="erik@bågfors-01"/>

191

<file executable="yes" file_id="bår-02"

192

name="bår" parent_id="sµbdir-01"

193

revision="erik@bågfors-02"/>

194

</inventory>

195

"""

196

197

# Before revision_id was always stored as an attribute

198

_inventory_v5a = """<inventory format="5">

199

</inventory>

200

"""

201

202

# Before revision_id was always stored as an attribute

203

_inventory_v5b = """<inventory format="5" revision_id="a-rev-id">

128

204

129

</inventory>

205

130

"""

206

131

207

132

208

133

class TestSerializer(TestCase):

209

134

"""Test XML serialization"""

210

211

135

def test_canned_inventory(self):

212

136

"""Test unpacked a canned inventory v4 file."""

213

137

inp = StringIO(_working_inventory_v4)

276

200

eq(ie.name, 'bar')

277

201

eq(inv[ie.parent_id].kind, 'directory')

278

202

279

def test_unpack_inventory_5a(self):

280

inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(

281

_inventory_v5a, revision_id='test-rev-id')

282

self.assertEqual('test-rev-id', inv.root.revision)

283

284

def test_unpack_inventory_5b(self):

285

inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(

286

_inventory_v5b, revision_id='test-rev-id')

287

self.assertEqual('a-rev-id', inv.root.revision)

288

289

203

def test_repack_inventory_5(self):

290

204

inp = StringIO(_committed_inv_v5)

291

205

inv = bzrlib.xml5.serializer_v5.read_inventory(inp)

301

215

outp = StringIO()

302

216

bzrlib.xml5.serializer_v5.write_inventory(inv, outp)

303

217

self.assertEqualDiff(xml_string, outp.getvalue())

304

lines = bzrlib.xml5.serializer_v5.write_inventory_to_lines(inv)

305

outp.seek(0)

306

self.assertEqual(outp.readlines(), lines)

307

218

inv2 = bzrlib.xml5.serializer_v5.read_inventory(StringIO(outp.getvalue()))

308

219

self.assertEqual(inv, inv2)

309

220

348

259

txt = s_v5.write_revision_to_string(rev)

349

260

new_rev = s_v5.read_revision_from_string(txt)

350

261

self.assertEqual(props, new_rev.properties)

351

352

def get_sample_inventory(self):

353

inv = Inventory('tree-root-321', revision_id='rev_outer')

354

inv.add(inventory.InventoryFile('file-id', 'file', 'tree-root-321'))

355

inv.add(inventory.InventoryDirectory('dir-id', 'dir',

356

'tree-root-321'))

357

inv.add(inventory.InventoryLink('link-id', 'link', 'tree-root-321'))

358

inv['tree-root-321'].revision = 'rev_outer'

359

inv['dir-id'].revision = 'rev_outer'

360

inv['file-id'].revision = 'rev_outer'

361

inv['file-id'].text_sha1 = 'A'

362

inv['file-id'].text_size = 1

363

inv['link-id'].revision = 'rev_outer'

364

inv['link-id'].symlink_target = 'a'

365

return inv

366

367

def test_roundtrip_inventory_v7(self):

368

inv = self.get_sample_inventory()

369

inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',

370

'rev_outer', 'rev_inner'))

371

txt = xml7.serializer_v7.write_inventory_to_string(inv)

372

lines = xml7.serializer_v7.write_inventory_to_lines(inv)

373

self.assertEqual(bzrlib.osutils.split_lines(txt), lines)

374

self.assertEqualDiff(_expected_inv_v7, txt)

375

inv2 = xml7.serializer_v7.read_inventory_from_string(txt)

376

self.assertEqual(5, len(inv2))

377

for path, ie in inv.iter_entries():

378

self.assertEqual(ie, inv2[ie.file_id])

379

380

def test_wrong_format_v7(self):

381

"""Can't accidentally open a file with wrong serializer"""

382

s_v6 = bzrlib.xml6.serializer_v6

383

s_v7 = xml7.serializer_v7

384

self.assertRaises(errors.UnexpectedInventoryFormat,

385

s_v7.read_inventory_from_string, _expected_inv_v5)

386

self.assertRaises(errors.UnexpectedInventoryFormat,

387

s_v6.read_inventory_from_string, _expected_inv_v7)

388

389

def test_tree_reference(self):

390

s_v5 = bzrlib.xml5.serializer_v5

391

s_v6 = bzrlib.xml6.serializer_v6

392

s_v7 = xml7.serializer_v7

393

inv = Inventory('tree-root-321', revision_id='rev-outer')

394

inv.root.revision = 'root-rev'

395

inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',

396

'rev-outer', 'rev-inner'))

397

self.assertRaises(errors.UnsupportedInventoryKind,

398

s_v5.write_inventory_to_string, inv)

399

self.assertRaises(errors.UnsupportedInventoryKind,

400

s_v6.write_inventory_to_string, inv)

401

txt = s_v7.write_inventory_to_string(inv)

402

lines = s_v7.write_inventory_to_lines(inv)

403

self.assertEqual(bzrlib.osutils.split_lines(txt), lines)

404

inv2 = s_v7.read_inventory_from_string(txt)

405

self.assertEqual('tree-root-321', inv2['nested-id'].parent_id)

406

self.assertEqual('rev-outer', inv2['nested-id'].revision)

407

self.assertEqual('rev-inner', inv2['nested-id'].reference_revision)

408

self.assertRaises(errors.UnsupportedInventoryKind,

409

s_v6.read_inventory_from_string,

410

txt.replace('format="7"', 'format="6"'))

411

self.assertRaises(errors.UnsupportedInventoryKind,

412

s_v5.read_inventory_from_string,

413

txt.replace('format="7"', 'format="5"'))

414

415

def test_roundtrip_inventory_v8(self):

416

inv = self.get_sample_inventory()

417

txt = xml8.serializer_v8.write_inventory_to_string(inv)

418

inv2 = xml8.serializer_v8.read_inventory_from_string(txt)

419

self.assertEqual(4, len(inv2))

420

for path, ie in inv.iter_entries():

421

self.assertEqual(ie, inv2[ie.file_id])

422

423

def test_inventory_text_v8(self):

424

inv = self.get_sample_inventory()

425

txt = xml8.serializer_v8.write_inventory_to_string(inv)

426

lines = xml8.serializer_v8.write_inventory_to_lines(inv)

427

self.assertEqual(bzrlib.osutils.split_lines(txt), lines)

428

self.assertEqualDiff(_expected_inv_v8, txt)

429

430

def test_revision_text_v6(self):

431

"""Pack revision to XML v6"""

432

rev = bzrlib.xml6.serializer_v6.read_revision_from_string(

433

_expected_rev_v5)

434

serialized = bzrlib.xml6.serializer_v6.write_revision_to_string(rev)

435

self.assertEqualDiff(serialized, _expected_rev_v5)

436

437

def test_revision_text_v7(self):

438

"""Pack revision to XML v7"""

439

rev = bzrlib.xml7.serializer_v7.read_revision_from_string(

440

_expected_rev_v5)

441

serialized = bzrlib.xml7.serializer_v7.write_revision_to_string(rev)

442

self.assertEqualDiff(serialized, _expected_rev_v5)

443

444

def test_revision_text_v8(self):

445

"""Pack revision to XML v8"""

446

rev = bzrlib.xml8.serializer_v8.read_revision_from_string(

447

_expected_rev_v8)

448

serialized = bzrlib.xml8.serializer_v8.write_revision_to_string(rev)

449

self.assertEqualDiff(serialized, _expected_rev_v8)

450

451

def test_revision_ids_are_utf8(self):

452

"""Parsed revision_ids should all be utf-8 strings, not unicode."""

453

s_v5 = bzrlib.xml5.serializer_v5

454

rev = s_v5.read_revision_from_string(_revision_utf8_v5)

455

self.assertEqual('erik@b\xc3\xa5gfors-02', rev.revision_id)

456

self.assertIsInstance(rev.revision_id, str)

457

self.assertEqual(['erik@b\xc3\xa5gfors-01'], rev.parent_ids)

458

for parent_id in rev.parent_ids:

459

self.assertIsInstance(parent_id, str)

460

self.assertEqual(u'Include \xb5nicode characters\n', rev.message)

461

self.assertIsInstance(rev.message, unicode)

462

463

# ie.revision should either be None or a utf-8 revision id

464

inv = s_v5.read_inventory_from_string(_inventory_utf8_v5)

465

rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')

466

rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')

467

fid_root = u'TRE\xe9_ROOT'.encode('utf8')

468

fid_bar1 = u'b\xe5r-01'.encode('utf8')

469

fid_sub = u's\xb5bdir-01'.encode('utf8')

470

fid_bar2 = u'b\xe5r-02'.encode('utf8')

471

expected = [(u'', fid_root, None, rev_id_2),

472

(u'b\xe5r', fid_bar1, fid_root, rev_id_1),

473

(u's\xb5bdir', fid_sub, fid_root, rev_id_1),

474

(u's\xb5bdir/b\xe5r', fid_bar2, fid_sub, rev_id_2),

475

]

476

self.assertEqual(rev_id_2, inv.revision_id)

477

self.assertIsInstance(inv.revision_id, str)

478

479

actual = list(inv.iter_entries_by_dir())

480

for ((exp_path, exp_file_id, exp_parent_id, exp_rev_id),

481

(act_path, act_ie)) in zip(expected, actual):

482

self.assertEqual(exp_path, act_path)

483

self.assertIsInstance(act_path, unicode)

484

self.assertEqual(exp_file_id, act_ie.file_id)

485

self.assertIsInstance(act_ie.file_id, str)

486

self.assertEqual(exp_parent_id, act_ie.parent_id)

487

if exp_parent_id is not None:

488

self.assertIsInstance(act_ie.parent_id, str)

489

self.assertEqual(exp_rev_id, act_ie.revision)

490

if exp_rev_id is not None:

491

self.assertIsInstance(act_ie.revision, str)

492

493

self.assertEqual(len(expected), len(actual))

494

495

def test_registry(self):

496

self.assertIs(serializer_v4,

497

xml_serializer.format_registry.get('4'))

498

self.assertIs(bzrlib.xml5.serializer_v5,

499

xml_serializer.format_registry.get('5'))

500

self.assertIs(bzrlib.xml6.serializer_v6,

501

xml_serializer.format_registry.get('6'))

502

self.assertIs(bzrlib.xml7.serializer_v7,

503

xml_serializer.format_registry.get('7'))

504

self.assertIs(bzrlib.xml8.serializer_v8,

505

xml_serializer.format_registry.get('8'))

506

507

508

class TestEncodeAndEscape(TestCase):

509

"""Whitebox testing of the _encode_and_escape function."""

510

511

def setUp(self):

512

# Keep the cache clear before and after the test

513

bzrlib.xml8._ensure_utf8_re()

514

bzrlib.xml8._clear_cache()

515

self.addCleanup(bzrlib.xml8._clear_cache)

516

517

def test_simple_ascii(self):

518

# _encode_and_escape always appends a final ", because these parameters

519

# are being used in xml attributes, and by returning it now, we have to

520

# do fewer string operations later.

521

val = bzrlib.xml8._encode_and_escape('foo bar')

522

self.assertEqual('foo bar"', val)

523

# The second time should be cached

524

val2 = bzrlib.xml8._encode_and_escape('foo bar')

525

self.assertIs(val2, val)

526

527

def test_ascii_with_xml(self):

528

self.assertEqual('&'"<>"',

529

bzrlib.xml8._encode_and_escape('&\'"<>'))

530

531

def test_utf8_with_xml(self):

532

# u'\xb5\xe5&\u062c'

533

utf8_str = '\xc2\xb5\xc3\xa5&\xd8\xac'

534

self.assertEqual('µå&ج"',

535

bzrlib.xml8._encode_and_escape(utf8_str))

536

537

def test_unicode(self):

538

uni_str = u'\xb5\xe5&\u062c'

539

self.assertEqual('µå&ج"',

540

bzrlib.xml8._encode_and_escape(uni_str))

Older »