~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (3286 to 5401)
• stop comparing with revision 5401

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)

363

301

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

364

302

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

365

303

            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

304

 

369

305

        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

306

 

374

307

    def test_win32_local_path_to_url(self):

375

308

        to_url = urlutils._win32_local_path_to_url

384

317

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

385

318

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

386

319

 

387

 

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

388

 

 

389

320

        try:

390

321

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

391

322

        except UnicodeError:

417

348

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

418

349

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

419

350

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

420

 

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

421

351

 

422

352

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

423

353

        # Not a valid _win32 url, no drive letter

476

406

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

477

407

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

478

408

 

479

 

    def test_split_segment_parameters_raw(self):

480

 

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

481

 

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

482

 

            split_segment_parameters_raw("/some/path"))

483

 

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

484

 

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

485

 

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

486

 

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

487

 

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

488

 

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

489

 

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

490

 

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

491

 

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

492

 

            split_segment_parameters_raw(",key1=val1"))

493

 

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

494

 

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

495

 

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

496

 

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

497

 

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

498

 

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

499

 

 

500

 

    def test_split_segment_parameters(self):

501

 

        split_segment_parameters = urlutils.split_segment_parameters

502

 

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

503

 

            split_segment_parameters("/some/path"))

504

 

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

505

 

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

506

 

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

507

 

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

508

 

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

509

 

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

510

 

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

511

 

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

512

 

            split_segment_parameters(

513

 

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

514

 

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

515

 

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

516

 

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

517

 

            split_segment_parameters(",key1=val1"))

518

 

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

519

 

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

520

 

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

521

 

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

522

 

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

523

 

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

524

 

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

525

 

 

526

409

    def test_win32_strip_local_trailing_slash(self):

527

410

        strip = urlutils._win32_strip_local_trailing_slash

528

411

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

612

495

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

613

496

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

614

497

 

615

 

    def test_escape_tildes(self):

616

 

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

617

 

 

618

498

    def test_unescape(self):

619

499

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

620

500

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

631

511

        def test(expected, base, other):

632

512

            result = urlutils.relative_url(base, other)

633

513

            self.assertEqual(expected, result)

634

 

 

 

514

            

635

515

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

636

516

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

637

517

                    'http://entirely/different')

646

526

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

647

527

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

648

528

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

649

 

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

 

529

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

650

530

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

651

531

        # relative_url should preserve a trailing slash

652

532

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

710

590

 

711

591

        os.chdir(u'dod\xe9')

712

592

 

713

 

        # On Mac OSX this directory is actually:

 

593

        # On Mac OSX this directory is actually: 

714

594

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

715

 

        # but we should normalize it back to

 

595

        # but we should normalize it back to 

716

596

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

717

597

        url = urlutils.local_path_to_url('.')

718

598

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

734

614

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

735

615

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

736

616

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

737

 

 

738

 

 

739

 

class TestRebaseURL(TestCase):

740

 

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

741

 

 

742

 

    def test_non_relative(self):

743

 

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

744

 

                                     'file://foo/bar')

745

 

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

746

 

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

747

 

                                     'file://foo/bar')

748

 

        self.assertEqual('/foo', result)

749

 

 

750

 

    def test_different_ports(self):

751

 

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

752

 

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

753

 

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

754

 

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

755

 

 

756

 

    def test_different_hosts(self):

757

 

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

758

 

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

759

 

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

760

 

                         " and 'http://baz'")

761

 

 

762

 

    def test_different_protocol(self):

763

 

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

764

 

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

765

 

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

766

 

                         " and 'ftp://bar'")

767

 

 

768

 

    def test_rebase_success(self):

769

 

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

770

 

                         'http://baz/qux'))

771

 

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

772

 

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

773

 

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

774

 

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

775

 

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

776

 

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

777

 

 

778

 

    def test_determine_relative_path(self):

779

 

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

780

 

                         urlutils.determine_relative_path(

781

 

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

782

 

        self.assertEqual('..',

783

 

                         urlutils.determine_relative_path(

784

 

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

785

 

        self.assertEqual('baz',

786

 

                         urlutils.determine_relative_path(

787

 

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

788

 

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

789

 

                         '/bar', '/bar'))

790

 

 

791

 

 

792

 

class TestParseURL(TestCase):

793

 

 

794

 

    def test_parse_url(self):

795

 

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

796

 

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

797

 

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

798

 

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

799

 

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

800

 

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

• Older »

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