def test_is_pickled(self):
cb = CacheBackend()
tid2 = gen_unique_id()
result = {"foo": "baz", "bar": SomeClass(12345)}
cb.mark_as_done(tid2, result)
# is serialized properly.
rindb = cb.get_result(tid2)
self.assertEqual(rindb.get("foo"), "baz")
self.assertEqual(rindb.get("bar").data, 12345)
def test_is_pickled(self):
cb = CacheBackend(app=app)
tid2 = gen_unique_id()
result = {'foo': 'baz', 'bar': SomeClass(12345)}
cb.mark_as_done(tid2, result)
# is serialized properly.
rindb = cb.get_result(tid2)
self.assertEqual(rindb.get('foo'), 'baz')
self.assertEqual(rindb.get('bar').data, 12345)
def test_is_pickled(self):
cb = CacheBackend()
tid2 = gen_unique_id()
result = {'foo': 'baz', 'bar': SomeClass(12345)}
cb.mark_as_done(tid2, result)
# is serialized properly.
rindb = cb.get_result(tid2)
self.assertEqual(rindb.get('foo'), 'baz')
self.assertEqual(rindb.get('bar').data, 12345)
def test_is_pickled(self):
cb = CacheBackend()
tid2 = gen_unique_id()
result = {"foo": "baz", "bar": SomeClass(12345)}
cb.mark_as_done(tid2, result)
# is serialized properly.
rindb = cb.get_result(tid2)
self.assertEqual(rindb.get("foo"), "baz")
self.assertEqual(rindb.get("bar").data, 12345)
def test_forget(self):
b = CacheBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {"foo": "bar"})
self.assertEqual(b.get_result(tid).get("foo"), "bar")
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_forget(self):
b = CacheBackend(app=app)
tid = gen_unique_id()
b.mark_as_done(tid, {'foo': 'bar'})
self.assertEqual(b.get_result(tid).get('foo'), 'bar')
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_mark_as_done(self):
cb = CacheBackend(app=app)
tid = gen_unique_id()
self.assertEqual(cb.get_status(tid), states.PENDING)
self.assertIsNone(cb.get_result(tid))
cb.mark_as_done(tid, 42)
self.assertEqual(cb.get_status(tid), states.SUCCESS)
self.assertEqual(cb.get_result(tid), 42)
self.assertTrue(cb.get_result(tid), 42)
def test_forget(self):
b = CacheBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {"foo": "bar"})
self.assertEqual(b.get_result(tid).get("foo"), "bar")
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_forget(self):
b = CacheBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {'foo': 'bar'})
self.assertEqual(b.get_result(tid).get('foo'), 'bar')
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_mark_as_failure(self):
cb = CacheBackend()
einfo = None
tid3 = gen_unique_id()
try:
raise KeyError('foo')
except KeyError, exception:
einfo = ExceptionInfo(sys.exc_info())
pass
def test_save_restore_taskset(self):
backend = CacheBackend()
taskset_id = gen_unique_id()
subtask_ids = [gen_unique_id() for i in range(10)]
subtasks = map(result.AsyncResult, subtask_ids)
res = result.TaskSetResult(taskset_id, subtasks)
res.save(backend=backend)
saved = result.TaskSetResult.restore(taskset_id, backend=backend)
self.assertListEqual(saved.subtasks, subtasks)
self.assertEqual(saved.taskset_id, taskset_id)
def test_mark_as_done(self):
cb = CacheBackend()
tid = gen_unique_id()
self.assertEqual(cb.get_status(tid), states.PENDING)
self.assertIsNone(cb.get_result(tid))
cb.mark_as_done(tid, 42)
self.assertEqual(cb.get_status(tid), states.SUCCESS)
self.assertEqual(cb.get_result(tid), 42)
self.assertTrue(cb.get_result(tid), 42)
def test_save_restore_delete_group(self):
backend = CacheBackend(app=app)
group_id = gen_unique_id()
subtask_ids = [gen_unique_id() for i in range(10)]
subtasks = list(map(result.AsyncResult, subtask_ids))
res = result.GroupResult(group_id, subtasks)
res.save(backend=backend)
saved = result.GroupResult.restore(group_id, backend=backend)
self.assertListEqual(saved.subtasks, subtasks)
self.assertEqual(saved.id, group_id)
saved.delete(backend=backend)
self.assertIsNone(result.GroupResult.restore(group_id,
backend=backend))
def test_mark_as_failure(self):
cb = CacheBackend(app=app)
einfo = None
tid3 = gen_unique_id()
try:
raise KeyError('foo')
except KeyError as exception:
einfo = ExceptionInfo(sys.exc_info())
cb.mark_as_failure(tid3, exception, traceback=einfo.traceback)
self.assertEqual(cb.get_status(tid3), states.FAILURE)
self.assertIsInstance(cb.get_result(tid3), KeyError)
self.assertEqual(cb.get_traceback(tid3), einfo.traceback)
def test_mark_as_failure(self):
cb = CacheBackend(app=app)
einfo = None
tid3 = gen_unique_id()
try:
raise KeyError('foo')
except KeyError as exception:
einfo = ExceptionInfo(sys.exc_info())
cb.mark_as_failure(tid3, exception, traceback=einfo.traceback)
self.assertEqual(cb.get_status(tid3), states.FAILURE)
self.assertIsInstance(cb.get_result(tid3), KeyError)
self.assertEqual(cb.get_traceback(tid3), einfo.traceback)
def ajax_account_creation_done(request, task_id):
result = BaseAsyncResult(task_id, CacheBackend(default_app))
if not result.ready():
return {"ok": True, "ready": False}
result = result.get()
return {
"ok":
True,
"ready":
True,
"slug":
result['slug'],
"mt4_id":
result['mt4_id'],
"mt4_password":
result['mt4_password'],
"redirect":
reverse("mt4_account_welcome", args=[result['slug'],
result['mt4_id']]),
}
def test_process_cleanup(self):
cb = CacheBackend()
cb.process_cleanup()
def test_set_expires(self):
cb1 = CacheBackend(app=app, expires=timedelta(seconds=16))
self.assertEqual(cb1.expires, 16)
cb2 = CacheBackend(app=app, expires=32)
self.assertEqual(cb2.expires, 32)
def test_process_cleanup(self):
cb = CacheBackend(app=app)
cb.process_cleanup()
# coding=utf-8
from celery.app import default_app
from celery.task import task
from djcelery.backends.cache import CacheBackend
from log.models import Logger, Events
from platforms.mt4 import mt4api
from platforms.models import TradingAccount
from platforms.signals import account_created
from platforms.types import (get_account_type)
from referral.models import PartnerDomain
@task(backend=CacheBackend(default_app), time_limit=120)
def register_mt4account(details,
user,
account_type_details,
form_class,
partner_api_id,
additional_fields=None):
additional_fields = additional_fields or dict()
engine = "demo" if account_type_details["is_demo"] else "default"
mt4_id = mt4api.RemoteMT4Manager(engine).create_account(**details)
# mt4_id = api.SocketAPI(engine=account_type_details['engine']).create_account(**details)
account = TradingAccount(
user=user,
mt4_id=mt4_id,
_login=str(mt4_id),
group_name=account_type_details['slug'],
agreement_type=additional_fields.get('agreement_type'))
