~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

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

• reverse the comparison (4086.2.1 to 5020.1.1)
• stop comparing with revision 5020.1.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_config.py

1

 

# Copyright (C) 2005, 2006, 2008, 2009 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

12

13

#

13

14

# You should have received a copy of the GNU General Public License

14

15

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

16

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

17

 

17

18

"""Tests for finding and reading the bzr config file[s]."""

18

19

# import system imports here

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

151

150

        self._transport = self.control_files = \

152

151

            FakeControlFilesAndTransport(user_id=user_id)

153

152

 

154

 

    def _get_config(self):

155

 

        return config.TransportConfig(self._transport, 'branch.conf')

156

 

 

157

153

    def lock_write(self):

158

154

        pass

159

155

 

210

206

        self._calls.append('_get_signature_checking')

211

207

        return self._signatures

212

208

 

213

 

    def _get_change_editor(self):

214

 

        self._calls.append('_get_change_editor')

215

 

        return 'vimdiff -fo @new_path @old_path'

216

 

 

217

209

 

218

210

bool_config = """[DEFAULT]

219

211

active = true

320

312

        my_config = config.Config()

321

313

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

322

314

 

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

315

 

332

316

class TestConfigPath(tests.TestCase):

333

317

 

334

318

    def setUp(self):

335

319

        super(TestConfigPath, self).setUp()

336

320

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

337

 

        os.environ['XDG_CACHE_DIR'] = ''

338

321

        if sys.platform == 'win32':

339

322

            os.environ['BZR_HOME'] = \

340

323

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

362

345

        self.assertEqual(config.authentication_config_filename(),

363

346

                         self.bzr_home + '/authentication.conf')

364

347

 

365

 

    def test_xdg_cache_dir(self):

366

 

        self.assertEqual(config.xdg_cache_dir(),

367

 

            '/home/bogus/.cache')

368

 

 

369

348

 

370

349

class TestIniConfig(tests.TestCase):

371

350

 

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

351

    def test_contructs(self):

381

352

        my_config = config.IniBasedConfig("nothing")

382

353

 

394

365

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

395

366

 

396

367

 

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

 

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

410

 

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

411

 

 

412

 

 

413

 

    def test_get_user_option_as_list(self):

414

 

        conf, parser = self.make_config_parser("""

415

 

a_list = a,b,c

416

 

length_1 = 1,

417

 

one_item = x

418

 

""")

419

 

        get_list = conf.get_user_option_as_list

420

 

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

421

 

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

422

 

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

423

 

        # automatically cast to list

424

 

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

425

 

 

426

 

 

427

 

class TestSupressWarning(TestIniConfig):

428

 

 

429

 

    def make_warnings_config(self, s):

430

 

        conf, parser = self.make_config_parser(s)

431

 

        return conf.suppress_warning

432

 

 

433

 

    def test_suppress_warning_unknown(self):

434

 

        suppress_warning = self.make_warnings_config('')

435

 

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

436

 

 

437

 

    def test_suppress_warning_known(self):

438

 

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

439

 

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

440

 

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

441

 

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

442

 

 

443

 

 

444

368

class TestGetConfig(tests.TestCase):

445

369

 

446

370

    def test_constructs(self):

680

604

        my_config = self._get_sample_config()

681

605

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

682

606

 

683

 

    def test_get_change_editor(self):

684

 

        my_config = self._get_sample_config()

685

 

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

686

 

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

687

 

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

688

 

                         ' '.join(change_editor.command_template))

689

 

 

690

 

    def test_get_no_change_editor(self):

691

 

        my_config = self._get_empty_config()

692

 

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

693

 

        self.assertIs(None, change_editor)

694

 

 

695

607

 

696

608

class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):

697

609

 

1295

1207

 

1296

1208

    def test_set_unset_default_stack_on(self):

1297

1209

        my_dir = self.make_bzrdir('.')

1298

 

        bzrdir_config = config.BzrDirConfig(my_dir)

 

1210

        bzrdir_config = config.BzrDirConfig(my_dir.transport)

1299

1211

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

1300

1212

        bzrdir_config.set_default_stack_on('Foo')

1301

1213

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

1515

1427

    def test_set_credentials(self):

1516

1428

        conf = config.AuthenticationConfig()

1517

1429

        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',

1518

 

        99, path='/foo', verify_certificates=False, realm='realm')

 

1430

        99, path='/foo', verify_certificates=False)

1519

1431

        credentials = conf.get_credentials(host='host', scheme='scheme',

1520

 

                                           port=99, path='/foo',

1521

 

                                           realm='realm')

 

1432

                                           port=99, path='/foo')

1522

1433

        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',

1523

 

                       'verify_certificates': False, 'scheme': 'scheme', 

1524

 

                       'host': 'host', 'port': 99, 'path': '/foo', 

1525

 

                       'realm': 'realm'}

 

1434

                       'verify_certificates': False,}

1526

1435

        self.assertEqual(CREDENTIALS, credentials)

1527

1436

        credentials_from_disk = config.AuthenticationConfig().get_credentials(

1528

 

            host='host', scheme='scheme', port=99, path='/foo', realm='realm')

 

1437

            host='host', scheme='scheme', port=99, path='/foo')

1529

1438

        self.assertEqual(CREDENTIALS, credentials_from_disk)

1530

1439

 

1531

1440

    def test_reset_credentials_different_name(self):

1535

1444

        self.assertIs(None, conf._get_config().get('name'))

1536

1445

        credentials = conf.get_credentials(host='host', scheme='scheme')

1537

1446

        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':

1538

 

                       'password', 'verify_certificates': True, 

1539

 

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

1540

 

                       'path': None, 'realm': None}

 

1447

                       'password', 'verify_certificates': True}

1541

1448

        self.assertEqual(CREDENTIALS, credentials)

1542

1449

 

1543

1450

 

1544

1451

class TestAuthenticationConfig(tests.TestCase):

1545

1452

    """Test AuthenticationConfig behaviour"""

1546

1453

 

1547

 

    def _check_default_password_prompt(self, expected_prompt_format, scheme,

1548

 

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

1549

 

                                       path=None):

 

1454

    def _check_default_prompt(self, expected_prompt_format, scheme,

 

1455

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

1550

1456

        if host is None:

1551

1457

            host = 'bar.org'

1552

1458

        user, password = 'jim', 'precious'

1555

1461

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

1556

1462

 

1557

1463

        stdout = tests.StringIOWrapper()

1558

 

        stderr = tests.StringIOWrapper()

1559

1464

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

1560

 

                                            stdout=stdout, stderr=stderr)

 

1465

                                            stdout=stdout)

1561

1466

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

1562

1467

        conf = config.AuthenticationConfig()

1563

1468

        self.assertEquals(password,

1564

1469

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

1565

1470

                                            realm=realm, path=path))

1566

 

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

1567

 

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

1568

 

 

1569

 

    def _check_default_username_prompt(self, expected_prompt_format, scheme,

1570

 

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

1571

 

                                       path=None):

1572

 

        if host is None:

1573

 

            host = 'bar.org'

1574

 

        username = 'jim'

1575

 

        expected_prompt = expected_prompt_format % {

1576

 

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

1577

 

            'realm': realm}

1578

 

        stdout = tests.StringIOWrapper()

1579

 

        stderr = tests.StringIOWrapper()

1580

 

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

1581

 

                                            stdout=stdout, stderr=stderr)

1582

 

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

1583

 

        conf = config.AuthenticationConfig()

1584

 

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

1585

 

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

1586

 

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

1587

 

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

1588

 

 

1589

 

    def test_username_defaults_prompts(self):

1590

 

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

1591

 

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

1592

 

        self._check_default_username_prompt(

1593

 

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

1594

 

        self._check_default_username_prompt(

1595

 

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

1596

 

 

1597

 

    def test_username_default_no_prompt(self):

1598

 

        conf = config.AuthenticationConfig()

1599

 

        self.assertEquals(None,

1600

 

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

1601

 

        self.assertEquals("explicitdefault",

1602

 

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

1603

 

 

1604

 

    def test_password_default_prompts(self):

1605

 

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

1606

 

        self._check_default_password_prompt(

1607

 

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

1608

 

        self._check_default_password_prompt(

1609

 

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

1610

 

        self._check_default_password_prompt(

1611

 

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

 

1471

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

 

1472

 

 

1473

    def test_default_prompts(self):

 

1474

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

 

1475

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

 

1476

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

 

1477

                                   'ftp', port=10020)

 

1478

 

 

1479

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

 

1480

                                   'ssh', port=12345)

1612

1481

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

1613

1482

        # host too)

1614

1483

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

1615

1484

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

1616

 

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

1617

 

                                            'smtp')

1618

 

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

1619

 

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

1620

 

        self._check_default_password_prompt(

 

1485

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

 

1486

                                   'smtp')

 

1487

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

 

1488

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

 

1489

        self._check_default_prompt(

1621

1490

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

1622

1491

            'smtp', port=10025)

1623

1492

 

1632

1501

"""))

1633

1502

        entered_password = 'typed-by-hand'

1634

1503

        stdout = tests.StringIOWrapper()

1635

 

        stderr = tests.StringIOWrapper()

1636

1504

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

1637

 

                                            stdout=stdout, stderr=stderr)

 

1505

                                            stdout=stdout)

1638

1506

 

1639

1507

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

1640

1508

        # the user is prompted

1641

1509

        self.assertEquals(entered_password,

1642

1510

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

1643

1511

        self.assertContainsRe(

1644

 

            self.get_log(),

 

1512

            self._get_log(keep_log_file=True),

1645

1513

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

1646

1514

 

1647

1515

    def test_ssh_without_password_doesnt_emit_warning(self):

1654

1522

"""))

1655

1523

        entered_password = 'typed-by-hand'

1656

1524

        stdout = tests.StringIOWrapper()

1657

 

        stderr = tests.StringIOWrapper()

1658

1525

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

1659

 

                                            stdout=stdout,

1660

 

                                            stderr=stderr)

 

1526

                                            stdout=stdout)

1661

1527

 

1662

1528

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

1663

1529

        # the user is prompted

1666

1532

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

1667

1533

        # providing "user".

1668

1534

        self.assertNotContainsRe(

1669

 

            self.get_log(),

 

1535

            self._get_log(keep_log_file=True),

1670

1536

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

1671

1537

 

1672

 

    def test_uses_fallback_stores(self):

1673

 

        self.overrideAttr(config, 'credential_store_registry',

1674

 

                          config.CredentialStoreRegistry())

1675

 

        store = StubCredentialStore()

1676

 

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

1677

 

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

1678

 

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

1679

 

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

1680

 

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

1681

 

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

1682

 

 

1683

 

 

1684

 

class StubCredentialStore(config.CredentialStore):

1685

 

 

1686

 

    def __init__(self):

1687

 

        self._username = {}

1688

 

        self._password = {}

1689

 

 

1690

 

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

1691

 

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

1692

 

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

1693

 

 

1694

 

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

1695

 

        path=None, realm=None):

1696

 

        key = (scheme, host)

1697

 

        if not key in self._username:

1698

 

            return None

1699

 

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

1700

 

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

1701

 

 

1702

 

 

1703

 

class CountingCredentialStore(config.CredentialStore):

1704

 

 

1705

 

    def __init__(self):

1706

 

        self._calls = 0

1707

 

 

1708

 

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

1709

 

        path=None, realm=None):

1710

 

        self._calls += 1

1711

 

        return None

1712

 

 

1713

1538

 

1714

1539

class TestCredentialStoreRegistry(tests.TestCase):

1715

1540

 

1727

1552

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

1728

1553

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

1729

1554

 

1730

 

    def test_fallback_none_registered(self):

1731

 

        r = config.CredentialStoreRegistry()

1732

 

        self.assertEquals(None,

1733

 

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

1734

 

 

1735

 

    def test_register(self):

1736

 

        r = config.CredentialStoreRegistry()

1737

 

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

1738

 

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

1739

 

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

1740

 

 

1741

 

    def test_register_lazy(self):

1742

 

        r = config.CredentialStoreRegistry()

1743

 

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

1744

 

                        "StubCredentialStore", fallback=False)

1745

 

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

1746

 

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

1747

 

                              StubCredentialStore)

1748

 

 

1749

 

    def test_is_fallback(self):

1750

 

        r = config.CredentialStoreRegistry()

1751

 

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

1752

 

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

1753

 

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

1754

 

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

1755

 

 

1756

 

    def test_no_fallback(self):

1757

 

        r = config.CredentialStoreRegistry()

1758

 

        store = CountingCredentialStore()

1759

 

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

1760

 

        self.assertEquals(None,

1761

 

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

1762

 

        self.assertEquals(0, store._calls)

1763

 

 

1764

 

    def test_fallback_credentials(self):

1765

 

        r = config.CredentialStoreRegistry()

1766

 

        store = StubCredentialStore()

1767

 

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

1768

 

                              "somebody", "geheim")

1769

 

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

1770

 

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

1771

 

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

1772

 

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

1773

 

 

1774

 

    def test_fallback_first_wins(self):

1775

 

        r = config.CredentialStoreRegistry()

1776

 

        stub1 = StubCredentialStore()

1777

 

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

1778

 

                              "somebody", "stub1")

1779

 

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

1780

 

        stub2 = StubCredentialStore()

1781

 

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

1782

 

                              "somebody", "stub2")

1783

 

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

1784

 

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

1785

 

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

1786

 

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

1787

 

 

1788

1555

 

1789

1556

class TestPlainTextCredentialStore(tests.TestCase):

1790

1557

 

• Older »

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