def test_org_quota_overrides_user_quota(self):
redis_conn = MockRedis()
redis_conn.hset('rails:users:my_username', 'mapzen_routing_quota', 42)
redis_conn.hset('rails:orgs:acme', 'mapzen_routing_quota', 31415)
redis_config = ServicesRedisConfig(redis_conn).build('my_username', 'acme')
assert 'mapzen_routing_quota' in redis_config
assert int(redis_config['mapzen_routing_quota']) == 31415
def test_it_picks_mapzen_routing_quota_from_redis(self):
redis_conn = MockRedis()
redis_conn.hset('rails:users:my_username', 'mapzen_routing_quota', 42)
redis_config = ServicesRedisConfig(redis_conn).build(
'my_username', None)
assert 'mapzen_routing_quota' in redis_config
assert int(redis_config['mapzen_routing_quota']) == 42
def init_app(self, app):
if app.config.get("TESTING", False):
from mockredis import MockRedis
self.redis_cli = MockRedis()
else:
self.redis_cli = Redis(host=app.config['REDIS_HOST'],
port=app.config.get('REDIS_PORT', 6379),
db=app.config.get('REDIS_DB', 0))
def setUp(self):
user_geocoder_config = UserGeocoderConfig(
username='******',
organization=None,
period_end_date=datetime.date.today())
redis_conn = MockRedis()
self.user_metrics_service = UserMetricsService(user_geocoder_config,
redis_conn)
def test_can_get_a_config_field(self):
connection = MockRedis()
connection.hset(self.CONFIG_HASH_KEY, 'field1', 42)
redis_config = RedisConfigStorage(connection, self.CONFIG_HASH_KEY)
value = redis_config.get('field1')
assert type(
value
) == str # this is something to take into account, redis always returns strings
assert value == '42'
def setUp(self):
self.pubsub = MockRedis()
self.trans = connection.begin()
self.session = Session(connection)
currency = Currency(name='Pesos', code='ARG')
self.exchange = Exchange(name='Merval', code='MERV', currency=currency)
self.owner = Owner(name='poor owner')
self.broker = Broker(name='broker1')
self.account = Account(owner=self.owner, broker=self.broker)
self.account.deposit(Money(amount=10000, currency=currency))
def test_routing_quota_check_passes_when_enough_quota(self):
user_service_config = RoutingConfigMock(
username=self.username,
organization=None,
service_type=self.service_type,
monthly_quota=1000,
period_end_date=datetime.today(),
soft_limit=False)
redis_conn = MockRedis()
redis_conn.zincrby(self.redis_key, self.period_end_date.day, 999)
assert QuotaChecker(user_service_config, redis_conn).check() == True
def setUp(self):
self.pubsub = MockRedis()
self.config = PyConfig("test_config.ini")
self.symbols = ['GOOG']
self.strategy = StrategyFactory.create_strategy(
self.config.get(CONF_ANALYZER_SECTION, CONF_STRATEGY_NAME),
self.symbols, self.config)
self.strategy2 = StrategyFactory.create_strategy(
self.config.get(CONF_ANALYZER_SECTION, CONF_STRATEGY_NAME),
self.symbols, self.config.getSection(CONF_ANALYZER_SECTION))
def test_main_view_assert_error():
"""Test main view with fake redis."""
import pytest
import shortmagnet
from mockredis import MockRedis
redis = MockRedis()
with patch('shortmagnet.request') as request:
with pytest.raises(AssertionError):
request.method = "POST"
request.form = {'magnet': 'foobar'}
shortmagnet.index("foobar", redis)
def test_routing_quota_check_passes_if_no_quota_but_soft_limit(self):
user_service_config = RoutingConfigMock(
username=self.username,
organization=None,
service_type=self.service_type,
monthly_quota=1000,
period_end_date=datetime.today(),
soft_limit=True)
redis_conn = MockRedis()
redis_conn.zincrby(self.redis_key, self.period_end_date.day, 1001)
checker = QuotaChecker(user_service_config, redis_conn)
assert checker.check() == True
def create_redis(_app):
global redis_client
# loading redis
from flask_redis import FlaskRedis
if app.config['TESTING']:
# loading mockredis
from mockredis import MockRedis
redis_client = MockRedis(FlaskRedis.from_custom_provider(MockRedis))
else:
# loading the real redis instance
redis_client = FlaskRedis(app)
def test_routing_quota_check_fails_when_quota_exhausted(self):
user_service_config = RoutingConfigMock(
username=self.username,
organization=None,
service_type=self.service_type,
monthly_quota=1000,
period_end_date=datetime.today(),
soft_limit=False)
redis_conn = MockRedis()
redis_conn.zincrby(self.redis_key, self.period_end_date.strftime('%d'),
1001)
checker = QuotaChecker(user_service_config, redis_conn)
assert checker.check() == False
def setUp(self):
self.mock = mox.Mox()
self.pubsub = MockRedis()
self.pesos = Currency(name='Pesos', code='ARG')
self.exchange = Exchange(name='Merval', currency=self.pesos)
self.stock_one = Stock(symbol='PBR',
description='Petrobras BR',
ISIN='US71654V4086',
exchange=self.exchange)
self.stock_two = Stock(symbol='YPF',
description='YPF S.A',
ISIN='US9842451000',
exchange=self.exchange)
class StupidRedis(DefaultClient):
_fake = MockRedis()
def __init__(self, server, params, backend):
self._options = {}
self._backend = backend
self._serializer = PickleSerializer({})
self._compressor = IdentityCompressor({})
def get_client(self, *args, **kwargs):
return self._fake
def close(self, **kw):
return
def test_main_view():
"""Test main view with fake redis."""
import shortmagnet
from mockredis import MockRedis
redis = MockRedis()
with patch('shortmagnet.request') as request:
request.method = "POST"
request.form = {'magnet': 'magnet:foobar'}
result = shortmagnet.index("magnet:foobar", redis)
assert result
request.method = "GET"
response = shortmagnet.index(result, redis)
assert response.status_code == 302
assert response.location == "magnet:foobar"
def setUp(self):
plpy_mock_config()
cartodb_services.init(plpy_mock, _GD={})
self.username = '******'
self.orgname = 'test_org'
self.redis_conn = MockRedis()
build_redis_user_config(self.redis_conn, self.username, 'geocoding')
build_redis_org_config(self.redis_conn,
self.orgname,
'geocoding',
provider='mapzen')
self.environment = 'production'
plpy_mock._define_result("CDB_Conf_GetConf\('server_conf'\)",
[{
'conf': '{"environment": "production"}'
}])
plpy_mock._define_result(
"CDB_Conf_GetConf\('redis_metadata_config'\)",
[{
'conf': '{"redis_host":"localhost","redis_port":"6379"}'
}])
plpy_mock._define_result(
"CDB_Conf_GetConf\('redis_metrics_config'\)",
[{
'conf': '{"redis_host":"localhost","redis_port":"6379"}'
}])
basic_server_conf = {
"server_conf": {
"environment": "testing"
},
"mapzen_conf": {
"geocoder": {
"api_key": "search-xxxxxxx",
"monthly_quota": 1500000,
"service": {
"base_url": "http://base"
}
}
},
"logger_conf": {}
}
self.empty_server_config = InMemoryConfigStorage(basic_server_conf)
self.empty_redis_config = InMemoryConfigStorage({})
self.user_config = RedisUserConfigStorageBuilder(
self.redis_conn, self.username).get()
self.org_config = RedisOrgConfigStorageBuilder(self.redis_conn,
self.orgname).get()
self.server_config = ServerConfigBackendFactory().get()
def test_routing_quota_check_fails_right_in_the_limit(self):
"""
I have 1000 credits and I just spent 1000 today. I should not pass
the check to perform the 1001th routing operation.
"""
user_service_config = RoutingConfigMock(
username=self.username,
organization=None,
service_type=self.service_type,
monthly_quota=1000,
period_end_date=datetime.today(),
soft_limit=False)
redis_conn = MockRedis()
redis_conn.zincrby(self.redis_key, self.period_end_date.day, 1000)
checker = QuotaChecker(user_service_config, redis_conn)
assert checker.check() == False
def models():
"""Create some sample machine learning models."""
rng = np.random.RandomState(42)
X = rng.random_sample((20, 5))
y = rng.random_sample(20)
lm = linear_model.LinearRegression()
dt = tree.DecisionTreeRegressor()
svr = svm.SVR()
lm.fit(X, y)
dt.fit(X, y)
svr.fit(X, y)
r = MockRedis()
r.set("1.0.0", pickle.dumps(lm))
r.set("1.1.0", pickle.dumps(dt))
r.set("1.2.0", pickle.dumps(svr))
return r
def test_register_script_client(self):
# lpush two values in LIST1 in first instance of redis
self.redis.lpush(LIST1, VAL2, VAL1)
# create script on first instance of redis
script_content = LPOP_SCRIPT
script = self.redis.register_script(script_content)
# lpush two values in LIST1 in redis2 (second instance of redis)
redis2 = MockRedis()
redis2.lpush(LIST1, VAL4, VAL3)
# execute LPOP script on redis2 instance
list_item = script(keys=[LIST1], client=redis2)
# validate lpop from LIST1 in redis2
eq_(VAL3, list_item)
eq_([VAL4], redis2.lrange(LIST1, 0, -1))
eq_([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))
def setUp(self):
self._redis_connection = MockRedis()
self._server_config = InMemoryConfigStorage({
"server_conf": {
"environment": "testing"
},
"mapzen_conf": {
"geocoder": {
"api_key": "search-xxxxxxx",
"monthly_quota": 1500000
}
},
"logger_conf": {}
})
self._username = '******'
self._user_key = "rails:users:{0}".format(self._username)
self._user_config = RedisUserConfigStorageBuilder(
self._redis_connection, self._username).get()
self._org_config = RedisOrgConfigStorageBuilder(
self._redis_connection, None).get()
self._set_default_config_values()
def setUp(self):
self._redis_conn = MockRedis()
self._db_conn = plpy_mock
self._username = '******'
self._user_key = "rails:users:{0}".format(self._username)
self._redis_conn.hset(self._user_key, 'period_end_date', '2016-10-10')
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def setup(self):
self.redis = MockRedis(load_lua_dependencies=False)
self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT.encode("utf-8")).hexdigest()
try:
lua, lua_globals = MockRedisScript._import_lua(load_dependencies=False)
except RuntimeError:
raise SkipTest("mockredispy was not installed with lua support")
self.lua = lua
self.lua_globals = lua_globals
assert_equal_list = """
function compare_list(list1, list2)
if #list1 ~= #list2 then
return false
end
for i, item1 in ipairs(list1) do
if item1 ~= list2[i] then
return false
end
end
return true
end
function assert_equal_list(list1, list2)
assert(compare_list(list1, list2))
end
return assert_equal_list
"""
self.lua_assert_equal_list = self.lua.execute(assert_equal_list)
assert_equal_list_with_pairs = """
function pair_exists(list1, key, value)
i = 1
for i, item1 in ipairs(list1) do
if i%2 == 1 then
if (list1[i] == key) and (list1[i + 1] == value) then
return true
end
end
end
return false
end
function compare_list_with_pairs(list1, list2)
if #list1 ~= #list2 or #list1 % 2 == 1 then
return false
end
for i = 1, #list1, 2 do
if not pair_exists(list2, list1[i], list1[i + 1]) then
return false
end
end
return true
end
function assert_equal_list_with_pairs(list1, list2)
assert(compare_list_with_pairs(list1, list2))
end
return assert_equal_list_with_pairs
"""
self.lua_assert_equal_list_with_pairs = self.lua.execute(assert_equal_list_with_pairs)
compare_val = """
function compare_val(var1, var2)
return var1 == var2
end
return compare_val
"""
self.lua_compare_val = self.lua.execute(compare_val)
def setUp(self):
self.redis_conn = MockRedis()
def broken_model():
"""Create a non-functional model object."""
r = MockRedis()
r.set("1.2.0", pickle.dumps("lol"))
return lambda: r
def test_returns_nothing_if_field_not_present(self):
connection = MockRedis()
connection.hmset(self.CONFIG_HASH_KEY, {'field1': 42, 'field2': 43})
redis_config = RedisConfigStorage(connection, self.CONFIG_HASH_KEY)
redis_config.get('whatever_field')
def setUp(self):
self.redis_conn = MockRedis()
plpy_mock_config()
def redis_client():
return MockRedis()
def setUp(self):
from redis import StrictRedis as Redis
self.redis = Redis(db=15)
self.mockredis = MockRedis()
self.logger = logging.getLogger("mockredis.TestReads")
def test_raises_an_exception_if_config_key_not_present(self):
connection = MockRedis()
redis_config = RedisConfigStorage(connection, self.CONFIG_HASH_KEY)
redis_config.get('whatever_field')
