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 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 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='******')
