def setUp(self):
self.client = Client()
self.user = self.client.login_as()
self.avatar = any_model(Avatar, owner=self.user, today=0, hours_spent=0, health=50)
self.company = any_model(Company, owner=self.avatar)
self.company_url = reverse("company_index", kwargs={"avatar_pk": self.avatar.pk, "company_pk": self.company.pk})
def test_short_generic_fk_creation(self):
content_object = any_model(RelatedContentModel)
related_object = any_model(ModelWithGenericRelation,
content_object=content_object)
self.assertEqual(related_object.content_object, content_object)
self.assertEqual(related_object.content_type, ContentType.objects.get_for_model(RelatedContentModel))
self.assertEqual(related_object.object_id, content_object.id)
def test_fk_referencing_self(self):
self_referencing = any_model(SelfReferencingModel)
self.assertTrue(self_referencing.parent is None)
root = any_model(SelfReferencingModel)
child = any_model(SelfReferencingModel, parent=root)
self.assertEqual(type(child.parent), SelfReferencingModel)
def users_in_database(step):
for user_dict in step.hashes:
user = any_model(User, is_active=True, **user_dict)
user.set_password('123')
user.save()
any_model(Profile, avatar=None, user=user)
def setUp(self):
"""
Test's init sequence.
- saves test data directly into model needed for tests
Creates random timesheet
"""
# Every test needs a client.
self.client = Client()
self.client, self.response = client_login(self.client, callback=reverse('tms_timesheets'))
self.datetime = datetime.datetime.now
self.user = new_test_user()
self.job_model = any_model(Job, is_active=True)
try:
self.employee = any_model(Employee, user = self.user)
except:
#employee with this user already exists
self.employee = Employee.objects.get(user=self.user)
self.timesheet1 = any_model(Timesheet,
employee=self.employee,
is_submitted=False,
is_billed=False,
comment='Django_tests comment for timesheet model1')
self.expense1 = any_model(Expense,
comment='Django_tests comment for expense model1')
def setUp(self):
self.client = APIClient()
self.user = any_model(User, name='testuser', password='******')
kwargs = {
'info': {},
'type': 'country',
}
[any_model(Address, id=i, **kwargs) for i in range(0, 10)]
def test_work_with_enough_company_money_succeed(self):
CompanyWorker.objects.create(worker=self.avatar, company=self.company, salary_per_hour=1)
any_model(InventoryItem, owner=self.avatar, quantity=10, item_type=INVENTORY_TYPE.DUBLONS)
initial_health = self.avatar.health
self.client.post(self.company_url, {"action": "work"})
new_health = Avatar.objects.get(pk=self.avatar.pk).health
self.assertTrue(initial_health > new_health)
def setUp(self):
"""
Setting up model instances. Using factory (django_any) instead of fixtures (couse fixtures are evil)
"""
self.currency1 = any_model(Currency)
self.currency2 = any_model(Currency)
self.account1 = any_model(Account, amount=25, currency=self.currency1)
self.account2 = any_model(Account, amount=0, currency=self.currency1)
self.account3 = any_model(Account, amount=1000)
def test_short_generic_fk_creation(self):
content_object = any_model(RelatedContentModel)
related_object = any_model(ModelWithGenericRelation,
content_object=content_object)
self.assertEqual(related_object.content_object, content_object)
self.assertEqual(
related_object.content_type,
ContentType.objects.get_for_model(RelatedContentModel))
self.assertEqual(related_object.object_id, content_object.id)
def setUp(self):
"""
Initialization. Creating model instances for tests
"""
self.root_room1 = any_model(Room, parent=None,
title="root room 1 title", description = "root room 1 description")
self.root_room2 = any_model(Room, parent=None, title="root room 2 title")
self.child_room_1_1 = any_model(Room, parent=self.root_room1, title="child room 1 1 title")
self.child_room_2_1 = any_model(Room, parent=self.root_room2, title="child room 2 1 title")
def test_qobject_multiple_objects_returned(self):
"""If Q() lookup return multiple objects, we select
random one.
"""
# Create additional related instance
any_model(QObjectRelated, flag=False)
result = any_model(RelatedToQObject, related=Q(flag=False))
self.assertIn(result.related, list(QObjectRelated.objects.all()))
def test_search_form_manager(self):
u = any_model(User)
s1 = any_model(SearchForm, owner=u, public=False, name='A')
s2 = any_model(SearchForm, owner=u, public=True, name='B')
res = SearchForm.objects.get_for_user(AnonymousUser())
self.assertEquals(list(res), [s2])
res = SearchForm.objects.get_for_user(u)
self.assertEquals(list(res), [s1, s2])
def setUp(self):
self.client = Client()
self.user = self.client.login_as()
self.avatar = any_model(
Avatar, owner=self.user,
today=0, hours_spent=0,
health=50)
self.market = any_model(
Market, buy_item_type=INVENTORY_TYPE.DUBLONS,
sell_item_type=INVENTORY_TYPE.BANANAS)
self.market_url = reverse('market_index', kwargs={'avatar_pk':self.avatar.pk, 'market_pk':self.market.pk})
def setUp(self):
self.user1 = any_model(User, is_active=True, username=self.USER_NAME1)
self.user2 = any_model(User, is_active=True, username=self.USER_NAME2)
self.user1.set_password(self.USER_PASS1)
self.user2.set_password(self.USER_PASS2)
self.user1.save()
self.user2.save()
self.album_public = any_model(Album, id=1, access=Album.ACCESS_PUBLIC, kind=Album.KIND_CUSTOM)
self.album_private1 = any_model(Album, id=2, access=Album.ACCESS_PRIVATE, kind=Album.KIND_CUSTOM, user=self.user1)
self.album_private2 = any_model(Album, id=3, access=Album.ACCESS_PRIVATE, kind=Album.KIND_CUSTOM, user=self.user2)
def test_fk_relation_autocreate(self):
result = any_model(BaseModel)
self.assertEqual(type(result), BaseModel)
self.assertEqual(type(result.related), RelatedModel)
self.assertTrue(result.related.name is not None)
def test_oneto_one_autocreate(self):
result = any_model(ModelWithOneToOneField)
self.assertEqual(type(result), ModelWithOneToOneField)
self.assertTrue(result.name is not None)
self.assertEqual(type(result.related), OneToOneRelated)
self.assertTrue(result.related.name is not None)
def any_user(password=None, permissions=[], groups=[], **kwargs):
"""
Shortcut for creating Users
Permissions could be a list of permission names
If not specified, creates active, non superuser
and non staff user
"""
is_active = kwargs.pop('is_active', True)
is_superuser = kwargs.pop('is_superuser', False)
is_staff = kwargs.pop('is_staff', False)
user = any_model(User,
is_active=is_active,
is_superuser=is_superuser,
is_staff=is_staff,
**kwargs)
for group_name in groups:
group = Group.objects.get(name=group_name)
user.groups.add(group)
for permission_name in permissions:
app_label, codename = permission_name.split('.')
permission = Permission.objects.get(content_type__app_label=app_label,
codename=codename)
user.user_permissions.add(permission)
if password:
user.set_password(password)
user.save()
return user
def _create_account(self):
acc = any_model(
Account,
user__is_active=True,
user__password=make_password('qwerty'),
)
return acc
def test_fk_relation_autocreate(self):
result = any_model(BaseModel)
self.assertEqual(type(result), BaseModel)
self.assertEqual(type(result.related), RelatedModel)
self.assertTrue(result.related.name is not None)
def test_oneto_one_autocreate(self):
result = any_model(ModelWithOneToOneField)
self.assertEqual(type(result), ModelWithOneToOneField)
self.assertTrue(result.name is not None)
self.assertEqual(type(result.related), OneToOneRelated)
self.assertTrue(result.related.name is not None)
def any_user(password=None, permissions=[], groups=[], **kwargs):
"""
Shortcut for creating Users
Permissions could be a list of permission names
If not specified, creates active, non superuser
and non staff user
"""
is_active = kwargs.pop('is_active', True)
is_superuser = kwargs.pop('is_superuser', False)
is_staff = kwargs.pop('is_staff', False)
user = any_model(User, is_active = is_active, is_superuser = is_superuser,
is_staff = is_staff, **kwargs)
for group_name in groups :
group = Group.objects.get(name=group_name)
user.groups.add(group)
for permission_name in permissions:
app_label, codename = permission_name.split('.')
permission = Permission.objects.get(
content_type__app_label=app_label,
codename=codename)
user.user_permissions.add(permission)
if password:
user.set_password(password)
user.save()
return user
def setUp(self):
self.client.session.clear()
self.user1 = any_model(User, is_active=True, username=self.USER_NAME1)
self.user1.set_password(self.USER_PASS1)
self.user1.save()
def setUp(self):
self.user = any_model(User, is_active=True)
self.user.set_password('test')
self.user.save()
result_login = self.client.login(username=self.user.username, password='******')
self.assertTrue(result_login)
def test_Root(self):
"""
Tests that 1 + 1 always equalsss 2.
"""
#print self
#print dir(self)
#print self.__class__.__doc__
#print dir(self.test_Root.__str__)
#print self.__call__.__doc__
#print dir(self.test_Root.__func__)
print self.test_Root.__doc__
print self.test_Root.__format__
print dir(self.test_Root)
#print self.test_Root.__name__
user = any_model(Root)
self.assertEqual(1 + 1, 2)
# test all pages
# when debug off 404
# only get one result for a page
#
# ============================================================================ #
# EOF #
# ============================================================================ #
def test_detail(self):
album = any_model(Album, user__is_active=True)
photo = Photo.objects.create(user=album.user, album=album)
response = self.client.get(reverse('photos-photo', args=[album.id, photo.id]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['photo'], photo)
def test_process_partial_bids_success(self):
bid1 = any_model(Bid, direction=Bid.TYPE.SELL, market=self.market, quantity=5, rate=2)
any_model(InventoryItem, owner=bid1.owner, quantity=bid1.quantity, item_type=self.market.sell_item_type)
bid2 = any_model(Bid, direction=Bid.TYPE.SELL, market=self.market, quantity=5, rate=2)
any_model(InventoryItem, owner=bid2.owner, quantity=bid2.quantity, item_type=self.market.sell_item_type)
bid3 = any_model(Bid, direction=Bid.TYPE.BUY, market=self.market, quantity=10, rate=2)
any_model(InventoryItem, owner=bid3.owner, quantity=bid3.quantity*bid3.rate, item_type=self.market.buy_item_type)
process_market(self.market.id)
self.assertEqual(0, Bid.objects.count())
def test_model_creation_succeed(self):
result = any_model(SimpleModel)
self.assertEqual(type(result), SimpleModel)
for field in result._meta.fields:
value = getattr(result, field.name)
self.assertTrue(value is not None, "%s is uninitialized" % field.name)
def setUp(self):
self.client = Client()
self.user = self.client.login_as()
self.avatar = any_model(
Avatar, owner=self.user,
today=0, hours_spent=0,
health=50)
self.avatar_url = reverse('avatar_index', kwargs={'avatar_pk':self.avatar.pk})
def test_subject_unicode(self):
subj = any_model(TestSubject,name=u'Математика')
self.assertEqual(subj.__unicode__(),u'Математика')
#class AbitRequestTest(TestCase):
# def setUp(self):
# self.abitreq = any_model()
def test_created_model_with_custom_field(self):
model = any_model(ModelWithCustomField)
self.assertEqual(type(model), ModelWithCustomField)
self.assertEqual(len(model._meta.fields), len(ModelWithCustomField._meta.local_fields))
self.assertTrue(model.slug)
self.assertTrue(isinstance(model.slug, basestring))
def test_unconfirmed_listeners(self):
self.setup_unit_and_followers(confirmed=False)
dispatch = any_model(models.Dispatch)
dispatch.units.add(self.unit)
self.mox.ReplayAll()
dispatch.notify_listeners()
self.mox.VerifyAll()
self.assertEqual(len(mail.outbox), 0)
def test_get_context_data(self):
self.request.POST = {}
self.request.POST['json'] = None
self.assertEquals(
self.msp.get_context_data(),
dict(result=unicode(ERR_NO_FORM_DATA)))
self.request.POST['json'] = "wcale, nie, json"
self.assertEquals(
self.msp.get_context_data(),
dict(result=unicode(ERR_PARSING_DATA)))
self.request.POST['json'] = '[{"field": "foo", "bad": "field"}]'
self.assertEquals(
self.msp.get_context_data(),
dict(result=unicode(ERR_LOADING_DATA)))
self.request.POST['json'] = \
'{"form_data": [{"field": "foo", "operation": "' \
+ unicode(EQUAL) \
+ '", "value": "foo"}]}'
self.request.POST['name'] = ''
self.assertEquals(
self.msp.get_context_data(),
dict(result=unicode(ERR_FORM_NAME)))
sf = any_model(SearchForm, name='foo')
self.request.POST['name'] = 'foo'
self.assertEquals(
self.msp.get_context_data(),
dict(result=OVERWRITE_PROMPT))
self.request.POST['overwrite'] = 'true'
self.request.user = any_model(User)
self.assertEquals(
self.msp.get_context_data(),
dict(result=SAVED, pk=1))
self.assertEquals(SearchForm.objects.all().count(), 1)
self.assertEquals(SearchForm.objects.all()[0].public, False)
self.request.POST['public'] = 'true'
self.msp.get_context_data()
self.assertEquals(SearchForm.objects.all()[0].public, True)
def test_created_model_with_custom_field(self):
model = any_model(ModelWithCustomField)
self.assertEqual(type(model), ModelWithCustomField)
self.assertEqual(len(model._meta.fields),
len(ModelWithCustomField._meta.local_fields))
self.assertTrue(model.slug)
self.assertTrue(isinstance(model.slug, basestring))
def test_create(self):
obj = any_model(Account)
count = ActionNote.objects.filter(
app='account.models',
model='Account',
object_id=obj.id,
note='created',
).count()
self.assertTrue(count)
def test_list(self):
album = any_model(Album, user__is_active=True)
Photo.objects.create(user=album.user, album=album)
Photo.objects.create(user=album.user, album=album)
response = self.client.get(reverse('photos-photo-list', args=[album.id]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['album'], album)
self.assertEqual(len(response.context['photo_list']), 2)
def test_dispatch_msg(self):
dispatch = any_model(
models.Dispatch, location='test_location',
call_type_desc='test_call_type_desc')
dispatch.tf = 'test_tf' # not valid at db, but possible for instance
dispatch.units.create(id='test_unit')
self.assertEqual(
utils.dispatch_msg(dispatch),
'test_call_type_desc\ntest_location\nUnit: test_unit\n'
'http://tfdd.co/gm/test_tf/')
def setUp(self):
"""
Crating a test environment with logged in
client and at least one timesheet model
and one Expense and Job models.
"""
self.client = Client()
self.client, self.response = client_login(self.client, callback=reverse('tms_timesheets'))
self.datetime = datetime.datetime.now
self.user = new_test_user()
self.job_model = any_model(Job, is_active=True)
try:
self.employee = any_model(Employee, user = self.user)
except:
#employee with this user already exists
self.employee = Employee.objects.get(user=self.user)
self.timesheet1 = any_model(Timesheet,
employee=self.employee,
is_submitted=False,
is_billed=False,
start_time='2011-08-29 20:57:34.848614',
end_time='2011-08-29 22:57:34.848614',
comment='Django_tests comment for timesheet model1')
self.expense1 = any_model(Expense,
expense_date='2011-09-10',
claim_date='2011-09-10',
is_receipted=True,
is_submitted=False,
is_billed=False,
is_taxable=True,
comment='Django_tests comment for expense model1')
self.reports_list = reporting.all_reports()
self.reporting_post_data = { 'consultant': '',
'date_end_datepicker' : '',
'date_end_day': '13',
'date_end_yearmonth': '2011-9',
'date_start_datepicker': '',
'date_start_day': '16',
'date_start_yearmonth': '2011-8',
'generate': 'Generate',
}
def test_model_creation_succeed(self):
result = any_model(SimpleModel)
self.assertEqual(type(result), SimpleModel)
self.assertEqual(len(result._meta.fields),
len(SimpleModel._meta.local_fields))
for field, original_field in zip(result._meta.fields,
SimpleModel._meta.local_fields):
value = getattr(result, field.name)
if field.name != 'null_boolead_field':
self.assertTrue(value is not None,
"%s is uninitialized" % field.name)
self.assertTrue(isinstance(field, original_field.__class__),
"%s has correct field type" % field.name)
def test_notify_listeners(self):
self.setup_unit_and_followers()
dispatch = any_model(models.Dispatch)
dispatch.units.add(self.unit)
models.send_msg('phone_follower #', None, dispatch=dispatch)
models.send_msg('both_follower #', None, dispatch=dispatch)
self.mox.ReplayAll()
dispatch.notify_listeners()
self.mox.VerifyAll()
self.assertEqual(len(mail.outbox), 2)
m0, m1 = mail.outbox
# can't guarantee order due to use of set
self.assertTrue(
m0.to == ['*****@*****.**'] and m1.to == ['*****@*****.**'] or
m1.to == ['*****@*****.**'] and m0.to == ['*****@*****.**'])
def _test_reverse_relation_spec_succeed(self):
related = any_model(OneToOneRelated,
modelwithonetoonefield__name='test')
self.assertEqual(related.modelwithonetoonefield.name, 'test')
def test_qobject_specification(self):
result = any_model(RelatedToQObject, related=Q(pk=self.related.pk))
self.assertEqual(self.related, result.related)
def _prepare_models(self):
for x in range(0, 10):
r = any_model(Related)
m = any_model(M2M)
any_model(Search, related=r, m2m=m)
def test_del(self):
todo = any_model(ToDo)
id = todo.id
todo.delete()
self.assertEquals(0, ToDo.objects.filter(pk=id).count())
def _test_partial_specification(self):
result = any_model(SimpleModel, char_field='test')
self.assertEqual(result.char_field, 'test')
def setUp(self):
self.modlog = ModelLog.objects.filter().delete()
self.my_info = any_model(MyInfo, my_photo='')
def test_created_model_with_filefield_string_upload_to(self):
model = any_model(ModelUploadToString)
self.assertEqual(model.file_field, 'sample_file.txt')
def test_do_done(self):
todo = any_model(ToDo)
todo.do_done()
self.assertEquals(True, ToDo.objects.get(pk=todo.id).done)
def setUp(self):
self.related = any_model(QObjectRelated, flag=False)
def test_partial_specification_succeed(self):
result = any_model(ModelWithOneToOneField, related__name='test')
self.assertEqual(result.related.name, 'test')
def test_created_model_with_filefield_callable_upload_to(self):
model = any_model(ModelWithFileFieldUploadToCallable)
self.assertEqual(model.file_field, 'sample_file.txt')
def test_related_onetoone_not_created_by_default(self):
simple_model = any_model(OneToOneRelated)
self.assertRaises(ModelWithOneToOneField.DoesNotExist,
lambda: simple_model.modelwithonetoonefield)
def setUp(self):
self.related = any_model(QObjectRelated)
def test_created_value_pass_validation(self):
result = any_model(ModelWithValidatedField)
validate_even(result.even_field)
def test_related_specification_succeed(self):
related = any_model(OneToOneRelated)
result = any_model(ModelWithOneToOneField, related=related)
self.assertEqual(related, result.related)
def test_raw_user_creation(self):
result = any_model(User)
self.assertEqual(type(result), User)
def test_nested_models_specification(self):
result = any_model(BaseModel, related__name='test')
self.assertEqual(result.related.name, 'test')
