~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (6169.1.3 to 5755.2.10)
• stop comparing with revision 5755.2.10

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, urlutils.local_path_to_url)

340

 

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

 

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)

341

343

        else:

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)

 

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)

344

348

 

345

349

    def test_posix_local_path_to_url(self):

346

350

        to_url = urlutils._posix_local_path_to_url

347

351

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

348

352

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

349

353

 

 

354

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

 

355

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

 

356

 

350

357

        try:

351

358

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

352

359

        except UnicodeError:

359

366

        from_url = urlutils._posix_local_path_from_url

360

367

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

361

368

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

 

369

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

 

370

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

362

371

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

363

372

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

364

373

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

386

395

 

387

396

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

388

397

 

 

398

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

 

399

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

389

400

        try:

390

401

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

391

402

        except UnicodeError:

418

429

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

419

430

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

420

431

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

 

432

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

 

433

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

421

434

 

422

435

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

423

436

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

428

441

    def test_win32_unc_path_from_url(self):

429

442

        from_url = urlutils._win32_local_path_from_url

430

443

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

 

444

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

 

445

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

431

446

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

432

447

        # we want to use only 2 slashes

433

448

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

442

457

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

443

458

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

444

459

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

445

466

 

446

467

    def test_split(self):

447

468

        # Test bzrlib.urlutils.split()

494

515

            split_segment_parameters_raw(",key1=val1"))

495

516

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

496

517

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

 

518

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

 

519

            split_segment_parameters_raw("foo,key1=val1"))

497

520

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

498

521

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

499

522

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

793

816

 

794

817

class TestParseURL(TestCase):

795

818

 

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

 

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)

• Older »

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