class ProfileTest(unittest.TestCase):
def setUp(self):
self.user = User()
self.user.save()
def tearDown(self):
self.user.delete()
def test_has_user_profile(self):
try:
profile = self.user.get_profile()
except UserProfile.DoesNotExist:
profile = None
self.assertIsNotNone(profile)
def test_set_sex(self):
self.user.userprofile.sex = 'f'
self.user.userprofile.save()
self.assertEqual(self.user.userprofile.sex, 'f')
def test_set_birthday(self):
self.user.userprofile.birthday = date(1984, 9, 28)
self.user.userprofile.save()
self.assertEqual(self.user.userprofile.birthday, date(1984, 9, 28))
def test_set_birthday_greater_than_today(self):
self.user.userprofile.birthday = date(2984, 9, 28)
self.assertRaises(ValidationError, self.user.userprofile.save)
def test_get_quota(self):
"""
Tests cluster.get_quota() method
Verifies:
* if no user is passed, return default quota values
* if user has quota, return values from Quota
* if user doesn't have quota, return default cluster values
"""
default_quota = {'default': 1, 'ram': 1,
'virtual_cpus': None, 'disk': 3}
user_quota = {'default': 0, 'ram': 4, 'virtual_cpus': 5, 'disk': None}
cluster = Cluster(hostname='foo.fake.hostname')
cluster.__dict__.update(default_quota)
cluster.save()
user = User(username='******')
user.save()
# default quota
self.assertEqual(default_quota, cluster.get_quota())
# user without quota, defaults to default
self.assertEqual(default_quota, cluster.get_quota(user.get_profile()))
# user with custom quota
quota = Quota(cluster=cluster, user=user.get_profile())
quota.__dict__.update(user_quota)
quota.save()
self.assertEqual(user_quota, cluster.get_quota(user.get_profile()))
quota.delete()
cluster.delete()
user.delete()
def signup(request):
form = SignUpForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
if User.objects.filter(username=form.cleaned_data['email']).exists():
messages.error(request, 'Username already exists')
return redirect('forms:signup')
user = User(
username=form.cleaned_data['email'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name']
)
user.set_password(form.cleaned_data['password1'])
user.save()
try:
user.profile.mobile_phone = form.cleaned_data['mobile_phone']
# user.groups.add(Group.objects.get(name='basic'))
user.save()
except:
# TODO : Find possible exceptions that can be thrown and add handling
user.delete()
messages.error(request, f'Unable to Create Account')
return redirect('forms:signup')
else:
login(request, user)
return redirect('app:dashboard')
return render(request, 'signup.html', {'form': form})
class TestRating(TestCase):
''' test class for Rating model '''
def setUp(self):
''' method called before all tests '''
self.test_user = User(username='******', password='******')
self.test_user.save()
self.test_profile = self.test_user.profile
self.test_profile.save()
self.test_post = Post(image='images/vik.jpg', title='Vinstagram',description='Instagram Clone', profile=self.test_profile, live_link='https://vinsta.herokuapp.com/', created_on=datetime.now())
self.test_post.save()
self.test_rate = Rating(interface=5, experience=6, content=5, user=self.test_profile, post=self.test_post)
def tearDown(self):
''' method called after every test '''
self.test_user.delete()
Post.objects.all().delete()
Rating.objects.all().delete()
def test_instance(self):
''' method to test instance creation '''
self.assertIsInstance(self.test_rate, Rating)
def test_save_and_delete_rating(self):
''' test method to save and delete ratings'''
self.test_rate.save_rating()
self.assertEqual(len(Rating.objects.all()), 1)
self.test_rate.delete_rating()
self.assertEqual(len(Rating.objects.all()), 0)
class testComments(TestCase):
def setUp(self):
self.new_user = User(password='******',username='******',is_superuser=False)
self.new_user.save()
self.new_photo = Photo(id = 1000,name='deans',user=self.new_user,captions='The greatest',likes=0)
self.new_photo.savephoto()
self.new_comment = Comments(id = 1000, user = self.new_user, photo= self.new_photo,comment='No')
def tearDown(self):
User.objects.all().delete()
Photo.objects.all().delete()
Comments.objects.all().delete()
def testinstance(self):
self.assertTrue(isinstance(self.new_comment, Comments))
def testcommentsaved(self):
self.new_comment.savecomments()
comments = Comments.objects.all()
self.assertTrue(len(comments)> 0)
def testdeletecomment(self):
self.new_comment.savecomments()
comments = Comments.objects.all()
self.assertTrue(len(comments)> 0)
self.new_comment.deletecomments()
self.new_user.delete()
self.new_photo.deletephoto()
comments = Comments.objects.all()
self.assertTrue(len(comments) < 1)
class TestStaticMethods(TestCase):
"""
Test static functions
"""
def setUp(self):
"""
Set up the authtoken testcase
"""
self.user = User(username='******',
email='*****@*****.**',
last_name='User',
first_name='Test')
self.user.save()
def tearDown(self):
"""
Tear down the authtoken testcase
"""
self.user.delete()
def testUserFromJsonStr(self):
"""
Ensure we can properly decode a json string
"""
u = SharedAuthBackend.userFromJsonStr(JSON_STR)
self.assertEqual(self.user, u)
class TestLoggedUser(TestCase):
def setup(self):
self.client = Client()
self.user=User(username='******', email='*****@*****.**',password='******')
self.user.save()
self.client.login(username='******', password='******')
def test_homepage(self):
response = self.client.get('/')
print response
self.assertEqual(response.status_code, 200)
def test_logged_user_get_registration(self):
response = self.client.get('/welcome/stureg/')
print response
self.assertEqual(response.status_code, 200)
def test_logged_user_get_student_list(self):
response = self.client.get('/welcome/stureg/student_list/')
print response
self.assertEqual(response.status_code, 302)
def tearDown(self):
self.user.delete()
def delete(self, using=None):
'''
also delete from user table
'''
user = User.objects.get_by_natural_key(self.ma_so)
User.delete(user, using)
models.Model.delete(self, using=using)
def add_user(request, id=None):
if id:
user = get_object_or_404(User, id=id)
else:
user = User()
if request.method == 'POST':
form = UserForm(request.POST, instance=user)
if form.is_valid():
if id:
user.delete()
messages.add_message(request, messages.INFO,
'Edited user successfully')
else:
messages.add_message(request, messages.INFO,
'Added user successfully')
new_user = User.objects.create_user(**form.cleaned_data)
return HttpResponseRedirect('/manage/')
else:
messages.add_message(request, messages.ERROR, 'Form invalid.')
else:
form = UserForm(instance=user)
return render(request, "form.html", {'form': form})
def regCoach(request):
if request.method == "POST":
form = CoachForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
username = (data["first_name"]+"_"+data["last_name"]).replace(" ", "_")
user = User(username=username, first_name=data["first_name"], last_name=data["last_name"])
user.set_password(data["password1"])
user.save()
except Exception as error:
print("ERROR:", error)
return render(request, "tournament/form.html", {"form": form, "title": "Register Coach", "url": "/tournament/register/coach/"})
try:
coach = Coach(user=user, team=data["team"], birthday=data["birthday"])
coach.save()
except Exception as error:
print("ERROR:", error)
user.delete()
return render(request, "tournament/form.html", {"form": form, "title": "Register Coach", "url": "/tournament/register/coach/"})
return render(request, "tournament/success.html", {"name": "coach"})
return render(request, "tournament/form.html", {"form": form, "title": "Register Coach", "url": "/tournament/register/coach/"})
else:
form = CoachForm()
return render(request, "tournament/form.html", {"form": form, "title": "Register Coach", "url": "/tournament/register/coach/"})
class TestStaticMethods(TestCase):
"""
Test static functions
"""
def setUp(self):
"""
Set up the authtoken testcase
"""
settings.SIGNED = False
self.user = User(username='******', email='*****@*****.**', last_name='User',
first_name='Test')
self.user.save()
def tearDown(self):
"""
Tear down the authtoken testcase
"""
self.user.delete()
def testUserFromJsonStr(self):
"""
Ensure we can properly decode a json string
"""
u = SharedAuthBackend.userFromJsonStr(JSON_STR)
self.assertEqual(self.user, u)
class ProfileTest(TestCase):
def setUp(self):
self.user = User(
username='******',
first_name='John',
last_name='Doe'
)
self.user.save()
self.profile = Profile()
self.profile.user = self.user
self.profile.nickname = 'doer'
self.profile.save()
def tearDown(self):
self.profile.delete()
self.user.delete()
def test_get_fullname(self):
self.assertEqual(self.user.get_profile().get_fullname(), 'John Doe')
def test_public_profile_url(self):
x_url = reverse('person_public_profile', args=['xxx'])
with_dash_url = reverse('person_public_profile', args=['abc-cde'])
eq_(with_dash_url, x_url.replace('xxx', 'abc-cde'))
def test_fake_profile(self):
resp = self.client.get(reverse('person_public_profile', args=['xxx']))
eq_(404, resp.status_code)
class AdminIntegrationTest(SearchTestBase):
urls = "watson.tests"
def setUp(self):
super(AdminIntegrationTest, self).setUp()
self.user = User(
username = "******",
is_staff = True,
is_superuser = True,
)
self.user.set_password("bar")
self.user.save()
@skipUnless("django.contrib.admin" in settings.INSTALLED_APPS, "Django admin site not installed")
def testAdminIntegration(self):
self.client.login(username="******", password="******")
# Test a search with no query.
response = self.client.get("/admin/auth/watsontestmodel1/")
self.assertContains(response, "instance11")
self.assertContains(response, "instance12")
self.assertContains(response, "searchbar") # Ensure that the search bar renders.
# Test a search for all the instances.
response = self.client.get("/admin/auth/watsontestmodel1/?q=title content description")
self.assertContains(response, "instance11")
self.assertContains(response, "instance12")
# Test a search for half the instances.
response = self.client.get("/admin/auth/watsontestmodel1/?q=instance11")
self.assertContains(response, "instance11")
self.assertNotContains(response, "instance12")
def tearDown(self):
super(AdminIntegrationTest, self).tearDown()
self.user.delete()
del self.user
def __add_user_to_db(post, active, host):
user = User()
user.username = post['email_username']
user.email = post['email_username']
user.set_password(post['password'])
user.first_name = post['realname']
user.is_active = active
user.save()
#为user创建mail统计记录
mail_statistic = MailStatistic()
mail_statistic.user = user
mail_statistic.save()
profile = Profile()
profile.user = user
if active == 0:
from Captcha.Base import randomIdentifier
profile.activate_code = randomIdentifier()[:20]
profile.save()
if active == 0:
url = profile.activate_code + str(profile.id)
mail_content = '''
请通过访问此链接http://%s/login/activate/%s/ 激活您的ClubHome账户。
''' % (host, url)
try:
user.email_user('ClubHome账户激活', mail_content)
except Exception, e:
profile.delete()
mail_statistic.delete()
user.delete()
return False
def Register(request):
if request.method=='POST':
print request.POST
rf=RegisterForm(request.POST,request.FILES)
print rf,"rf.is_valid()===",rf.is_valid(),rf.cleaned_data['image']
if rf.is_valid():
rg_user=User()
rg_bbs_user=models.BbsUser()
print '=============================================================='
rg_user.username=rf.cleaned_data['username']
rg_user.password=rf.cleaned_data['password']
rg_user.email=rf.cleaned_data['email']
rg_user.first_name=rf.cleaned_data['firstname']
rg_user.last_name=rf.cleaned_data['lastname']
rg_user.date_joined=datetime.datetime.now()
print "rg_user:"******"保存失败，请重试！"})
return render(request,'newbbs/register.html')
class WeaveServerTest(TestCase):
def setUp(self, *args, **kwargs):
super(WeaveServerTest, self).setUp(*args, **kwargs)
settings.WEAVE.DISABLE_LOGIN = False
# Create a test user with basic auth data
self.testuser = User(username="******")
raw_password = "******"
self.testuser.set_password(raw_password)
self.testuser.save()
raw_auth_data = "%s:%s" % (self.testuser.username, raw_password)
self.auth_data = "basic %s" % base64.b64encode(raw_auth_data)
self.client = Client()
def tearDown(self, *args, **kwargs):
super(WeaveServerTest, self).tearDown(*args, **kwargs)
self.testuser.delete()
def assertWeaveTimestamp(self, response):
""" Check if a valid weave timestamp is in response. """
key = "x-weave-timestamp"
try:
raw_timestamp = response[key]
except KeyError, err:
self.fail("Weave timestamp (%s) not in response." % key)
timestamp = float(raw_timestamp)
comparison_value = time.time() - 1
self.failUnless(timestamp > comparison_value,
"Weave timestamp %r is not bigger than comparison value %r" % (timestamp, comparison_value)
)
def register(request):
if request.method == 'POST':
# Añadimos los datos recibidos al formulario
form = register_users(request.POST)
if form.is_valid():
username = request.POST.get('username', None)
first_name = request.POST.get('first_name', None)
last_name = request.POST.get('last_name', None)
email = request.POST.get('email', None)
briday_Date = request.POST.get('briday_Date', None)
password1 = request.POST.get('password1', None)
try:
newuser = User(username=username,
first_name=first_name,
last_name=last_name,
email=email)
newuser.set_password(password1)
newuser.save()
newinformation_users = InformationUsers(
user=newuser, briday_date=briday_Date, imagen=None)
newinformation_users.save()
messages.success(request, 'Registro exitoso.')
form = register_users()
except:
newuser.delete()
newinformation_users.delete()
messages.error(request, 'Ocurrio un error.')
else:
form = register_users()
return render(request, 'users/register.html', {'form': form})
class NewsletterSendViewTestCase(TestCase):
USERNAME = '******'
PASSWORD = '******'
EMAIL = '*****@*****.**'
SUBJECT = 'Hi'
CONTENT = 'Newsletter content'
def setUp(self):
self.client = Client()
self.user = User(username=self.USERNAME, email=self.EMAIL)
self.user.set_password(self.PASSWORD)
self.user.is_staff = True
self.user.save()
self.user.profile.wants_newsletter = True
self.client.login(username=self.USERNAME, password=self.PASSWORD)
def tearDown(self):
self.user.delete()
def test_admin_can_send_newsletter(self):
response = self.client.post(reverse('newsletter-send'),
{'subject': self.SUBJECT,
'content': self.CONTENT,
'member_only': False})
news_num = User.objects.filter(profile__wants_newsletter=True).count()
self.assertRedirects(response, reverse('newsletter-success'))
self.assertEqual(len(mail.outbox),
news_num)
self.assertEqual(mail.outbox[0].body, self.CONTENT)
self.assertIn(self.EMAIL, mail.outbox[0].to)
class NewsletterSendViewTestCase(TestCase):
USERNAME = '******'
PASSWORD = '******'
EMAIL = '*****@*****.**'
SUBJECT = 'Hi'
CONTENT = 'Newsletter content'
def setUp(self):
self.client = Client()
self.user = User(username=self.USERNAME, email=self.EMAIL)
self.user.set_password(self.PASSWORD)
self.user.is_staff = True
self.user.save()
self.user.profile.wants_newsletter = True
self.client.login(username=self.USERNAME, password=self.PASSWORD)
def tearDown(self):
self.user.delete()
def test_admin_can_send_newsletter(self):
response = self.client.post(reverse('newsletter-send'), {
'subject': self.SUBJECT,
'content': self.CONTENT,
'member_only': False
})
news_num = User.objects.filter(profile__wants_newsletter=True).count()
self.assertRedirects(response, reverse('newsletter-success'))
self.assertEqual(len(mail.outbox), news_num)
self.assertEqual(mail.outbox[0].body, self.CONTENT)
self.assertIn(self.EMAIL, mail.outbox[0].to)
def create_user_with_profile(validated_data):
"""
Creates a user with Meta and Main Profile
"""
user = User(username=validated_data['username'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
email=validated_data['email'])
user.set_password(validated_data['password'])
user.save()
main_profile = MainProfile(user=user,
mobile=validated_data['mobile'],
business_name=validated_data['business_name'],
procom_secret=''.join([
choice(ascii_letters + digits)
for i in range(32)
]))
meta_profile = MetaProfile(user=user, meta_info={})
try:
main_profile.save()
meta_profile.save()
except IntegrityError:
user.delete()
return None
return user
def signup_parishioner(request):
form = SignUpForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
if User.objects.filter(username=form.cleaned_data['email']).exists():
messages.error(request, 'Username already exists')
return redirect('registration:signup')
user = User(
username=form.cleaned_data['email'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name']
)
user.set_password(form.cleaned_data['password1'])
user.save()
try:
user.parishioner.parish = form.cleaned_data['parish']
user.parishioner.street_address = form.cleaned_data['street_address']
user.parishioner.city = form.cleaned_data['city']
user.parishioner.state = form.cleaned_data['state']
user.parishioner.zipcode = form.cleaned_data['zipcode']
user.groups.add(Group.objects.get(name='Parishioner'))
user.save()
except:
# TODO : Find possible exceptions that can be thrown and add handling
user.delete()
messages.error(request, f'Unable to Create Account')
return redirect('registration:signup')
else:
login(request, user)
return redirect('dashboard:home')
return render(request, 'signup_parishioner.html', {'form': form})
class ProfileTest(TestCase):
def setUp(self):
self.user = User(username="******", first_name="John", last_name="Doe")
self.user.save()
self.profile = Profile()
self.profile.user = self.user
self.profile.nickname = "doer"
self.profile.save()
def tearDown(self):
self.profile.delete()
self.user.delete()
def test_get_fullname(self):
self.assertEqual(self.user.get_profile().get_fullname(), "John Doe")
def test_public_profile_url(self):
x_url = reverse("person_public_profile", args=["xxx"])
with_dash_url = reverse("person_public_profile", args=["abc-cde"])
eq_(with_dash_url, x_url.replace("xxx", "abc-cde"))
with_underscore_url = reverse("person_public_profile", args=["abc_de"])
eq_(with_underscore_url, x_url.replace("xxx", "abc_de"))
def test_fake_profile(self):
resp = self.client.get(reverse("person_public_profile", args=["xxx"]))
eq_(404, resp.status_code)
class CreateNew(DRPTestCase):
"""Performs rudimentary tests on form validation for missing data and complete data."""
def setUp(self):
"""Set up user instances for test."""
self.user1 = User(first_name='Aslan', password=make_password(
'old_magic'), username="******", email="*****@*****.**")
self.user2 = User(first_name='White', last_name='Witch', password=make_password(
'new_magic'), username="******", email="*****@*****.**")
self.user1.save()
self.user2.save()
self.users = [self.user1, self.user2]
self.formData = {'title': 'CreationTest', 'address': 'war drobe',
'email': '*****@*****.**', 'accessCode': 'turkishdelight'}
def test_missingTitle(self):
"""Test to determine whether a form is correctly marked as invalid when a title is not present."""
formData = copy(self.formData)
del formData['title']
form = LabGroupForm(formData)
self.assertFalse(form.is_valid())
def test_missingAddress(self):
"""Test to determine whether a form is correctly marked as invalid when an address is not present."""
formData = copy(self.formData)
del formData['address']
form = LabGroupForm(formData)
self.assertFalse(form.is_valid())
def test_missingEmail(self):
"""Test to determine whether a form is correctly marked as invalid when an email address is not present."""
formData = copy(self.formData)
del formData['email']
form = LabGroupForm(formData)
self.assertFalse(form.is_valid())
def test_missingPass(self):
"""Test to determine whether a form is correctly marked as invalid when a password is not present."""
formData = copy(self.formData)
del formData['accessCode']
form = LabGroupForm(formData)
self.assertFalse(form.is_valid())
def completeData(self):
"""Test to determine whether a form is correctly marked as valid when it has all required information."""
form = LabGroupForm(self.formData)
self.assertTrue(form.is_valid())
def completeDataAndUsers(self):
"""Test to determine whether a LabGroupForm is correctly marked as valid when it has all required information and a list of user ids."""
formData = copy(self.formData)
formData['users'] = [u.id for u in self.users]
form = LabGroupForm()
self.assertTrue(form.is_valid())
def tearDown(self):
"""Delete users created for this test."""
self.user1.delete()
self.user2.delete()
def load_csv(csv_file):
handler = open(csv_file, 'r')
for line in handler.readlines():
bits = [chunk.strip().strip('"').strip() for chunk in line.split(',')]
name_slug = slugify(bits[1]).replace('-', '_')[:30]
if User.objects.filter(username=name_slug).count() == 0:
user = User(username=name_slug)
user.is_active = False
user.set_unusable_password()
try:
user.save()
except Exception, e:
print 'User', str(e)
print bits
if user.id:
document = ''.join(DOCUMENT_RE.findall(
bits[2])) if bits[2] not in ('', '\N') else ''
subscriber = Subscriber(user=user)
subscriber.contact_id = int(bits[0])
subscriber.name = bits[1]
subscriber.document = document
subscriber.phone = get_phone(bits[3])
try:
subscriber.save()
except Exception, e:
print 'Subscriber', str(e)
print bits
user.delete()
class UserTestCase(unittest.TestCase):
def setUp(self):
self.user = User(username="******")
def test_delete_user(self):
self.user.delete()
self.assertEqual(self.user, null)
def do_save(row):
# save user
u=User()
try:
u=User.objects.create_user(username=row["username"],
password=row["password"],
email=row["email"])
u.groups.add(STUDENT_GROUP)
u.save()
except:
return False
# save profile
try:
p=StudentUserProfile.objects.create(user=u,
fullname=row["fullname"],
matric_number=row["matric_number"],
)
# save groups
#TODO: to support saving multiple groups
p.add_group_by_name(row["groups"].strip())
p.save()
except:
u.delete()
return False
return True
def create_account(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
name = request.POST['name']
last_name = request.POST['last_name']
email = request.POST['email']
date = request.POST['date']
sex = request.POST['sex']
user_exist = User.objects.filter(username=username).first()
email_exist = User.objects.filter(email=email).first()
if not user_exist:
if email_exist:
sms = "%s ya esta siendo usado por otro usuario" % email
return render(request, 'create_account.html', locals())
profile = UserProfile()
profile.born_date = date
profile.sex = sex
user = User(username=username, email=email, first_name=name, last_name=last_name)
user.set_password(password)
try:
user.save()
profile.user = user
profile.save()
except ValidationError:
user.delete()
sms = "el formato de la fecha esta mal"
return render(request, 'create_account.html', locals())
return redirect(reverse('account:dashboard'))
else:
sms = "%s ya esta siendo usado por otro, por favor seleccione otro" % username
return render(request, 'create_account.html', locals())
else:
return render(request, 'create_account.html', locals())
class UserProfileTest(TestCase):
def setUp(self):
userdata = {
'username': '******',
'first_name': 'Bob',
'last_name': 'Tremblay',
'email': '*****@*****.**',
}
self.user_test = User(**userdata)
self.user_test.save()
# Crea el profile manualmente
self.userProfile = getUserProfile( self.user_test )
entry = User.objects.get(id = self.user_test.id)
self.userProfile = UserProfile.objects.get(id = entry.id)
def tearDown(self):
self.user_test.delete()
self.userProfile.delete()
def test_user_post_save(self):
self.assertIsNotNone(self.userProfile)
def test_verifying_string_representation(self):
self.assertEqual(self.userProfile.user.username, str(self.user_test))
def collaborator_registration(request, sede_url):
errors = []
user_form = UserRegistrationForm(request.POST or None)
if request.POST:
collaborator_form = CollaboratorRegistrationForm(request.POST)
forms = [user_form, collaborator_form]
if user_form.is_valid():
user = user_form.save()
try:
if collaborator_form.is_valid():
collaborator = collaborator_form.save()
user = add_collaborator_perms(user)
user.save()
collaborator.user = user
collaborator.save()
messages.success(request, _("You've been registered successfully!"))
return HttpResponseRedirect('/sede/' + sede_url)
except Exception:
User.delete(user)
messages.error(request, _("You haven't been registered successfully (check form errors)"))
errors = get_forms_errors(forms)
else:
sede = Sede.objects.get(url=sede_url)
collaborator = Collaborator(sede=sede)
collaborator_form = CollaboratorRegistrationForm(instance=collaborator)
forms = [user_form, collaborator_form]
return render(request,
'registration/collaborator-registration.html',
update_sede_info(sede_url, {'forms': forms, 'errors': errors, 'multipart': False}))
class TestPost(TestCase):
''' test class for image model '''
def setUp(self):
''' method called before each test case'''
self.test_user = User(username='******', password='******')
self.test_user.save()
self.test_profile = self.test_user.profile
self.test_profile.save()
self.test_post = Post(image='images/vik.jpg', title='vinstagram',description='Instagram Clone', profile=self.test_profile, live_link='https://vinsta.herokuapp.com/', created_on=datetime.now())
def test_instance(self):
''' test method to ensure post instance creation '''
self.assertTrue(isinstance(self.test_post, Post))
def test_save_and_delete(self):
''' test method to save and delete post instance to db '''
self.test_post.save_post()
self.assertEqual(len(Post.objects.all()), 1)
self.test_post.delete_post()
self.assertEqual(len(Post.objects.all()), 0)
def test_search_project(self):
''' test method to search projects by title '''
self.test_post.save_post()
res = Post.search_project('Vinstagram')
self.assertIsNotNone(res)
def tearDown(self):
''' method to clear all setup instances after each test run '''
self.test_user.delete()
Post.objects.all().delete()
class TestCreatePoll(TestCase):
request_body = {}
def setUp(self):
self.new_user = User(username='******')
self.new_user.save()
self.request_body['username'] = '******'
request_body_poll = {}
request_body_poll['title'] = 'test title'
request_body_poll['description'] = 'test description'
request_body_poll['participants'] = ['test user']
request_body_poll['options'] = [{'label':'test label', 'time': { 'startDate': '2019-02-13T12:00:00Z',
'endDate': '2019-02-13T12:10:00Z'}}]
request_body_poll['isPeriodic']= True
request_body_poll['periodDays']= 7
request_body_poll['startDate']= '2019-01-10T12:00:00Z'
request_body_poll['endDate']= '2019-01-10T12:00:02Z'
self.request_body['poll'] = request_body_poll
def test_create_poll(self):
Polls.create_poll(self.request_body)
self.assertEqual(EventPolls.objects.filter(creator__username= '******').values_list('title', flat= True)[0],
'test title')
self.assertEqual(Options.objects.filter(event_poll__creator__username= '******').values_list('label', flat= True)[0],
'test label')
def tearDown(self):
self.new_user.delete()
class WeaveServerTest(TestCase):
def setUp(self, *args, **kwargs):
super(WeaveServerTest, self).setUp(*args, **kwargs)
settings.WEAVE.DISABLE_LOGIN = False
# Create a test user with basic auth data
self.testuser = User(username="******")
raw_password = "******"
self.testuser.set_password(raw_password)
self.testuser.save()
raw_auth_data = "%s:%s" % (self.testuser.username, raw_password)
self.auth_data = "basic %s" % base64.b64encode(raw_auth_data)
self.client = Client()
def tearDown(self, *args, **kwargs):
super(WeaveServerTest, self).tearDown(*args, **kwargs)
self.testuser.delete()
def assertWeaveTimestamp(self, response):
""" Check if a valid weave timestamp is in response. """
key = "x-weave-timestamp"
try:
raw_timestamp = response[key]
except KeyError, err:
self.fail("Weave timestamp (%s) not in response." % key)
timestamp = float(raw_timestamp)
comparison_value = time.time() - 1
self.failUnless(
timestamp > comparison_value,
"Weave timestamp %r is not bigger than comparison value %r" %
(timestamp, comparison_value))
class TemplateTagsTestCase(unittest.TestCase):
def setUp(self):
self.user = User(
username='******',
email='*****@*****.**',
)
self.user.save()
self.template = '{% load generic_ct %}'
def tearDown(self):
self.user.delete()
def test_render_type(self):
template = Template(self.template + '{% content_type obj %}')
context = Context({'obj': self.user})
html = template.render(context)
self.assertIn('auth.user', html, 'Content type was not render')
def test_render_as_name(self):
template = Template(
self.template + '{% content_type obj as ct %}{{ ct.app_label }}.{{ ct.model }}')
context = Context({'obj': self.user})
html = template.render(context)
self.assertIn('auth.user', html, 'Content type was not render')
class TestImage(TestCase):
''' test class for image model '''
def setUp(self):
''' method called before each test case'''
self.test_user = User(username='******', password='******')
self.test_user.save()
self.test_profile = self.test_user.profile
self.test_profile.save()
self.test_image = Image(image='images/test.jpg',
caption='some text',
profile=self.test_profile,
created_on=datetime.now())
def test_instance(self):
''' test method to ensure image instance creation '''
self.assertTrue(isinstance(self.test_image, Image))
def test_save(self):
''' test method to save image instance to db '''
self.test_image.save_image()
self.assertEqual(len(Image.objects.all()), 1)
def tearDown(self):
''' method to clear all setup instances after each test run '''
self.test_user.delete() #deletes it's profile too
Image.objects.all().delete()
def _do_save(self, row):
# save user
u = User()
try:
u = User.objects.create_user(username=row["username"],
password=row["password"],
email=row["email"])
u.groups.add(self.group_to_add)
u.save()
except:
return False
# save profile
try:
p = StudentUserProfile.objects.create(
user=u,
fullname=row["fullname"],
matric_number=row["matric_number"],
)
p.add_groups_by_names(row["groups"].strip().split(
self.group_name_splitter))
p.save()
except:
u.delete()
return False
return True
def save(self):
""" Save registration forms data into User and Staff.
If any save operation fails, the others will be rolled back.
@return: User instance
"""
data = self.cleaned_data
try:
user = User(username=data['username'])
user.email = data['email']
user.set_password(data['password'])
user.first_name = data['firstname']
user.last_name = data['lastname']
user.is_active = True
user.save()
if data['team']:
try:
g = get_object_or_404(Group, pk=data['team'])
user.groups.add(g)
except:
pass
try:
staff = Staff(user=user)
staff.gender = data['gender']
staff.role = data['role']
staff.save()
return user
except Exception, e:
logger.error('RegisterForm.save():%s' % e)
user.delete()
raise e
except Exception, e:
logger.error('RegisterForm.save():%s' % e)
raise e
class TestProject(TestCase):
def setUp(self):
''' method called before each test case'''
self.test_user = User(username='******', password='******')
self.test_user.save()
self.test_project = Project(image='images/test.jpg', title='some text',description='some info', user=self.test_user, link='https://www.google.com', date_posted=datetime.now())
def test_instance(self):
self.assertTrue(isinstance(self.test_project, Project))
def test_save_and_delete(self):
self.test_project.save_project()
self.assertEqual(len(Project.objects.all()), 1)
self.test_project.delete_project()
self.assertEqual(len(Project.objects.all()), 0)
def test_search_project(self):
self.test_project.save_project()
res = Project.search_by_title('some text')
self.assertIsNotNone(res)
def tearDown(self):
self.test_user.delete()
project.objects.all().delete()
class TokenModelTest(TestCase):
fixtures = ['tokit/fixtures/initial_data.json']
def setUp(self):
self.c = Client()
self.key_owner = User(username="******")
self.key_owner.save()
self.token = Token(description='test key valid', owner=self.key_owner, is_valid=True)
self.key_invalid = Token(description='test key invalid', owner=self.key_owner)
self.token.save()
self.key_invalid.save()
self.request = HttpRequest()
def tearDown(self):
self.key_owner.delete()
def test_extract_api_key_should_return_a_key_when_set_in_header(self):
self.assertEqual(extract_api_key(self.request), None)
self.request.META['HTTP_API_KEY'] = 12345
self.assertEqual(extract_api_key(self.request), 12345)
def test_extract_api_key_should_return_the_key_from_the_querystring_for_get(self):
self.request.method = "GET"
self.request.GET['api_key'] = 12345
self.assertEqual(extract_api_key(self.request), 12345)
def test_extract_api_key_should_return_the_key_from_the_querystring_for_post(self):
self.request.method = "POST"
self.request.POST['api_key'] = 12345
self.assertEqual(extract_api_key(self.request), 12345)
def unique_instructor():
# Create User and hope there is no user with such id
# This is hack for mongo onboarding issue
instructor = User(username='******', id=random.randint(9999, 999999))
instructor.save()
yield instructor
instructor.delete()
def tearDownClass(cls):
User.delete(cls.user)
PartOfSpeech.delete(cls.pos)
Glossary.delete(cls.glossary)
Language.delete(cls.language)
Concept.delete(cls.concept)
Translation.delete(cls.translation)
def tearDownClass(cls):
User.delete(cls.user)
PartOfSpeech.delete(cls.pos)
Glossary.delete(cls.glossary)
Language.delete(cls.language)
Concept.delete(cls.concept)
Translation.delete(cls.translation)
def save(self):
""" Save registration forms data into User and Staff.
If any save operation fails, the others will be rolled back.
@return: User instance
"""
data = self.cleaned_data
try:
user = User(username=data["username"])
user.email = data["email"]
user.set_password(data["password"])
user.first_name = data["firstname"]
user.last_name = data["lastname"]
user.is_active = True
user.save()
if data["team"]:
try:
g = get_object_or_404(Group, pk=data["team"])
user.groups.add(g)
except:
pass
try:
staff = Staff(user=user)
staff.gender = data["gender"]
staff.role = data["role"]
staff.save()
return user
except Exception, e:
logger.error("RegisterForm.save():%s" % e)
user.delete()
raise e
except Exception, e:
logger.error("RegisterForm.save():%s" % e)
raise e
def post(self, request, *args, **kwargs):
"""
Create new user from post data
"""
if User.objects.filter(email=request.data['email']):
self.token, created = self.token_model.objects.get_or_create(
user=user_obj
)
return self.get_response()
else:
try:
user_data = User(email=request.data['email'], username=request.data['email'], )
user_data.password = make_password(request.data['password'])
user_data.is_active = True
user_data.save()
# send_mail('Welcome to Django Rest example', message, '*****@*****.**', [str(user_data.email)],
# fail_silently=False)
self.login(user_data)
return self.get_response()
except Exception as e:
print e, "<--- Exception at Create User"
try:
user_data.delete()
return Response({'code': 0, 'status': 200, 'message': 'All fields are mandatory'})
except:
return Response({'code': 0, 'status': 200, 'message': 'Failed'})
class RegisterTests(TestCase):
def setUp(self):
self.client = Client()
self.url = '/accounts/register/'
self.user = User(username="******")
#.objects.create_user("leGuin", "lefthand"))
self.user.set_password("lefthand")
self.user.save()
def tearDown(self):
self.user.delete()
def test_register_page(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only.'
)
def test_valid_user(self):
response = self.client.post(self.url, {
'username': '******',
'password': make_password('downbelow')
})
self.assertEqual(response.status_code, 302) # 302 = URL redirection
self.assertQuerysetEqual(User.objects.all(),
["<User: leGuin>", "<User: Cherryh>"],
ordered=False)
cherryh = User.objects.get(username="******")
cherryh.delete()
def test_repeat_user(self):
response = self.client.post(self.url, {
'username': "******",
'password': make_password("lefthand")
})
#self.assertEqual(response.status_code, 409) #currently doesn't work
self.assertQuerysetEqual(User.objects.all(), ["<User: leGuin>"],
ordered=False)
def test_long_username(self): #length limits might change?
response = self.client.get(
self.url, {
'username': '******',
'password': make_password('password')
})
#self.assertEqual(response.status_code, 400)
self.assertQuerysetEqual(User.objects.all(), ["<User: leGuin>"],
ordered=False)
def test_spacey_username(self):
response = self.client.get(self.url, {
'username': '******',
'password': '******'
})
#self.assertEqual(response.status_code, 400)
self.assertQuerysetEqual(User.objects.all(), ["<User: leGuin>"],
ordered=False)
def test_delete_profile(self):
new_user = User(id=1,
username="******",
email="*****@*****.**",
password="******")
new_user.delete()
users = User.objects.all()
self.assertTrue(len(users) <= 0)
def unique_instructor():
# Create User and hope there is no user with such id
# This is hack for mongo onboarding issue
instructor = User(username='******',
id=random.randint(9999, 999999))
instructor.save()
yield instructor
instructor.delete()
def test_create_remove(self):
# Create a user
user1 = User.objects.create_user('john', '*****@*****.**', 'johnpassword')
self.assertIsNotNone(user1)
# Remove user
user2 = User.objects.get_by_natural_key('john')
self.assertEqual(user1, user2)
User.delete(user2)
def user_reg(request):
''' функция для регистрации пользователя в системе'''
if request.method == 'POST':
referer_id = request.POST["referer_id"]
user_name = request.POST["user_name"]
email = request.POST["user_email"]
password = request.POST["user_password1"]
#создаем пользователя
user = User(username=user_name, email=email, password=password)
user.is_active = False
user.save()
try:
#определяем персональный id
new_person_id = str(create_person_id())
b_person_id = bytes(new_person_id, 'utf-8')
uid = base64.urlsafe_b64encode(b_person_id).decode('utf-8')
#определяем токен для активации аккаунта
user_token, url_token = my_token.create_token()
current_datetime = timezone.now()
#определяем реферальную ссылку
referal_link = "http://{0}/registration_from_{1}".format(
request.META['HTTP_HOST'], uid)
#создаём пользователя с дополнительными возможностями
my_user = MyUsers(user=user,
person_id=new_person_id,
token=user_token,
time_activation=current_datetime,
user_rating=0,
referal_link=referal_link)
#если пользователь зарегистрировался по реферальной ссылке
if referer_id != 'None':
referer = MyUsers.objects.get(person_id=referer_id)
my_user.referer = referer
my_user.save()
#сообщение для активационного письма
mail_text = '''Hello, {0}.
Confirm email for activation your account to host {1}.
<a href="http://{1}/confirm_email_{2}/{3}">http://{1}/confirm_email_{2}/{3}</a>'''.format(
user_name, request.META['HTTP_HOST'], uid, url_token)
#отправка письма пользователю
send_mail('Confirm your email',
mail_text,
settings.EMAIL_HOST_USER, [email],
html_message=mail_text)
message = "На указанную вами почту, было выслано письмо для активации аккаунта"
except Exception as err:
print(err)
user.delete()
message = "Что-то не так"
else:
message = "Попробуйте по-другому"
return render(request, 'message.html', {'message': message})
class AuthenticatedTestCase(TestCase):
USERNAME = '******'
PASSWORD = '******'
FIRST_NAME = 'Ogier'
EMAIL = '*****@*****.**'
LAST_NAME = 'Bouvier'
CURRENT_END_DATE = datetime.date(2015, 4, 12)
users = []
def setUp(self):
self.user = User(username=self.USERNAME,
first_name=self.FIRST_NAME,
email=self.EMAIL,
last_name=self.LAST_NAME)
self.user.set_password(self.PASSWORD)
self.user.save()
self.user.profile.until = self.CURRENT_END_DATE
self.user.profile.save()
self.users = []
def tearDown(self):
self.user.delete()
# Deleting users created by child TestCases
for user in self.users:
user.delete()
def login(self, user):
self.client.login(username=user.username, password=self.PASSWORD)
def makeAuthRequest(self, path, method, data={}):
request = method(path, data)
request.user = self.user
return request
def makeMemberUser(self):
user = self.makeUser()
user.profile.until = (timezone.now() + datetime.timedelta(1)).date()
user.profile.save()
return user
def makeUser(self):
user = User(username=randomword(20))
user.set_password(self.PASSWORD)
user.save()
user.profile.until = timezone.now().date()
user.profile.save()
self.users.append(user)
return user
def reset_user(self):
self.user.profile.until = self.CURRENT_END_DATE
self.user.last_name = randomword(20)
self.user.first_name = randomword(20)
self.user.email = '*****@*****.**'
self.user.save()
class AdminIntegrationTest(SearchTestBase):
urls = "watson.tests"
def setUp(self):
self.old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(admin.__file__),
"templates"), )
super(AdminIntegrationTest, self).setUp()
self.user = User(
username="******",
is_staff=True,
is_superuser=True,
)
self.user.set_password("bar")
self.user.save()
@skipUnless("django.contrib.admin" in settings.INSTALLED_APPS,
"Django admin site not installed")
def testAdminIntegration(self):
# Log the user in.
if hasattr(self, "settings"):
with self.settings(INSTALLED_APPS=tuple(
set(
tuple(settings.INSTALLED_APPS) +
("django.contrib.sessions", ))
)): # HACK: Without this the client won't log in, for some reason.
self.client.login(
username="******",
password="******",
)
else:
self.client.login(
username="******",
password="******",
)
# Test a search with no query.
response = self.client.get("/admin/auth/watsontestmodel1/")
self.assertContains(response, "instance11")
self.assertContains(response, "instance12")
self.assertContains(response,
"searchbar") # Ensure that the search bar renders.
# Test a search for all the instances.
response = self.client.get(
"/admin/auth/watsontestmodel1/?q=title content description")
self.assertContains(response, "instance11")
self.assertContains(response, "instance12")
# Test a search for half the instances.
response = self.client.get(
"/admin/auth/watsontestmodel1/?q=instance11")
self.assertContains(response, "instance11")
self.assertNotContains(response, "instance12")
def tearDown(self):
super(AdminIntegrationTest, self).tearDown()
self.user.delete()
del self.user
settings.TEMPLATE_DIRS = self.old_TEMPLATE_DIRS
def signup(request):
"""
Register the user and log him in
"""
if request.user.is_authenticated():
return redirect(settings.LOGIN_REDIRECT_URL)
if request.method == 'GET':
return render_login_page(request, parameters={'signup': 'active'})
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password"]
email = form.cleaned_data["email"]
user = User(username=username,
first_name=form.cleaned_data["first_name"],
last_name=form.cleaned_data["last_name"],
email=email,
is_active=False
)
user.set_password(password)
user.save()
registration = Registration(user=user)
try:
registration.register(request)
registration.save()
except:
print sys.exc_info()[0]
user.delete()
error = True
error_message = ["Unable to Register user"]
errors = {
'error': error,
'error_list': True,
'error_message': error_message, 'signup': 'active'
}
return render_login_page(request, register_form=form,
parameters=errors)
info = {
'info': True,
'info_message': 'Successfully registered. \
Check %s and activate your account.' % (email)}
return render_login_page(request, parameters=info)
else:
error = True
error_message = []
for key, value in form.errors.iteritems():
error_message.append((', '.join(value)))
errors = {
'error': error,
'error_list': True,
'error_message': error_message, 'signup': 'active'}
return render_login_page(request, register_form=form,
parameters=errors)
else:
raise Http404
class AuthenticatedTestCase(TestCase):
USERNAME = '******'
PASSWORD = '******'
FIRST_NAME = 'Ogier'
EMAIL = '*****@*****.**'
LAST_NAME = 'Bouvier'
CURRENT_END_DATE = datetime.date(2015, 4, 12)
users = []
def setUp(self):
self.user = User(username=self.USERNAME, first_name=self.FIRST_NAME,
email=self.EMAIL, last_name=self.LAST_NAME)
self.user.set_password(self.PASSWORD)
self.user.save()
self.user.profile.until = self.CURRENT_END_DATE
self.user.profile.save()
self.users = []
def tearDown(self):
self.user.delete()
# Deleting users created by child TestCases
for user in self.users:
user.delete()
def login(self, user):
self.client.login(username=user.username, password=self.PASSWORD)
def makeAuthRequest(self, path, method, data={}):
request = method(path, data)
request.user = self.user
return request
def makeMemberUser(self):
user = self.makeUser()
user.profile.until = (timezone.now() + datetime.timedelta(1)).date()
user.profile.save()
return user
def makeUser(self):
user = User(username=randomword(20))
user.set_password(self.PASSWORD)
user.save()
user.profile.until = timezone.now().date()
user.profile.save()
self.users.append(user)
return user
def reset_user(self):
self.user.profile.until = self.CURRENT_END_DATE
self.user.last_name = randomword(20)
self.user.first_name = randomword(20)
self.user.email = '*****@*****.**'
self.user.save()
def user_context():
details = {'username': '******', 'password': '******'}
user = User(username=details['username'])
user.set_password(details['password'])
user.save()
details['id'] = user.id
try:
yield details
finally:
user.delete()
def test_get_or_create_profile(self):
"""
Tests get_user_profile from UserProfileManager.
"""
new_user = User(username = '******')
new_user.save()
user_profile = UserProfile.objects.get_user_profile(new_user)
self.assertTrue(new_user.profile)
self.assertEqual(new_user.username, new_user.profile.display_name)
new_user.delete()
class HTTPTestCase(TestCase):
def setUp(self):
self.user = User(username="******", email="*****@*****.**", password="******")
self.user.save()
self.user_no_related = User(username="******", email="*****@*****.**", password="******")
self.user_no_related.save()
self.famille = models.Famille(user=self.user)
self.famille.save()
self.request = MagicMock(META={"CONTENT_TYPE": "text/html"}, body="my body")
def tearDown(self):
self.user.delete()
self.user_no_related.delete()
self.famille.delete()
def test_require_json(self):
def view(request, user):
return "success"
decorated = http.require_JSON(view)
self.assertIsInstance(decorated(self.request, "user"), HttpResponseBadRequest)
self.request.META["CONTENT_TYPE"] = "application/json"
self.assertIsInstance(decorated(self.request, "user"), HttpResponseBadRequest)
self.request.body = '{"some": "json"}'
self.assertEqual(decorated(self.request, "user"), "success")
# charset in content type
self.request.META["CONTENT_TYPE"] = "application/json; charset=utf-8"
self.assertEqual(decorated(self.request, "user"), "success")
def test_require_related(self):
def view(request):
return "success"
decorated = http.require_related(view)
self.request.user = self.user_no_related
self.assertRaises(Http404, decorated, self.request)
self.request.user = self.user
self.assertEqual(decorated(self.request), "success")
self.assertEqual(self.request.related_user, self.famille)
def test_jsonresponse(self):
resp = http.JsonResponse({"toto": "tata"})
self.assertEqual(resp.content, '{"toto": "tata"}')
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp["Content-Type"], "application/json")
resp = http.JsonResponse({"toto": "tata"}, status=400)
self.assertEqual(resp.status_code, 400)
def test_process_ax_data(self):
"""
Tests integration of OpenID AX data with the current user's profile.
"""
new_user = User(username = utils.generate_random_user_name())
new_user.save()
user_profile = UserProfile.objects.get_user_profile(new_user)
utils.process_ax_data(new_user, self.openid.ax)
user_profile = UserProfile.objects.get_user_profile(new_user)
self.assertEqual(new_user.profile.display_name, 'hanbox')
self.assertEqual(new_user.email, '*****@*****.**')
new_user.delete()
def test_view_ssh_keys(self):
"""
Test getting SSH keys belonging to users, who have admin permission on
specified cluster
"""
vm = VirtualMachine.objects.create(cluster=self.cluster,
hostname='vm1.example.bak')
user1 = User(id=3, username='******')
user1.set_password('secret')
user1.save()
# add some keys
SSHKey.objects.create(key="ssh-rsa test test@test", user=self.user)
SSHKey.objects.create(key="ssh-dsa test asd@asd", user=self.user)
SSHKey.objects.create(key="ssh-dsa test foo@bar", user=user1)
# get API key
# XXX agh oh god what why are you doing this argfl
import settings
key = settings.WEB_MGR_API_KEY
url = '/cluster/%s/keys/%s/'
args = (self.cluster.slug, key)
self.assert_standard_fails(url, args,
login_required=False,
authorized=False)
# cluster without users who have admin perms
response = self.c.get(url % args)
self.assertEqual(200, response.status_code)
self.assertEquals("application/json", response["content-type"])
self.assertEqual(len(json.loads(response.content)), 0)
self.assertNotContains(response, "test@test")
self.assertNotContains(response, "asd@asd")
# vm with users who have admin perms
# grant admin permission to first user
# XXX ...but we aren't using these users anywhere after this...
self.user.grant("admin", vm)
user1.grant("admin", self.cluster)
response = self.c.get(url % args)
self.assertEqual(200, response.status_code)
self.assertEquals("application/json", response["content-type"])
self.assertEqual(len(json.loads(response.content)), 3)
self.assertContains(response, "test@test", count=1)
self.assertContains(response, "asd@asd", count=1)
self.assertContains(response, "foo@bar", count=1)
user1.delete()
def test_view_delete_user(self):
new_user = User(id=3, username='******')
new_user.save()
url = self.url_edit % new_user.id
self.assertTrue(self.c.login(username=self.user.username,
password='******'))
response = self.c.delete(url)
self.assertEqual(403, response.status_code)
self.assertTrue(User.objects.filter(id=new_user.id).exists())
new_user.delete()
