Python BaseSettings.set方法代码示例

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
 def test_update_jsonstring(self):
     settings = BaseSettings({'number': 0, 'dict': BaseSettings({'key': 'val'})})
     settings.update('{"number": 1, "newnumber": 2}')
     self.assertEqual(settings['number'], 1)
     self.assertEqual(settings['newnumber'], 2)
     settings.set("dict", '{"key": "newval", "newkey": "newval2"}')
     self.assertEqual(settings['dict']['key'], "newval")
     self.assertEqual(settings['dict']['newkey'], "newval2")

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
 def test_delete(self):
     settings = BaseSettings({'key': None})
     settings.set('key_highprio', None, priority=50)
     settings.delete('key')
     settings.delete('key_highprio')
     self.assertNotIn('key', settings)
     self.assertIn('key_highprio', settings)
     del settings['key_highprio']
     self.assertNotIn('key_highprio', settings)

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
 def test_setitem(self):
     settings = BaseSettings()
     settings.set('key', 'a', 'default')
     settings['key'] = 'b'
     self.assertEqual(settings['key'], 'b')
     self.assertEqual(settings.getpriority('key'), 20)
     settings['key'] = 'c'
     self.assertEqual(settings['key'], 'c')
     settings['key2'] = 'x'
     self.assertIn('key2', settings)
     self.assertEqual(settings['key2'], 'x')
     self.assertEqual(settings.getpriority('key2'), 20)

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
    def test_set_per_key_priorities(self):
        attribute = SettingsAttribute(
            BaseSettings({'one': 10, 'two': 20}, 0), 0)

        new_dict = {'one': 11, 'two': 21}
        attribute.set(new_dict, 10)
        self.assertEqual(attribute.value['one'], 11)
        self.assertEqual(attribute.value['two'], 21)

        new_settings = BaseSettings()
        new_settings.set('one', 12, 20)
        new_settings.set('two', 12, 0)
        attribute.set(new_settings, 0)
        self.assertEqual(attribute.value['one'], 12)
        self.assertEqual(attribute.value['two'], 21)

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
 def _map_keys(compdict):
     if isinstance(compdict, BaseSettings):
         compbs = BaseSettings()
         for k, v in six.iteritems(compdict):
             prio = compdict.getpriority(k)
             if compbs.getpriority(convert(k)) == prio:
                 raise ValueError('Some paths in {!r} convert to the same '
                                  'object, please update your settings'
                                  ''.format(list(compdict.keys())))
             else:
                 compbs.set(convert(k), v, priority=prio)
         return compbs
     else:
         _check_components(compdict)
         return {convert(k): v for k, v in six.iteritems(compdict)}

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
    def test_update(self):
        settings = BaseSettings({'key_lowprio': 0}, priority=0)
        settings.set('key_highprio', 10, priority=50)
        custom_settings = BaseSettings({'key_lowprio': 1, 'key_highprio': 11}, priority=30)
        custom_settings.set('newkey_one', None, priority=50)
        custom_dict = {'key_lowprio': 2, 'key_highprio': 12, 'newkey_two': None}

        settings.update(custom_dict, priority=20)
        self.assertEqual(settings['key_lowprio'], 2)
        self.assertEqual(settings.getpriority('key_lowprio'), 20)
        self.assertEqual(settings['key_highprio'], 10)
        self.assertIn('newkey_two', settings)
        self.assertEqual(settings.getpriority('newkey_two'), 20)

        settings.update(custom_settings)
        self.assertEqual(settings['key_lowprio'], 1)
        self.assertEqual(settings.getpriority('key_lowprio'), 30)
        self.assertEqual(settings['key_highprio'], 10)
        self.assertIn('newkey_one', settings)
        self.assertEqual(settings.getpriority('newkey_one'), 50)

        settings.update({'key_lowprio': 3}, priority=20)
        self.assertEqual(settings['key_lowprio'], 1)

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
 def test_duplicate_components_in_basesettings(self):
     # Higher priority takes precedence
     duplicate_bs = BaseSettings({'one': 1, 'two': 2}, priority=0)
     duplicate_bs.set('ONE', 4, priority=10)
     self.assertEqual(build_component_list(duplicate_bs, convert=lambda x: x.lower()),
                      ['two', 'one'])
     duplicate_bs.set('one', duplicate_bs['one'], priority=20)
     self.assertEqual(build_component_list(duplicate_bs, convert=lambda x: x.lower()),
                      ['one', 'two'])
     # Same priority raises ValueError
     duplicate_bs.set('ONE', duplicate_bs['ONE'], priority=20)
     self.assertRaises(ValueError,
                       build_component_list, duplicate_bs, convert=lambda x: x.lower())

# 需要导入模块: from scrapy.settings import BaseSettings [as 别名]
# 或者: from scrapy.settings.BaseSettings import set [as 别名]
class BaseSettingsTest(unittest.TestCase):

    if six.PY3:
        assertItemsEqual = unittest.TestCase.assertCountEqual

    def setUp(self):
        self.settings = BaseSettings()

    def test_set_new_attribute(self):
        self.settings.set('TEST_OPTION', 'value', 0)
        self.assertIn('TEST_OPTION', self.settings.attributes)

        attr = self.settings.attributes['TEST_OPTION']
        self.assertIsInstance(attr, SettingsAttribute)
        self.assertEqual(attr.value, 'value')
        self.assertEqual(attr.priority, 0)

    def test_set_settingsattribute(self):
        myattr = SettingsAttribute(0, 30) # Note priority 30
        self.settings.set('TEST_ATTR', myattr, 10)
        self.assertEqual(self.settings.get('TEST_ATTR'), 0)
        self.assertEqual(self.settings.getpriority('TEST_ATTR'), 30)

    def test_set_instance_identity_on_update(self):
        attr = SettingsAttribute('value', 0)
        self.settings.attributes = {'TEST_OPTION': attr}
        self.settings.set('TEST_OPTION', 'othervalue', 10)

        self.assertIn('TEST_OPTION', self.settings.attributes)
        self.assertIs(attr, self.settings.attributes['TEST_OPTION'])

    def test_set_calls_settings_attributes_methods_on_update(self):
        attr = SettingsAttribute('value', 10)
        with mock.patch.object(attr, '__setattr__') as mock_setattr, \
                mock.patch.object(attr, 'set') as mock_set:

            self.settings.attributes = {'TEST_OPTION': attr}

            for priority in (0, 10, 20):
                self.settings.set('TEST_OPTION', 'othervalue', priority)
                mock_set.assert_called_once_with('othervalue', priority)
                self.assertFalse(mock_setattr.called)
                mock_set.reset_mock()
                mock_setattr.reset_mock()

    def test_setitem(self):
        settings = BaseSettings()
        settings.set('key', 'a', 'default')
        settings['key'] = 'b'
        self.assertEqual(settings['key'], 'b')
        self.assertEqual(settings.getpriority('key'), 20)
        settings['key'] = 'c'
        self.assertEqual(settings['key'], 'c')
        settings['key2'] = 'x'
        self.assertIn('key2', settings)
        self.assertEqual(settings['key2'], 'x')
        self.assertEqual(settings.getpriority('key2'), 20)

    def test_setdict_alias(self):
        with mock.patch.object(self.settings, 'set') as mock_set:
            self.settings.setdict({'TEST_1': 'value1', 'TEST_2': 'value2'}, 10)
            self.assertEqual(mock_set.call_count, 2)
            calls = [mock.call('TEST_1', 'value1', 10),
                     mock.call('TEST_2', 'value2', 10)]
            mock_set.assert_has_calls(calls, any_order=True)

    def test_setmodule_only_load_uppercase_vars(self):
        class ModuleMock():
            UPPERCASE_VAR = 'value'
            MIXEDcase_VAR = 'othervalue'
            lowercase_var = 'anothervalue'

        self.settings.attributes = {}
        self.settings.setmodule(ModuleMock(), 10)
        self.assertIn('UPPERCASE_VAR', self.settings.attributes)
        self.assertNotIn('MIXEDcase_VAR', self.settings.attributes)
        self.assertNotIn('lowercase_var', self.settings.attributes)
        self.assertEqual(len(self.settings.attributes), 1)

    def test_setmodule_alias(self):
        with mock.patch.object(self.settings, 'set') as mock_set:
            self.settings.setmodule(default_settings, 10)
            mock_set.assert_any_call('TEST_DEFAULT', 'defvalue', 10)
            mock_set.assert_any_call('TEST_DICT', {'key': 'val'}, 10)

    def test_setmodule_by_path(self):
        self.settings.attributes = {}
        self.settings.setmodule(default_settings, 10)
        ctrl_attributes = self.settings.attributes.copy()

        self.settings.attributes = {}
        self.settings.setmodule(
            'tests.test_settings.default_settings', 10)

        self.assertItemsEqual(six.iterkeys(self.settings.attributes),
                              six.iterkeys(ctrl_attributes))

        for key in six.iterkeys(ctrl_attributes):
            attr = self.settings.attributes[key]
            ctrl_attr = ctrl_attributes[key]
#.........这里部分代码省略.........