~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

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

• reverse the comparison (4280 to 5200.1.2)
• stop comparing with revision 5200.1.2

Show diffs side-by-side

added

removed

bzrlib/tests/test_config.py

1

 

# Copyright (C) 2005-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2008 Canonical Ltd

 

2

#   Authors: Robert Collins <robert.collins@canonical.com>

2

3

#

3

4

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

4

5

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

25

26

    branch,

26

27

    bzrdir,

27

28

    config,

28

 

    diff,

29

29

    errors,

30

30

    osutils,

31

31

    mail_client,

43

43

[DEFAULT]

44

44

email=Erik B\u00e5gfors <erik@bagfors.nu>

45

45

editor=vim

46

 

change_editor=vimdiff -of @new_path @old_path

47

46

gpg_signing_command=gnome-gpg

48

47

log_format=short

49

48

user_global_option=something

210

209

        self._calls.append('_get_signature_checking')

211

210

        return self._signatures

212

211

 

213

 

    def _get_change_editor(self):

214

 

        self._calls.append('_get_change_editor')

215

 

        return 'vimdiff -fo @new_path @old_path'

216

 

 

217

212

 

218

213

bool_config = """[DEFAULT]

219

214

active = true

320

315

        my_config = config.Config()

321

316

        self.assertEqual('long', my_config.log_format())

322

317

 

323

 

    def test_get_change_editor(self):

324

 

        my_config = InstrumentedConfig()

325

 

        change_editor = my_config.get_change_editor('old_tree', 'new_tree')

326

 

        self.assertEqual(['_get_change_editor'], my_config._calls)

327

 

        self.assertIs(diff.DiffFromTool, change_editor.__class__)

328

 

        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],

329

 

                         change_editor.command_template)

330

 

 

331

318

 

332

319

class TestConfigPath(tests.TestCase):

333

320

 

334

321

    def setUp(self):

335

322

        super(TestConfigPath, self).setUp()

336

323

        os.environ['HOME'] = '/home/bogus'

337

 

        os.environ['XDG_CACHE_DIR'] = ''

338

324

        if sys.platform == 'win32':

339

325

            os.environ['BZR_HOME'] = \

340

326

                r'C:\Documents and Settings\bogus\Application Data'

362

348

        self.assertEqual(config.authentication_config_filename(),

363

349

                         self.bzr_home + '/authentication.conf')

364

350

 

365

 

    def test_xdg_cache_dir(self):

366

 

        self.assertEqual(config.xdg_cache_dir(),

367

 

            '/home/bogus/.cache')

368

 

 

369

351

 

370

352

class TestIniConfig(tests.TestCase):

371

353

 

372

 

    def make_config_parser(self, s):

373

 

        conf = config.IniBasedConfig(None)

374

 

        parser = conf._get_parser(file=StringIO(s.encode('utf-8')))

375

 

        return conf, parser

376

 

 

377

 

 

378

 

class TestIniConfigBuilding(TestIniConfig):

379

 

 

380

354

    def test_contructs(self):

381

355

        my_config = config.IniBasedConfig("nothing")

382

356

 

394

368

        self.failUnless(my_config._get_parser() is parser)

395

369

 

396

370

 

397

 

class TestGetUserOptionAs(TestIniConfig):

398

 

 

399

 

    def test_get_user_option_as_bool(self):

400

 

        conf, parser = self.make_config_parser("""

401

 

a_true_bool = true

402

 

a_false_bool = 0

403

 

an_invalid_bool = maybe

404

 

a_list = hmm, who knows ? # This is interpreted as a list !

405

 

""")

406

 

        get_bool = conf.get_user_option_as_bool

407

 

        self.assertEqual(True, get_bool('a_true_bool'))

408

 

        self.assertEqual(False, get_bool('a_false_bool'))

409

 

        warnings = []

410

 

        def warning(*args):

411

 

            warnings.append(args[0] % args[1:])

412

 

        self.overrideAttr(trace, 'warning', warning)

413

 

        msg = 'Value "%s" is not a boolean for "%s"'

414

 

        self.assertIs(None, get_bool('an_invalid_bool'))

415

 

        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])

416

 

        warnings = []

417

 

        self.assertIs(None, get_bool('not_defined_in_this_config'))

418

 

        self.assertEquals([], warnings)

419

 

 

420

 

    def test_get_user_option_as_list(self):

421

 

        conf, parser = self.make_config_parser("""

422

 

a_list = a,b,c

423

 

length_1 = 1,

424

 

one_item = x

425

 

""")

426

 

        get_list = conf.get_user_option_as_list

427

 

        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))

428

 

        self.assertEqual(['1'], get_list('length_1'))

429

 

        self.assertEqual('x', conf.get_user_option('one_item'))

430

 

        # automatically cast to list

431

 

        self.assertEqual(['x'], get_list('one_item'))

432

 

 

433

 

 

434

 

class TestSupressWarning(TestIniConfig):

435

 

 

436

 

    def make_warnings_config(self, s):

437

 

        conf, parser = self.make_config_parser(s)

438

 

        return conf.suppress_warning

439

 

 

440

 

    def test_suppress_warning_unknown(self):

441

 

        suppress_warning = self.make_warnings_config('')

442

 

        self.assertEqual(False, suppress_warning('unknown_warning'))

443

 

 

444

 

    def test_suppress_warning_known(self):

445

 

        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')

446

 

        self.assertEqual(False, suppress_warning('c'))

447

 

        self.assertEqual(True, suppress_warning('a'))

448

 

        self.assertEqual(True, suppress_warning('b'))

449

 

 

450

 

 

451

371

class TestGetConfig(tests.TestCase):

452

372

 

453

373

    def test_constructs(self):

687

607

        my_config = self._get_sample_config()

688

608

        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))

689

609

 

690

 

    def test_get_change_editor(self):

691

 

        my_config = self._get_sample_config()

692

 

        change_editor = my_config.get_change_editor('old', 'new')

693

 

        self.assertIs(diff.DiffFromTool, change_editor.__class__)

694

 

        self.assertEqual('vimdiff -of @new_path @old_path',

695

 

                         ' '.join(change_editor.command_template))

696

 

 

697

 

    def test_get_no_change_editor(self):

698

 

        my_config = self._get_empty_config()

699

 

        change_editor = my_config.get_change_editor('old', 'new')

700

 

        self.assertIs(None, change_editor)

701

 

 

702

610

 

703

611

class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):

704

612

 

1302

1210

 

1303

1211

    def test_set_unset_default_stack_on(self):

1304

1212

        my_dir = self.make_bzrdir('.')

1305

 

        bzrdir_config = config.BzrDirConfig(my_dir)

 

1213

        bzrdir_config = config.BzrDirConfig(my_dir.transport)

1306

1214

        self.assertIs(None, bzrdir_config.get_default_stack_on())

1307

1215

        bzrdir_config.set_default_stack_on('Foo')

1308

1216

        self.assertEqual('Foo', bzrdir_config._config.get_option(

1551

1459

class TestAuthenticationConfig(tests.TestCase):

1552

1460

    """Test AuthenticationConfig behaviour"""

1553

1461

 

1554

 

    def _check_default_password_prompt(self, expected_prompt_format, scheme,

1555

 

                                       host=None, port=None, realm=None,

1556

 

                                       path=None):

 

1462

    def _check_default_prompt(self, expected_prompt_format, scheme,

 

1463

                              host=None, port=None, realm=None, path=None):

1557

1464

        if host is None:

1558

1465

            host = 'bar.org'

1559

1466

        user, password = 'jim', 'precious'

1562

1469

            'user': user, 'realm': realm}

1563

1470

 

1564

1471

        stdout = tests.StringIOWrapper()

1565

 

        stderr = tests.StringIOWrapper()

1566

1472

        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',

1567

 

                                            stdout=stdout, stderr=stderr)

 

1473

                                            stdout=stdout)

1568

1474

        # We use an empty conf so that the user is always prompted

1569

1475

        conf = config.AuthenticationConfig()

1570

1476

        self.assertEquals(password,

1571

1477

                          conf.get_password(scheme, host, user, port=port,

1572

1478

                                            realm=realm, path=path))

1573

 

        self.assertEquals(expected_prompt, stderr.getvalue())

1574

 

        self.assertEquals('', stdout.getvalue())

1575

 

 

1576

 

    def _check_default_username_prompt(self, expected_prompt_format, scheme,

1577

 

                                       host=None, port=None, realm=None,

1578

 

                                       path=None):

1579

 

        if host is None:

1580

 

            host = 'bar.org'

1581

 

        username = 'jim'

1582

 

        expected_prompt = expected_prompt_format % {

1583

 

            'scheme': scheme, 'host': host, 'port': port,

1584

 

            'realm': realm}

1585

 

        stdout = tests.StringIOWrapper()

1586

 

        stderr = tests.StringIOWrapper()

1587

 

        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',

1588

 

                                            stdout=stdout, stderr=stderr)

1589

 

        # We use an empty conf so that the user is always prompted

1590

 

        conf = config.AuthenticationConfig()

1591

 

        self.assertEquals(username, conf.get_user(scheme, host, port=port,

1592

 

                          realm=realm, path=path, ask=True))

1593

 

        self.assertEquals(expected_prompt, stderr.getvalue())

1594

 

        self.assertEquals('', stdout.getvalue())

1595

 

 

1596

 

    def test_username_defaults_prompts(self):

1597

 

        # HTTP prompts can't be tested here, see test_http.py

1598

 

        self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')

1599

 

        self._check_default_username_prompt(

1600

 

            'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)

1601

 

        self._check_default_username_prompt(

1602

 

            'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)

1603

 

 

1604

 

    def test_username_default_no_prompt(self):

1605

 

        conf = config.AuthenticationConfig()

1606

 

        self.assertEquals(None,

1607

 

            conf.get_user('ftp', 'example.com'))

1608

 

        self.assertEquals("explicitdefault",

1609

 

            conf.get_user('ftp', 'example.com', default="explicitdefault"))

1610

 

 

1611

 

    def test_password_default_prompts(self):

1612

 

        # HTTP prompts can't be tested here, see test_http.py

1613

 

        self._check_default_password_prompt(

1614

 

            'FTP %(user)s@%(host)s password: ', 'ftp')

1615

 

        self._check_default_password_prompt(

1616

 

            'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)

1617

 

        self._check_default_password_prompt(

1618

 

            'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)

 

1479

        self.assertEquals(stdout.getvalue(), expected_prompt)

 

1480

 

 

1481

    def test_default_prompts(self):

 

1482

        # HTTP prompts can't be tested here, see test_http.py

 

1483

        self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')

 

1484

        self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',

 

1485

                                   'ftp', port=10020)

 

1486

 

 

1487

        self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',

 

1488

                                   'ssh', port=12345)

1619

1489

        # SMTP port handling is a bit special (it's handled if embedded in the

1620

1490

        # host too)

1621

1491

        # FIXME: should we: forbid that, extend it to other schemes, leave

1622

1492

        # things as they are that's fine thank you ?

1623

 

        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',

1624

 

                                            'smtp')

1625

 

        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',

1626

 

                                            'smtp', host='bar.org:10025')

1627

 

        self._check_default_password_prompt(

 

1493

        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',

 

1494

                                   'smtp')

 

1495

        self._check_default_prompt('SMTP %(user)s@%(host)s password: ',

 

1496

                                   'smtp', host='bar.org:10025')

 

1497

        self._check_default_prompt(

1628

1498

            'SMTP %(user)s@%(host)s:%(port)d password: ',

1629

1499

            'smtp', port=10025)

1630

1500

 

1639

1509

"""))

1640

1510

        entered_password = 'typed-by-hand'

1641

1511

        stdout = tests.StringIOWrapper()

1642

 

        stderr = tests.StringIOWrapper()

1643

1512

        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',

1644

 

                                            stdout=stdout, stderr=stderr)

 

1513

                                            stdout=stdout)

1645

1514

 

1646

1515

        # Since the password defined in the authentication config is ignored,

1647

1516

        # the user is prompted

1648

1517

        self.assertEquals(entered_password,

1649

1518

                          conf.get_password('ssh', 'bar.org', user='jim'))

1650

1519

        self.assertContainsRe(

1651

 

            self.get_log(),

 

1520

            self._get_log(keep_log_file=True),

1652

1521

            'password ignored in section \[ssh with password\]')

1653

1522

 

1654

1523

    def test_ssh_without_password_doesnt_emit_warning(self):

1661

1530

"""))

1662

1531

        entered_password = 'typed-by-hand'

1663

1532

        stdout = tests.StringIOWrapper()

1664

 

        stderr = tests.StringIOWrapper()

1665

1533

        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',

1666

 

                                            stdout=stdout,

1667

 

                                            stderr=stderr)

 

1534

                                            stdout=stdout)

1668

1535

 

1669

1536

        # Since the password defined in the authentication config is ignored,

1670

1537

        # the user is prompted

1673

1540

        # No warning shoud be emitted since there is no password. We are only

1674

1541

        # providing "user".

1675

1542

        self.assertNotContainsRe(

1676

 

            self.get_log(),

 

1543

            self._get_log(keep_log_file=True),

1677

1544

            'password ignored in section \[ssh with password\]')

1678

1545

 

1679

 

    def test_uses_fallback_stores(self):

1680

 

        self.overrideAttr(config, 'credential_store_registry',

1681

 

                          config.CredentialStoreRegistry())

1682

 

        store = StubCredentialStore()

1683

 

        store.add_credentials("http", "example.com", "joe", "secret")

1684

 

        config.credential_store_registry.register("stub", store, fallback=True)

1685

 

        conf = config.AuthenticationConfig(_file=StringIO())

1686

 

        creds = conf.get_credentials("http", "example.com")

1687

 

        self.assertEquals("joe", creds["user"])

1688

 

        self.assertEquals("secret", creds["password"])

1689

 

 

1690

 

 

1691

 

class StubCredentialStore(config.CredentialStore):

1692

 

 

1693

 

    def __init__(self):

1694

 

        self._username = {}

1695

 

        self._password = {}

1696

 

 

1697

 

    def add_credentials(self, scheme, host, user, password=None):

1698

 

        self._username[(scheme, host)] = user

1699

 

        self._password[(scheme, host)] = password

1700

 

 

1701

 

    def get_credentials(self, scheme, host, port=None, user=None,

1702

 

        path=None, realm=None):

1703

 

        key = (scheme, host)

1704

 

        if not key in self._username:

1705

 

            return None

1706

 

        return { "scheme": scheme, "host": host, "port": port,

1707

 

                "user": self._username[key], "password": self._password[key]}

1708

 

 

1709

 

 

1710

 

class CountingCredentialStore(config.CredentialStore):

1711

 

 

1712

 

    def __init__(self):

1713

 

        self._calls = 0

1714

 

 

1715

 

    def get_credentials(self, scheme, host, port=None, user=None,

1716

 

        path=None, realm=None):

1717

 

        self._calls += 1

1718

 

        return None

1719

 

 

1720

1546

 

1721

1547

class TestCredentialStoreRegistry(tests.TestCase):

1722

1548

 

1734

1560

        # 'unknown' so we use that as an never registered key.

1735

1561

        self.assertRaises(KeyError, r.get_credential_store, 'unknown')

1736

1562

 

1737

 

    def test_fallback_none_registered(self):

1738

 

        r = config.CredentialStoreRegistry()

1739

 

        self.assertEquals(None,

1740

 

                          r.get_fallback_credentials("http", "example.com"))

1741

 

 

1742

 

    def test_register(self):

1743

 

        r = config.CredentialStoreRegistry()

1744

 

        r.register("stub", StubCredentialStore(), fallback=False)

1745

 

        r.register("another", StubCredentialStore(), fallback=True)

1746

 

        self.assertEquals(["another", "stub"], r.keys())

1747

 

 

1748

 

    def test_register_lazy(self):

1749

 

        r = config.CredentialStoreRegistry()

1750

 

        r.register_lazy("stub", "bzrlib.tests.test_config",

1751

 

                        "StubCredentialStore", fallback=False)

1752

 

        self.assertEquals(["stub"], r.keys())

1753

 

        self.assertIsInstance(r.get_credential_store("stub"),

1754

 

                              StubCredentialStore)

1755

 

 

1756

 

    def test_is_fallback(self):

1757

 

        r = config.CredentialStoreRegistry()

1758

 

        r.register("stub1", None, fallback=False)

1759

 

        r.register("stub2", None, fallback=True)

1760

 

        self.assertEquals(False, r.is_fallback("stub1"))

1761

 

        self.assertEquals(True, r.is_fallback("stub2"))

1762

 

 

1763

 

    def test_no_fallback(self):

1764

 

        r = config.CredentialStoreRegistry()

1765

 

        store = CountingCredentialStore()

1766

 

        r.register("count", store, fallback=False)

1767

 

        self.assertEquals(None,

1768

 

                          r.get_fallback_credentials("http", "example.com"))

1769

 

        self.assertEquals(0, store._calls)

1770

 

 

1771

 

    def test_fallback_credentials(self):

1772

 

        r = config.CredentialStoreRegistry()

1773

 

        store = StubCredentialStore()

1774

 

        store.add_credentials("http", "example.com",

1775

 

                              "somebody", "geheim")

1776

 

        r.register("stub", store, fallback=True)

1777

 

        creds = r.get_fallback_credentials("http", "example.com")

1778

 

        self.assertEquals("somebody", creds["user"])

1779

 

        self.assertEquals("geheim", creds["password"])

1780

 

 

1781

 

    def test_fallback_first_wins(self):

1782

 

        r = config.CredentialStoreRegistry()

1783

 

        stub1 = StubCredentialStore()

1784

 

        stub1.add_credentials("http", "example.com",

1785

 

                              "somebody", "stub1")

1786

 

        r.register("stub1", stub1, fallback=True)

1787

 

        stub2 = StubCredentialStore()

1788

 

        stub2.add_credentials("http", "example.com",

1789

 

                              "somebody", "stub2")

1790

 

        r.register("stub2", stub1, fallback=True)

1791

 

        creds = r.get_fallback_credentials("http", "example.com")

1792

 

        self.assertEquals("somebody", creds["user"])

1793

 

        self.assertEquals("stub1", creds["password"])

1794

 

 

1795

1563

 

1796

1564

class TestPlainTextCredentialStore(tests.TestCase):

1797

1565

 

• Older »

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