~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (4634.146.5 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2005 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

17

17

"""Tests for the urlutils wrapper."""

18

18

 

19

19

import os

 

20

import re

20

21

import sys

21

22

 

22

23

from bzrlib import osutils, urlutils, win32utils

156

157

        # Weird stuff

157

158

        # Can't have slashes or colons in the scheme

158

159

        test_one('/path/to/://foo', None)

159

 

        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))

 

160

        test_one('path:path://foo', None)

160

161

        # Must have more than one character for scheme

161

162

        test_one('C://foo', None)

162

163

        test_one('ab://foo', ('ab', 'foo'))

195

196

            dirname('path/to/foo/', exclude_trailing_slash=False))

196

197

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

197

198

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

198

 

    

199

 

    def test_is_url(self):

200

 

        self.assertTrue(urlutils.is_url('http://foo/bar'))

201

 

        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))

202

 

        self.assertTrue(urlutils.is_url('lp:foo/bar'))

203

 

        self.assertTrue(urlutils.is_url('file:///foo/bar'))

204

 

        self.assertFalse(urlutils.is_url(''))

205

 

        self.assertFalse(urlutils.is_url('foo'))

206

 

        self.assertFalse(urlutils.is_url('foo/bar'))

207

 

        self.assertFalse(urlutils.is_url('/foo'))

208

 

        self.assertFalse(urlutils.is_url('/foo/bar'))

209

 

        self.assertFalse(urlutils.is_url('C:/'))

210

 

        self.assertFalse(urlutils.is_url('C:/foo'))

211

 

        self.assertFalse(urlutils.is_url('C:/foo/bar'))

212

199

 

213

200

    def test_join(self):

214

201

        def test(expected, *args):

224

211

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

225

212

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

226

213

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

227

 

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

228

 

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

229

214

 

230

215

        # Absolute paths

231

216

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

235

220

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

236

221

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

237

222

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

238

 

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

239

 

        test('lp:bar', 'lp:foo', 'lp:bar')

240

 

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

241

223

 

242

224

        # From a base path

243

225

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

289

271

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

290

272

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

291

273

 

292

 

    def test_join_segment_parameters_raw(self):

293

 

        join_segment_parameters_raw = urlutils.join_segment_parameters_raw

294

 

        self.assertEquals("/somedir/path", 

295

 

            join_segment_parameters_raw("/somedir/path"))

296

 

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

297

 

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

298

 

        self.assertRaises(InvalidURLJoin,

299

 

            join_segment_parameters_raw, "/somedir/path",

300

 

                "rawdata1,rawdata2,rawdata3")

301

 

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

302

 

            join_segment_parameters_raw("/somedir/path", "bla", "bar"))

303

 

        self.assertEquals("/somedir,exist=some/path,bla,bar",

304

 

            join_segment_parameters_raw("/somedir,exist=some/path",

305

 

                "bla", "bar"))

306

 

        self.assertRaises(TypeError, join_segment_parameters_raw, 

307

 

            "/somepath", 42)

308

 

 

309

 

    def test_join_segment_parameters(self):

310

 

        join_segment_parameters = urlutils.join_segment_parameters

311

 

        self.assertEquals("/somedir/path", 

312

 

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

313

 

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

314

 

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

315

 

        self.assertRaises(InvalidURLJoin,

316

 

            join_segment_parameters, "/somedir/path",

317

 

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

318

 

        self.assertRaises(InvalidURLJoin,

319

 

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

320

 

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

321

 

            join_segment_parameters("/somedir/path", {

322

 

                "key1": "val1", "key2": "val2"}))

323

 

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

324

 

            join_segment_parameters("/somedir/path,key1=val1", {

325

 

                "key2": "val2"}))

326

 

        self.assertEquals("/somedir/path,key1=val2",

327

 

            join_segment_parameters("/somedir/path,key1=val1", {

328

 

                "key1": "val2"}))

329

 

        self.assertEquals("/somedir,exist=some/path,key1=val1",

330

 

            join_segment_parameters("/somedir,exist=some/path",

331

 

                {"key1": "val1"}))

332

 

        self.assertEquals("/,key1=val1,key2=val2",

333

 

            join_segment_parameters("/,key1=val1", {"key2": "val2"}))

334

 

        self.assertRaises(TypeError,

335

 

            join_segment_parameters, "/,key1=val1", {"foo": 42})

336

 

 

337

274

    def test_function_type(self):

338

275

        if sys.platform == 'win32':

339

276

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

363

300

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

364

301

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

365

302

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

366

 

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

367

 

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

368

303

 

369

304

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

370

 

        self.assertRaises(

371

 

            InvalidURL, from_url,

372

 

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

373

305

 

374

306

    def test_win32_local_path_to_url(self):

375

307

        to_url = urlutils._win32_local_path_to_url

476

408

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

477

409

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

478

410

 

479

 

    def test_split_segment_parameters_raw(self):

480

 

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

481

 

        self.assertEquals(("/some/path", []),

482

 

            split_segment_parameters_raw("/some/path"))

483

 

        self.assertEquals(("/some/path", ["tip"]),

484

 

            split_segment_parameters_raw("/some/path,tip"))

485

 

        self.assertEquals(("/some,dir/path", ["tip"]),

486

 

            split_segment_parameters_raw("/some,dir/path,tip"))

487

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),

488

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))

489

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),

490

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))

491

 

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

492

 

            split_segment_parameters_raw(",key1=val1"))

493

 

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

494

 

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

495

 

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

496

 

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

497

 

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

498

 

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

499

 

 

500

 

    def test_split_segment_parameters(self):

501

 

        split_segment_parameters = urlutils.split_segment_parameters

502

 

        self.assertEquals(("/some/path", {}),

503

 

            split_segment_parameters("/some/path"))

504

 

        self.assertEquals(("/some/path", {"branch": "tip"}),

505

 

            split_segment_parameters("/some/path,branch=tip"))

506

 

        self.assertEquals(("/some,dir/path", {"branch": "tip"}),

507

 

            split_segment_parameters("/some,dir/path,branch=tip"))

508

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),

509

 

            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))

510

 

        self.assertEquals(("/somedir/path",

511

 

            {"ref": "heads%2Ftip", "key1": "val1"}),

512

 

            split_segment_parameters(

513

 

                "/somedir/path,ref=heads%2Ftip,key1=val1"))

514

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),

515

 

            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))

516

 

        self.assertEquals(("/", {"key1": "val1"}),

517

 

            split_segment_parameters(",key1=val1"))

518

 

        self.assertEquals(("foo/", {"key1": "val1"}),

519

 

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

520

 

        self.assertEquals(("foo/base,key1=val1/other/elements", {}),

521

 

            split_segment_parameters("foo/base,key1=val1/other/elements"))

522

 

        self.assertEquals(("foo/base,key1=val1/other/elements",

523

 

            {"key2": "val2"}), split_segment_parameters(

524

 

                "foo/base,key1=val1/other/elements,key2=val2"))

525

 

 

526

411

    def test_win32_strip_local_trailing_slash(self):

527

412

        strip = urlutils._win32_strip_local_trailing_slash

528

413

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

• Older »

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