示例#1
0
    def test_partial_3(self):

        d = {'x': DotDictWithAcquisition()}
        d['x'].local_config = DotDictWithAcquisition()

        class A(object):
            def __init__(self, config):
                self.config = config
                eq_(d['x'].local_config, config)

        wrapped_class = class_with_partial_init(
            A,
            d['x'].local_config,
        )
        a = wrapped_class()
        del d['x']
        # the DotDictWithAcquisition should try to look to its parent
        # for the key "bad_key", but the weakly referenced parent should be
        # gone and raise a ReferenceError
        try:
            a.config.bad_key
        except ReferenceError:
            # this is the correct behavior
            # 'assertRaises' was not used because we're not testing a callable
            pass
示例#2
0
 def test_access_combos(self):
     d = DotDictWithAcquisition()
     d.x = DotDictWithAcquisition()
     d.x.y = DotDictWithAcquisition()
     d.x.y.a = 'Wilma'
     self.assertEqual(d['x.y.a'], 'Wilma')
     self.assertEqual(d['x.y'].a, 'Wilma')
     self.assertEqual(d['x'].y.a, 'Wilma')
     self.assertEqual(d.x.y.a, 'Wilma')
     self.assertEqual(d.x.y['a'], 'Wilma')
     self.assertEqual(d.x['y.a'], 'Wilma')
     self.assertEqual(d['x'].y['a'], 'Wilma')
     self.assertEqual(d['x']['y']['a'], 'Wilma')
     self.assertTrue(isinstance(d.x, DotDictWithAcquisition))
     self.assertTrue(isinstance(d.x.y, DotDictWithAcquisition))
示例#3
0
 def test_access_combos(self):
     d = DotDictWithAcquisition()
     d.x = DotDictWithAcquisition()
     d.x.y = DotDictWithAcquisition()
     d.x.y.a = 'Wilma'
     self.assertEqual(d['x.y.a'], 'Wilma')
     self.assertEqual(d['x.y'].a, 'Wilma')
     self.assertEqual(d['x'].y.a, 'Wilma')
     self.assertEqual(d.x.y.a, 'Wilma')
     self.assertEqual(d.x.y['a'], 'Wilma')
     self.assertEqual(d.x['y.a'], 'Wilma')
     self.assertEqual(d['x'].y['a'], 'Wilma')
     self.assertEqual(d['x']['y']['a'], 'Wilma')
     self.assertTrue(isinstance(d.x, DotDictWithAcquisition))
     self.assertTrue(isinstance(d.x.y, DotDictWithAcquisition))
示例#4
0
 def test_access_combos(self):
     d = DotDictWithAcquisition()
     d.x = DotDictWithAcquisition()
     d.x.y = DotDictWithAcquisition()
     d.x.y.a = "Wilma"
     self.assertEqual(d["x.y.a"], "Wilma")
     self.assertEqual(d["x.y"].a, "Wilma")
     self.assertEqual(d["x"].y.a, "Wilma")
     self.assertEqual(d.x.y.a, "Wilma")
     self.assertEqual(d.x.y["a"], "Wilma")
     self.assertEqual(d.x["y.a"], "Wilma")
     self.assertEqual(d["x"].y["a"], "Wilma")
     self.assertEqual(d["x"]["y"]["a"], "Wilma")
     self.assertTrue(isinstance(d.x, DotDictWithAcquisition))
     self.assertTrue(isinstance(d.x.y, DotDictWithAcquisition))
示例#5
0
 def test_copy_constructor_2(self):
     d = {
         'a': {
             'aa': 13,
             'ab': 14
         },
         'b': {
             'ba': {
                 'baa': 0,
                 'bab': 1
             },
             'bb': {
                 'bba': 2
             }
         },
         'c': 9,
         'd': {
             'dd': 2
         }
     }
     dd = DotDictWithAcquisition(d)
     e = [('a.aa', 13), ('a.ab', 14), ('b.ba.baa', 0), ('b.ba.bab', 1),
          ('b.bb.bba', 2), ('c', 9), ('d.dd', 2)]
     a = [x for x in iteritems_breadth_first(d)]
     e = sorted(e)
     a = sorted(a)
     self.assertEqual(a, e)
     self.assertTrue(isinstance(dd.a, DotDictWithAcquisition))
示例#6
0
 def setUp(self):
     """Create a configuration context."""
     rabbitmq = DotDictWithAcquisition()
     rabbitmq.host='localhost'
     rabbitmq.port=5672
     rabbitmq.priority_queue_name='socorro.priority'
     rabbitmq.rabbitmq_class=Mock()
     rabbitmq.rabbitmq_password='******'
     rabbitmq.rabbitmq_user='******'
     rabbitmq.standard_queue_name='socorro.normal'
     rabbitmq.virtual_host='/'
     self.config = DotDictWithAcquisition()
     self.config.logger = Mock()
     self.config.rabbitmq = rabbitmq
示例#7
0
 def __init__(self, config):
     if 'rabbitmq' in config:
         # the normal configman case
         self.config = config.rabbitmq
         self.context = self.config.rabbitmq_class(self.config)
     else:
         # the old middleware case without configman
         rabbitconfig = DotDictWithAcquisition()
         rabbitconfig.host = config['rabbitMQHost']
         rabbitconfig.port = config['rabbitMQPort']
         rabbitconfig.virtual_host = config['rabbitMQVirtualhost']
         rabbitconfig.rabbitmq_user = config['rabbitMQUsername']
         rabbitconfig.rabbitmq_password = config['rabbitMQPassword']
         rabbitconfig.standard_queue_name = config['rabbitMQStandardQueue']
         rabbitconfig.priority_queue_name = config['rabbitMQPriorityQueue']
         rabbitconfig.logger = logger
         self.config = rabbitconfig
         self.context = ConnectionContext(rabbitconfig)
示例#8
0
 def __init__(self, config):
     if 'rabbitmq' in config:
         # the normal configman case
         self.config = config.rabbitmq
         self.context = self.config.rabbitmq_class(self.config)
     else:
         # the old middleware case without configman
         rabbitconfig = DotDictWithAcquisition()
         rabbitconfig.host = config['rabbitMQHost']
         rabbitconfig.port = config['rabbitMQPort']
         rabbitconfig.virtual_host = config['rabbitMQVirtualhost']
         rabbitconfig.rabbitmq_user = config['rabbitMQUsername']
         rabbitconfig.rabbitmq_password = config['rabbitMQPassword']
         rabbitconfig.standard_queue_name = config['rabbitMQStandardQueue']
         rabbitconfig.priority_queue_name = config['rabbitMQPriorityQueue']
         rabbitconfig.logger = logger
         self.config = rabbitconfig
         self.context = ConnectionContext(rabbitconfig)
示例#9
0
    def test_nesting(self):
        d = DotDictWithAcquisition()
        d.e = 1
        d.dd = DotDictWithAcquisition()
        d.dd.f = 2
        d.dd.ddd = DotDictWithAcquisition()
        d.dd.ddd.g = 3
        d['a'] = 21
        d.dd['a'] = 22

        self.assertEqual(d.dd.ddd.e, 1)
        self.assertEqual(d.dd.e, 1)
        self.assertEqual(d.e, 1)

        self.assertEqual(d.dd.ddd.a, 22)
        self.assertEqual(d.dd.a, 22)
        self.assertEqual(d.a, 21)

        self.assertEqual(d.dd.ddd.f, 2)
        self.assertEqual(d.dd.f, 2)
        try:
            d.f
            raise AssertionError("should have raised KeyError")
        except KeyError:
            pass
        self.assertEqual(d.dd.dd.dd.dd.ddd.f, 2)
        self.assertEqual(d.dd.ddd.dd.ddd.dd.ddd.e, 1)

        self.assertEqual(len(d), 3)
        _keys = [x for x in d]
        self.assertEqual(_keys, ['a', 'dd', 'e'])
        self.assertEqual(d.keys(), ['a', 'dd', 'e'])
        self.assertEqual(list(d.iterkeys()), ['a', 'dd', 'e'])

        d.xxx = DotDictWithAcquisition()
        d.xxx.p = 69
        del d.xxx.p
        try:
            d.xxx.p
            assert 0
        except KeyError:
            pass

        # initialization
        d.yy = DotDictWithAcquisition(dict(foo='bar'))
        self.assertEqual(d.yy.foo, 'bar')

        # clashing names
        d.zzz = DotDictWithAcquisition()
        d.zzz.Bool = 'True'
        d.zzz.www = DotDictWithAcquisition()
        self.assertEqual(d.zzz.www.Bool, 'True')
        d.zzz.www.Bool = 'False'
        self.assertEqual(d.zzz.www.Bool, 'False')

        # test __setitem__ and __getitem__
        d = DotDictWithAcquisition()
        d.a = 17
        d['dd'] = DotDictWithAcquisition()
        self.assertEqual(d.dd.a, 17)
        d['dd']['ddd'] = DotDictWithAcquisition()
        self.assertEqual(d.dd.ddd.a, 17)
        self.assertEqual(d['dd']['ddd'].a, 17)
        self.assertEqual(d['dd']['ddd']['dd'].a, 17)
示例#10
0
import logging
import logging.handlers
import functools
import signal

from configman import (
    ConfigurationManager,
    Namespace,
    RequiredConfig,
    command_line,
    ConfigFileFutureProxy,
    class_converter
)
from configman.dotdict import DotDictWithAcquisition

environment = DotDictWithAcquisition(os.environ)
environment.always_ignore_mismatches = True


#==============================================================================
class AppDetailMissingError(AttributeError):
    pass


#==============================================================================
class App(RequiredConfig):
    """The base class from which Socorro apps are based"""
    #--------------------------------------------------------------------------
    def __init__(self, config):
        self.config = config
示例#11
0
    def test_nesting(self):
        d = DotDictWithAcquisition()
        d.e = 1
        d.dd = DotDictWithAcquisition()
        d.dd.f = 2
        d.dd.ddd = DotDictWithAcquisition()
        d.dd.ddd.g = 3
        d['a'] = 21
        d.dd['a'] = 22

        self.assertEqual(d.dd.ddd.e, 1)
        self.assertEqual(d.dd.e, 1)
        self.assertEqual(d.e, 1)

        self.assertEqual(d.dd.ddd.a, 22)
        self.assertEqual(d.dd.a, 22)
        self.assertEqual(d.a, 21)

        self.assertEqual(d.dd.ddd.f, 2)
        self.assertEqual(d.dd.f, 2)
        try:
            d.f
            raise AssertionError("should have raised KeyError")
        except KeyError:
            pass
        self.assertEqual(d.dd.dd.dd.dd.ddd.f, 2)
        self.assertEqual(d.dd.ddd.dd.ddd.dd.ddd.e, 1)

        self.assertEqual(len(d), 3)
        _keys = [x for x in d]
        self.assertEqual(_keys, ['e', 'dd', 'a'])
        self.assertEqual(d.keys(), ['e', 'dd', 'a'])
        self.assertEqual(list(d.iterkeys()), ['e', 'dd', 'a'])

        d.xxx = DotDictWithAcquisition()
        d.xxx.p = 69
        del d.xxx.p
        try:
            d.xxx.p
            assert 0
        except KeyError:
            pass

        # initialization
        d.yy = DotDictWithAcquisition(dict(foo='bar'))
        self.assertEqual(d.yy.foo, 'bar')

        # clashing names
        d.zzz = DotDictWithAcquisition()
        d.zzz.Bool = 'True'
        d.zzz.www = DotDictWithAcquisition()
        self.assertEqual(d.zzz.www.Bool, 'True')
        d.zzz.www.Bool = 'False'
        self.assertEqual(d.zzz.www.Bool, 'False')

        # test __setitem__ and __getitem__
        d = DotDictWithAcquisition()
        d.a = 17
        d['dd'] = DotDictWithAcquisition()
        self.assertEqual(d.dd.a, 17)
        d['dd']['ddd'] = DotDictWithAcquisition()
        self.assertEqual(d.dd.ddd.a, 17)
        self.assertEqual(d['dd']['ddd'].a, 17)
        self.assertEqual(d['dd']['ddd']['dd'].a, 17)
示例#12
0
 def setUp(self):
     """Create a configuration context."""
     super(IntegrationTestPriorityjobs, self).setUp()
     rabbitmq = DotDictWithAcquisition()
     rabbitmq.host = 'localhost'
     rabbitmq.port = 5672
     rabbitmq.priority_queue_name = 'socorro.priority'
     rabbitmq.rabbitmq_class = Mock()
     rabbitmq.rabbitmq_password = '******'
     rabbitmq.rabbitmq_user = '******'
     rabbitmq.standard_queue_name = 'socorro.normal'
     rabbitmq.virtual_host = '/'
     self.config = DotDictWithAcquisition()
     self.config.logger = Mock()
     self.config.rabbitmq = rabbitmq
示例#13
0
    def setUp(self):
        """Create a configuration context."""
        old_config = DotDictWithAcquisition()
        old_config.rabbitMQUsername = '******'
        old_config.rabbitMQPassword = '******'
        old_config.rabbitMQHost = 'localhost'
        old_config.rabbitMQPort = 5672
        old_config.rabbitMQVirtualhost = '/'
        old_config.rabbitMQStandardQueue = 'socorro.normal'
        old_config.rabbitMQPriorityQueue = 'socorro.priority'
        old_config.logger = Mock()
        self.old_config = old_config

        rabbitmq = DotDictWithAcquisition()
        rabbitmq.host='localhost'
        rabbitmq.port=5672
        rabbitmq.priority_queue_name='socorro.priority'
        rabbitmq.rabbitmq_class=Mock()
        rabbitmq.rabbitmq_password='******'
        rabbitmq.rabbitmq_user='******'
        rabbitmq.standard_queue_name='socorro.normal'
        rabbitmq.virtual_host='/'
        self.new_config = DotDictWithAcquisition()
        self.new_config.logger = Mock()
        self.new_config.rabbitmq = rabbitmq
示例#14
0
import datetime
import json
import os
import unittest
from past.builtins import basestring
from collections import Sequence, Mapping, defaultdict

import mock

import configman
from configman.dotdict import DotDictWithAcquisition

from socorro.cron.crontabber_app import CronTabberApp, JobStateDatabase

environment = DotDictWithAcquisition(os.environ)
environment.always_ignore_mismatches = True


class IntegrationTestCaseBase(unittest.TestCase):
    """Useful class for running integration tests related to crontabber apps
    since this class takes care of setting up a psycopg connection and it
    makes sure the ``cron_job`` and ``cron_log`` tables are empty.

    """
    def _setup_config_manager(self, jobs_string, extra_value_source=None):
        """setup and return a configman.ConfigurationManager and a the
        crontabber json file.
            jobs_string - a formatted string list services to be offered
            config - a string representing a config file OR a mapping of
                     key/value pairs to be used to override config defaults or
示例#15
0
    def setUp(self):
        """Create a configuration context."""
        old_config = DotDictWithAcquisition()
        old_config.rabbitMQUsername = '******'
        old_config.rabbitMQPassword = '******'
        old_config.rabbitMQHost = 'localhost'
        old_config.rabbitMQPort = 5672
        old_config.rabbitMQVirtualhost = '/'
        old_config.rabbitMQStandardQueue = 'socorro.normal'
        old_config.rabbitMQPriorityQueue = 'socorro.priority'
        old_config.logger = Mock()
        self.old_config = old_config

        rabbitmq = DotDictWithAcquisition()
        rabbitmq.host = 'localhost'
        rabbitmq.port = 5672
        rabbitmq.priority_queue_name = 'socorro.priority'
        rabbitmq.rabbitmq_class = Mock()
        rabbitmq.rabbitmq_password = '******'
        rabbitmq.rabbitmq_user = '******'
        rabbitmq.standard_queue_name = 'socorro.normal'
        rabbitmq.virtual_host = '/'
        self.new_config = DotDictWithAcquisition()
        self.new_config.logger = Mock()
        self.new_config.rabbitmq = rabbitmq
示例#16
0
    def test_nesting(self):
        d = DotDictWithAcquisition()
        d.e = 1
        d.dd = DotDictWithAcquisition()
        d.dd.f = 2
        d.dd.ddd = DotDictWithAcquisition()
        d.dd.ddd.g = 3
        d["a"] = 21
        d.dd["a"] = 22

        self.assertEqual(d.dd.ddd.e, 1)
        self.assertEqual(d.dd.e, 1)
        self.assertEqual(d.e, 1)

        self.assertEqual(d.dd.ddd.a, 22)
        self.assertEqual(d.dd.a, 22)
        self.assertEqual(d.a, 21)

        self.assertEqual(d.dd.ddd.f, 2)
        self.assertEqual(d.dd.f, 2)
        try:
            d.f
            raise AssertionError("should have raised KeyError")
        except KeyError:
            pass
        self.assertEqual(d.dd.dd.dd.dd.ddd.f, 2)
        self.assertEqual(d.dd.ddd.dd.ddd.dd.ddd.e, 1)

        self.assertEqual(len(d), 3)
        _keys = [x for x in d]
        self.assertEqual(_keys, ["e", "dd", "a"])
        self.assertEqual(d.keys(), ["e", "dd", "a"])
        self.assertEqual(list(d.iterkeys()), ["e", "dd", "a"])

        d.xxx = DotDictWithAcquisition()
        d.xxx.p = 69
        del d.xxx.p
        try:
            d.xxx.p
            assert 0
        except KeyError:
            pass

        # initialization
        d.yy = DotDictWithAcquisition(dict(foo="bar"))
        self.assertEqual(d.yy.foo, "bar")

        # clashing names
        d.zzz = DotDictWithAcquisition()
        d.zzz.Bool = "True"
        d.zzz.www = DotDictWithAcquisition()
        self.assertEqual(d.zzz.www.Bool, "True")
        d.zzz.www.Bool = "False"
        self.assertEqual(d.zzz.www.Bool, "False")

        # test __setitem__ and __getitem__
        d = DotDictWithAcquisition()
        d.a = 17
        d["dd"] = DotDictWithAcquisition()
        self.assertEqual(d.dd.a, 17)
        d["dd"]["ddd"] = DotDictWithAcquisition()
        self.assertEqual(d.dd.ddd.a, 17)
        self.assertEqual(d["dd"]["ddd"].a, 17)
        self.assertEqual(d["dd"]["ddd"]["dd"].a, 17)