~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (6076 to 5040)
• stop comparing with revision 5040

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

1

 

# Copyright (C) 2005 Canonical Ltd

 

1

# Copyright (C) 2006-2010 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

156

156

        # Weird stuff

157

157

        # Can't have slashes or colons in the scheme

158

158

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

159

 

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

 

159

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

160

160

        # Must have more than one character for scheme

161

161

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

162

162

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

195

195

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

196

196

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

197

197

        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'))

198

212

 

199

213

    def test_join(self):

200

214

        def test(expected, *args):

210

224

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

211

225

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

212

226

        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')

213

229

 

214

230

        # Absolute paths

215

231

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

219

235

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

220

236

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

221

237

        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')

222

241

 

223

242

        # From a base path

224

243

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

270

289

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

271

290

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

272

291

 

 

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

 

273

337

    def test_function_type(self):

274

338

        if sys.platform == 'win32':

275

339

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

355

419

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

356

420

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

357

421

 

 

422

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

 

423

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

358

424

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

359

425

        # Not a valid _win32 url, no drive letter

360

426

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

412

478

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

413

479

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

414

480

 

 

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

 

415

528

    def test_win32_strip_local_trailing_slash(self):

416

529

        strip = urlutils._win32_strip_local_trailing_slash

417

530

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

680

793

 

681

794

class TestParseURL(TestCase):

682

795

 

683

 

    def test_parse_url(self):

684

 

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

685

 

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

686

 

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

687

 

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

688

 

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

689

 

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

 

796

    def test_parse_simple(self):

 

797

        parsed = urlutils.parse_url('http://example.com:80/one')

 

798

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

 

799

            parsed)

 

800

 

 

801

    def test_ipv6(self):

 

802

        parsed = urlutils.parse_url('http://[1:2:3::40]/one')

 

803

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

 

804

            parsed)

 

805

 

 

806

    def test_ipv6_port(self):

 

807

        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')

 

808

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

 

809

            parsed)

 

810

 

 

811

 

 

812

class TestURL(TestCase):

 

813

 

 

814

    def test_parse_simple(self):

 

815

        parsed = urlutils.URL.from_string('http://example.com:80/one')

 

816

        self.assertEquals('http', parsed.scheme)

 

817

        self.assertIs(None, parsed.user)

 

818

        self.assertIs(None, parsed.password)

 

819

        self.assertEquals('example.com', parsed.host)

 

820

        self.assertEquals(80, parsed.port)

 

821

        self.assertEquals('/one', parsed.path)

 

822

 

 

823

    def test_ipv6(self):

 

824

        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')

 

825

        self.assertEquals('http', parsed.scheme)

 

826

        self.assertIs(None, parsed.port)

 

827

        self.assertIs(None, parsed.user)

 

828

        self.assertIs(None, parsed.password)

 

829

        self.assertEquals('1:2:3::40', parsed.host)

 

830

        self.assertEquals('/one', parsed.path)

 

831

 

 

832

    def test_ipv6_port(self):

 

833

        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

834

        self.assertEquals('http', parsed.scheme)

 

835

        self.assertEquals('1:2:3::40', parsed.host)

 

836

        self.assertIs(None, parsed.user)

 

837

        self.assertIs(None, parsed.password)

 

838

        self.assertEquals(80, parsed.port)

 

839

        self.assertEquals('/one', parsed.path)

 

840

 

 

841

    def test_quoted(self):

 

842

        parsed = urlutils.URL.from_string(

 

843

            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')

 

844

        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')

 

845

        self.assertEquals(parsed.host, 'exAmple.com')

 

846

        self.assertEquals(parsed.port, 2222)

 

847

        self.assertEquals(parsed.quoted_user, 'ro%62ey')

 

848

        self.assertEquals(parsed.user, 'robey')

 

849

        self.assertEquals(parsed.quoted_password, 'h%40t')

 

850

        self.assertEquals(parsed.password, 'h@t')

 

851

        self.assertEquals(parsed.path, '/path')

 

852

 

 

853

    def test_eq(self):

 

854

        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

855

        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

856

        self.assertEquals(parsed1, parsed2)

 

857

        self.assertEquals(parsed1, parsed1)

 

858

        parsed2.path = '/two'

 

859

        self.assertNotEquals(parsed1, parsed2)

 

860

 

 

861

    def test_repr(self):

 

862

        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

863

        self.assertEquals(

 

864

            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",

 

865

            repr(parsed))

 

866

 

 

867

    def test_str(self):

 

868

        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

869

        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))

 

870

 

 

871

    def test__combine_paths(self):

 

872

        combine = urlutils.URL._combine_paths

 

873

        self.assertEqual('/home/sarah/project/foo',

 

874

                         combine('/home/sarah', 'project/foo'))

 

875

        self.assertEqual('/etc',

 

876

                         combine('/home/sarah', '../../etc'))

 

877

        self.assertEqual('/etc',

 

878

                         combine('/home/sarah', '../../../etc'))

 

879

        self.assertEqual('/etc',

 

880

                         combine('/home/sarah', '/etc'))

 

881

 

 

882

    def test_clone(self):

 

883

        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')

 

884

        url1 = url.clone("two")

 

885

        self.assertEquals("/one/two", url1.path)

 

886

        url2 = url.clone("/two")

 

887

        self.assertEquals("/two", url2.path)

 

888

        url3 = url.clone()

 

889

        self.assertIsNot(url, url3)

 

890

        self.assertEquals(url, url3)

• Older »

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