~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (5027 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

156

156

        # Weird stuff

157

157

        # Can't have slashes or colons in the scheme

158

158

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

159

 

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

 

159

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

160

160

        # Must have more than one character for scheme

161

161

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

162

162

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

195

195

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

196

196

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

197

197

        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

198

 

213

199

    def test_join(self):

214

200

        def test(expected, *args):

224

210

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

225

211

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

226

212

        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

213

 

230

214

        # Absolute paths

231

215

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

235

219

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

236

220

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

237

221

        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

222

 

242

223

        # From a base path

243

224

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

289

270

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

290

271

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

291

272

 

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

273

    def test_function_type(self):

338

274

        if sys.platform == 'win32':

339

275

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

476

412

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

477

413

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

478

414

 

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

415

    def test_win32_strip_local_trailing_slash(self):

527

416

        strip = urlutils._win32_strip_local_trailing_slash

528

417

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

• Older »

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