def test_handler(self): mixer.cycle(3).blend(Reimbursement, search_vector=None) command = Command() command.handle(batch_size=2, silent=True) queryset = Reimbursement.objects.exclude(search_vector=None) self.assertEqual(3, queryset.count())
def test_paginator(self): from adrest.mixin import EmitterMixin from django.views.generic import View from django.test import RequestFactory from tests.core.models import Pirate from adrest.utils.paginator import Paginator mixer.cycle(3).blend('core.pirate') class SomeResource(EmitterMixin, View): class Meta: model = 'core.pirate' dyn_prefix = 'adr-' limit_per_page = 2 def dispatch(self, request, **resources): p = Paginator(request, self, Pirate.objects.all()) return self.emit(p, request=request) rf = RequestFactory() resource = SomeResource() response = resource.dispatch(rf.get('/')) self.assertContains(response, '"page": 1') self.assertContains(response, '"num_pages": 2')
def test_many_to_many_random(mixer): mixer.cycle(5).blend('django_app.message') assert Message.objects.all() mixer.cycle(10).blend('django_app.tag', messages=mixer.RANDOM) assert Tag.objects.all() assert Tag.objects.all().count() == 10
def test_many_to_many_select(mixer): mixer.cycle(5).blend('django_app.message') assert Message.objects.all() assert Message.objects.all().count() == 5 mixer.cycle(10).blend('django_app.tag', messages=mixer.SELECT) assert Tag.objects.all() assert Message.objects.all().count() == 5
def test_get_include_many_many_db_queries(self): mixer.cycle(10).blend("testapp.comment") # prefetch related join is done in python twice. with self.assertNumQueries(3): self.client.get( '/api/author?include=posts,posts.comments', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' )
def test_get_sort(self): mixer.cycle(2).blend("testapp.comment") response = self.client.get( '/api/comment?sort=-id', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) data = json.loads(response.content.decode("utf-8")) self.assertEqual([o['id'] for o in data['data']], [2, 1])
def setUp(self): #Create/log in a normal user. self.a_user = mixer.blend(User, username='******', is_superuser=True, is_staff=True) self.a_user.set_password('pass') self.a_user.save() self.client.login(username='******', password='******') mixer.blend(ChangeRequest) mixer.cycle(2).blend(ChangeLog) self.rfc = ChangeRequest.objects.first()
def test_get_filter_queryset_custom_filter(self): mixer.cycle(3).blend("testapp.comment") response = self.client.get( '/api/comment?filter=is_outdated=1', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) data = json.loads(response.content.decode("utf-8")) self.assertEqual(len(data['data']), 1)
def test_oneof_any_completed(self): request_states = ['WINDOW_EXPIRED', 'COMPLETED', 'PENDING'] ur = dmixer.blend(UserRequest, operator='ONEOF') dmixer.cycle(3).blend(Request, state=(state for state in request_states), user_request=ur) aggregate_state = aggregate_request_states(ur) self.assertEqual(aggregate_state, 'COMPLETED')
def test_many_all_expired(self): request_states = ['WINDOW_EXPIRED', 'WINDOW_EXPIRED', 'WINDOW_EXPIRED'] ur = dmixer.blend(UserRequest, operator='MANY') dmixer.cycle(3).blend(Request, state=(state for state in request_states), user_request=ur) aggregate_state = aggregate_request_states(ur) self.assertEqual(aggregate_state, 'WINDOW_EXPIRED')
def test_many_canceled_and_complete(self): request_states = ['CANCELED', 'COMPLETED', 'CANCELED'] ur = dmixer.blend(UserRequest, operator='MANY') dmixer.cycle(3).blend(Request, state=(state for state in request_states), user_request=ur) aggregate_state = aggregate_request_states(ur) self.assertEqual(aggregate_state, 'COMPLETED')
def test_many_any_pending(self): request_states = ['COMPLETED', 'CANCELED', 'PENDING'] ur = dmixer.blend(UserRequest, operator='MANY') dmixer.cycle(3).blend(Request, state=(state for state in request_states), user_request=ur) aggregate_state = aggregate_request_states(ur) self.assertEqual(aggregate_state, 'PENDING')
def test_deffered(mixer): simples = mixer.cycle(3).blend(Simple) rabbits = mixer.cycle(3).blend( Rabbit, content_object=(s for s in simples) ) assert rabbits rabbit = rabbits[0] rabbit = rabbit.__class__.objects.get(pk=rabbit.pk) assert rabbit.content_object
def _set_up_static_data(self): self.stdout.write("Seeding Priorities") mixer.cycle(3).blend(Priority, title=iter(("High", "Medium", "Low"))) self.stdout.write("Seeding Statuses") mixer.cycle(2).blend(Status, title=iter(("Ongoing", "Completed"))) self.stdout.write("Seeding Groups and Permissions") return self._set_up_roles()
def test_get_include_db_query(self): mixer.cycle(10).blend("testapp.comment") # prefetch related join is done in python twice. # TODO: add 'comments.author' relationship (->to-many->to-one). with self.assertNumQueries(3): self.client.get( '/api/post?include=author,comments,author.comments', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' )
def test_oneof_all_canceled(self): request_states = ['CANCELED', 'CANCELED', 'CANCELED'] ur = dmixer.blend(UserRequest, operator='ONEOF') dmixer.cycle(3).blend(Request, state=(state for state in request_states), user_request=ur) aggregate_state = aggregate_request_states(ur) self.assertEqual(aggregate_state, 'CANCELED')
def setUp(self): self.tree = create_nomenclature_tree("UK") self.heading = mixer.blend(Heading, tts_json="{}", nomenclature_tree=self.tree) self.parent_subheadings = mixer.cycle(5).blend( SubHeading, heading=self.heading, nomenclature_tree=self.tree ) self.heading_commodities = mixer.cycle(5).blend( Commodity, heading=self.heading, nomenclature_tree=self.tree )
def test_get_filter_queryset_two_fields(self): mixer.cycle(3).blend("testapp.comment", author__name=(x for x in ['Alice', 'Bob', 'Bill'])) response = self.client.get( '/api/comment?filter=id__lt=3&filter=author__name__startswith=B', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json') data = json.loads(response.content.decode("utf-8")) self.assertEqual(len(data['data']), 1) self.assertEqual(data['data'][0]['id'], 2)
def test_get_contest_users(): contest1 = mixer.blend('contests.Contest', id=1) mixer.cycle(5).blend('contests.User', name='Name', contest=contest1) result = get_contest_users(1) assert len(result) == 5 for user in result: assert user.name == 'Name' with pytest.raises(NoSuchContestError): get_contest_users(2)
def test_risk_types(self): """ Test for the RiskTypes get endpoint """ state = mixer.blend('base.State', name='Active') mixer.cycle(5).blend('core.RiskType', state=state) request = RequestFactory().get('api/risk_types/') response = RiskTypes().get(request) assert json.loads( response.content )['status'] == 'success', 'Should successfully return the RiskTypes retrieved'
def test_model(self): event = mixer.blend('competition.Event', poster='', competition_rank=self.competition_rank) assert event.pk == 1 mixer.cycle(9).blend('competition.Event', poster='', competition_rank=self.competition_rank_2) all_events = models.Event.objects.all().count() # Should return 10: 1 (event) + 9 (mixer.cycle(9)) assert all_events == 10
def setUp(self): super(DepartmentUserAdminTestCase, self).setUp() # Create & log in an admin user. self.admin_user = mixer.blend(User, username='******', is_superuser=True, is_staff=True) self.admin_user.set_password('pass') self.admin_user.save() self.client.login(username='******', password='******') mixer.cycle(5).blend(DepartmentUser)
def setUpClass(cls): super(ToDoModelTestCase, cls).setUpClass() cls.user_one = get_user_model().objects.create_user( username='******', password='******', email='*****@*****.**') cls.user_two = get_user_model().objects.create_user( username='******', password='******', email='*****@*****.**') cls.todo_user_one = mixer.cycle(5).\ blend('todo.ToDo', created_by=cls.user_one) cls.todo_user_two = mixer.cycle(3).\ blend('todo.ToDo', created_by=cls.user_two)
def test_list(self): # setup: mixer.cycle(3).blend(Transfer, from_acc=(a for a in self.user.accounts.all())) # when: response = self.client.get(reverse('transfer-list')) # then: self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 3)
def setUp(self): super(AssetsAdminTestCase, self).setUp() # Create/log in an admin user. self.admin_user = mixer.blend(User, username='******', is_superuser=True, is_staff=True) self.admin_user.set_password('pass') self.admin_user.save() self.client.login(username='******', password='******') mixer.cycle(5).blend( HardwareAsset, purchased_value=randint(100, 1000), date_purchased=random_datetime) mixer.cycle(5).blend( SoftwareAsset, support_expiry=random_datetime)
def setUp(self): # Create/log in a normal user. self.a_user = mixer.blend(User, username='******', is_superuser=True, is_staff=True) self.a_user.set_password('pass') self.a_user.save() self.client.login(username='******', password='******') mixer.blend(ChangeRequest) mixer.cycle(2).blend(ChangeLog) self.rfc = ChangeRequest.objects.first()
def setUp(self): super(ReferralCreateChildTest, self).setUp() self.ref = Referral.objects.first() # Ensure that conditions with 'approved' text exist on the referral. mixer.cycle(3).blend( Condition, referral=self.ref, category=mixer.SELECT, condition=mixer.RANDOM, model_condition=mixer.SELECT, proposed_condition=mixer.RANDOM) for i in Condition.objects.filter(referral=self.ref): i.proposed_condition_html = '<p>Proposed condition</p>' i.condition_html = '<p>Actual condition</p>' i.save()
def test_create_proposal_with_nonexistant_cois(self): app = mixer.blend(ScienceApplication, submitter=self.user, pi='') mixer.cycle(3).blend(CoInvestigator, science_application=app) tr = mixer.blend(TimeRequest, approved=True, science_application=app) proposal = app.convert_to_proposal() self.assertEqual(app.proposal, proposal) self.assertEqual(self.user, proposal.membership_set.get(role=Membership.PI).user) self.assertEqual(proposal.timeallocation_set.first().std_allocation, tr.std_time) self.assertEqual( ProposalInvite.objects.filter(proposal=proposal).count(), 3)
def test_filter(self): """ Test for the RiskFieldService filter(*args, **kwargs) method """ state = mixer.blend('base.State', name='Active') mixer.cycle(5).blend('core.RiskField', state=state) risk_fields = RiskFieldService().filter(state__name='Active') assert len( risk_fields) == 5, 'Should return 5 RiskFields with state Active' risk_fields = RiskFieldService().filter(state__name='Approval Pending') assert len(risk_fields) == 0, 'Should return an empty queryset'
def setUp(self): self.user = blend_user() self.proposals = mixer.cycle(3).blend(Proposal) for proposal in self.proposals: mixer.blend(Membership, proposal=proposal, user=self.user) self.request_groups = mixer.cycle(3).blend( RequestGroup, proposal=(p for p in self.proposals)) self.requests = mixer.cycle(3).blend( Request, request_group=(rg for rg in self.request_groups), ) self.client.force_login(self.user)
def setUp(self): # Create/log in a normal user. self.n_user = mixer.blend(User, username='******', is_superuser=False, is_staff=False) self.n_user.set_password('pass') self.n_user.save() self.client.login(username='******', password='******') mixer.cycle(2).blend(ChangeRequest) mixer.cycle(2).blend(ChangeLog) self.rfc = ChangeRequest.objects.first() mixer.blend(ITSystem) mixer.blend(Incident) self.incident = Incident.objects.first()
def test_select(mixer): mixer.cycle(3).blend(Rabbit) hole = mixer.blend(Hole, rabbit=mixer.SELECT) assert not hole.rabbit rabbits = Rabbit.objects.all() hole = mixer.blend(Hole, owner=mixer.SELECT) assert hole.owner in rabbits rabbit = rabbits[0] hole = mixer.blend(Hole, owner=mixer.SELECT(email=rabbit.email)) assert hole.owner == rabbit
def test_post_urls_authenticated(client, url, agruments, status): username = "******" password = "******" User.objects.create_user(username=username, password=password) client.login(username=username, password=password) mixer.cycle(10).blend("app.company") mixer.cycle(5).blend("app.offer") url = reverse(url, kwargs=agruments) response = client.post(url) assert response.status_code == status
def test_get_users_who_liked(self): post = mixer.blend(Post) # create 5 likes for 'post' likes = mixer.cycle(5).blend(Like, post=post) # create another likes for some other Post instance another_likes = mixer.cycle(5).blend(Like) self.assertEqual(post.get_users_who_liked().count(), 5) user_ids = post.get_users_who_liked().order_by('id').values_list( 'id', flat=True) # get users ids from Like objects user_ids_like = [like.user_id for like in likes] self.assertEqual(list(user_ids), sorted(user_ids_like))
def test_raffle_secret_friend_with_pair_participants(self): mixer.cycle(50).blend('core.Participant') participants = Participant.objects.all() for _ in range(participants.count()): participant = Participant.objects.filter(raffled=False).first() raffle_secret_friend(participant) all_chosen = all(participants.values_list('chosen', flat=True)) all_raffled = all(participants.values_list('raffled', flat=True)) self.assertTrue(all_chosen) self.assertTrue(all_raffled)
def test_AdminExport_with_related_get_should_return_200(admin_client): reporter = mixer.blend(Reporter) mixer.cycle(3).blend(Article, reporter=reporter) params = { 'related': True, 'model_ct': ContentType.objects.get_for_model(Article).pk, 'field': 'reporter', 'path': 'reporter.first_name', } url = "{}?{}".format(reverse('export_action:export'), urlencode(params)) response = admin_client.get(url) assert response.status_code == 200
def test_export(self): mixer.cycle(5).blend('claims.Claim', description='') start_date = Claim.objects.order_by('date').first().date - relativedelta(days=1) end_date = Claim.objects.order_by('-date').first().date + relativedelta(days=1) request = self.factory.post('/', { 'category': '', 'start_date': start_date.date().isoformat(), 'end_date': end_date.date().isoformat(), }) response = self.view(request) self.assertEqual(response.status_code, 200) lines = response.content.decode('utf8').split('\n') self.assertEqual(len(lines), 7) # headers and one blank line
def test_get_include(self): author = mixer.blend("testapp.author") mixer.cycle(2).blend("testapp.post", author=author) response = self.client.get('/api/post?include=author', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json') data = json.loads(response.content.decode("utf-8"))["linked"] expected_data = [{ "type": "author", "id": author.id, "name": author.name }] self.assertEqual(data, expected_data)
def test_manager_methods(self): """Test the inherited ReferralLookup manager methods. """ mixer.cycle(2).blend(DopTrigger) # Some extras. obj_del = mixer.blend(DopTrigger) # One to delete. obj_del.delete() all_pks = [i.pk for i in DopTrigger.objects.all()] current_pks = [i.pk for i in DopTrigger.objects.current()] del_pks = [i.pk for i in DopTrigger.objects.deleted()] self.assertTrue(obj_del.pk in all_pks) self.assertFalse(obj_del.pk in current_pks) self.assertTrue(obj_del.pk in del_pks) self.assertFalse(self.obj.pk in del_pks)
def test_filtering(self): # setup: mixer.cycle(3).blend(Transfer, from_acc=(a for a in self.user.accounts.all())) # when: response = self.client.get(reverse('transfer-list'), { 'from_acc__currency': Currency.USD.value, }) # then: self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 1)
def test_raffle_secret_friend_different_secret_friends_with_unpair_participants( self): mixer.cycle(51).blend('core.Participant') participants = Participant.objects.all() secret_friends = [] for _ in range(participants.count()): participant = Participant.objects.filter(raffled=False).first() secret_friend = raffle_secret_friend(participant) secret_friends.append(secret_friend.pk) for participant in participants: self.assertEqual(secret_friends.count(participant.pk), 1)
def setUp(self): country = mixer.blend(LocationCountryCode) state = mixer.blend(LocationStateCode, country_id=country.id) company = mixer.blend(Company, state_id=state.id, country_id=country.id) mixer.cycle(2).blend( JobListing, company=company, country=country, state=state, )
def handle(self, *args, **options): self.stdout.write('Deleting data.......' ) BlogCategory.objects.all().delete() BlogTopic.objects.all().delete() BlogPost.objects.all().delete() self.stdout.write('Start loading.......' ) categories = mixer.cycle(10).blend(BlogCategory) for c in categories: topics = mixer.cycle(10).blend(BlogTopic,category=c, title=u'Заголовок блога категории '+c.name) for t in topics: posts = mixer.cycle(10).blend(BlogPost,topic=t,content=mixer.fake, author='Fedot') self.stdout.write('Well done' )
def setUp(self): # We need a defined Group, because of the user_post_save signal in # the tracking app. Group.objects.create(name='Edit Resource Tracking Device') # Create User object. self.user1 = User.objects.create_user( username='******', email='*****@*****.**') self.user1.set_password('pass') self.user1.save() # Log in user1 by default. self.client.login(username=self.user1.username, password='******') # Create a WeatherStation object. self.ws = mixer.blend(WeatherStation) mixer.cycle(5).blend(WeatherObservation, station=self.ws)
def test_select(self): from mixer.backend.django import mixer mixer.cycle(3).blend(Rabbit) hole = mixer.blend(Hole, rabbit=mixer.select) self.assertFalse(hole.rabbit) rabbits = Rabbit.objects.all() hole = mixer.blend(Hole, owner=mixer.select) self.assertTrue(hole.owner in rabbits) rabbit = rabbits[0] hole = mixer.blend(Hole, owner=mixer.select(email=rabbit.email)) self.assertEqual(hole.owner, rabbit)
def test_get_include_many_to_many(self): group = mixer.blend('testapp.group') authors = mixer.cycle(2).blend('testapp.author') memberships = mixer.cycle(2).blend('testapp.membership', group=group, author=(a for a in authors)) # prefetch related join is done in python with self.assertNumQueries(2): response = self.client.get( '/api/author?include=memberships', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) data = json.loads(response.content.decode("utf-8")) expected_data = { "data": [{ "id": author.id, "name": author.name, "links": { "memberships": author.membership_set.values_list( "id", flat=True) } } for author in authors], "links": { }, "linked": [{ "type": "memberships", "id": membership.id, "links": { "group": membership.group_id, "author": membership.author_id, } } for membership in memberships] } compare(data, expected_data) response = self.client.get( '/api/author?include=memberships,memberships.group', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) data = json.loads(response.content.decode("utf-8")) expected_data["linked"].append({ "type": "group", "id": group.id, "name": group.name, }) compare(data, expected_data)
def setUp(self): """Generate from FreshdeskTicket objects. """ super(FreshdeskTicketResourceTestCase, self).setUp() mixer.cycle(5).blend( FreshdeskContact, email=random_dpaw_email) mixer.cycle(5).blend( FreshdeskTicket, subject=mixer.RANDOM, description_text=mixer.RANDOM, type='Test', freshdesk_requester=mixer.SELECT, it_system=mixer.SELECT, custom_fields={ 'support_category': None, 'support_subcategory': None}, ) self.ticket = FreshdeskTicket.objects.first()
def test_get_include(self): author = mixer.blend("testapp.author") mixer.cycle(2).blend("testapp.post", author=author) response = self.client.get( '/api/post?include=author', content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) data = json.loads(response.content.decode("utf-8"))["linked"] expected_data = [{ "type": "author", "id": author.id, "name": author.name }] self.assertEqual(data, expected_data)
def test_update_models_save_error_atomic(self): """ Ensure models are not created if one of them raises exception.""" authors = mixer.cycle(2).blend('testapp.author', name="name") response = self.client.put( '/api/author/{}'.format(",".join([str(a.id) for a in authors])), json.dumps({ "data": [{ "id": authors[0].id, "name": "allowed name", }, { "id": authors[1].id, "name": "forbidden name", }], }), content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) self.assertEqual(response.status_code, 400) expected_data = { "errors": [{ "status": 400, "code": 32102, "title": "Model form save error", "detail": "Name forbidden name is not allowed", }] } data = json.loads(response.content.decode("utf-8")) self.assertEqual(data, expected_data) self.assertEqual(Author.objects.count(), 2) self.assertEqual( set(Author.objects.values_list("name", flat=True)), {'name'})
def test_pagination(self): pirates = mixer.cycle(3).blend('core.pirate') class SomeResource(DynamicMixin, View): class Meta: model = 'core.pirate' limit_per_page = 2 def dispatch(self, request, **resources): collection = self.get_collection(request, **resources) return self.paginate(request, collection) rf = RequestFactory() resource = SomeResource() response = resource.dispatch(rf.get('/')) self.assertEqual(len(response.resources), 2) resource._meta.limit_per_page = 0 response = resource.dispatch(rf.get('/')) self.assertEqual(len(response), len(pirates)) response = resource.dispatch(rf.get('/?adr-max=1')) self.assertEqual(len(response.resources), 1)
def test_base(self): pirates = mixer.cycle(3).blend('core.pirate') class SomeResource(DynamicMixin, View): class Meta: model = 'core.pirate' def dispatch(self, request, **resources): return self.get_collection(request, **resources) rf = RequestFactory() resource = SomeResource() response = resource.dispatch(rf.get('/')) self.assertEqual(len(response), len(pirates)) response = resource.dispatch(rf.get('/?name=' + pirates[0].name)) self.assertEqual(list(response), [pirates[0]]) response = resource.dispatch( rf.get('/?adr-sort=name&adr-sort=captain')) self.assertEqual(list(response), sorted( pirates, key=lambda p: (p.name, p.captain)))
def test_update_models(self): authors = mixer.cycle(2).blend("testapp.author", name="") response = self.client.put( '/api/author/{}'.format(",".join([str(a.id) for a in authors])), json.dumps({ "data": [{ "id": a.id, "name": "author", } for a in authors], }), content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) self.assertEqual(response.status_code, 200) self.assertEqual(Author.objects.count(), 2) for author in Author.objects.all(): self.assertEqual(author.name, "author") expected_data = { "data": [{ "id": a.id, "name": "author", } for a in authors], } data = json.loads(response.content.decode("utf-8")) self.assertEqual(data, expected_data)
def test_sfm_ajax_endpoints(self): """Test sfm JSON endpoints for AJAX requests. """ # For this, we need some dummy records. mixer.cycle(10).blend(Quarter) mixer.cycle(10).blend(SFMMetric) mixer.cycle(10).blend(MeasurementType) mixer.cycle(10).blend(CostCentre) mixer.cycle(10).blend(MeasurementValue) self.client.login(username='******', password='******') for endpoint in [ 'ajax_quarter', 'ajax_outcome_financialyear', 'ajax_sfmmetric_metricid', 'ajax_measurementvalue']: url = reverse(endpoint) response = self.client.get(url) self.assertEqual(response.status_code, 200)
def test_delete_models(self): authors = mixer.cycle(2).blend("testapp.author") response = self.client.delete( '/api/author/{}'.format(",".join([str(a.id) for a in authors])), content_type='application/vnd.api+json', HTTP_ACCEPT='application/vnd.api+json' ) self.assertEqual(response.status_code, 204) self.assertEqual(Author.objects.count(), 0)
def setUp(self): self.user = User.objects.create_user( username='******', email='*****@*****.**', password='******') self.admin = User.objects.create_user( username='******', email='*****@*****.**', password='******', is_superuser=True) # Log in testuser by default. self.client.login(username='******', password='******') # Generate some DepartmentUser objects. mixer.cycle(5).blend( DepartmentUser, photo=None, active=True, email=random_dpaw_email, org_unit=None, cost_centre=None) # Generate some locations. self.loc1 = mixer.blend(Location, manager=None) self.loc2 = mixer.blend(Location, manager=None) # Generate a basic org structure. # NOTE: don't use mixer to create OrgUnit objects (it breaks MPTT). self.dept = OrgUnit.objects.create(name='Department 1', unit_type=0) self.div1 = OrgUnit.objects.create( name='Divison 1', unit_type=1, parent=self.dept, location=self.loc1) self.cc1 = CostCentre.objects.create( name='Cost centre 1', code='001', division=self.div1, org_position=self.div1) self.div2 = OrgUnit.objects.create( name='Divison 2', unit_type=1, parent=self.dept, location=self.loc2) self.cc2 = CostCentre.objects.create( name='Cost centre 2', code='002', division=self.div2, org_position=self.div2) # Give each of the divisions some members. users = DepartmentUser.objects.all() self.user1 = users[0] self.user1.org_unit = self.div1 self.user1.cost_centre = self.cc1 self.user1.save() self.div1.manager = self.user1 self.div1.save() self.user2 = users[1] self.user2.org_unit = self.div2 self.user2.cost_centre = self.cc2 self.user2.save() self.div2.manager = self.user2 self.div2.save() # Generate some IT Systems. self.it1 = mixer.blend(ITSystem, status=0, owner=self.user1) self.it2 = mixer.blend(ITSystem, status=1, owner=self.user2)
def test_deferred_emails(self): self.assertEqual( deferred_emails()['status'], SERVER_STATUS['OK'], msg='Without deferred emails, the status should be OK.' ) mixer.cycle(1).blend('mailer.Message', priority=PRIORITY_DEFERRED) self.assertEqual( deferred_emails()['status'], SERVER_STATUS['WARNING'], msg='With 1 deferred email, the status should be WARNING.' ) mixer.cycle(9).blend('mailer.Message', priority=PRIORITY_DEFERRED) self.assertEqual( deferred_emails()['status'], SERVER_STATUS['DANGER'], msg='With 10 deferred emails, the status should be DANGER.' )
def setUp(self): super(RegistersAdminTestCase, self).setUp() # Create an admin user. self.admin_user = mixer.blend(User, username='******', is_superuser=True, is_staff=True) self.admin_user.set_password('pass') self.admin_user.save() # Create some Computers self.com1 = mixer.blend(Computer) self.com2 = mixer.blend(Computer) # Create some ITSystemHardware objects self.itsys1 = mixer.blend(ITSystemHardware, computer=self.com1, production=True) self.itsys2 = mixer.blend(ITSystemHardware, computer=self.com2) # Attach ITSystemHardware to ITSystem objects. self.it1.hardwares.add(self.itsys1) self.it2.hardwares.add(self.itsys2) # Create some Incidents and IncidentLogs. mixer.cycle(3).blend(Incident) mixer.cycle(3).blend(IncidentLog) # Log in as admin user by default self.client.login(username='******', password='******')