def authenticate(self, linkedin_access_token, user=None): linkedin = LinkedIn(LINKEDIN_CONSUMER_KEY, LINKEDIN_CONSUMER_SECRET) # get their profile profile = ProfileApi(linkedin).getMyProfile(access_token=linkedin_access_token) try: user_profile = LinkedInUserProfile.objects.get(linkedin_uid=profile.id) user = user_profile.user return user except LinkedInUserProfile.DoesNotExist: # Create a new user username = "******" % profile.id if not user: user = User(username=username) user.first_name, user.last_name = (profile.firstname, profile.lastname) user.email = "%s@socialauth" % (username) user.save() userprofile = LinkedInUserProfile(user=user, linkedin_uid=profile.id) userprofile.save() auth_meta = AuthMeta(user=user, provider="LinkedIn").save() return user
def tester_registraion(request): if request.method == 'POST': form = TesterForm(request.POST) if form.is_valid(): tester = Tester() user = User() user.username = user.email = form.cleaned_data['email'] user.set_password(form.cleaned_data['password']) user.save() tester.user = user tester.surname = form.cleaned_data['last_name'] tester.first_name = form.cleaned_data['first_name'] tester.second_name = form.cleaned_data['second_name'] tester.email = form.cleaned_data['email'] tester.description = form.cleaned_data['description'] tester.save() tester.osystems = form.cleaned_data['os'] tester.program_languages = form.cleaned_data['program_languages'] tester.testing_types = form.cleaned_data['testing_types'] tester.browsers = form.cleaned_data['browsers'] tester.save() return HttpResponseRedirect('/thanks') else: form = TesterForm() return render_to_response('tester_registraion.html',{'form': form})
def user_add_page(request): success_message = '' if request.POST: form = AddUserForm(request.POST) if form.is_valid(): user = User( username=form.cleaned_data['username'], email=form.cleaned_data['email'], ) user.set_password(form.cleaned_data['password']) user.save() UserMisc.objects.create(user=user) success_message = 'User {} created.'.format(user.username) else: form = AddUserForm() crumbs = [ ('Users', '/comic/settings/users/'), ('Add', '/comic/settings/users/add/'), ] context = { 'form': form, 'menu': Menu(request.user, 'Users'), 'breadcrumbs': generate_breadcrumbs_from_menu(crumbs), 'error_message': form.errors, 'success_message': success_message, 'title': 'CBWebReader - Add User', } return render(request, 'comic/settings_page.html', context)
def setUp(self): "Initial Setup" if not self.prepared: Object.objects.all().delete() # Create objects try: self.group = Group.objects.get(name='test') except Group.DoesNotExist: Group.objects.all().delete() self.group = Group(name='test') self.group.save() try: self.user = DjangoUser.objects.get(username=self.username) self.user.set_password(self.password) try: self.profile = self.user.get_profile() except Exception: User.objects.all().delete() self.user = DjangoUser(username=self.username, password='') self.user.set_password(self.password) self.user.save() except DjangoUser.DoesNotExist: User.objects.all().delete() self.user = DjangoUser(username=self.username, password='') self.user.set_password(self.password) self.user.save() try: perspective = Perspective.objects.get(name='default') except Perspective.DoesNotExist: Perspective.objects.all().delete() perspective = Perspective(name='default') perspective.set_default_user() perspective.save() ModuleSetting.set('default_perspective', perspective.id) self.folder = Folder(name='test') self.folder.set_default_user() self.folder.save() self.document = Document(title='test_document', folder=self.folder) self.document.set_default_user() self.document.save() self.file = File(name='test_file', folder=self.folder) self.file.set_default_user() self.file.save() self.link = WebLink(title='test', folder=self.folder, url='test') self.link.set_default_user() self.link.save() self.client = Client() self.prepared = True
def authenticate(request=None): _module_name, _function_name = settings.USER_DATA_FN.rsplit('.', 1) _module = __import__(_module_name, fromlist=[None]) # We need a non-empty fromlist USER_DATA_FN = getattr(_module, _function_name) if not request.is_secure(): logger.debug("insecure request") return None authentication_status = request.META.get('HTTP_X_SSL_AUTHENTICATED', None) if (authentication_status != "SUCCESS" or 'HTTP_X_SSL_USER_DN' not in request.META): logger.warn( "HTTP_X_SSL_AUTHENTICATED marked failed or " "HTTP_X_SSL_USER_DN " "header missing") return None dn = request.META.get('HTTP_X_SSL_USER_DN') user_data = USER_DATA_FN(dn) username = user_data['username'] try: user = User.objects.get(username=username) except User.DoesNotExist: logger.info("user {0} not found".format(username)) if settings.AUTOCREATE_VALID_SSL_USERS: user = User(**user_data) user.save() else: return None if not user.is_active: logger.warning("user {0} inactive".format(username)) return None logger.info("user {0} authenticated using a certificate issued to " "{1}".format(username, dn)) return user
def handle(self, *args, **options): reader = csv.DictReader(open(args[0], 'rb'), fields) csvfile = open('new_' + args[0], 'wb') writer = csv.writer(csvfile) for row in reader: for key in row: if isinstance(row[key], str): row[key] = unicode(row[key], 'UTF-8').strip() if isinstance(row[key], basestring): row[key] = row[key].strip() login = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(6)) password = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(6)) user = User( username=login, first_name=row['first_name'], last_name=row['last_name'], email=row['email'] ) user.set_password(password) user.save() new_row = [row['last_name'], row['first_name'], row['second_name'], row['email'], row['phone'], login, password] new_row = [s.encode('UTF-8') for s in new_row] writer.writerow(new_row) csvfile.close()
def authenticate(self, **kwargs): result = None tenantKey = kwargs.get('tenant') userId = kwargs.get('userId') if tenantKey != None and userId != None: tenantPackages = get_subpackages(tenant) logger.warn(str(tenantPackages)) if tenantKey in tenantPackages: result = self.get_user(userId) logger.warn(str(tenantKey)) if result == None: if 'emailAddress'in kwargs.keys(): # 'Long' call has been issued userId = kwargs['userId'] emailAddress = kwargs['emailAddress'] firstname = kwargs['firstname'] lastname = kwargs['lastname'] role = kwargs['role'] raw_password = userId[::-1] user = User(username=userId, email=emailAddress, first_name=firstname, last_name=lastname) user.set_password(raw_password) user.save() result = user return result
def setUp(self): user = User() user.is_superuser = 1 user.username = '******' user.set_password('password2') user.email = '*****@*****.**' user.first_name = 'aa' user.is_active = 1 user.save() self.user = user c = Client() self.c = c self.c.login( username='******', password='******') product = Products() product.name = '123123' product.price = 123 product.price_type = 1 product.total_price = 1*2 product.order_time = datetime.datetime.strptime('2014-03-20','%Y-%m-%d') product.trip_start_time = datetime.datetime.strptime('2014-06-20','%Y-%m-%d') product.trip_end_time = datetime.datetime.strptime('2014-09-09','%Y-%m-%d') product.key_desc = '123' product.start_city = '123' product.end_city = '123' product.pics = '' product.trips = '' product.date_count = 4 product.user = self.user product.save() self.product = product
class LocationLocationTest(TestCase): def setUp(self): # create the objects needed self.client = Client() self.location = Location() self.user = User(username='******') self.user.set_password('google') self.user.is_active = True self.user.save() def tearDown(self): self.client = None self.location = None self.user = None def test_save(self): self.location.location_name = 'Unit Testing' self.location.description = 'Unit Testing' # required fields self.location.creator = self.user self.location.creator_username = self.user.username self.location.owner = self.user self.location.owner_username = self.user.username self.location.status = True self.location.status_detail = 'active' self.location.enclosure_length = 0 self.location.timezone = 'America/Chicago' self.location.save() self.assertTrue(isinstance(self.location.id, int))
def site_signup(request): if request.method == 'POST': form = PatientRegistrationForm(request.POST) if form.is_valid(): cd = form.cleaned_data uname = cd['username'] pword = cd['password'] firstname = cd['firstname'] lastname = cd['lastname'] email = cd['emailid'] mobNum = cd['mobNum'] locality = cd['locality'] user = User(username=uname,password=make_password(pword),first_name=firstname,last_name=lastname,email=email) user.backend='django.contrib.auth.backends.ModelBackend' user.save() usr = User.objects.get(username=uname) if usr: pat = Patient(phone_number=mobNum,locality=locality,user=usr) pat.save() usr.groups.add(Group.objects.get(name='Patient')) #usr = authenticate(username=uname,password=pword) login(request,user) request.session['new_un'] = uname #return HttpResponseRedirect("/signupsuccess/") return HttpResponseRedirect("/home/") else: form = PatientRegistrationForm(error_class=DivErrorList) return render(request,"signup_patient.html",{'form':form})
def update_user(self, existing_user=None, save=True, **kwargs): is_update_successful = False # From what I can tell, everything that invokes this method invokes it # with a value for existing_user. It also looks like the code below is # not behaving properly for mobile workers when existing_user is None. # If the soft asserts confirm this isn't ever being passed existing_user=None, # I propose making existing_user a required arg and removing the code below # that creates the user. _assert = soft_assert('@'.join(['gcapalbo', 'dimagi.com']), exponential_backoff=False) _assert(existing_user is not None, "existing_user is None") if not existing_user and 'email' in self.cleaned_data: from django.contrib.auth.models import User django_user = User() django_user.username = self.cleaned_data['email'] django_user.save() existing_user = CouchUser.from_django_user(django_user) existing_user.save() is_update_successful = True for prop in self.direct_properties: setattr(existing_user, prop, self.cleaned_data[prop]) is_update_successful = True if is_update_successful and save: existing_user.save() return is_update_successful
class TokenCreationTest(TestCase): def setUp(self): self.user = User(username='******') self.user.save() def test_create_token_string(self): from auth_remember.utils import create_token_string value = create_token_string(self.user) self.assertTrue(value.startswith('%d:' % self.user.id)) def test_get_by_token_string(self): from auth_remember.models import RememberToken from auth_remember.utils import create_token_string value = create_token_string(self.user) token = RememberToken.objects.get_by_string(value) self.assertEqual(token.user, self.user) def test_create_token_string_token_arg(self): from auth_remember.models import RememberToken from auth_remember.utils import create_token_string value = create_token_string(self.user) token = RememberToken.objects.get_by_string(value) time.sleep(0.1) new_value = create_token_string(self.user, token) new_token = RememberToken.objects.get_by_string(new_value) self.assertEqual(new_token.created_initial, token.created) self.assertTrue(new_token.created > token.created)
def new_random_profile(year): sn = random_student_number(year) while TutorProfile.objects.filter(studentnumber__exact=sn).exists(): sn = random_student_number(year) first_name = random_first_name() last_name = random_last_name() email = random_email(sn) tp = TutorProfile( studentnumber=sn, name=first_name+' '+last_name, email=email, street=random_street(), city=random_city(), phone=random_phone_number(), study=random_study(), ) u = User( username=sn, email=email, first_name=first_name, last_name=last_name, ) u.save() tp.user = u tp.save() return tp
class CheckTokenTestCase(TestCase): def setUp(self): super(CheckTokenTestCase, self).setUp() self.alice = User(username="******", email="*****@*****.**") self.alice.set_password("password") self.alice.save() self.profile = Profile(user=self.alice) self.profile.token = make_password("secret-token") self.profile.save() def test_it_redirects(self): r = self.client.get("/accounts/check_token/alice/secret-token/") self.assertRedirects(r, "/checks/") # After login, token should be blank self.profile.refresh_from_db() self.assertEqual(self.profile.token, "") def test_it_redirects_already_logged_in(self): # Login self.client.login(username="******", password="******") # Login again, when already authenticated r = self.client.get("/accounts/check_token/alice/secret-token/") self.assertRedirects(r, "/checks/") def test_it_redirects_bad_login(self): # Login with a bad token url = "/accounts/check_token/alice/invalid-token/" r = self.client.get(url, follow=True) self.assertRedirects(r, "/accounts/login/") self.assertContains(r, "incorrect or expired")
class ArticleTest(TestCase): def setUp(self): # create the objects needed self.client = Client() self.article = Article() self.user = User(username='******') self.user.set_password('google') self.user.is_active = True self.user.save() def tearDown(self): self.client = None self.article = None self.user = None def test_save(self): self.article.headline = 'Unit Testing' self.article.summary = 'Unit Testing' # required fields self.article.creator = self.user self.article.creator_username = self.user.username self.article.owner = self.user self.article.owner_username = self.user.username self.article.status = True self.article.status_detail = 'active' self.article.enclosure_length = 0 self.article.timezone = 'America/Chicago' self.article.save() self.assertTrue(isinstance(self.article.id, int))
def test_user_info(self): user = User(username="******", email="*****@*****.**") user.set_password("admin") user.save() self.assertRaises(Exception, self.client.get, reverse("sentry-raise-exc")) self.assertEquals(len(self.raven.events), 1) event = self.raven.events.pop(0) self.assertTrue("sentry.interfaces.User" in event) user_info = event["sentry.interfaces.User"] self.assertTrue("is_authenticated" in user_info) self.assertFalse(user_info["is_authenticated"]) self.assertFalse("username" in user_info) self.assertFalse("email" in user_info) self.assertTrue(self.client.login(username="******", password="******")) self.assertRaises(Exception, self.client.get, reverse("sentry-raise-exc")) self.assertEquals(len(self.raven.events), 1) event = self.raven.events.pop(0) self.assertTrue("sentry.interfaces.User" in event) user_info = event["sentry.interfaces.User"] self.assertTrue("is_authenticated" in user_info) self.assertTrue(user_info["is_authenticated"]) self.assertTrue("username" in user_info) self.assertEquals(user_info["username"], "admin") self.assertTrue("email" in user_info) self.assertEquals(user_info["email"], "*****@*****.**")
def import_user(u): user_info = u["u"] up_info = u["up"] # HACK to handle dates user_info["last_login"] = dateutil.parser.parse(user_info["last_login"]) user_info["date_joined"] = dateutil.parser.parse(user_info["date_joined"]) user_keys = [ "id", "username", "email", "password", "is_staff", "is_active", "is_superuser", "last_login", "date_joined", "password", ] up_keys = ["language", "location", "meta", "name", "id", "user_id"] u = User() for key in user_keys: u.__setattr__(key, user_info[key]) u.save() up = UserProfile() up.user = u for key in up_keys: up.__setattr__(key, up_info[key]) up.save()
def initial_setup(request): if User.objects.all().exists(): return redirect('/comic/') if request.POST: form = InitialSetupForm(request.POST) if form.is_valid(): user = User( username=form.cleaned_data['username'], email=form.cleaned_data['email'], is_staff=True, is_superuser=True, ) user.set_password(form.cleaned_data['password']) user.save() base_dir, _ = Setting.objects.get_or_create(name='BASE_DIR') base_dir.value = form.cleaned_data['base_dir'] base_dir.save() user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) login(request, user) return redirect('/comic/') else: form = InitialSetupForm() context = { 'form': form, 'title': 'CBWebReader - Setup', 'error_message': form.errors, } return render(request, 'comic/settings_page.html', context)
def passet(request): """ Set credentials for new users registered with social auth. """ ctx = { 'title': _("Set your password"), } if request.method == 'POST': f = SocialAuthPassetForm(request.POST) if f.is_valid(): user = User(request.user.id) user.username = f.cleaned_data['username'] user.set_password(f.cleaned_data['password']) # Re-fetch user object from DB user = User.objects.get(pk=request.user.id) # Create user profile if not exists try: prof = UserProfile.objects.get(user=request.user.id) except: prof = UserProfile() prof.user = user prof.save() return redirect('user:index') ctx['form'] = SocialAuthPassetForm(request.POST) return render(request, 'userspace/pass.html', ctx) ctx['form'] = SocialAuthPassetForm() return render(request, 'userspace/pass.html', ctx)
def setUpAuth(self): self.user_ctype = ContentType.objects.get_for_model(User) self.group_ctype = ContentType.objects.get_for_model(Group) User.objects.all().delete() self.abe = User(username='******', email='*****@*****.**') self.jack = User(username='******', email='*****@*****.**') self.james = User(username='******', email='*****@*****.**') self.john = User(username='******', email='*****@*****.**') self.elton = User(username='******', email='*****@*****.**', pk=10) self.abe.save() self.jack.save() self.james.save() self.john.save() Group.objects.all().delete() self.rockers = Group(name='rockers') self.bluesmen = Group(name='bluesmen') self.jazzmen = Group(name='jazzmen') self.emos = Group(name='emos', pk=10) self.rockers.save() self.bluesmen.save() self.jazzmen.save() self.emos.save()
def test_no_data_submission(self): """ Form submission should add a submission with no data, which shouldn't generate any errors to the user. """ user = User( username='******', email='*****@*****.**' ) user.save() locker = Locker( form_url='http://equity.psu.edu/contact-form', form_identifier='contact-form', name='Contact Us', owner=user, create_timestamp='2015-01-14 15:00:00+05:00', archive_timestamp='2014-04-19 12:00:00+05:00', ) response = self.client.post( reverse('datalocker:form_submission'), { 'form-id': 'contact-form', 'url': 'http://equity.psu.edu/contact-form', 'owner': 'das66', 'name': 'Contact Us', }) self.assertEqual(response.status_code, 201) try: submission = Submission.objects.all()[0] except IndexError: self.assertTrue(False) else: self.assertDictEqual(submission.data_dict(), {})
def seed_users(): for num in range(0, 10): username = fake.name() email = fake.free_email() new_user = User(username=username, email=email) new_user.set_password('password') new_user.save()
def save(self): "Creates the User and Member records with the field data and returns the user" if not self.is_valid(): raise Exception('The form must be valid in order to save') user = User(username=self.cleaned_data['username'], first_name=self.cleaned_data['first_name'], last_name=self.cleaned_data['last_name'], email=self.cleaned_data['email']) user.save() member = user.get_profile() member.email2 = self.cleaned_data['email2'] member.phone = self.cleaned_data['phone'] member.phone = self.cleaned_data['phone2'] member.address1 = self.cleaned_data['address1'] member.address2 = self.cleaned_data['address2'] member.city = self.cleaned_data['city'] member.state = self.cleaned_data['state'] member.zipcode = self.cleaned_data['zipcode'] member.url_personal = self.cleaned_data['url_personal'] member.url_professional = self.cleaned_data['url_professional'] member.url_facebook = self.cleaned_data['url_facebook'] member.url_twitter = self.cleaned_data['url_twitter'] member.url_linkedin = self.cleaned_data['url_linkedin'] member.url_biznik = self.cleaned_data['url_biznik'] member.url_github = self.cleaned_data['url_github'] member.url_aboutme = self.cleaned_data['url_aboutme'] member.gender = self.cleaned_data['gender'] member.howHeard = self.cleaned_data['howHeard'] member.industry = self.cleaned_data['industry'] member.neighborhood = self.cleaned_data['neighborhood'] member.has_kids = self.cleaned_data['has_kids'] member.self_emplyed = self.cleaned_data['self_employed'] member.company_name = self.cleaned_data['company_name'] member.notes = self.cleaned_data['notes'] member.photo = self.cleaned_data['photo'] member.save() return user
def test_new_form_entry(self): """ Form submission should create a new locker and save the submission. """ user = User( username='******', email='*****@*****.**' ) user.save() response = self.client.post( reverse('datalocker:form_submission'), { 'form-id': 'contact-form', 'url': 'http://equity.psu.edu/contact-form', 'owner': 'das66', 'name': 'Contact Us', 'data': json.dumps({ 'Your E-mail Address': '*****@*****.**', 'Subject': 'New Form Entry Test', 'Comments': 'Testing locker creation from initial form submission', }), }) self.assertEqual(response.status_code, 201) try: locker = Locker.objects.get(form_identifier='contact-form') except Locker.DoesNotExist: self.assertTrue(False) else: self.assertEqual(len(locker.submissions.all()), 1)
class MonitorUpdateTestCase(ResourceTestCase): def setUp(self): super(MonitorUpdateTestCase, self).setUp() self.user = User(username='******', password='******', email='*****@*****.**') self.user.save() fixture = AutoFixture(MonitorUpdate) fixture.create(10) try: self.api_key = ApiKey.objects.get(user=self.user) except ApiKey.DoesNotExist: self.api_key = ApiKey.objects.create(user=self.user) self.auth_string = '&username={0}&api_key={1}'.format( self.user.username, self.api_key.key) def tearDown(self): MonitorUpdate.objects.all().delete() def test_source_get(self): url = '/api/v1/monitorUpdate/1/?format=json{}'.format(self.auth_string) response = self.api_client.get(url) self.assertEqual(response.status_code, 200) unauth_url = '/api/v1/source/?format=json' response = self.api_client.get(unauth_url) self.assertEqual(response.status_code, 401)
def user_signup(request): context = RequestContext(request) registered = False user = User(username = '') next_link = "" if request.GET: next_link = request.GET['next'] if request.method == 'POST': next_link = request.POST['signup_next'] user.first_name = request.POST['user[full_name]'] user.last_name = request.POST['user[sur_name]'] user.username = request.POST['user[email]'] user.email = request.POST['user[email]'] user.password = request.POST['user[password]'] user.set_password(user.password) user.save() patron = Patron(user = user) account = PatronAccount(balance = 0, frozen = False, valid = True ) account.save() patron.account = account patron.save() user = authenticate(username = request.POST['user[email]'], password = request.POST['user[password]']) if user is not None: if user.is_active: login(request, user) if next_link == "": return HttpResponseRedirect('/giftcards') else: return HttpResponseRedirect(next_link) else: return render_to_response('login.html', {'next':next_link}, context) return
def setUp(self): self.super_user = User(username="******", is_staff = True, is_active = True, is_superuser = True) self.super_user.set_password("test") self.super_user.save() self.slave = User(username="******", is_staff=True, is_active=True, is_superuser=False) self.slave.set_password("slave") self.slave.save() self.login_user(self.super_user) # create 3 sections self.sections = [] self.section_pks = [] for i in range(3): section = Section.objects.create(name="section %s" %i) self.sections.append(section) self.section_pks.append(section.pk) self.section_count = len(self.sections) # create 10 articles by section for section in self.sections: for j in range(10): Article.objects.create( title="article %s" % j, section=section ) self.FIRST_LANG = settings.LANGUAGES[0][0] self.SECOND_LANG = settings.LANGUAGES[1][0]
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 create_new_user_from_current_session(session): """ This function creates a user from the session after shib validates """ now = timezone.now() new_user = User(username=session.get(SESSION_VARS['gatorlink']), email=session.get(SESSION_VARS['email']), last_login=now, last_name=session.get(SESSION_VARS['last_name']), first_name=session.get(SESSION_VARS['first_name'])) new_user.save() new_person = Person(user=new_user, gatorlink=new_user.username, first_name=new_user.first_name, last_name=new_user.last_name, email_address=new_user.email, last_login_time=now, account_expiration_time=utils.get_account_expiration_date(now)) new_person.save(last_modified_by=new_user) return new_user
def setUp(self): self.user = User(username="******", email="admin@localhost", is_staff=True, is_superuser=True) self.user.set_password('admin') self.user.save() self.user2 = User(username="******", email="member@localhost") self.user2.set_password('member') self.user2.save() self.user3 = User(username="******", email="nobody@localhost") self.user3.set_password('nobody') self.user3.save() self.user4 = User(username="******", email="owner@localhost") self.user4.set_password('owner') self.user4.save() self.team = Team.objects.create(owner=self.user4, name='foo', slug='foo') self.project = Project.objects.get(id=1) self.project.update(public=False, team=self.team) self.tm = TeamMember.objects.get_or_create( user=self.user2, team=self.team, type=MEMBER_USER, )[0] TeamMember.objects.get_or_create( user=self.user4, team=self.team, type=MEMBER_OWNER, )[0]
def test_adding_user_create_default_prefe_rences(self): u = User(username="******") u.save() self.assertEqual(u.preferences.count(), len(user_preferences_registry.preferences()))
def setUp(self): self.test_user = User(username="******", password="******", email="*****@*****.**") self.test_user.save() self.test_site = Site(domain="www.test.com", name="test") self.test_site.save()
def setUp(self): self.henri = User(username="******", password="******", email="*****@*****.**") self.henri.save()
class TestDynamicPreferences(LiveServerTestCase): def setUp(self): self.test_user = User(username="******", password="******", email="*****@*****.**") self.test_user.save() self.test_site = Site(domain="www.test.com", name="test") self.test_site.save() def test_can_get_preference_value_by_key(self): site_pref1 = site_preferences_registry.get("TestSitePref1", "test") self.assertEqual(site_pref1.default, TestSitePref1.default) user_pref1 = user_preferences_registry.get("TestUserPref1", "test") self.assertEqual(user_pref1.default, TestUserPref1.default) def test_can_change_site_preference_value(self): site_pref1 = site_preferences_registry.get("TestSitePref1", "test") site_pref1.value = "new value" self.assertEqual(site_preferences_registry.get("TestSitePref1", "test").value, "new value") user_pref1 = user_preferences_registry.get("TestUserPref1", "test") user_pref1.value = "new value" self.assertEqual(user_preferences_registry.get("TestUserPref1", "test").value, "new value") def test_site_preference_is_saved_to_database(self): site_pref1 = site_preferences_registry.get("TestSitePref1", "test") site_pref1.to_model(site=self.test_site, value="new site value") test_site_pref1 = SitePreferenceModel.objects.get(section="test", name="TestSitePref1", site=self.test_site) self.assertEqual(site_pref1, test_site_pref1.preference) self.assertEqual(test_site_pref1.section, "test") self.assertEqual(test_site_pref1.name, "TestSitePref1") self.assertEqual(test_site_pref1.value, "new site value") def test_user_preference_is_saved_to_database(self): with self.settings(CREATE_DEFAULT_PREFERENCES_FOR_NEW_USERS=False): user = User(username="******") user.save() user_pref1 = user_preferences_registry.get("TestUserPref1", "test") user_pref1.to_model(user=user, value="new user value") test_user_pref1 = UserPreferenceModel.objects.get(section="test", name="TestUserPref1", user=user) self.assertEqual(user_pref1, test_user_pref1.preference) self.assertEqual(test_user_pref1.section, "test") self.assertEqual(test_user_pref1.name, "TestUserPref1") self.assertEqual(test_user_pref1.value, "new user value") def test_site_preference_stay_unique_in_db(self): site_pref1 = site_preferences_registry.get("TestSitePref1", "test") site_pref1.to_model(site=self.test_site, value="new value") duplicate = SitePreferenceModel(section="test", name="TestSitePref1", site=self.test_site) with self.assertRaises(IntegrityError): duplicate.save() def test_user_preference_stay_unique_in_db(self): user_pref1 = user_preferences_registry.get("TestUserPref1", "test") user_pref1.to_model(user=self.test_user, value="new value") duplicate = UserPreferenceModel(section="test", name="TestUserPref1", user=self.test_user) with self.assertRaises(IntegrityError): duplicate.save() def test_preference_value_set_to_default(self): pref = user_preferences_registry.get("TestUserPref1", "test") pref.to_model(user=self.test_user) instance = UserPreferenceModel.objects.get(section="test", name="TestUserPref1", user=self.test_user) self.assertEqual(pref.default, instance.value) pref = site_preferences_registry.get("TestSitePref1", "test") pref.to_model(site=self.test_site) instance = SitePreferenceModel.objects.get(section="test", name="TestSitePref1", site=self.test_site) self.assertEqual(pref.default, instance.value)
def addUser(request): if not request.user.is_authenticated(): return HttpResponseRedirect('/login') else: if request.method == 'POST': user = User() user.username = request.POST.get('username') user.first_name = request.POST.get('firstname') user.last_name = request.POST.get('lastname') user.email = request.POST.get('email') user.set_password(request.POST.get('password')) user.is_staff = True, user.is_active = True, user.save() print(user.id) return HttpResponseRedirect('/')
class TestViews(LiveServerTestCase): def setUp(self): self.henri = User(username="******", password="******", email="*****@*****.**") self.henri.set_password('test') self.henri.save() self.admin = User(username="******", email="*****@*****.**", is_superuser=True, is_staff=True) self.admin.set_password('test') self.admin.save() def test_can_build_global_preference_form(self): # We want to display a form with two global preferences # RegistrationAllowed and MaxUsers form = global_preference_form_builder(preferences=['user.registration_allowed', "user.max_users"])() self.assertEqual(len(form.fields), 2) self.assertEqual(form.fields['user.registration_allowed'].initial, False) def test_can_build_preference_form_from_sections(self): form = global_preference_form_builder(section='test')() self.assertEqual(len(form.fields), 3) def test_can_build_global_preference_form_from_sections(self): form = global_preference_form_builder(section='test')() self.assertEqual(len(form.fields), 3) def test_can_build_user_preference_form_from_sections(self): form = user_preference_form_builder(user=self.admin, section='test')() self.assertEqual(len(form.fields), 4) def test_global_preference_view_requires_staff_member(self): url = reverse("dynamic_preferences.global") response = self.client.get(url, follow=True) self.assertRedirects(response, "/admin/login/?next=/global/") self.client.login(username='******', password="******") response = self.client.get(url) self.assertRedirects(response, "/admin/login/?next=/global/") self.client.login(username='******', password="******") response = self.client.get(url) self.assertEqual(self.admin.is_authenticated(), True) self.assertEqual(response.status_code, 200) def test_global_preference_view_display_form(self): url = reverse("dynamic_preferences.global") self.client.login(username='******', password="******") response = self.client.get(url) self.assertEqual(len(response.context['form'].fields), 8) self.assertEqual(response.context['registry'], global_preferences_registry) def test_global_preference_filters_by_section(self): self.client.login(username='******', password="******") url = reverse("dynamic_preferences.global.section", kwargs={"section": 'user'}) response = self.client.get(url) self.assertEqual(len(response.context['form'].fields), 4) def test_preference_are_updated_on_form_submission(self): self.client.login(username='******', password="******") url = reverse("dynamic_preferences.global.section", kwargs={"section": 'user'}) self.client.post(url, {'user.max_users': 95, 'user.registration_allowed': True, 'user.favorite_vegetable': "P", "user.items_per_page": 12}) self.assertEqual(global_preferences.get(section="user", name="max_users").value, 95) self.assertEqual(global_preferences.get(section="user", name="registration_allowed").value, True) self.assertEqual(global_preferences.get(section="user", name="favorite_vegetable").value, 'P') def test_user_preference_form_is_bound_with_current_user(self): self.client.login(username='******', password="******") self.assertEqual( user_preferences.get_or_create(user=self.henri, section="misc", name='favourite_colour')[0].value, 'Green') self.assertEqual(user_preferences.get_or_create(user=self.henri, section="misc", name='is_zombie')[0].value, True) url = reverse("dynamic_preferences.user.section", kwargs={'section': 'misc'}) self.client.post(url, {'misc.favourite_colour': 'Purple', 'misc.is_zombie': False}) self.assertEqual(self.henri.preferences.get(section="misc", name='favourite_colour').value, 'Purple') self.assertEqual(self.henri.preferences.get(section="misc", name='is_zombie').value, False) def test_preference_model_manager_to_dict(self): call_command('checkpreferences', verbosity=1, interactive=False) expected = {u'test': {u'TestGlobal1': u'default value', u'TestGlobal2': False, u'TestGlobal3': False}, None: {u'no_section': False}, u'user': {u'max_users': 100, u'items_per_page': 25, u'registration_allowed': False, u'favorite_vegetable': u'C'}} self.assertEqual(global_preferences.to_dict(), expected) def test_user_preference_model_manager_to_dict(self): call_command('checkpreferences', verbosity=1, interactive=False) user = User.objects.get(pk=self.henri.pk) expected = {u'misc': {u'favourite_colour': u'Green', u'is_zombie': True}, u'test': {u'SUserStringPref': u'Hello world!', u'SiteBooleanPref': False, u'TestUserPref1': u'default value', u'TestUserPref2': u''}} self.assertEqual(user_preferences.to_dict(user=user), expected) def test_template_gets_global_preferences_via_template_processor(self): call_command('checkpreferences', verbosity=1, interactive=False) url = reverse("dynamic_preferences.test.templateview") response = self.client.get(url) self.assertEqual(response.context['global_preferences'], global_preferences.to_dict()) def test_template_gets_user_preferences_via_template_processor(self): call_command('checkpreferences', verbosity=1, interactive=False) user = User.objects.get(pk=self.henri.pk) self.client.login(username=user.username, password="******") url = reverse("dynamic_preferences.test.templateview") response = self.client.get(url) to_dict = user_preferences.to_dict(user=user) self.assertEqual(response.context['user_preferences'], to_dict)