~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2255.2.50 to 4011.6.1)
• stop comparing with revision 4011.6.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

20

20

import re

21

21

import sys

22

22

 

23

 

from bzrlib import osutils, urlutils, win32utils

24

 

from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs

 

23

from bzrlib import osutils, urlutils

 

24

import bzrlib

 

25

from bzrlib.errors import InvalidURL, InvalidURLJoin

25

26

from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped

26

27

 

27

28

 

81

82

 

82

83

        # Local paths are assumed to *not* be escaped at all

83

84

        try:

84

 

            u'uni/\xb5'.encode(osutils.get_user_encoding())

 

85

            u'uni/\xb5'.encode(bzrlib.user_encoding)

85

86

        except UnicodeError:

86

87

            # locale cannot handle unicode 

87

88

            pass

114

115

        eq('http://host/ab/%C2%B5/%C2%B5',

115

116

            normalize_url(u'http://host/ab/%C2%B5/\xb5'))

116

117

 

117

 

        # Unescape characters that don't need to be escaped

118

 

        eq('http://host/~bob%2525-._',

119

 

                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))

120

 

        eq('http://host/~bob%2525-._',

121

 

                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))

122

 

 

123

118

        # Normalize verifies URLs when they are not unicode

124

119

        # (indicating they did not come from the user)

125

120

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

202

197

            joined = urlutils.join(*args)

203

198

            self.assertEqual(expected, joined)

204

199

 

 

200

        # Test a single element

 

201

        test('foo', 'foo')

 

202

 

205

203

        # Test relative path joining

206

 

        test('foo', 'foo') # relative fragment with nothing is preserved.

207

204

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

208

205

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

209

206

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

210

207

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

211

208

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

212

209

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

213

 

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

214

210

 

215

211

        # Absolute paths

216

 

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

217

212

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

218

213

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

219

214

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

220

 

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

221

 

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

222

 

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

223

215

 

224

216

        # From a base path

225

217

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

229

221

        

230

222

        # Invalid joinings

231

223

        # Cannot go above root

232

 

        # Implicitly at root:

233

224

        self.assertRaises(InvalidURLJoin, urlutils.join,

234

225

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

235

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

236

 

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

237

 

        # Joining from a path explicitly under the root.

238

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

239

 

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

240

 

 

241

 

    def test_joinpath(self):

242

 

        def test(expected, *args):

243

 

            joined = urlutils.joinpath(*args)

244

 

            self.assertEqual(expected, joined)

245

 

 

246

 

        # Test a single element

247

 

        test('foo', 'foo')

248

 

 

249

 

        # Test relative path joining

250

 

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

251

 

        test('foo/bar', 'foo', '.', 'bar')

252

 

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

253

 

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

254

 

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

255

 

 

256

 

        # Test joining to an absolute path

257

 

        test('/foo', '/foo')

258

 

        test('/foo', '/foo', '.')

259

 

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

260

 

        test('/', '/foo', '..')

261

 

 

262

 

        # Test joining with an absolute path

263

 

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

264

 

 

265

 

        # Test joining to a path with a trailing slash

266

 

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

267

 

        

268

 

        # Invalid joinings

269

 

        # Cannot go above root

270

 

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

271

 

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

272

 

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

273

226

 

274

227

    def test_function_type(self):

275

228

        if sys.platform == 'win32':

290

243

            raise TestSkipped("local encoding cannot handle unicode")

291

244

 

292

245

        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

293

 

        self.assertFalse(isinstance(result, unicode))

294

246

 

295

247

    def test_posix_local_path_from_url(self):

296

248

        from_url = urlutils._posix_local_path_from_url

315

267

        #     to_url('C:/path/to/foo '))

316

268

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

317

269

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

318

 

        

319

 

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

320

270

 

321

271

        try:

322

272

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

324

274

            raise TestSkipped("local encoding cannot handle unicode")

325

275

 

326

276

        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

327

 

        self.assertFalse(isinstance(result, unicode))

328

277

 

329

278

    def test_win32_unc_path_to_url(self):

330

279

        to_url = urlutils._win32_local_path_to_url

339

288

            raise TestSkipped("local encoding cannot handle unicode")

340

289

 

341

290

        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

342

 

        self.assertFalse(isinstance(result, unicode))

 

291

 

343

292

 

344

293

    def test_win32_local_path_from_url(self):

345

294

        from_url = urlutils._win32_local_path_from_url

349

298

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

350

299

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

351

300

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

352

 

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

353

301

 

354

302

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

355

303

        # Not a valid _win32 url, no drive letter

495

443

    def test_escape(self):

496

444

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

497

445

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

498

 

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

499

446

 

500

447

    def test_unescape(self):

501

448

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

546

493

        #test('.', 'http://host/', 'http://host')

547

494

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

548

495

 

549

 

        # On Windows file:///C:/path/to and file:///D:/other/path

550

 

        # should not use relative url over the non-existent '/' directory.

551

 

        if sys.platform == 'win32':

552

 

            # on the same drive

553

 

            test('../../other/path',

554

 

                'file:///C:/path/to', 'file:///C:/other/path')

555

 

            #~next two tests is failed, i.e. urlutils.relative_url expects

556

 

            #~to see normalized file URLs?

557

 

            #~test('../../other/path',

558

 

            #~    'file:///C:/path/to', 'file:///c:/other/path')

559

 

            #~test('../../other/path',

560

 

            #~    'file:///C:/path/to', 'file:///C|/other/path')

561

 

 

562

 

            # check UNC paths too

563

 

            test('../../other/path',

564

 

                'file://HOST/base/path/to', 'file://HOST/base/other/path')

565

 

            # on different drives

566

 

            test('file:///D:/other/path',

567

 

                'file:///C:/path/to', 'file:///D:/other/path')

568

 

            # TODO: strictly saying in UNC path //HOST/base is full analog

569

 

            # of drive letter for hard disk, and this situation is also

570

 

            # should be exception from rules. [bialix 20071221]

571

 

 

572

496

 

573

497

class TestCwdToURL(TestCaseInTempDir):

574

498

    """Test that local_path_to_url works base on the cwd"""

582

506

        self.assertEndsWith(url, '/mytest')

583

507

 

584

508

    def test_non_ascii(self):

585

 

        if win32utils.winver == 'Windows 98':

586

 

            raise TestSkipped('Windows 98 cannot handle unicode filenames')

587

 

 

588

509

        try:

589

510

            os.mkdir(u'dod\xe9')

590

511

        except UnicodeError:

598

519

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

599

520

        url = urlutils.local_path_to_url('.')

600

521

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

601

 

 

602

 

 

603

 

class TestDeriveToLocation(TestCase):

604

 

    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""

605

 

 

606

 

    def test_to_locations_derived_from_paths(self):

607

 

        derive = urlutils.derive_to_location

608

 

        self.assertEqual("bar", derive("bar"))

609

 

        self.assertEqual("bar", derive("../bar"))

610

 

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

611

 

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

612

 

        self.assertEqual("bar", derive("c:bar"))

613

 

 

614

 

    def test_to_locations_derived_from_urls(self):

615

 

        derive = urlutils.derive_to_location

616

 

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

617

 

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

618

 

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

619

 

 

620

 

 

621

 

class TestRebaseURL(TestCase):

622

 

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

623

 

 

624

 

    def test_non_relative(self):

625

 

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

626

 

                                     'file://foo/bar')

627

 

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

628

 

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

629

 

                                     'file://foo/bar')

630

 

        self.assertEqual('/foo', result)

631

 

 

632

 

    def test_different_ports(self):

633

 

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

634

 

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

635

 

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

636

 

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

637

 

 

638

 

    def test_different_hosts(self):

639

 

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

640

 

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

641

 

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

642

 

                         " and 'http://baz'")

643

 

 

644

 

    def test_different_protocol(self):

645

 

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

646

 

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

647

 

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

648

 

                         " and 'ftp://bar'")

649

 

 

650

 

    def test_rebase_success(self):

651

 

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

652

 

                         'http://baz/qux'))

653

 

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

654

 

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

655

 

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

656

 

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

657

 

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

658

 

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

659

 

 

660

 

    def test_determine_relative_path(self):

661

 

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

662

 

                         urlutils.determine_relative_path(

663

 

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

664

 

        self.assertEqual('..',

665

 

                         urlutils.determine_relative_path(

666

 

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

667

 

        self.assertEqual('baz',

668

 

                         urlutils.determine_relative_path(

669

 

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

670

 

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

671

 

                         '/bar', '/bar'))

• Older »

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