def test_custom(self):
mixer = Mixer()
def postprocess(x):
x.name += ' Done'
return x
mixer.register(Test, {
'name': 'Mike',
'one': mixer.G.get_float,
'body': lambda: mixer.G.get_datetime((1980, 1, 1)),
}, postprocess=postprocess)
test = mixer.blend(Test)
self.assertEqual(test.name, 'Mike Done')
self.assertTrue(isinstance(test.one, float))
self.assertTrue(test.body >= datetime.datetime(1980, 1, 1))
from mixer.main import GenFactory
class MyFactory(GenFactory):
generators = {str: lambda: "Always same"}
mixer = Mixer(factory=MyFactory, fake=False)
test = mixer.blend(Test)
self.assertEqual(test.name, "Always same")
def test_invalid_scheme():
from mixer.main import mixer
try:
mixer.blend('tests.test_main.Unknown')
except ValueError:
return False
raise Exception('test.failed')
def test_invalid_scheme():
from mixer.main import mixer
try:
mixer.blend('tests.test_main.Unknown')
except ValueError:
return False
raise Exception('test.failed')
def test_request_state_pond_state_failed_and_threshold_failed(self):
request = dmixer.blend(Request,
state='PENDING',
completion_threshold=95.0)
fail_count = request.fail_count
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule,
completed=False,
failed=True,
event=[
{
'completedExposures': 9
},
],
exp_time=100,
exp_cnt=10)
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules,
start=now - timedelta(minutes=30),
end=now + timedelta(minutes=30))._to_dict(),
mixer.blend(PondBlock, molecules=molecules)._to_dict()
]
state_changed = update_request_state(request, pond_blocks, False)
request.refresh_from_db()
self.assertTrue(state_changed)
self.assertEqual(request.state, 'PENDING')
self.assertEqual(fail_count + 1, request.fail_count)
def test_request_state_pond_state_failed_2(self):
request = dmixer.blend(Request, state='PENDING')
fail_count = request.fail_count
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule,
completed=False,
failed=False,
event=[])
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules,
start=now - timedelta(minutes=30),
end=now - timedelta(minutes=20))._to_dict(),
mixer.blend(PondBlock,
molecules=molecules,
start=now - timedelta(minutes=30),
end=now - timedelta(minutes=20))._to_dict()
]
state_changed = update_request_state(request, pond_blocks, False)
request.refresh_from_db()
self.assertTrue(state_changed)
self.assertEqual(request.state, 'PENDING')
self.assertEqual(fail_count + 1, request.fail_count)
def test_custom():
mixer = Mixer()
@mixer.middleware(Test)
def postprocess(x): # noqa
x.name += ' Done'
return x
mixer.register(
Test,
name='Mike',
one=mixer.faker.pyfloat,
body=mixer.faker.date_time,
)
test = mixer.blend(Test)
assert test.name == 'Mike Done'
assert isinstance(test.one, float)
assert isinstance(test.body, datetime.datetime)
from mixer.main import GenFactory
class MyFactory(GenFactory):
generators = {str: lambda: "Always same"}
mixer = Mixer(factory=MyFactory, fake=False)
test = mixer.blend(Test)
assert test.name == "Always same"
def test_pond_blocks_failed_but_threshold_complete_multi(self):
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule,
completed=False,
failed=True,
event=[{
'completedExposures': 0,
}],
exp_time=10,
exp_cnt=1)
molecules.append(
mixer.blend(PondMolecule,
completed=True,
failed=False,
event=[{
'completedExposures': 10,
}],
exp_time=100,
exp_cnt=10))
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules,
canceled=False,
start=now - timedelta(minutes=30),
end=now + timedelta(minutes=20))._to_dict()
]
initial_state = 'INITIAL'
pond_state = get_request_state_from_pond_blocks(
initial_state, 95.0, pond_blocks)
self.assertEqual(pond_state, 'COMPLETED')
def test_custom():
mixer = Mixer()
@mixer.middleware(Test)
def postprocess(x): # noqa
x.name += ' Done'
return x
mixer.register(
Test,
name='Mike',
one=mixer.faker.pyfloat,
body=mixer.faker.date_time,
)
test = mixer.blend(Test)
assert test.name == 'Mike Done'
assert isinstance(test.one, float)
assert isinstance(test.body, datetime.datetime)
from mixer.main import GenFactory
class MyFactory(GenFactory):
generators = {str: lambda: "Always same"}
mixer = Mixer(factory=MyFactory, fake=False)
test = mixer.blend(Test)
assert test.name == "Always same"
def test_request_state_pond_state_failed_but_threshold_complete(self):
request = dmixer.blend(Request,
state='PENDING',
acceptability_threshold=90.0)
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule,
completed=False,
failed=True,
events=[
{
'completed_exposures': 9
},
],
exposure_time=100,
exposure_count=10)
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules,
start=now - timedelta(minutes=30),
end=now + timedelta(minutes=30))._to_dict(),
mixer.blend(PondBlock, molecules=molecules)._to_dict()
]
state_changed = update_request_state(request, pond_blocks, False)
request.refresh_from_db()
self.assertTrue(state_changed)
self.assertEqual(request.state, 'COMPLETED')
def test_fake():
from mixer.main import mixer
test = mixer.blend(Test, name=mixer.FAKE, title=mixer.FAKE)
assert ' ' in test.name
assert ' ' in test.title
test = mixer.blend(Test, name=mixer.FAKE(bool))
assert test.name in (True, False)
def test_fake(self):
from mixer.main import mixer
test = mixer.blend(Test, name=mixer.fake, title=mixer.fake)
self.assertTrue(' ' in test.name)
self.assertTrue(' ' in test.title)
test = mixer.blend(Test, name=mixer.fake(bool))
self.assertTrue(test.name in (True, False))
def test_fake():
from mixer.main import mixer
test = mixer.blend(Test, name=mixer.FAKE, title=mixer.FAKE)
assert ' ' in test.name
assert ' ' in test.title
test = mixer.blend(Test, name=mixer.FAKE(bool))
assert test.name in (True, False)
def test_fake(self):
from mixer.main import mixer
test = mixer.blend(Test, name=mixer.FAKE, title=mixer.FAKE)
self.assertTrue(' ' in test.name)
self.assertTrue(' ' in test.title)
test = mixer.blend(Test, name=mixer.FAKE(bool))
self.assertTrue(test.name in (True, False))
def test_pond_blocks_in_future_use_initial(self):
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule, completed=False, failed=False, event=[])
molecules.append(mixer.blend(PondMolecule, completed=False, failed=True, event=[]))
pond_blocks = [mixer.blend(PondBlock, molecules=molecules, canceled=False, start=now + timedelta(minutes=30),
end=now+timedelta(minutes=40))._to_dict()]
initial_state = 'INITIAL'
pond_state = get_request_state_from_pond_blocks(initial_state, 100.0, pond_blocks)
self.assertEqual(pond_state, initial_state)
def test_ctx(self):
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
self.assertNotEqual(LOGGER.level, level)
self.assertEqual(LOGGER.level, level)
def test_mixer(self):
mixer = Mixer()
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
self.assertEqual(test.name, 'test0')
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test2')
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test1')
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 1)
mixer.register('tests.test_main.Test', dict(
name='Michel',
one=lambda: 'ID',
unknown="No error here"
))
test = mixer.blend(Test)
self.assertEqual(test.one, 'ID')
self.assertEqual(test.name, 'Michel')
def test_request_state_complete(self):
request = dmixer.blend(Request, state='COMPLETED')
molecules = mixer.cycle(4).blend(PondMolecule)
pond_blocks = [mixer.blend(PondBlock, molecules=molecules)._to_dict(),
mixer.blend(PondBlock, molecules=molecules)._to_dict()]
state_changed = update_request_state(request, pond_blocks, True)
request.refresh_from_db()
self.assertFalse(state_changed)
self.assertEqual(request.state, 'COMPLETED')
def test_ctx():
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
assert LOGGER.level != level
assert LOGGER.level == level
def test_ctx():
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
assert LOGGER.level != level
assert LOGGER.level == level
def test_silence():
mixer = Mixer()
@mixer.middleware(Test)
def falsed(test): # noqa
raise Exception('Unhandled')
with pytest.raises(Exception):
mixer.blend(Test)
with mixer.ctx(silence=True):
mixer.blend(Test)
def test_silence():
mixer = Mixer()
@mixer.middleware(Test)
def falsed(test): # noqa
raise Exception('Unhandled')
with pytest.raises(Exception):
mixer.blend(Test)
with mixer.ctx(silence=True):
mixer.blend(Test)
def test_mix(self):
from mixer.main import mixer
lama = type('One', tuple(),
dict(two=int, one=type('Two', tuple(), dict(two=2.1))))
mix = mixer.mix.one.two
self.assertEqual(mix & lama, 2.1)
test = mixer.blend(lama, one__two=2.1)
self.assertEqual(test.one.two, 2.1)
self.assertNotEqual(test.two, test.one.two)
test = mixer.blend(lama, one__two=2.1, two=mixer.mix.one.two)
self.assertEqual(test.two, test.one.two)
def test_request_state_pond_state_complete(self):
request = dmixer.blend(Request, state='PENDING')
molecules = mixer.cycle(4).blend(PondMolecule, completed=False, failed=False, event=[])
complete_molecules = mixer.cycle(4).blend(PondMolecule, completed=True, failed=False, event=[])
pond_blocks = [mixer.blend(PondBlock, molecules=molecules)._to_dict(),
mixer.blend(PondBlock, molecules=complete_molecules)._to_dict()]
state_changed = update_request_state(request, pond_blocks, True)
request.refresh_from_db()
self.assertTrue(state_changed)
self.assertEqual(request.state, 'COMPLETED')
def test_request_state_pond_state_initial_state_pending_ur_expired(self):
request = dmixer.blend(Request, state='PENDING')
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule, completed=False, failed=False, event=[])
pond_blocks = [mixer.blend(PondBlock, molecules=molecules, start=now - timedelta(minutes=30), end=now + timedelta(minutes=30))._to_dict(),
mixer.blend(PondBlock, molecules=molecules)._to_dict()]
state_changed = update_request_state(request, pond_blocks, True)
request.refresh_from_db()
self.assertTrue(state_changed)
self.assertEqual(request.state, 'WINDOW_EXPIRED')
def test_random():
from mixer._compat import string_types
mixer = TypeMixer(Test)
test = mixer.blend(name=mixer.RANDOM)
assert isinstance(test.name, string_types)
test = mixer.blend(name=mixer.RANDOM(int))
assert isinstance(test.name, int)
names = ['john_', 'kenn_', 'lenny_']
test = mixer.blend(name=mixer.RANDOM(*names))
assert test.name in names
def test_random():
from mixer._compat import string_types
mixer = TypeMixer(Test)
test = mixer.blend(name=mixer.RANDOM)
assert isinstance(test.name, string_types)
test = mixer.blend(name=mixer.RANDOM(int))
assert isinstance(test.name, int)
names = ['john_', 'kenn_', 'lenny_']
test = mixer.blend(name=mixer.RANDOM(*names))
assert test.name in names
def test_mix():
from mixer.main import mixer
lama = type('One', tuple(),
dict(two=int, one=type('Two', tuple(), dict(two=2.1))))
mix = mixer.MIX.one.two
assert mix & lama == 2.1
test = mixer.blend(lama, one__two=2.1)
assert test.one.two == 2.1
assert test.two != test.one.two
test = mixer.blend(lama, one__two=2.1, two=mixer.MIX.one.two)
assert test.two == test.one.two
def test_ctx():
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
assert LOGGER.level != level
with mixer.ctx(locale='ru'):
dw = mixer.faker.day_of_week()
assert dw[0] in 'ПВСЧ'
assert LOGGER.level == level
def test_mix(self):
from mixer.main import mixer
lama = type('One', tuple(), dict(
two=int,
one=type('Two', tuple(), dict(two=2.1))
))
mix = mixer.mix.one.two
self.assertEqual(mix & lama, 2.1)
test = mixer.blend(lama, one__two=2.1)
self.assertEqual(test.one.two, 2.1)
self.assertNotEqual(test.two, test.one.two)
test = mixer.blend(lama, one__two=2.1, two=mixer.mix.one.two)
self.assertEqual(test.two, test.one.two)
def test_random(self):
from mixer.main import TypeMixer
from mixer.six import string_types
mixer = TypeMixer(Test)
test = mixer.blend(name=mixer.RANDOM)
self.assertTrue(isinstance(test.name, string_types))
self.assertFalse(' ' in test.name)
test = mixer.blend(name=mixer.RANDOM(int))
self.assertTrue(isinstance(test.name, int))
names = ['john_', 'kenn_', 'lenny_']
test = mixer.blend(name=mixer.RANDOM(*names))
self.assertTrue(test.name in names)
def test_silence(self):
mixer = Mixer()
def falsed(test):
raise Exception('Unhandled')
mixer.register(Test, postprocess=falsed)
try:
mixer.blend(Test)
raise AssertionError("Test should be failed.")
except Exception: # noqa
pass
with mixer.ctx(silence=True):
mixer.blend(Test)
def test_random(self):
from mixer.main import TypeMixer
from mixer.six import string_types
mixer = TypeMixer(Test)
test = mixer.blend(name=mixer.random)
self.assertTrue(isinstance(test.name, string_types))
self.assertFalse(' ' in test.name)
test = mixer.blend(name=mixer.random(int))
self.assertTrue(isinstance(test.name, int))
names = ['john_', 'kenn_', 'lenny_']
test = mixer.blend(name=mixer.random(*names))
self.assertTrue(test.name in names)
def test_ctx():
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
assert LOGGER.level != level
with mixer.ctx(locale='ru'):
phone = mixer.faker.phone_number()
assert phone.startswith('+7')
assert LOGGER.level == level
def test_ctx():
from mixer.main import LOGGER
mixer = Mixer()
level = LOGGER.level
with mixer.ctx(loglevel='INFO'):
mixer.blend(Test)
assert LOGGER.level != level
with mixer.ctx(locale='ru'):
phone = mixer.faker.phone_number()
assert phone.startswith('+7')
assert LOGGER.level == level
def test_mix():
from mixer.main import mixer
lama = type('One', tuple(), dict(
two=int,
one=type('Two', tuple(), dict(two=2.1))
))
mix = mixer.MIX.one.two
assert mix & lama == 2.1
test = mixer.blend(lama, one__two=2.1)
assert test.one.two == 2.1
assert test.two != test.one.two
test = mixer.blend(lama, one__two=2.1, two=mixer.MIX.one.two)
assert test.two == test.one.two
def test_many_requests_canceled_to_completed(self, modify_mock):
now = timezone.now()
for req in self.requests:
req.state = 'CANCELED'
req.save()
self.ur.state = 'CANCELED'
self.ur.save()
dmixer.cycle(3).blend(Window,
request=(r for r in self.requests),
start=now - timedelta(days=2),
end=now - timedelta(days=1))
molecules3 = mixer.cycle(3).blend(PondMolecule,
completed=True,
failed=False,
request_num=self.requests[2].id,
tracking_num=self.ur.id)
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules3,
start=now - timedelta(minutes=30),
end=now - timedelta(minutes=20))._to_dict()
]
update_request_states_from_pond_blocks(pond_blocks)
request_states = ['CANCELED', 'CANCELED', 'COMPLETED']
for i, req in enumerate(self.requests):
req.refresh_from_db()
self.assertEqual(req.state, request_states[i])
self.ur.refresh_from_db()
self.assertEqual(self.ur.state, 'COMPLETED')
def generate(self, num_events=60, num_days=45):
from orders_manager.models import Order
from mixer.main import mixer
import json
class Scheme:
address_details = str
details = str
executor_comment = str
orders_list = []
while len(orders_list) < num_events:
data = mixer.blend(Scheme)
common_gen = CommonDataGenerator()
client_id = self._get_client_id()
program_id = self._get_program_id()
program_duration = self._get_program_duration(program_id)
program_price = self._get_program_price(program_id,
program_duration)
additional_services_ids = self._get_additional_serveces_ids()
address = common_gen.generate_address()
address.update({
'details': data.address_details
})
order_info = {
'author_id': self._get_author_id(),
'client_id': client_id,
'client_children_id': self._get_client_children_ids(client_id),
'children_num': self._get_children_num(),
'celebrate_date': common_gen.generate_date_in_future(
num_days_for_start=-7, num_days_for_end=num_days),
'celebrate_time': common_gen.generate_time(),
'celebrate_place': self._get_celebrate_place(),
'address': json.dumps(address),
'program_id': program_id,
'program_executors_id': self._get_program_executors_ids(
program_id),
'duration': program_duration,
'services_executors': self._get_services_to_executors(
additional_services_ids),
'discount_id': self._get_discount(),
'details': data.details,
'executor_comment': data.executor_comment,
'where_was_found': self._get_where_was_found(),
'cost_of_the_way': self._get_cost_of_the_way(),
'price': program_price,
'total_price': program_price,
'total_price_with_discounts': program_price
}
orders_list.append(Order.objects.create(**order_info))
return orders_list
def test_reload():
mixer = Mixer()
test = mixer.blend(Test)
test2 = mixer.reload(test)
assert test is not test2
assert test.name == test2.name
test3, test4 = mixer.reload(test, test2)
assert test3 and test4
def test_reload():
mixer = Mixer()
test = mixer.blend(Test)
test2 = mixer.reload(test)
assert test is not test2
assert test.name == test2.name
test3, test4 = mixer.reload(test, test2)
assert test3 and test4
def setUp(self):
super(ApiAddNodesToTreeTestCase, self).setUp()
# first setup a test channel...
self.channel = channel()
self.root_node = self.channel.main_tree
# get our random data from mixer
random_data = mixer.blend(SampleContentNodeDataSchema)
self.fileobj = fileobj_video()
self.title = random_data.title
self.sample_data = {
"root_id":
self.root_node.id,
"content_data": [{
"title":
self.title,
"language":
"en",
"description":
random_data.description,
"node_id":
random_data.node_id,
"content_id":
random_data.content_id,
"source_domain":
random_data.source_domain,
"source_id":
random_data.source_id,
"author":
random_data.author,
"files": [{
"size": self.fileobj.file_size,
"preset": "video",
"filename": self.fileobj.filename(),
"original_filename": self.fileobj.original_filename,
"language": self.fileobj.language,
"source_url": self.fileobj.source_url,
}],
"kind":
"document",
"license":
"CC BY",
"license_description":
None,
"copyright_holder":
random_data.copyright_holder,
"questions": [],
"extra_fields":
"{}",
"role":
"learner",
}],
}
self.resp = self.admin_client().post(
reverse_lazy("api_add_nodes_to_tree"),
data=self.sample_data,
format="json")
def test_pond_blocks_all_molecules_complete(self):
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule, completed=True)
pond_blocks = [mixer.blend(PondBlock, molecules=molecules, canceled=False, start=now - timedelta(minutes=30),
end=now-timedelta(minutes=20))._to_dict()]
initial_state = 'INITIAL'
pond_state = get_request_state_from_pond_blocks(initial_state, 100.0, pond_blocks)
self.assertEqual(pond_state, 'COMPLETED')
def setUp(self):
super(ApiAddNodesToTreeTestCase, self).setUp()
# get our random data from mixer
random_data = mixer.blend(SampleContentNodeDataSchema)
self.root_node = tree()
self.fileobj = fileobj_video()
self.title = random_data.title
sample_data = {
"root_id":
self.root_node.id,
"content_data": [{
"title":
self.title,
"language":
"en",
"description":
random_data.description,
"node_id":
random_data.node_id,
"content_id":
random_data.content_id,
"source_domain":
random_data.source_domain,
"source_id":
random_data.source_id,
"author":
random_data.author,
"files": [{
"size": self.fileobj.file_size,
"preset": "video",
"filename": self.fileobj.filename(),
"original_filename": self.fileobj.original_filename,
"language": self.fileobj.language,
"source_url": self.fileobj.source_url
}],
"kind":
"document",
"license":
"CC BY",
"license_description":
None,
"copyright_holder":
random_data.copyright_holder,
"questions": [],
"extra_fields":
"{}",
"role":
"learner"
}]
}
self.resp = self.admin_client().post("/api/internal/add_nodes",
data=sample_data,
format='json')
def test_mixer(self):
mixer = Mixer()
self.assertEqual(Mixer.SKIP, mixer.SKIP)
try:
Mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
try:
mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
self.assertEqual(test.name, 'test0')
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test2')
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test1')
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 1)
mixer.register('tests.test_main.Test', dict(
name='Michel',
one=lambda: 'ID',
unknown="No error here"
))
test = mixer.blend(Test)
self.assertEqual(test.one, 'ID')
self.assertEqual(test.name, 'Michel')
def test_mixer():
mixer = Mixer()
assert Mixer.SKIP == mixer.SKIP
try:
Mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
try:
mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
assert test.name == 'test0'
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 'test2'
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 'test1'
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 1
mixer.register('tests.test_main.Test',
name='Michel',
one=lambda: 'ID',
unknown="No error here")
test = mixer.blend(Test)
assert test.one == 'ID'
assert test.name == 'Michel'
def test_mixer():
mixer = Mixer()
assert Mixer.SKIP == mixer.SKIP
try:
Mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
try:
mixer.SKIP = 111
raise AssertionError('test are failed')
except AttributeError:
pass
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
assert test.name == 'test0'
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 'test2'
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 'test1'
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
assert test.name == 1
mixer.register('tests.test_main.Test',
name='Michel', one=lambda: 'ID', unknown="No error here")
test = mixer.blend(Test)
assert test.one == 'ID'
assert test.name == 'Michel'
def setUp(self):
super(ApiAddNodesToTreeTestCase, self).setUp()
# get our random data from mixer
random_data = mixer.blend(SampleContentNodeDataSchema)
self.root_node = tree()
self.fileobj = fileobj_video()
self.title = random_data.title
sample_data = {
"root_id": self.root_node.id,
"content_data": [
{
"title": self.title,
"language": "en",
"description": random_data.description,
"node_id": random_data.node_id,
"content_id": random_data.content_id,
"source_domain": random_data.source_domain,
"source_id": random_data.source_id,
"author": random_data.author,
"files": [
{
"size": self.fileobj.file_size,
"preset": "video",
"filename": self.fileobj.filename(),
"original_filename": self.fileobj.original_filename,
"language": self.fileobj.language,
"source_url": self.fileobj.source_url
}
],
"kind": "document",
"license": "CC BY",
"license_description": None,
"copyright_holder": random_data.copyright_holder,
"questions": [],
"extra_fields": "{}",
"role": "learner"
}
]
}
self.resp = self.admin_client().post(
"/api/internal/add_nodes",
data=sample_data,
format='json'
)
def generate(self, num=1):
from random import randint
from mixer.main import mixer
from orders_manager.models import Client
class Scheme:
username = str
email = str
comments = str
common_gen = CommonDataGenerator()
clients = []
while len(clients) < num:
data = mixer.blend(
Scheme,
username=mixer.FAKE,
email=mixer.FAKE,
comments=mixer.FAKE
)
info = {
'name': common_gen.generate_full_name(),
'phone': common_gen.generate_phone(),
'phone_2': common_gen.generate_phone(),
'email': data.email,
'vk_link': 'http://vk.com/' + data.username,
'odnoklassniki_link': 'http://odnoklassniki.ru/' + data.username,
'instagram_link': 'http://instagram.com/' + data.username,
'facebook_link': 'http://facebook.com/' + data.username,
'secondby_link': 'http://secondby.in/' + data.username,
'comments': data.comments
}
client = Client.objects.update_or_create(**info)
ClientChildGenerator().generate(client, randint(1, 4))
# client.children = [x.id for x in children]
clients.append(client)
return clients
def test_mixer(self):
mixer = Mixer()
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
self.assertEqual(test.name, 'test0')
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test2')
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test1')
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 1)
def test_mixer(self):
mixer = Mixer()
gen = ('test{0}'.format(i) for i in range(500))
test = mixer.blend('tests.test_main.Test', name=gen)
self.assertEqual(test.name, 'test0')
name_gen = mixer.sequence(lambda c: 'test' + str(c))
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test2')
name_gen = mixer.sequence('test{0}')
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 'test1')
name_gen = mixer.sequence()
test = mixer.blend(Test, name=name_gen)
test = mixer.blend(Test, name=name_gen)
self.assertEqual(test.name, 1)
def generate(self, num=1):
from random import randint
from mixer.main import mixer
from orders_manager.models import Client
class Scheme:
username = str
email = str
comments = str
common_gen = CommonDataGenerator()
clients = []
while len(clients) < num:
data = mixer.blend(Scheme,
username=mixer.FAKE,
email=mixer.FAKE,
comments=mixer.FAKE)
info = {
'name': common_gen.generate_full_name(),
'phone': common_gen.generate_phone(),
'phone_2': common_gen.generate_phone(),
'email': data.email,
'vk_link': 'http://vk.com/' + data.username,
'odnoklassniki_link':
'http://odnoklassniki.ru/' + data.username,
'instagram_link': 'http://instagram.com/' + data.username,
'facebook_link': 'http://facebook.com/' + data.username,
'secondby_link': 'http://secondby.in/' + data.username,
'comments': data.comments
}
client = Client.objects.update_or_create(**info)
ClientChildGenerator().generate(client, randint(1, 4))
# client.children = [x.id for x in children]
clients.append(client)
return clients
def generate(self, role, num=1):
from mixer.main import mixer
from orders_manager.models import UserProfile
class Scheme:
username = str
email = str
address = str
common_gen = CommonDataGenerator()
profiles = []
while len(profiles) < num:
data = mixer.blend(Scheme)
user_info = {
'username': data.username,
'first_name': common_gen.generate_first_name(),
'last_name': common_gen.generate_last_name(),
'email': data.email,
'phone': common_gen.generate_phone(),
'password': '******',
'address': data.address,
}
try:
if role == self.MANAGER:
profiles.append(
UserProfile.objects.create_manager(**user_info))
elif role == self.ANIMATOR:
profiles.append(
UserProfile.objects.create_animator(**user_info))
elif role == self.PHOTOGRAPHER:
profiles.append(
UserProfile.objects.create_photographer(**user_info))
except IntegrityError:
pass
return profiles
def generate(self, role, num=1):
from mixer.main import mixer
from orders_manager.models import UserProfile
class Scheme:
username = str
email = str
address = str
common_gen = CommonDataGenerator()
profiles = []
while len(profiles) < num:
data = mixer.blend(Scheme)
user_info = {
'username': data.username,
'first_name': common_gen.generate_first_name(),
'last_name': common_gen.generate_last_name(),
'email': data.email,
'phone': common_gen.generate_phone(),
'password': '******',
'address': data.address,
}
try:
if role == self.MANAGER:
profiles.append(
UserProfile.objects.create_manager(**user_info))
elif role == self.ANIMATOR:
profiles.append(
UserProfile.objects.create_animator(**user_info))
elif role == self.PHOTOGRAPHER:
profiles.append(
UserProfile.objects.create_photographer(**user_info))
except IntegrityError:
pass
return profiles
def test_pond_blocks_failed_and_threshold_failed(self):
now = timezone.now()
molecules = mixer.cycle(4).blend(PondMolecule,
completed=False,
failed=True,
events=[{
'completed_exposures': 9,
}],
exposure_time=100,
exposure_count=10)
pond_blocks = [
mixer.blend(PondBlock,
molecules=molecules,
canceled=False,
start=now - timedelta(minutes=30),
end=now + timedelta(minutes=20))._to_dict()
]
initial_state = 'INITIAL'
pond_state = get_request_state_from_pond_blocks(
initial_state, 91.0, pond_blocks)
self.assertEqual(pond_state, 'FAILED')
def test_silence():
mixer = Mixer()
class CustomException(Exception):
pass
@mixer.middleware(Test)
def falsed(test): # noqa
raise CustomException('Unhandled')
with pytest.raises(CustomException):
mixer.blend(Test)
with mixer.ctx(silence=True):
mixer.blend(Test)
mixer.unregister_middleware(Test, falsed)
mixer.blend(Test) # does not raise any exceptions
def test_invalid_scheme():
from mixer.main import mixer
with pytest.raises(ValueError):
mixer.blend('tests.test_main.Unknown')
def setUp(self):
super(ApiAddExerciseNodesToTreeTestCase, self).setUp()
# get our random data from mixer
random_data = mixer.blend(SampleContentNodeDataSchema)
self.root_node = tree()
self.exercise_image = fileobj_exercise_image() # a vanilla image file associated with question
self.exercise_graphie = fileobj_exercise_graphie() # a perseus image file associated with question
self.title = random_data.title
sample_data = {
"root_id": self.root_node.id,
"content_data": [
{
"title": self.title,
"language": "en",
"description": random_data.description,
"node_id": random_data.node_id,
"content_id": random_data.content_id,
"source_domain": random_data.source_domain,
"source_id": random_data.source_id,
"author": random_data.author,
"files": [],
"kind": "exercise",
"license": "CC BY",
"license_description": None,
"copyright_holder": random_data.copyright_holder,
"questions": [
{
"assessment_id": "abf45e8fd7f151adb1b3df2d751e945e",
"type": "multiple_selection",
"files": [
{
"size": self.exercise_image.file_size,
"preset": "exercise_image",
"filename": self.exercise_image.filename(),
"original_filename": None,
"language": None,
"source_url": None
}
],
"question": u"Which numbers are even?\n\nTest local image include: " % self.exercise_image.filename(),
"hints": "[]",
"answers": "[{\"answer\": \"1\", \"correct\": false, \"order\": 0}, {\"answer\": \"2\", \"correct\": True, \"order\": 1}, {\"answer\": \"3\", \"correct\": false, \"order\": 2}, {\"answer\": \"4\", \"correct\": true, \"order\": 3}, {\"answer\": \"5\", \"correct\": false, \"order\": 4}]",
"raw_data": "",
"source_url": None,
"randomize": False
},
{
"assessment_id": "98856e24d53b57ea9023782ab6018767",
"type": "perseus_question",
"files": [
{
"size": self.exercise_graphie.file_size,
"preset": "exercise_graphie",
"filename": self.exercise_graphie.filename(),
"original_filename": self.exercise_graphie.original_filename,
"language": None,
"source_url": None
}
],
"question": "",
"hints": "[]",
"answers": "[]",
"raw_data": u"{\"question\": {\"content\": \"What was the main idea in the passage you just read?\\n\\n[[☃ radio 1]]\\n\\n Test web+graphie image \", \"images\": {}, \"widgets\": {\"radio 1\": {\"type\": \"radio\", \"alignment\": \"default\", \"static\": false, \"graded\": true, \"options\": {\"choices\": [{\"content\": \"The right answer\", \"correct\": true}, {\"content\": \"Another option\", \"correct\": false}, {\"isNoneOfTheAbove\": false, \"content\": \"Nope, not this\", \"correct\": false}], \"randomize\": false, \"multipleSelect\": false, \"countChoices\": false, \"displayCount\": null, \"hasNoneOfTheAbove\": false, \"deselectEnabled\": false}, \"version\": {\"major\": 1, \"minor\": 0}}}}, \"answerArea\": {\"calculator\": false, \"chi2Table\": false, \"periodicTable\": false, \"tTable\": false, \"zTable\": false}, \"itemDataVersion\": {\"major\": 0, \"minor\": 1}, \"hints\": []}" % self.exercise_graphie.original_filename,
"source_url": None,
"randomize": False
}
],
"extra_fields": "{\"mastery_model\": \"m_of_n\", \"randomize\": true, \"m\": 1, \"n\": 2}",
"role": "learner"
}
]
}
self.resp = self.admin_client().post(
"/api/internal/add_nodes",
data=sample_data,
format='json'
)
def test_mixer_default(self):
from mixer.main import mixer
test = mixer.blend(Test)
self.assertTrue(test.name)
def test_mixer_default():
from mixer.main import mixer
test = mixer.blend(Test)
assert test.name
def test_skip():
mixer = Mixer()
test = mixer.blend(Test, one=mixer.SKIP)
assert test.one is not mixer.SKIP
assert test.one is int
