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_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_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(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_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_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_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 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 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 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 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: ![](${☣ CONTENTSTORAGE}/%s)" % 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 ![graph](web+graphie:${☣ CONTENTSTORAGE}/%s)\", \"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