Python MemcacheMiddleware Examples

Example #1

File: test_memcache.py Project: this-pama/swift-1

 def test_conf_from_extra_conf(self):
     with mock.patch.object(memcache, 'ConfigParser', get_config_parser()):
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     self.assertEqual(app.memcache_servers, '1.2.3.4:5')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, True)
     self.assertEqual(app.memcache._client_cache['1.2.3.4:5'].max_size, 4)

Example #2

 def test_conf_default_read(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = ExcConfigParser
     count = 0
     try:
         for d in ({},
                   {'memcache_servers': '6.7.8.9:10'},
                   {'memcache_serialization_support': '0'},
                   {'memcache_max_connections': '30'},
                   {'memcache_servers': '6.7.8.9:10',
                    'memcache_serialization_support': '0'},
                   {'memcache_servers': '6.7.8.9:10',
                    'memcache_max_connections': '30'},
                   {'memcache_serialization_support': '0',
                    'memcache_max_connections': '30'}
                   ):
             try:
                 memcache.MemcacheMiddleware(FakeApp(), d)
             except Exception as err:
                 self.assertEqual(
                     str(err),
                     "read called with '/etc/swift/memcache.conf'")
                 count += 1
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(count, 7)

Example #3

 def test_conf_default(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = EmptyConfigParser
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(app.memcache_servers, '127.0.0.1:11211')

Example #4

 def test_conf_default_read(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = ExcConfigParser
     exc = None
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     except Exception, err:
         exc = err

Example #5

File: test_memcache.py Project: this-pama/swift-1

 def test_conf_default(self):
     with mock.patch.object(memcache, 'ConfigParser', EmptyConfigParser):
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #6

 def test_conf_from_extra_conf(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = SetConfigParser
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(app.memcache_servers, '1.2.3.4:5')

Example #7

 def test_conf_set_no_read(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = ExcConfigParser
     exc = None
     try:
         app = memcache.MemcacheMiddleware(
             FakeApp(), {'memcache_servers': '1.2.3.4:5'})
     except Exception, err:
         exc = err

Example #8

File: test_memcache.py Project: this-pama/swift-1

 def test_conf_extra_no_section(self):
     with mock.patch.object(memcache, 'ConfigParser',
                            get_config_parser(section='foobar')):
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #9

File: test_memcache.py Project: KirillArkhipov1/swift-1

 def test_conf_inline_ratelimiting(self):
     with mock.patch.object(memcache, 'ConfigParser', get_config_parser()):
         app = memcache.MemcacheMiddleware(
             FakeApp(),
             {'error_suppression_limit': '5',
              'error_suppression_interval': '2.5'})
     self.assertEqual(app.memcache._error_limit_count, 5)
     self.assertEqual(app.memcache._error_limit_time, 2.5)
     self.assertEqual(app.memcache._error_limit_duration, 2.5)

Example #10

 def test_conf_from_inline_conf(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = SetConfigParser
     try:
         app = memcache.MemcacheMiddleware(
             FakeApp(), {'memcache_servers': '6.7.8.9:10'})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(app.memcache_servers, '6.7.8.9:10')

Example #11

File: test_memcache.py Project: this-pama/swift-1

 def test_conf_from_inline_and_sers_from_extra_conf(self):
     with mock.patch.object(memcache, 'ConfigParser', get_config_parser()):
         app = memcache.MemcacheMiddleware(FakeApp(), {
             'memcache_servers': '6.7.8.9:10',
             'memcache_max_connections': '42'
         })
     self.assertEqual(app.memcache_servers, '6.7.8.9:10')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, True)
     self.assertEqual(app.memcache._client_cache['6.7.8.9:10'].max_size, 42)

Example #12

File: test_memcache.py Project: KirillArkhipov1/swift-1

 def test_conf_extra_no_option(self):
     replacement_parser = get_config_parser(
         memcache_servers='error', memcache_serialization_support='error',
         memcache_max_connections='error')
     with mock.patch.object(memcache, 'ConfigParser', replacement_parser):
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #13

File: test_memcache.py Project: KirillArkhipov1/swift-1

 def test_conf_set_no_read(self):
     with mock.patch.object(memcache, 'ConfigParser', ExcConfigParser):
         exc = None
         try:
             memcache.MemcacheMiddleware(
                 FakeApp(), {'memcache_servers': '1.2.3.4:5',
                             'memcache_serialization_support': '2',
                             'memcache_max_connections': '30'})
         except Exception as err:
             exc = err
     self.assertIsNone(exc)

Example #14

File: test_memcache.py Project: chenbaihu/icehouse

 def test_conf_from_extra_conf(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = get_config_parser()
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(app.memcache_servers, '1.2.3.4:5')
     self.assertEquals(app.memcache._allow_pickle, False)
     self.assertEquals(app.memcache._allow_unpickle, True)
     self.assertEquals(app.memcache._client_cache['1.2.3.4:5'].max_size, 4)

Example #15

 def test_conf_extra_no_section(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = get_config_parser(section='foobar')
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #16

File: test_memcache.py Project: this-pama/swift-1

 def test_conf_inline_bad_max_conn(self):
     with mock.patch.object(memcache, 'ConfigParser', get_config_parser()):
         app = memcache.MemcacheMiddleware(
             FakeApp(), {
                 'memcache_servers': '6.7.8.9:10',
                 'memcache_serialization_support': '0',
                 'max_connections': 'bad42'
             })
     self.assertEqual(app.memcache_servers, '6.7.8.9:10')
     self.assertEqual(app.memcache._allow_pickle, True)
     self.assertEqual(app.memcache._allow_unpickle, True)
     self.assertEqual(app.memcache._client_cache['6.7.8.9:10'].max_size, 4)

Example #17

 def test_conf_default(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = EmptyConfigParser
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #18

 def test_conf_default_read(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = ExcConfigParser
     exc = None
     try:
         memcache.MemcacheMiddleware(FakeApp(), {})
     except Exception as err:
         exc = err
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(str(exc),
                       "read called with '/etc/swift/memcache.conf'")

Example #19

 def test_conf_from_inline_conf(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = SetConfigParser
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {
             'memcache_servers': '6.7.8.9:10',
             'serialization_format': '0'
         })
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEquals(app.memcache_servers, '6.7.8.9:10')
     self.assertEquals(app.memcache._allow_pickle, False)
     self.assertEquals(app.memcache._allow_unpickle, True)

Example #20

 def test_conf_from_inline_and_sers_from_extra_conf(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = get_config_parser()
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {
             'memcache_servers': '6.7.8.9:10',
             'memcache_max_connections': '42'
         })
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(app.memcache_servers, '6.7.8.9:10')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, True)
     self.assertEqual(app.memcache._client_cache['6.7.8.9:10'].max_size, 42)

Example #21

 def test_conf_set_no_read(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = ExcConfigParser
     exc = None
     try:
         memcache.MemcacheMiddleware(
             FakeApp(), {'memcache_servers': '1.2.3.4:5',
                         'memcache_serialization_support': '2',
                         'memcache_max_connections': '30'})
     except Exception as err:
         exc = err
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(exc, None)

Example #22

 def test_conf_extra_no_option(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = get_config_parser(
         memcache_servers='error', memcache_serialization_support='error',
         memcache_max_connections='error')
     try:
         app = memcache.MemcacheMiddleware(FakeApp(), {})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(app.memcache_servers, '127.0.0.1:11211')
     self.assertEqual(app.memcache._allow_pickle, False)
     self.assertEqual(app.memcache._allow_unpickle, False)
     self.assertEqual(
         app.memcache._client_cache['127.0.0.1:11211'].max_size, 2)

Example #23

File: test_memcache.py Project: KirillArkhipov1/swift-1

 def test_conf_inline_tls(self):
     fake_context = mock.Mock()
     with mock.patch.object(ssl, 'create_default_context',
                            return_value=fake_context):
         with mock.patch.object(memcache, 'ConfigParser',
                                get_config_parser()):
             memcache.MemcacheMiddleware(
                 FakeApp(),
                 {'tls_enabled': 'true',
                  'tls_cafile': 'cafile',
                  'tls_certfile': 'certfile',
                  'tls_keyfile': 'keyfile'})
         ssl.create_default_context.assert_called_with(cafile='cafile')
         fake_context.load_cert_chain.assert_called_with('certfile',
                                                         'keyfile')

Example #24

 def test_conf_inline_bad_max_conn(self):
     orig_parser = memcache.ConfigParser
     memcache.ConfigParser = get_config_parser()
     try:
         app = memcache.MemcacheMiddleware(
             FakeApp(),
             {'memcache_servers': '6.7.8.9:10',
              'memcache_serialization_support': '0',
              'max_connections': 'bad42'})
     finally:
         memcache.ConfigParser = orig_parser
     self.assertEqual(app.memcache_servers, '6.7.8.9:10')
     self.assertEqual(app.memcache._allow_pickle, True)
     self.assertEqual(app.memcache._allow_unpickle, True)
     self.assertEqual(
         app.memcache._client_cache['6.7.8.9:10'].max_size, 4)

Example #25

File: test_memcache.py Project: KirillArkhipov1/swift-1

 def test_conf_default_read(self):
     with mock.patch.object(memcache, 'ConfigParser', ExcConfigParser):
         for d in ({},
                   {'memcache_servers': '6.7.8.9:10'},
                   {'memcache_serialization_support': '0'},
                   {'memcache_max_connections': '30'},
                   {'memcache_servers': '6.7.8.9:10',
                    'memcache_serialization_support': '0'},
                   {'memcache_servers': '6.7.8.9:10',
                    'memcache_max_connections': '30'},
                   {'memcache_serialization_support': '0',
                    'memcache_max_connections': '30'}
                   ):
             with self.assertRaises(Exception) as catcher:
                 memcache.MemcacheMiddleware(FakeApp(), d)
             self.assertEqual(
                 str(catcher.exception),
                 "read called with '/etc/swift/memcache.conf'")

Example #26

File: test_memcache.py Project: this-pama/swift-1

 def setUp(self):
     self.app = memcache.MemcacheMiddleware(FakeApp(), {})