/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_urlutils.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_urlutils.py

21

21

 

22

22

from .. import osutils, urlutils, win32utils

23

23

from ..errors import (

24

 

    InvalidURL,

25

 

    InvalidURLJoin,

26

 

    InvalidRebaseURLs,

27

24

    PathNotChild,

28

25

    )

29

26

from . import features, TestCaseInTempDir, TestCase, TestSkipped

36

33

        # Test breezy.urlutils.split()

37

34

        basename = urlutils.basename

38

35

        if sys.platform == 'win32':

39

 

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

 

36

            self.assertRaises(urlutils.InvalidURL, basename,

 

37

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

40

38

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

41

39

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

42

40

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

126

124

 

127

125

        # Normalize verifies URLs when they are not unicode

128

126

        # (indicating they did not come from the user)

129

 

        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')

130

 

        self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')

 

127

        self.assertRaises(urlutils.InvalidURL, normalize_url,

 

128

                'http://host/\xb5')

 

129

        self.assertRaises(urlutils.InvalidURL, normalize_url, 'http://host/ ')

131

130

 

132

131

    def test_url_scheme_re(self):

133

132

        # Test paths that may be URLs

170

169

        # Test breezy.urlutils.dirname()

171

170

        dirname = urlutils.dirname

172

171

        if sys.platform == 'win32':

173

 

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

 

172

            self.assertRaises(urlutils.InvalidURL, dirname,

 

173

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

174

174

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

175

175

            self.assertEqual('file:///C|/', dirname('file:///C|/'))

176

176

        else:

253

253

        # Invalid joinings

254

254

        # Cannot go above root

255

255

        # Implicitly at root:

256

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

 

256

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

257

257

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

258

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

 

258

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

259

259

                'http://foo', '/..')

260

260

        # Joining from a path explicitly under the root.

261

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

 

261

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

262

262

                'http://foo/a', '../../b')

263

263

 

264

264

    def test_joinpath(self):

290

290

 

291

291

        # Invalid joinings

292

292

        # Cannot go above root

293

 

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

294

 

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

295

 

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

 

293

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

 

294

                '../baz')

 

295

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

 

296

                '..')

 

297

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

 

298

                '/..')

296

299

 

297

300

    def test_join_segment_parameters_raw(self):

298

301

        join_segment_parameters_raw = urlutils.join_segment_parameters_raw

300

303

            join_segment_parameters_raw("/somedir/path"))

301

304

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

302

305

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

303

 

        self.assertRaises(InvalidURLJoin,

 

306

        self.assertRaises(urlutils.InvalidURLJoin,

304

307

            join_segment_parameters_raw, "/somedir/path",

305

308

                "rawdata1,rawdata2,rawdata3")

306

309

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

317

320

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

318

321

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

319

322

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

320

 

        self.assertRaises(InvalidURLJoin,

 

323

        self.assertRaises(urlutils.InvalidURLJoin,

321

324

            join_segment_parameters, "/somedir/path",

322

325

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

323

 

        self.assertRaises(InvalidURLJoin,

 

326

        self.assertRaises(urlutils.InvalidURLJoin,

324

327

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

325

328

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

326

329

            join_segment_parameters("/somedir/path", {

380

383

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

381

384

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

382

385

 

383

 

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

 

386

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

384

387

        self.assertRaises(

385

 

            InvalidURL, from_url,

 

388

            urlutils.InvalidURL, from_url,

386

389

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

387

390

 

388

391

    def test_win32_local_path_to_url(self):

438

441

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

439

442

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

440

443

 

441

 

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

442

 

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

443

 

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

 

444

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

 

445

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

 

446

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

444

447

        # Not a valid _win32 url, no drive letter

445

 

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

 

448

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

446

449

 

447

450

    def test_win32_unc_path_from_url(self):

448

451

        from_url = urlutils._win32_local_path_from_url

452

455

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

453

456

        # we want to use only 2 slashes

454

457

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

455

 

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

456

 

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

457

 

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

 

458

        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')

 

459

        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')

 

460

        self.assertRaises(urlutils.InvalidURL, from_url, 'file://////HOST/path')

458

461

        # check for file://C:/ instead of file:///C:/

459

 

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

 

462

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

460

463

 

461

464

    def test_win32_extract_drive_letter(self):

462

465

        extract = urlutils._win32_extract_drive_letter

463

466

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

464

467

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

465

 

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

 

468

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

466

469

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

467

470

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

468

 

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

 

471

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

469

472

        # Invalid without drive separator or following forward slash

470

 

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

471

 

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

 

473

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

 

474

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

472

475

 

473

476

    def test_split(self):

474

477

        # Test breezy.urlutils.split()

475

478

        split = urlutils.split

476

479

        if sys.platform == 'win32':

477

 

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

 

480

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

478

481

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

479

482

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

480

483

        else:

656

659

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

657

660

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

658

661

 

659

 

        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')

660

 

        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')

661

 

        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')

 

662

        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')

 

663

        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '\xe5')

 

664

        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')

662

665

 

663

666

    def test_escape_unescape(self):

664

667

        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))

782

785

        self.assertEqual('/foo', result)

783

786

 

784

787

    def test_different_ports(self):

785

 

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

 

788

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

786

789

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

787

790

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

788

791

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

789

792

 

790

793

    def test_different_hosts(self):

791

 

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

 

794

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

792

795

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

793

796

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

794

797

                         " and 'http://baz'")

795

798

 

796

799

    def test_different_protocol(self):

797

 

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

 

800

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

798

801

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

799

802

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

800

803

                         " and 'ftp://bar'")

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0