~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2691.1.11 to 6017.1.2)
• stop comparing with revision 6017.1.2

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2005 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

12

12

#

13

13

# You should have received a copy of the GNU General Public License

14

14

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

16

 

17

17

"""Tests for the urlutils wrapper."""

18

18

 

19

19

import os

 

20

import re

20

21

import sys

21

22

 

22

23

from bzrlib import osutils, urlutils, win32utils

23

 

from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs

 

24

import bzrlib

 

25

from bzrlib.errors import InvalidURL, InvalidURLJoin

24

26

from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped

25

27

 

26

28

 

27

29

class TestUrlToPath(TestCase):

28

 

 

 

30

    

29

31

    def test_basename(self):

30

32

        # bzrlib.urlutils.basename

31

33

        # Test bzrlib.urlutils.split()

80

82

 

81

83

        # Local paths are assumed to *not* be escaped at all

82

84

        try:

83

 

            u'uni/\xb5'.encode(osutils.get_user_encoding())

 

85

            u'uni/\xb5'.encode(bzrlib.user_encoding)

84

86

        except UnicodeError:

85

 

            # locale cannot handle unicode

 

87

            # locale cannot handle unicode 

86

88

            pass

87

89

        else:

88

90

            norm_file('uni/%C2%B5', u'uni/\xb5')

156

158

        # Weird stuff

157

159

        # Can't have slashes or colons in the scheme

158

160

        test_one('/path/to/://foo', None)

159

 

        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))

 

161

        test_one('path:path://foo', None)

160

162

        # Must have more than one character for scheme

161

163

        test_one('C://foo', None)

162

164

        test_one('ab://foo', ('ab', 'foo'))

195

197

            dirname('path/to/foo/', exclude_trailing_slash=False))

196

198

        self.assertEqual('path/..', dirname('path/../foo'))

197

199

        self.assertEqual('../path', dirname('../path/foo'))

198

 

    

199

 

    def test_is_url(self):

200

 

        self.assertTrue(urlutils.is_url('http://foo/bar'))

201

 

        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))

202

 

        self.assertTrue(urlutils.is_url('lp:foo/bar'))

203

 

        self.assertTrue(urlutils.is_url('file:///foo/bar'))

204

 

        self.assertFalse(urlutils.is_url(''))

205

 

        self.assertFalse(urlutils.is_url('foo'))

206

 

        self.assertFalse(urlutils.is_url('foo/bar'))

207

 

        self.assertFalse(urlutils.is_url('/foo'))

208

 

        self.assertFalse(urlutils.is_url('/foo/bar'))

209

 

        self.assertFalse(urlutils.is_url('C:/'))

210

 

        self.assertFalse(urlutils.is_url('C:/foo'))

211

 

        self.assertFalse(urlutils.is_url('C:/foo/bar'))

212

200

 

213

201

    def test_join(self):

214

202

        def test(expected, *args):

224

212

        test('http://foo/bar/baz', 'http://foo', 'bar/baz')

225

213

        test('http://foo/baz', 'http://foo', 'bar/../baz')

226

214

        test('http://foo/baz', 'http://foo/bar/', '../baz')

227

 

        test('lp:foo/bar', 'lp:foo', 'bar')

228

 

        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')

229

215

 

230

216

        # Absolute paths

231

217

        test('http://foo', 'http://foo') # abs url with nothing is preserved.

235

221

        test('http://bar/', 'http://foo', 'http://bar/')

236

222

        test('http://bar/a', 'http://foo', 'http://bar/a')

237

223

        test('http://bar/a/', 'http://foo', 'http://bar/a/')

238

 

        test('lp:bar', 'http://foo', 'lp:bar')

239

 

        test('lp:bar', 'lp:foo', 'lp:bar')

240

 

        test('file:///stuff', 'lp:foo', 'file:///stuff')

241

224

 

242

225

        # From a base path

243

226

        test('file:///foo', 'file:///', 'foo')

244

227

        test('file:///bar/foo', 'file:///bar/', 'foo')

245

228

        test('http://host/foo', 'http://host/', 'foo')

246

229

        test('http://host/', 'http://host', '')

247

 

 

 

230

        

248

231

        # Invalid joinings

249

232

        # Cannot go above root

250

233

        # Implicitly at root:

282

265

 

283

266

        # Test joining to a path with a trailing slash

284

267

        test('foo/bar', 'foo/', 'bar')

285

 

 

 

268

        

286

269

        # Invalid joinings

287

270

        # Cannot go above root

288

271

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')

289

272

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')

290

273

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')

291

274

 

292

 

    def test_join_segment_parameters_raw(self):

293

 

        join_segment_parameters_raw = urlutils.join_segment_parameters_raw

294

 

        self.assertEquals("/somedir/path", 

295

 

            join_segment_parameters_raw("/somedir/path"))

296

 

        self.assertEquals("/somedir/path,rawdata", 

297

 

            join_segment_parameters_raw("/somedir/path", "rawdata"))

298

 

        self.assertRaises(InvalidURLJoin,

299

 

            join_segment_parameters_raw, "/somedir/path",

300

 

                "rawdata1,rawdata2,rawdata3")

301

 

        self.assertEquals("/somedir/path,bla,bar",

302

 

            join_segment_parameters_raw("/somedir/path", "bla", "bar"))

303

 

        self.assertEquals("/somedir,exist=some/path,bla,bar",

304

 

            join_segment_parameters_raw("/somedir,exist=some/path",

305

 

                "bla", "bar"))

306

 

        self.assertRaises(TypeError, join_segment_parameters_raw, 

307

 

            "/somepath", 42)

308

 

 

309

 

    def test_join_segment_parameters(self):

310

 

        join_segment_parameters = urlutils.join_segment_parameters

311

 

        self.assertEquals("/somedir/path", 

312

 

            join_segment_parameters("/somedir/path", {}))

313

 

        self.assertEquals("/somedir/path,key1=val1", 

314

 

            join_segment_parameters("/somedir/path", {"key1": "val1"}))

315

 

        self.assertRaises(InvalidURLJoin,

316

 

            join_segment_parameters, "/somedir/path",

317

 

            {"branch": "brr,brr,brr"})

318

 

        self.assertRaises(InvalidURLJoin,

319

 

            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})

320

 

        self.assertEquals("/somedir/path,key1=val1,key2=val2",

321

 

            join_segment_parameters("/somedir/path", {

322

 

                "key1": "val1", "key2": "val2"}))

323

 

        self.assertEquals("/somedir/path,key1=val1,key2=val2",

324

 

            join_segment_parameters("/somedir/path,key1=val1", {

325

 

                "key2": "val2"}))

326

 

        self.assertEquals("/somedir/path,key1=val2",

327

 

            join_segment_parameters("/somedir/path,key1=val1", {

328

 

                "key1": "val2"}))

329

 

        self.assertEquals("/somedir,exist=some/path,key1=val1",

330

 

            join_segment_parameters("/somedir,exist=some/path",

331

 

                {"key1": "val1"}))

332

 

        self.assertEquals("/,key1=val1,key2=val2",

333

 

            join_segment_parameters("/,key1=val1", {"key2": "val2"}))

334

 

        self.assertRaises(TypeError,

335

 

            join_segment_parameters, "/,key1=val1", {"foo": 42})

336

 

 

337

275

    def test_function_type(self):

338

276

        if sys.platform == 'win32':

339

277

            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)

353

291

            raise TestSkipped("local encoding cannot handle unicode")

354

292

 

355

293

        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

356

 

        self.assertFalse(isinstance(result, unicode))

357

294

 

358

295

    def test_posix_local_path_from_url(self):

359

296

        from_url = urlutils._posix_local_path_from_url

363

300

            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

364

301

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

365

302

            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

366

 

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

367

 

            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

368

303

 

369

304

        self.assertRaises(InvalidURL, from_url, '/path/to/foo')

370

 

        self.assertRaises(

371

 

            InvalidURL, from_url,

372

 

            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')

373

305

 

374

306

    def test_win32_local_path_to_url(self):

375

307

        to_url = urlutils._win32_local_path_to_url

384

316

        self.assertEqual('file:///C:/path/to/f%20oo',

385

317

            to_url('C:/path/to/f oo'))

386

318

 

387

 

        self.assertEqual('file:///', to_url('/'))

388

 

 

389

319

        try:

390

320

            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')

391

321

        except UnicodeError:

392

322

            raise TestSkipped("local encoding cannot handle unicode")

393

323

 

394

324

        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

395

 

        self.assertFalse(isinstance(result, unicode))

396

325

 

397

326

    def test_win32_unc_path_to_url(self):

398

327

        to_url = urlutils._win32_local_path_to_url

407

336

            raise TestSkipped("local encoding cannot handle unicode")

408

337

 

409

338

        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

410

 

        self.assertFalse(isinstance(result, unicode))

 

339

 

411

340

 

412

341

    def test_win32_local_path_from_url(self):

413

342

        from_url = urlutils._win32_local_path_from_url

417

346

            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

418

347

        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',

419

348

            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

420

 

        self.assertEqual('/', from_url('file:///'))

421

349

 

422

 

        self.assertRaises(InvalidURL, from_url, 'file:///C:')

423

 

        self.assertRaises(InvalidURL, from_url, 'file:///c')

424

350

        self.assertRaises(InvalidURL, from_url, '/path/to/foo')

425

351

        # Not a valid _win32 url, no drive letter

426

352

        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')

478

404

        self.assertEqual(('path/..', 'foo'), split('path/../foo'))

479

405

        self.assertEqual(('../path', 'foo'), split('../path/foo'))

480

406

 

481

 

    def test_split_segment_parameters_raw(self):

482

 

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

483

 

        self.assertEquals(("/some/path", []),

484

 

            split_segment_parameters_raw("/some/path"))

485

 

        self.assertEquals(("/some/path", ["tip"]),

486

 

            split_segment_parameters_raw("/some/path,tip"))

487

 

        self.assertEquals(("/some,dir/path", ["tip"]),

488

 

            split_segment_parameters_raw("/some,dir/path,tip"))

489

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),

490

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))

491

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),

492

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))

493

 

        self.assertEquals(("/", ["key1=val1"]),

494

 

            split_segment_parameters_raw(",key1=val1"))

495

 

        self.assertEquals(("foo/", ["key1=val1"]),

496

 

            split_segment_parameters_raw("foo/,key1=val1"))

497

 

        self.assertEquals(("foo/base,la=bla/other/elements", []),

498

 

            split_segment_parameters_raw("foo/base,la=bla/other/elements"))

499

 

        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),

500

 

            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))

501

 

 

502

 

    def test_split_segment_parameters(self):

503

 

        split_segment_parameters = urlutils.split_segment_parameters

504

 

        self.assertEquals(("/some/path", {}),

505

 

            split_segment_parameters("/some/path"))

506

 

        self.assertEquals(("/some/path", {"branch": "tip"}),

507

 

            split_segment_parameters("/some/path,branch=tip"))

508

 

        self.assertEquals(("/some,dir/path", {"branch": "tip"}),

509

 

            split_segment_parameters("/some,dir/path,branch=tip"))

510

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),

511

 

            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))

512

 

        self.assertEquals(("/somedir/path",

513

 

            {"ref": "heads%2Ftip", "key1": "val1"}),

514

 

            split_segment_parameters(

515

 

                "/somedir/path,ref=heads%2Ftip,key1=val1"))

516

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),

517

 

            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))

518

 

        self.assertEquals(("/", {"key1": "val1"}),

519

 

            split_segment_parameters(",key1=val1"))

520

 

        self.assertEquals(("foo/", {"key1": "val1"}),

521

 

            split_segment_parameters("foo/,key1=val1"))

522

 

        self.assertEquals(("foo/base,key1=val1/other/elements", {}),

523

 

            split_segment_parameters("foo/base,key1=val1/other/elements"))

524

 

        self.assertEquals(("foo/base,key1=val1/other/elements",

525

 

            {"key2": "val2"}), split_segment_parameters(

526

 

                "foo/base,key1=val1/other/elements,key2=val2"))

527

 

 

528

407

    def test_win32_strip_local_trailing_slash(self):

529

408

        strip = urlutils._win32_strip_local_trailing_slash

530

409

        self.assertEqual('file://', strip('file://'))

612

491

    def test_escape(self):

613

492

        self.assertEqual('%25', urlutils.escape('%'))

614

493

        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))

615

 

        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))

616

 

 

617

 

    def test_escape_tildes(self):

618

 

        self.assertEqual('~foo', urlutils.escape('~foo'))

619

494

 

620

495

    def test_unescape(self):

621

496

        self.assertEqual('%', urlutils.unescape('%25'))

633

508

        def test(expected, base, other):

634

509

            result = urlutils.relative_url(base, other)

635

510

            self.assertEqual(expected, result)

636

 

 

 

511

            

637

512

        test('a', 'http://host/', 'http://host/a')

638

513

        test('http://entirely/different', 'sftp://host/branch',

639

514

                    'http://entirely/different')

648

523

                    'sftp://host/home/jelmer/branch/2b')

649

524

        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',

650

525

                    'http://host/home/jelmer/branch/feature/%2b')

651

 

        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',

 

526

        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 

652

527

                    'http://host/home/jelmer/branch/feature/2b')

653

528

        # relative_url should preserve a trailing slash

654

529

        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',

666

541

        #test('.', 'http://host/', 'http://host')

667

542

        test('http://host', 'http://host/', 'http://host')

668

543

 

669

 

        # On Windows file:///C:/path/to and file:///D:/other/path

670

 

        # should not use relative url over the non-existent '/' directory.

671

 

        if sys.platform == 'win32':

672

 

            # on the same drive

673

 

            test('../../other/path',

674

 

                'file:///C:/path/to', 'file:///C:/other/path')

675

 

            #~next two tests is failed, i.e. urlutils.relative_url expects

676

 

            #~to see normalized file URLs?

677

 

            #~test('../../other/path',

678

 

            #~    'file:///C:/path/to', 'file:///c:/other/path')

679

 

            #~test('../../other/path',

680

 

            #~    'file:///C:/path/to', 'file:///C|/other/path')

681

 

 

682

 

            # check UNC paths too

683

 

            test('../../other/path',

684

 

                'file://HOST/base/path/to', 'file://HOST/base/other/path')

685

 

            # on different drives

686

 

            test('file:///D:/other/path',

687

 

                'file:///C:/path/to', 'file:///D:/other/path')

688

 

            # TODO: strictly saying in UNC path //HOST/base is full analog

689

 

            # of drive letter for hard disk, and this situation is also

690

 

            # should be exception from rules. [bialix 20071221]

691

 

 

692

544

 

693

545

class TestCwdToURL(TestCaseInTempDir):

694

546

    """Test that local_path_to_url works base on the cwd"""

712

564

 

713

565

        os.chdir(u'dod\xe9')

714

566

 

715

 

        # On Mac OSX this directory is actually:

 

567

        # On Mac OSX this directory is actually: 

716

568

        #   u'/dode\u0301' => '/dode\xcc\x81

717

 

        # but we should normalize it back to

 

569

        # but we should normalize it back to 

718

570

        #   u'/dod\xe9' => '/dod\xc3\xa9'

719

571

        url = urlutils.local_path_to_url('.')

720

572

        self.assertEndsWith(url, '/dod%C3%A9')

736

588

        self.assertEqual("bar", derive("http://foo/bar"))

737

589

        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))

738

590

        self.assertEqual("foo-bar", derive("lp:foo-bar"))

739

 

 

740

 

 

741

 

class TestRebaseURL(TestCase):

742

 

    """Test the behavior of rebase_url."""

743

 

 

744

 

    def test_non_relative(self):

745

 

        result = urlutils.rebase_url('file://foo', 'file://foo',

746

 

                                     'file://foo/bar')

747

 

        self.assertEqual('file://foo', result)

748

 

        result = urlutils.rebase_url('/foo', 'file://foo',

749

 

                                     'file://foo/bar')

750

 

        self.assertEqual('/foo', result)

751

 

 

752

 

    def test_different_ports(self):

753

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

754

 

                              'foo', 'http://bar:80', 'http://bar:81')

755

 

        self.assertEqual(str(e), "URLs differ by more than path:"

756

 

                         " 'http://bar:80' and 'http://bar:81'")

757

 

 

758

 

    def test_different_hosts(self):

759

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

760

 

                              'foo', 'http://bar', 'http://baz')

761

 

        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"

762

 

                         " and 'http://baz'")

763

 

 

764

 

    def test_different_protocol(self):

765

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

766

 

                              'foo', 'http://bar', 'ftp://bar')

767

 

        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"

768

 

                         " and 'ftp://bar'")

769

 

 

770

 

    def test_rebase_success(self):

771

 

        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',

772

 

                         'http://baz/qux'))

773

 

        self.assertEqual('qux/bar', urlutils.rebase_url('bar',

774

 

                         'http://baz/qux', 'http://baz/'))

775

 

        self.assertEqual('.', urlutils.rebase_url('foo',

776

 

                         'http://bar/', 'http://bar/foo/'))

777

 

        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',

778

 

                         'http://baz/qux/foo', 'http://baz/'))

779

 

 

780

 

    def test_determine_relative_path(self):

781

 

        self.assertEqual('../../baz/bar',

782

 

                         urlutils.determine_relative_path(

783

 

                         '/qux/quxx', '/baz/bar'))

784

 

        self.assertEqual('..',

785

 

                         urlutils.determine_relative_path(

786

 

                         '/bar/baz', '/bar'))

787

 

        self.assertEqual('baz',

788

 

                         urlutils.determine_relative_path(

789

 

                         '/bar', '/bar/baz'))

790

 

        self.assertEqual('.', urlutils.determine_relative_path(

791

 

                         '/bar', '/bar'))

792

 

 

793

 

 

794

 

class TestParseURL(TestCase):

795

 

 

796

 

    def test_parse_url(self):

797

 

        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),

798

 

            ('http', None, None, 'example.com', 80, '/one'))

799

 

        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),

800

 

                ('http', None, None, '1:2:3::40', None, '/one'))

801

 

        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),

802

 

                ('http', None, None, '1:2:3::40', 80, '/one'))

• Older »

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