~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (5691 to 6170)
• stop comparing with revision 6170

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

336

336

 

337

337

    def test_function_type(self):

338

338

        if sys.platform == 'win32':

339

 

            self.assertEqual(urlutils._win32_local_path_to_url,

340

 

                urlutils.local_path_to_url)

341

 

            self.assertEqual(urlutils._win32_local_path_from_url,

342

 

                urlutils.local_path_from_url)

 

339

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

 

340

            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)

343

341

        else:

344

 

            self.assertEqual(urlutils._posix_local_path_to_url,

345

 

                urlutils.local_path_to_url)

346

 

            self.assertEqual(urlutils._posix_local_path_from_url,

347

 

                urlutils.local_path_from_url)

 

342

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

 

343

            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)

348

344

 

349

345

    def test_posix_local_path_to_url(self):

350

346

        to_url = urlutils._posix_local_path_to_url

351

347

        self.assertEqual('file:///path/to/foo',

352

348

            to_url('/path/to/foo'))

353

349

 

354

 

        self.assertEqual('file:///path/to/foo%2Cbar',

355

 

            to_url('/path/to/foo,bar'))

356

 

 

357

350

        try:

358

351

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

359

352

        except UnicodeError:

366

359

        from_url = urlutils._posix_local_path_from_url

367

360

        self.assertEqual('/path/to/foo',

368

361

            from_url('file:///path/to/foo'))

369

 

        self.assertEqual('/path/to/foo',

370

 

            from_url('file:///path/to/foo,branch=foo'))

371

362

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

372

363

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

373

364

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

395

386

 

396

387

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

397

388

 

398

 

        self.assertEqual('file:///C:/path/to/foo%2Cbar',

399

 

            to_url('C:/path/to/foo,bar'))

400

389

        try:

401

390

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

402

391

        except UnicodeError:

429

418

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

430

419

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

431

420

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

432

 

        self.assertEqual('C:/path/to/foo',

433

 

            from_url('file:///C|/path/to/foo,branch=foo'))

434

421

 

435

422

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

436

423

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

441

428

    def test_win32_unc_path_from_url(self):

442

429

        from_url = urlutils._win32_local_path_from_url

443

430

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

444

 

        self.assertEqual('//HOST/path',

445

 

            from_url('file://HOST/path,branch=foo'))

446

431

        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine

447

432

        # we want to use only 2 slashes

448

433

        # Firefox understand only 5 slashes in URL, but it's ugly

457

442

        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))

458

443

        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))

459

444

        self.assertRaises(InvalidURL, extract, 'file://', '/path')

460

 

        # Root drives without slash treated as invalid, see bug #841322

461

 

        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))

462

 

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

463

 

        # Invalid without drive separator or following forward slash

464

 

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

465

 

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

466

445

 

467

446

    def test_split(self):

468

447

        # Test bzrlib.urlutils.split()

515

494

            split_segment_parameters_raw(",key1=val1"))

516

495

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

517

496

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

518

 

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

519

 

            split_segment_parameters_raw("foo,key1=val1"))

520

497

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

521

498

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

522

499

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

816

793

 

817

794

class TestParseURL(TestCase):

818

795

 

819

 

    def test_parse_simple(self):

820

 

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

821

 

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

822

 

            parsed)

823

 

 

824

 

    def test_ipv6(self):

825

 

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

826

 

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

827

 

            parsed)

828

 

 

829

 

    def test_ipv6_port(self):

830

 

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

831

 

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

832

 

            parsed)

833

 

 

834

 

 

835

 

class TestURL(TestCase):

836

 

 

837

 

    def test_parse_simple(self):

838

 

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

839

 

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

840

 

        self.assertIs(None, parsed.user)

841

 

        self.assertIs(None, parsed.password)

842

 

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

843

 

        self.assertEquals(80, parsed.port)

844

 

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

845

 

 

846

 

    def test_ipv6(self):

847

 

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

848

 

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

849

 

        self.assertIs(None, parsed.port)

850

 

        self.assertIs(None, parsed.user)

851

 

        self.assertIs(None, parsed.password)

852

 

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

853

 

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

854

 

 

855

 

    def test_ipv6_port(self):

856

 

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

857

 

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

858

 

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

859

 

        self.assertIs(None, parsed.user)

860

 

        self.assertIs(None, parsed.password)

861

 

        self.assertEquals(80, parsed.port)

862

 

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

863

 

 

864

 

    def test_quoted(self):

865

 

        parsed = urlutils.URL.from_string(

866

 

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

867

 

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

868

 

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

869

 

        self.assertEquals(parsed.port, 2222)

870

 

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

871

 

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

872

 

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

873

 

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

874

 

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

875

 

 

876

 

    def test_eq(self):

877

 

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

878

 

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

879

 

        self.assertEquals(parsed1, parsed2)

880

 

        self.assertEquals(parsed1, parsed1)

881

 

        parsed2.path = '/two'

882

 

        self.assertNotEquals(parsed1, parsed2)

883

 

 

884

 

    def test_repr(self):

885

 

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

886

 

        self.assertEquals(

887

 

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

888

 

            repr(parsed))

889

 

 

890

 

    def test_str(self):

891

 

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

892

 

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

893

 

 

894

 

    def test__combine_paths(self):

895

 

        combine = urlutils.URL._combine_paths

896

 

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

897

 

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

898

 

        self.assertEqual('/etc',

899

 

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

900

 

        self.assertEqual('/etc',

901

 

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

902

 

        self.assertEqual('/etc',

903

 

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

904

 

 

905

 

    def test_clone(self):

906

 

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

907

 

        url1 = url.clone("two")

908

 

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

909

 

        url2 = url.clone("/two")

910

 

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

911

 

        url3 = url.clone()

912

 

        self.assertIsNot(url, url3)

913

 

        self.assertEquals(url, url3)

 

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