/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_config.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_config.py

42

42

from ..sixish import (

43

43

    BytesIO,

44

44

    )

45

 

from ..symbol_versioning import (

46

 

    deprecated_in,

47

 

    )

48

45

from ..transport import remote as transport_remote

49

46

from . import (

50

47

    features,

488

485

                         my_config.username())

489

486

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

490

487

 

491

 

    def test_signatures_default(self):

492

 

        my_config = config.Config()

493

 

        self.assertFalse(

494

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

495

 

                my_config.signature_needed))

496

 

        self.assertEqual(config.CHECK_IF_POSSIBLE,

497

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

498

 

                my_config.signature_checking))

499

 

        self.assertEqual(config.SIGN_WHEN_REQUIRED,

500

 

                self.applyDeprecated(deprecated_in((2, 5, 0)),

501

 

                    my_config.signing_policy))

502

 

 

503

 

    def test_signatures_template_method(self):

504

 

        my_config = InstrumentedConfig()

505

 

        self.assertEqual(config.CHECK_NEVER,

506

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

507

 

                my_config.signature_checking))

508

 

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

509

 

 

510

 

    def test_signatures_template_method_none(self):

511

 

        my_config = InstrumentedConfig()

512

 

        my_config._signatures = None

513

 

        self.assertEqual(config.CHECK_IF_POSSIBLE,

514

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

515

 

                             my_config.signature_checking))

516

 

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

517

 

 

518

 

    def test_gpg_signing_command_default(self):

519

 

        my_config = config.Config()

520

 

        self.assertEqual('gpg',

521

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

522

 

                my_config.gpg_signing_command))

523

 

 

524

488

    def test_get_user_option_default(self):

525

489

        my_config = config.Config()

526

490

        self.assertEqual(None, my_config.get_user_option('no_option'))

527

491

 

528

 

    def test_post_commit_default(self):

529

 

        my_config = config.Config()

530

 

        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),

531

 

                                                    my_config.post_commit))

532

 

 

533

 

 

534

 

    def test_log_format_default(self):

535

 

        my_config = config.Config()

536

 

        self.assertEqual('long',

537

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

538

 

                                              my_config.log_format))

539

 

 

540

 

    def test_acceptable_keys_default(self):

541

 

        my_config = config.Config()

542

 

        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),

543

 

            my_config.acceptable_keys))

544

 

 

545

492

    def test_validate_signatures_in_log_default(self):

546

493

        my_config = config.Config()

547

494

        self.assertEqual(False, my_config.validate_signatures_in_log())

656

603

        self.assertTrue(isinstance(self.uid, int))

657

604

        self.assertTrue(isinstance(self.gid, int))

658

605

 

659

 

    def test_get_filename_parameter_is_deprecated_(self):

660

 

        conf = self.callDeprecated([

661

 

            'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'

662

 

            ' Use file_name instead.'],

663

 

            config.IniBasedConfig, lambda: 'ini.conf')

664

 

        self.assertEqual('ini.conf', conf.file_name)

665

 

 

666

 

    def test_get_parser_file_parameter_is_deprecated_(self):

667

 

        config_file = BytesIO(sample_config_text.encode('utf-8'))

668

 

        conf = config.IniBasedConfig.from_string(sample_config_text)

669

 

        conf = self.callDeprecated([

670

 

            'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'

671

 

            ' Use IniBasedConfig(_content=xxx) instead.'],

672

 

            conf._get_parser, file=config_file)

673

 

 

674

606

 

675

607

class TestIniConfigSaving(tests.TestCaseInTempDir):

676

608

 

1004

936

        # automatically cast to list

1005

937

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

1006

938

 

1007

 

    def test_get_user_option_as_int_from_SI(self):

1008

 

        conf, parser = self.make_config_parser("""

1009

 

plain = 100

1010

 

si_k = 5k,

1011

 

si_kb = 5kb,

1012

 

si_m = 5M,

1013

 

si_mb = 5MB,

1014

 

si_g = 5g,

1015

 

si_gb = 5gB,

1016

 

""")

1017

 

        def get_si(s, default=None):

1018

 

            return self.applyDeprecated(

1019

 

                deprecated_in((2, 5, 0)),

1020

 

                conf.get_user_option_as_int_from_SI, s, default)

1021

 

        self.assertEqual(100, get_si('plain'))

1022

 

        self.assertEqual(5000, get_si('si_k'))

1023

 

        self.assertEqual(5000, get_si('si_kb'))

1024

 

        self.assertEqual(5000000, get_si('si_m'))

1025

 

        self.assertEqual(5000000, get_si('si_mb'))

1026

 

        self.assertEqual(5000000000, get_si('si_g'))

1027

 

        self.assertEqual(5000000000, get_si('si_gb'))

1028

 

        self.assertEqual(None, get_si('non-exist'))

1029

 

        self.assertEqual(42, get_si('non-exist-with-default',  42))

1030

 

 

1031

939

 

1032

940

class TestSupressWarning(TestIniConfig):

1033

941

 

1181

1089

 

1182

1090

class TestGlobalConfigItems(tests.TestCaseInTempDir):

1183

1091

 

 

1092

    def _get_empty_config(self):

 

1093

        my_config = config.GlobalConfig()

 

1094

        return my_config

 

1095

 

 

1096

    def _get_sample_config(self):

 

1097

        my_config = config.GlobalConfig.from_string(sample_config_text)

 

1098

        return my_config

 

1099

 

1184

1100

    def test_user_id(self):

1185

1101

        my_config = config.GlobalConfig.from_string(sample_config_text)

1186

1102

        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",

1190

1106

        my_config = config.GlobalConfig()

1191

1107

        self.assertEqual(None, my_config._get_user_id())

1192

1108

 

1193

 

    def test_signatures_always(self):

1194

 

        my_config = config.GlobalConfig.from_string(sample_always_signatures)

1195

 

        self.assertEqual(config.CHECK_NEVER,

1196

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1197

 

                             my_config.signature_checking))

1198

 

        self.assertEqual(config.SIGN_ALWAYS,

1199

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1200

 

                             my_config.signing_policy))

1201

 

        self.assertEqual(True,

1202

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1203

 

                my_config.signature_needed))

1204

 

 

1205

 

    def test_signatures_if_possible(self):

1206

 

        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)

1207

 

        self.assertEqual(config.CHECK_NEVER,

1208

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1209

 

                             my_config.signature_checking))

1210

 

        self.assertEqual(config.SIGN_WHEN_REQUIRED,

1211

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1212

 

                             my_config.signing_policy))

1213

 

        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),

1214

 

            my_config.signature_needed))

1215

 

 

1216

 

    def test_signatures_ignore(self):

1217

 

        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)

1218

 

        self.assertEqual(config.CHECK_ALWAYS,

1219

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1220

 

                             my_config.signature_checking))

1221

 

        self.assertEqual(config.SIGN_NEVER,

1222

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1223

 

                             my_config.signing_policy))

1224

 

        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),

1225

 

            my_config.signature_needed))

1226

 

 

1227

 

    def _get_sample_config(self):

1228

 

        my_config = config.GlobalConfig.from_string(sample_config_text)

1229

 

        return my_config

1230

 

 

1231

 

    def test_gpg_signing_command(self):

1232

 

        my_config = self._get_sample_config()

1233

 

        self.assertEqual("gnome-gpg",

1234

 

            self.applyDeprecated(

1235

 

                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))

1236

 

        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),

1237

 

            my_config.signature_needed))

1238

 

 

1239

 

    def test_gpg_signing_key(self):

1240

 

        my_config = self._get_sample_config()

1241

 

        self.assertEqual("DD4D5088",

1242

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1243

 

                my_config.gpg_signing_key))

1244

 

 

1245

 

    def _get_empty_config(self):

1246

 

        my_config = config.GlobalConfig()

1247

 

        return my_config

1248

 

 

1249

 

    def test_gpg_signing_command_unset(self):

1250

 

        my_config = self._get_empty_config()

1251

 

        self.assertEqual("gpg",

1252

 

            self.applyDeprecated(

1253

 

                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))

1254

 

 

1255

1109

    def test_get_user_option_default(self):

1256

1110

        my_config = self._get_empty_config()

1257

1111

        self.assertEqual(None, my_config.get_user_option('no_option'))

1261

1115

        self.assertEqual("something",

1262

1116

                         my_config.get_user_option('user_global_option'))

1263

1117

 

1264

 

    def test_post_commit_default(self):

1265

 

        my_config = self._get_sample_config()

1266

 

        self.assertEqual(None,

1267

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1268

 

                                              my_config.post_commit))

1269

 

 

1270

 

    def test_configured_logformat(self):

1271

 

        my_config = self._get_sample_config()

1272

 

        self.assertEqual("short",

1273

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1274

 

                                              my_config.log_format))

1275

 

 

1276

 

    def test_configured_acceptable_keys(self):

1277

 

        my_config = self._get_sample_config()

1278

 

        self.assertEqual("amy",

1279

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1280

 

                my_config.acceptable_keys))

1281

 

 

1282

1118

    def test_configured_validate_signatures_in_log(self):

1283

1119

        my_config = self._get_sample_config()

1284

1120

        self.assertEqual(True, my_config.validate_signatures_in_log())

1517

1353

        self.assertEqual('Robert Collins <robertc@example.org>',

1518

1354

                         self.my_config.username())

1519

1355

 

1520

 

    def test_signatures_not_set(self):

1521

 

        self.get_branch_config('http://www.example.com',

1522

 

                                 global_config=sample_ignore_signatures)

1523

 

        self.assertEqual(config.CHECK_ALWAYS,

1524

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1525

 

                             self.my_config.signature_checking))

1526

 

        self.assertEqual(config.SIGN_NEVER,

1527

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1528

 

                             self.my_config.signing_policy))

1529

 

 

1530

 

    def test_signatures_never(self):

1531

 

        self.get_branch_config('/a/c')

1532

 

        self.assertEqual(config.CHECK_NEVER,

1533

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1534

 

                             self.my_config.signature_checking))

1535

 

 

1536

 

    def test_signatures_when_available(self):

1537

 

        self.get_branch_config('/a/', global_config=sample_ignore_signatures)

1538

 

        self.assertEqual(config.CHECK_IF_POSSIBLE,

1539

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1540

 

                             self.my_config.signature_checking))

1541

 

 

1542

 

    def test_signatures_always(self):

1543

 

        self.get_branch_config('/b')

1544

 

        self.assertEqual(config.CHECK_ALWAYS,

1545

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1546

 

                         self.my_config.signature_checking))

1547

 

 

1548

 

    def test_gpg_signing_command(self):

1549

 

        self.get_branch_config('/b')

1550

 

        self.assertEqual("gnome-gpg",

1551

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1552

 

                self.my_config.gpg_signing_command))

1553

 

 

1554

 

    def test_gpg_signing_command_missing(self):

1555

 

        self.get_branch_config('/a')

1556

 

        self.assertEqual("false",

1557

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1558

 

                self.my_config.gpg_signing_command))

1559

 

 

1560

 

    def test_gpg_signing_key(self):

1561

 

        self.get_branch_config('/b')

1562

 

        self.assertEqual("DD4D5088", self.applyDeprecated(deprecated_in((2, 5, 0)),

1563

 

            self.my_config.gpg_signing_key))

1564

 

 

1565

 

    def test_gpg_signing_key_default(self):

1566

 

        self.get_branch_config('/a')

1567

 

        self.assertEqual("erik@bagfors.nu",

1568

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1569

 

                self.my_config.gpg_signing_key))

1570

 

 

1571

1356

    def test_get_user_option_global(self):

1572

1357

        self.get_branch_config('/a')

1573

1358

        self.assertEqual('something',

1637

1422

            'http://www.example.com', 'norecurse_option'),

1638

1423

            config.POLICY_NONE)

1639

1424

 

1640

 

    def test_set_user_option_recurse_false_section(self):

1641

 

        # The following section has recurse=False set.  The test is to

1642

 

        # make sure that a normal option can be added to the section,

1643

 

        # converting recurse=False to the norecurse policy.

1644

 

        self.get_branch_config('http://www.example.com/norecurse')

1645

 

        self.callDeprecated(['The recurse option is deprecated as of 0.14.  '

1646

 

                             'The section "http://www.example.com/norecurse" '

1647

 

                             'has been converted to use policies.'],

1648

 

                            self.my_config.set_user_option,

1649

 

                            'foo', 'bar', store=config.STORE_LOCATION)

1650

 

        self.assertEqual(

1651

 

            self.my_location_config._get_option_policy(

1652

 

            'http://www.example.com/norecurse', 'foo'),

1653

 

            config.POLICY_NONE)

1654

 

        # The previously existing option is still norecurse:

1655

 

        self.assertEqual(

1656

 

            self.my_location_config._get_option_policy(

1657

 

            'http://www.example.com/norecurse', 'normal_option'),

1658

 

            config.POLICY_NORECURSE)

1659

 

 

1660

 

    def test_post_commit_default(self):

1661

 

        self.get_branch_config('/a/c')

1662

 

        self.assertEqual('breezy.tests.test_config.post_commit',

1663

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1664

 

                                              self.my_config.post_commit))

1665

 

 

1666

1425

    def get_branch_config(self, location, global_config=None,

1667

1426

                          location_config=None):

1668

1427

        my_branch = FakeBranch(location)

1678

1437

        self.my_config = my_config

1679

1438

        self.my_location_config = my_config._get_location_config()

1680

1439

 

1681

 

    def test_set_user_setting_sets_and_saves(self):

1682

 

        self.get_branch_config('/a/c')

1683

 

        record = InstrumentedConfigObj("foo")

1684

 

        self.my_location_config._parser = record

1685

 

 

1686

 

        self.callDeprecated(['The recurse option is deprecated as of '

1687

 

                             '0.14.  The section "/a/c" has been '

1688

 

                             'converted to use policies.'],

1689

 

                            self.my_config.set_user_option,

1690

 

                            'foo', 'bar', store=config.STORE_LOCATION)

1691

 

        self.assertEqual([('reload',),

1692

 

                          ('__contains__', '/a/c'),

1693

 

                          ('__contains__', '/a/c/'),

1694

 

                          ('__setitem__', '/a/c', {}),

1695

 

                          ('__getitem__', '/a/c'),

1696

 

                          ('__setitem__', 'foo', 'bar'),

1697

 

                          ('__getitem__', '/a/c'),

1698

 

                          ('as_bool', 'recurse'),

1699

 

                          ('__getitem__', '/a/c'),

1700

 

                          ('__delitem__', 'recurse'),

1701

 

                          ('__getitem__', '/a/c'),

1702

 

                          ('keys',),

1703

 

                          ('__getitem__', '/a/c'),

1704

 

                          ('__contains__', 'foo:policy'),

1705

 

                          ('write',)],

1706

 

                         record._calls[1:])

1707

 

 

1708

1440

    def test_set_user_setting_sets_and_saves2(self):

1709

1441

        self.get_branch_config('/a/c')

1710

1442

        self.assertIs(self.my_config.get_user_option('foo'), None)

1771

1503

        self.assertEqual("Robert Collins <robertc@example.org>",

1772

1504

                         my_config.username())

1773

1505

 

1774

 

    def test_signatures_forced(self):

1775

 

        my_config = self.get_branch_config(

1776

 

            global_config=sample_always_signatures)

1777

 

        self.assertEqual(config.CHECK_NEVER,

1778

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1779

 

                my_config.signature_checking))

1780

 

        self.assertEqual(config.SIGN_ALWAYS,

1781

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1782

 

                my_config.signing_policy))

1783

 

        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),

1784

 

            my_config.signature_needed))

1785

 

 

1786

 

    def test_signatures_forced_branch(self):

1787

 

        my_config = self.get_branch_config(

1788

 

            global_config=sample_ignore_signatures,

1789

 

            branch_data_config=sample_always_signatures)

1790

 

        self.assertEqual(config.CHECK_NEVER,

1791

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1792

 

                my_config.signature_checking))

1793

 

        self.assertEqual(config.SIGN_ALWAYS,

1794

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1795

 

                my_config.signing_policy))

1796

 

        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),

1797

 

            my_config.signature_needed))

1798

 

 

1799

 

    def test_gpg_signing_command(self):

1800

 

        my_config = self.get_branch_config(

1801

 

            global_config=sample_config_text,

1802

 

            # branch data cannot set gpg_signing_command

1803

 

            branch_data_config="gpg_signing_command=pgp")

1804

 

        self.assertEqual('gnome-gpg',

1805

 

            self.applyDeprecated(deprecated_in((2, 5, 0)),

1806

 

                my_config.gpg_signing_command))

1807

 

 

1808

1506

    def test_get_user_option_global(self):

1809

1507

        my_config = self.get_branch_config(global_config=sample_config_text)

1810

1508

        self.assertEqual('something',

1811

1509

                         my_config.get_user_option('user_global_option'))

1812

1510

 

1813

 

    def test_post_commit_default(self):

1814

 

        my_config = self.get_branch_config(global_config=sample_config_text,

1815

 

                                      location='/a/c',

1816

 

                                      location_config=sample_branches_text)

1817

 

        self.assertEqual(my_config.branch.base, '/a/c')

1818

 

        self.assertEqual('breezy.tests.test_config.post_commit',

1819

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1820

 

                                              my_config.post_commit))

1821

 

        my_config.set_user_option('post_commit', 'rmtree_root')

1822

 

        # post-commit is ignored when present in branch data

1823

 

        self.assertEqual('breezy.tests.test_config.post_commit',

1824

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1825

 

                                              my_config.post_commit))

1826

 

        my_config.set_user_option('post_commit', 'rmtree_root',

1827

 

                                  store=config.STORE_LOCATION)

1828

 

        self.assertEqual('rmtree_root',

1829

 

                         self.applyDeprecated(deprecated_in((2, 5, 0)),

1830

 

                                              my_config.post_commit))

1831

 

 

1832

1511

    def test_config_precedence(self):

1833

1512

        # FIXME: eager test, luckily no persitent config file makes it fail

1834

1513

        # -- vila 20100716

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0