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 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 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
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()