~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2127.1.1 to 2602)
• stop comparing with revision 2602

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

 

23

from bzrlib import osutils, urlutils

24

24

import bzrlib

25

25

from bzrlib.errors import InvalidURL, InvalidURLJoin

26

26

from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped

115

115

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

116

116

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

117

117

 

118

 

        # Unescape characters that don't need to be escaped

119

 

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

120

 

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

121

 

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

122

 

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

123

 

 

124

118

        # Normalize verifies URLs when they are not unicode

125

119

        # (indicating they did not come from the user)

126

120

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

203

197

            joined = urlutils.join(*args)

204

198

            self.assertEqual(expected, joined)

205

199

 

 

200

        # Test a single element

 

201

        test('foo', 'foo')

 

202

 

206

203

        # Test relative path joining

207

 

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

208

204

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

209

205

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

210

206

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

211

207

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

212

208

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

213

209

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

214

 

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

215

210

 

216

211

        # Absolute paths

217

 

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

218

212

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

219

213

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

220

214

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

221

 

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

222

 

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

223

 

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

224

215

 

225

216

        # From a base path

226

217

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

230

221

        

231

222

        # Invalid joinings

232

223

        # Cannot go above root

233

 

        # Implicitly at root:

234

224

        self.assertRaises(InvalidURLJoin, urlutils.join,

235

225

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

236

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

237

 

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

238

 

        # Joining from a path explicitly under the root.

239

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

240

 

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

241

 

 

242

 

    def test_joinpath(self):

243

 

        def test(expected, *args):

244

 

            joined = urlutils.joinpath(*args)

245

 

            self.assertEqual(expected, joined)

246

 

 

247

 

        # Test a single element

248

 

        test('foo', 'foo')

249

 

 

250

 

        # Test relative path joining

251

 

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

252

 

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

253

 

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

254

 

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

255

 

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

256

 

 

257

 

        # Test joining to an absolute path

258

 

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

259

 

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

260

 

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

261

 

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

262

 

 

263

 

        # Test joining with an absolute path

264

 

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

265

 

 

266

 

        # Test joining to a path with a trailing slash

267

 

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

268

 

        

269

 

        # Invalid joinings

270

 

        # Cannot go above root

271

 

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

272

 

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

273

 

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

274

226

 

275

227

    def test_function_type(self):

276

228

        if sys.platform == 'win32':

323

275

 

324

276

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

325

277

 

326

 

    def test_win32_unc_path_to_url(self):

327

 

        to_url = urlutils._win32_local_path_to_url

328

 

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

329

 

            to_url(r'\\HOST\path'))

330

 

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

331

 

            to_url('//HOST/path'))

332

 

 

333

 

        try:

334

 

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

335

 

        except UnicodeError:

336

 

            raise TestSkipped("local encoding cannot handle unicode")

337

 

 

338

 

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

339

 

 

340

 

 

341

278

    def test_win32_local_path_from_url(self):

342

279

        from_url = urlutils._win32_local_path_from_url

343

280

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

351

288

        # Not a valid _win32 url, no drive letter

352

289

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

353

290

 

354

 

    def test_win32_unc_path_from_url(self):

355

 

        from_url = urlutils._win32_local_path_from_url

356

 

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

357

 

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

358

 

        # we want to use only 2 slashes

359

 

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

360

 

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

361

 

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

362

 

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

363

 

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

364

 

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

365

 

 

366

 

    def test_win32_extract_drive_letter(self):

 

291

    def test__win32_extract_drive_letter(self):

367

292

        extract = urlutils._win32_extract_drive_letter

368

293

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

369

294

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

404

329

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

405

330

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

406

331

 

407

 

    def test_win32_strip_local_trailing_slash(self):

 

332

    def test__win32_strip_local_trailing_slash(self):

408

333

        strip = urlutils._win32_strip_local_trailing_slash

409

334

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

410

335

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

554

479

        self.assertEndsWith(url, '/mytest')

555

480

 

556

481

    def test_non_ascii(self):

557

 

        if win32utils.winver == 'Windows 98':

558

 

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

559

 

 

560

482

        try:

561

483

            os.mkdir(u'dod\xe9')

562

484

        except UnicodeError:

570

492

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

571

493

        url = urlutils.local_path_to_url('.')

572

494

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

573

 

 

574

 

 

575

 

class TestDeriveToLocation(TestCase):

576

 

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

577

 

 

578

 

    def test_to_locations_derived_from_paths(self):

579

 

        derive = urlutils.derive_to_location

580

 

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

581

 

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

582

 

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

583

 

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

584

 

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

585

 

 

586

 

    def test_to_locations_derived_from_urls(self):

587

 

        derive = urlutils.derive_to_location

588

 

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

589

 

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

590

 

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

• Older »

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