def test_seen_module(self, filter): user = User(username='******') LastSeen.objects.when(user=user, module='mod') filter.assert_called_with(user=user, module='mod')
def __init__(self): self.user = User() self.user.first_name = settings.ETL_USERNAME self.resources = [] self.se = SearchEngineFactory().create()
import datetime from django.test import TestCase from django.utils import timezone from polls.models import Poll, Choice, Vote from django.core.urlresolvers import reverse from django.contrib.auth.models import User import django_webtest if User.objects.filter(username='******'): user = User.objects.get(username='******') else: print 'creating new user' user = User(username='******') user.set_password('test') user.save() def create_poll(question, days): """ Creates a poll with the given 'question' published the given number of 'days' offset to now (negative for polls published in the past, positive for polls that have yet to be published """ return Poll.objects.create(author=user, question=question, pub_date=timezone.now() + datetime.timedelta(days=days)) # Create your tests here. class PollMethodTests(TestCase): def test_index_view_with_no_polls(self): """ If no polls exist, an appropriate message should be displayed
def manage(request): message = {} old_fields = {} error = False action = None if request.method == "POST": action = request.POST.get('action', None) if request.method == "POST" and action == "meow-switch": send_posts = request.POST.get('switch-x', None) if send_posts: s = MeowSetting.objects.get(setting_key="send_posts") old = s.setting_value s.setting_value = send_posts s.save() if send_posts != old: message = { "mtype": "success", "mtext": "Meow status successfully changed. Be careful out there.", } if request.method == "POST" and action == "post-site-message": site_message = request.POST.get('site-message', None) s = MeowSetting.objects.get(setting_key="site_message") old = s.setting_value s.setting_value = site_message s.save() if site_message != old: message = { "mtype": "success", "mtext": "Site message successfully changed", } if request.method == "POST" and action == "add-user": try: old_fields['first_name'] = request.POST['first_name'] old_fields['last_name'] = request.POST['last_name'] old_fields['email'] = request.POST['email'] old_fields['username'] = request.POST['username'] old_fields['permission'] = request.POST['permission'] password = User.objects.make_random_password() u = User(username=old_fields['username'], first_name=old_fields['first_name'], last_name=old_fields['last_name'], email=old_fields['email'], password="******") u.save() u.set_password(password) u.groups.add(Group.objects.get(name=old_fields['permission'])) u.save() message = { "mtype": "success", "mtext": "User added successfully!", } except KeyError as e: message = { "mtype": "alert", "mtext": "User not added; please fill out all fields!", } error = True except IntegrityError as e: message = { "mtype": "alert", "mtext": "Username " + old_fields['username'] + " already exists", } error = True # Now send them an email with the username/pass if not error: try: email_message = """ Hey {first_name}, Your new Meow account is ready. Log in with: Username: {username} Password: {password} at {site_url} and change your password. Thanks, {organization_name} """ site_url = MeowSetting.objects.get( setting_key='site_url').setting_value organization_name = MeowSetting.objects.get( setting_key='organization_name').setting_value from_email = MeowSetting.objects.get( setting_key='from_email').setting_value email_message = email_message.format( first_name=old_fields['first_name'], username=old_fields['username'], password=password, site_url=site_url, organization_name=organization_name) send_mail('[' + organization_name + '] Your new meow account', email_message, from_email, [old_fields['email']], fail_silently=False) old_fields = {} except: print(sys.exc_info()[0]) message = { "mtype": "alert", "mtext": "Account created but couldn't send password to " + old_fields['email'] + ".", } old_fields = {} error = True send_posts = MeowSetting.objects.get( setting_key='send_posts').setting_value site_message = MeowSetting.objects.get( setting_key='site_message').setting_value TWITTER_CONSUMER_KEY = MeowSetting.objects.get( setting_key='twitter_consumer_key').setting_value TWITTER_CONSUMER_SECRET = MeowSetting.objects.get( setting_key='twitter_consumer_secret').setting_value twitter_auth = tweepy.OAuthHandler( TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, MeowSetting.objects.get( setting_key="site_url").setting_value + "/manage/twitter-connect/" ) twitter_auth.secure = True twitter_auth_url = twitter_auth.get_authorization_url() request.session["twitter_auth_token"] = twitter_auth.request_token request.session.save() fb_app_id = MeowSetting.objects.get(setting_key="fb_app_id").setting_value fb_app_secret = MeowSetting.objects.get( setting_key="fb_app_secret").setting_value # TODO: find a better place for these constants fb_authorization_base_url = 'https://www.facebook.com/v2.10/dialog/oauth' fb_token_url = 'https://graph.facebook.com/oauth/access_token' redirect_uri = MeowSetting.objects.get( setting_key="site_url").setting_value + '/manage/fb-connect' fb_permissions = ["manage_pages", "publish_pages"] facebook = OAuth2Session(fb_app_id, redirect_uri=redirect_uri, scope=fb_permissions) facebook = facebook_compliance_fix(facebook) facebook_auth_url, state = facebook.authorization_url( fb_authorization_base_url) context = { "user": request.user, "message": message, "old_fields": old_fields, "send_posts": send_posts, "site_settings": get_settings(), "twitter_auth_url": twitter_auth_url, "facebook_auth_url": facebook_auth_url, "fb_app_id": fb_app_id } return render(request, 'scheduler/manage.html', context)
def create(self, validated_data): username = validated_data['username'] email = validated_data['email'] userObj = User(username=username, email=email) userObj.save() return validated_data
def test_check_quota_valid(self, _): self.resource_quota_user.handler = ResourceQuotaHandlerSub self.assertTrue(self.resource_quota_user.check_quota(User()))
def registerApi(request): if request.method == 'POST' : firstname = request.POST.get('first_name') lastname = request.POST.get('last_name') username = request.POST.get('username') email = request.POST.get('email') password = request.POST.get('password') password2 = request.POST.get('password2') image = request.FILES['file'] # image = request.FILES.get('file') print('vvgsgsgsggs',image) is_email=False Min_Length = 8 try: if firstname != None and lastname != None and username != None : try: validate_email(email) is_email=True except: data = { 'success':False, 'message':'Email is not valide' } if is_email : try: user_dup = User.objects.filter(email=email) if user_dup.exists(): data={ 'success':False, 'message': 'Ce mail existe Deja dans la BD' } elif image == None: data = { 'success':False, 'message': 'Verifie votre champ Image' } elif len(password) < Min_Length: data = { 'success':False, 'message': 'Mot de passe doit etre au minimum 8 chiffres' } elif password == password2 and (password is not None and password2 is not None): user = User(username = username, first_name = firstname, last_name = lastname, email = email) user.save() user.profile.imageprofile = image print(user.profile.imageprofile) user.save() # print("UUUUUUU", user.save()) user.password = password user.set_password(user.password) user.save() data={ 'success':True, 'message': 'Enregistrement effectue avec succes' } else: data={ 'success':False, 'message':'Mot de passe ne sont pas meme' } except: pass # data={ # 'success':False, # 'message':'Verifier les Champs' # } except: data = { 'success':False, 'message':'Verifier les Champs SVP' } else: data={ 'success':False, 'message':'Tous les Champs sont Vides' } return JsonResponse(data, safe=False)
def setUp(self): super(UserTestBase, self).setUp() self.user = User(username="******", is_staff=True, is_superuser=True) self.user.set_password("password") self.user.save()
def setUp(self): self.unorm = User(username='******', email='*****@*****.**') self.unorm.set_password('password') self.normpass = '******' self.unorm.save()
def test_user_seen_cached(self, seen): user = User(username='******', pk=1) module = 'test_mod' cache.set("last_seen:%s:%s" % (module, user.pk), time.time()) user_seen(user, module=module) self.assertFalse(seen.called)
def create(self, validated_data): u = User(**validated_data) u.set_password(validated_data['password']) u.save() return u
def test_user_seen_no_default(self, seen): user = User(username='******', pk=1) site = Site(pk=2) user_seen(user, module="test", site=site) seen.assert_called_with(user, module="test", site=site)
def test_unicode(self): user = User(username='******') ts = datetime.datetime(2013, 1, 1, 2, 3, 4) seen = LastSeen(user=user, last_seen=ts) self.assertIn('testuser', unicode(seen)) self.assertIn('2013-01-01 02:03:04', unicode(seen))
def test_seen_site(self, filter): user = User(username='******') site = Site() LastSeen.objects.when(user=user, site=site) filter.assert_called_with(user=user, site=site)
def internal_user(): user = User(username='******', is_staff=True, is_superuser=True) user.set_password("123carlosmart123") user.save()
def post(self, request): """" this should take email instead of username """ req_time = now_ms() log_message = req_log_message(request, req_time) logger.info(log_message) email = request.POST.get("email") password = request.POST.get("password") fullname = request.POST.get("fullname") bio = request.POST.get("bio") image = request.FILES.get("profile_picture") username = request.POST.get("username") response = RegisterValidation() response = response.post(request) if response.status_code == 400: log_result = 'Fail: Validation failed' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return (response) if username is None or username == "": log_result = 'Fail: No username' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return JsonResponse({"error": _("please enter username")}, status=HTTP_400_BAD_REQUEST) if not username_pattern.match(username): log_result = 'Fail: Invalid username' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return JsonResponse({"error": _("bad username")}, status=HTTP_400_BAD_REQUEST) if len(username) < 5: log_result = 'Fail: No username' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return JsonResponse({"error": _("bad username")}, status=HTTP_400_BAD_REQUEST) if not validate_charfield_input(bio, bio_max_length): log_result = 'Fail: No username' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return JsonResponse({"error": _("long bio")}, status=HTTP_400_BAD_REQUEST) try: user = User.objects.get(email=email) except User.DoesNotExist: user = None if Profile.objects.filter(main_username=username).count() > 0: log_result = 'Fail: Username already taken' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return Response({'error': _('this username is already taken')}, status=HTTP_400_BAD_REQUEST) # try: # validate_password(password) # except: # return JsonResponse({"error": _("weak_password")}, status=HTTP_400_BAD_REQUEST) if user is None: user = User(username=email, email=email) user.set_password(password) user.save() else: log_result = 'Fail: Email already taken' log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return Response({'error': _('this email is already taken')}, status=HTTP_400_BAD_REQUEST) profile = Profile.objects.get(user_id=user.id) profile.fullname = fullname profile.bio = bio profile.main_username = username profile.profile_picture = image profile.save() log_result = 'Success: User_{0} registered'.format(user.id) log_message = res_log_message(request, log_result, req_time) logger.info(log_message) return Response({'status': _('succeeded')})
def test_default_method_is_free(self): user, basket = User(), Basket() methods = self.repo.get_shipping_methods(user, basket) self.assertEqual(1, len(methods)) self.assertTrue(isinstance(methods[0], Free))
def create_user(self, uname, name, password=None): """ Creates a user (both SSL and regular)""" if not uname: return _('Must provide username') if not name: return _('Must provide full name') email_domain = getattr(settings, 'SSL_AUTH_EMAIL_DOMAIN', 'MIT.EDU') msg = u'' if settings.FEATURES['AUTH_USE_CERTIFICATES']: if '@' not in uname: email = '{0}@{1}'.format(uname, email_domain) else: email = uname if not email.endswith('@{0}'.format(email_domain)): # Translators: Domain is an email domain, such as "@gmail.com" msg += _('Email address must end in {domain}').format(domain="@{0}".format(email_domain)) return msg mit_domain = 'ssl:MIT' if ExternalAuthMap.objects.filter(external_id=email, external_domain=mit_domain): msg += _('Failed - email {email_addr} already exists as {external_id}').format( email_addr=email, external_id="external_id" ) return msg new_password = generate_password() else: if not password: return _('Password must be supplied if not using certificates') email = uname if '@' not in email: msg += _('email address required (not username)') return msg new_password = password user = User(username=uname, email=email, is_active=True) user.set_password(new_password) try: user.save() except IntegrityError: msg += _('Oops, failed to create user {user}, {error}').format( user=user, error="IntegrityError" ) return msg reg = Registration() reg.register(user) profile = UserProfile(user=user) profile.name = name profile.save() if settings.FEATURES['AUTH_USE_CERTIFICATES']: credential_string = getattr(settings, 'SSL_AUTH_DN_FORMAT_STRING', '/C=US/ST=Massachusetts/O=Massachusetts Institute of Technology/OU=Client CA v1/CN={0}/emailAddress={1}') credentials = credential_string.format(name, email) eamap = ExternalAuthMap( external_id=email, external_email=email, external_domain=mit_domain, external_name=name, internal_password=new_password, external_credentials=json.dumps(credentials), ) eamap.user = user eamap.dtsignup = timezone.now() eamap.save() msg += _('User {user} created successfully!').format(user=user) return msg
def create(self, validated_data): user = User(username=validated_data['username']) user.set_password(validated_data['password']) user.save() return user
def setUp(self): self.user = User(username="******", email="*****@*****.**") self.user.set_password("bar") self.user.save()
def get_or_create_user(self, username, password): try: user = User.objects.get(username=username) except User.DoesNotExist: try: debug = None if settings.AD_DEBUG_FILE and settings.AD_DEBUG: debug = open(settings.AD_DEBUG_FILE, 'a') print >> debug, "create user %s" % username #ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, settings.AD_CERT_FILE) ldap.set_option( ldap.OPT_REFERRALS, 0) # DO NOT TURN THIS OFF OR SEARCH WON'T WORK! # initialize if debug: print >> debug, "\tinitialize..." l = ldap.initialize(settings.AD_LDAP_URL) l.set_option(ldap.OPT_PROTOCOL_VERSION, 3) # bind if debug: print >> debug, "\tbind..." binddn = "%s@%s" % (username, settings.AD_NT4_DOMAIN) l.bind_s(binddn, password) # search if debug: print >> debug, "\tsearch..." result = l.search_ext_s( settings.AD_SEARCH_DN, ldap.SCOPE_SUBTREE, "%s=%s" % (settings.AD_LU_ACCOUNT_NAME, username), settings.AD_SEARCH_FIELDS)[0][1] # get personal info mail = result.get(settings.AD_LU_MAIL, ["*****@*****.**"])[0] last_name = result.get(settings.AD_LU_SURNAME, [username])[0] first_name = result.get(settings.AD_LU_GIVEN_NAME, [username])[0] l.unbind_s() user = User(username=username, first_name=first_name, last_name=last_name, email=mail) except Exception, e: if debug: print >> debug, "Exception:" print >> debug, e return None user.is_staff = False user.is_superuser = False user.set_password('ldap authenticated') user.save() if debug: print >> debug, "User created: %s" % username
def _get_or_create_user(self, d): base_username = d.get('username') or d['name'].replace(' ', '').lower() ans = "" updated = False users = User.objects.filter(email=d['email']) if users.count() > 1: ans = self._manage_multiple_duplicates( users, ('id', 'first_name', 'last_name', 'username', 'email')) # TODO TODO TODO elif users.count() == 1: user = users[0] log.info("FOUND USER WITH EMAIL %s: %s" % (d['email'], "name=%s surname=%s username=%s" % (user.first_name, user.last_name, user.username))) log.info("USER TO BE ADDED: name=%s surname=%s username=%s" % (d['name'], d['surname'], base_username)) ans = "A" if user.username == base_username: log.info( "Usernames match. Assuming person, contacts, and place info unchanged" ) else: msg = "Usernames don't match" ans = raw_input( "%s. What should I do?\na. Keep current user as is\nb. Overwrite current user with new info\nc. Create a new user\n[A/b/c] ?" % msg) ans = ans.upper() if ans == "C": user = User(username=base_username, email=d['email']) elif ans == "B": user.first_name = d['name'].capitalize() user.last_name = d['surname'].capitalize() if User.objects.filter(username=base_username).count(): log.warning( "CANNOT update username because it is already used") else: user.username = base_username updated = True else: user = User(username=base_username, email=d['email']) user.first_name = d['name'].capitalize() user.last_name = d['surname'].capitalize() # Process only if we are creating a new user c = 1 while not user.pk: try: sid = transaction.savepoint() user.save() transaction.savepoint_commit(sid) except IntegrityError: transaction.savepoint_rollback(sid) user.username = "******" % (base_username, c) c += 1 else: user.set_password("default") user.is_active = False user.save() log.info("CREATED USER %s" % user) user.save() return user, updated
def setUp(self): """ """ ie = Country.objects.get(code="ie") gb = Country.objects.get(code="gb") de = Country.objects.get(code="de") us = Country.objects.get(code="us") fr = Country.objects.get(code="fr") shop, created = Shop.objects.get_or_create(name="lfs test", shop_owner="John Doe", default_country=de) shop.save() shop.invoice_countries.add(ie) shop.invoice_countries.add(gb) shop.invoice_countries.add(de) shop.invoice_countries.add(us) shop.invoice_countries.add(fr) shop.shipping_countries.add(ie) shop.shipping_countries.add(gb) shop.shipping_countries.add(de) shop.shipping_countries.add(us) shop.shipping_countries.add(fr) shop.save() tax = Tax.objects.create(rate=19) shipping_method = ShippingMethod.objects.create(name="Standard", active=True, price=1.0, tax=tax) payment_method = PaymentMethod.objects.create( name="Direct Debit", active=True, tax=tax, ) self.address1 = Address.objects.create( firstname="John", lastname="Doe", company_name="Doe Ltd.", line1="Street 42", city="Gotham City", zip_code="23422", country=de, phone="555-111111", email="*****@*****.**", ) self.address2 = Address.objects.create( firstname="Jane", lastname="Doe", company_name="Doe Ltd.", line1="Street 43", city="Smallville", zip_code="24432", country=de, phone="666-111111", email="*****@*****.**", ) self.username = '******' self.password = '******' new_user = User(username=self.username) new_user.set_password(self.password) new_user.save() self.customer = Customer.objects.create( user=new_user, selected_shipping_method=shipping_method, selected_payment_method=payment_method, selected_shipping_address=self.address1, selected_invoice_address=self.address2, )
def save_user_from_row(user_row): user = User() user.id = user_row[0] user.username = user_row[1] user.save()
def create_test_user(): user = User() user.save() return user
def create_usr(cls): User(username="******", password="******", is_active=True, is_staff=True).save() usr = User.objects.filter(username="******").first() return usr
"uid=john,ou=people,o=test": { "uid": ["john"], "objectClass": settings.AUTH_LDAP_USER_OBJECTCLASS, "cn": ["John Smith"], "gentooLocation": ["City3, Country3"], "gentooRoles": ["kernel, security"], "gentooACL": ["user.group", "retired.group"], }, "uid=matt,ou=people,o=test": { "objectClass": settings.AUTH_LDAP_USER_OBJECTCLASS, "gentooACL": ["user.group", "retired.group"], }, } # User objects USER_ALICE = User(username='******', password='******') # Queue objects QUEUEDUSER = Queue( username='******', password='******', email='*****@*****.**', first_name='queued_first_name', last_name='queued_last_name', ) # login form data LOGIN_ALICE = {'username': '******', 'password': '******'} LOGIN_BOB = {'username': '******', 'password': '******'} LOGIN_WRONG = {'username': '******', 'password': '******'}
def register(request): up = UserProfile.objects.filter(ip_address=get_ip) if up is None or 1: print("reached0") form = TeamForm(request.POST) if request.method == 'POST': if form.is_valid(): print(form) print("reached1") data = form.cleaned_data ### Patch for Issue 2 ### TeamProfile object created here. team = TeamProfile() team.teamname = data['teamname1'] team.idno1 = data['idno1'] try: t = TeamProfile.objects.get(pk=data['idno1']) resp = { 'status': 'error', 'msg': 'BITS ID 1 has already been used to create a Team! ' } return HttpResponse(json.dumps(resp), content_type="application/json", status=500) except Exception: team.save() ### Patch Ends u = User() u.username = data['teamname1'] u.set_password(data['password1']) try: u.save() except IntegrityError: print("reached2") resp = { 'status': 'error', 'msg': 'Team name already registered or other conflicting entries' } return HttpResponse(json.dumps(resp), content_type="application/json", status=500) up = UserProfile() up.user = u up.teamname = data['teamname1'] up.idno1 = data['idno1'] up.idno2 = data['idno2'] up.ip_address = get_ip(request) up.save() #return redirect('mainapp:login') r = {"status": "redirect", "url": "login"} print("reachedXXXX") return HttpResponse(json.dumps(r), content_type="application/json") else: error = json.loads(json.dumps(form.errors)) error1 = [] for e in error: d = e print("d", d) if (d in ["password1", "teamname1"]): d = d[:-1] error1.append(d) error1.append('-') error1.append((error[e])[0]) error1.append('<br/>') print(error1) resp = {'status': 'error', 'msg': ' '.join(error1)} print("reachedbbbbb") return HttpResponse(json.dumps(resp), content_type="application/json", status=500) else: form = TeamForm(request.POST) r = {"status": "redirect", "url": "login"} print("reached3") return HttpResponse(json.dumps(r), content_type="application/json", status=301) else: return HttpResponse( 'You have already registered once from this pc! Contact nearest ACM invigilator' )
class TestUserProfile(TestCase): f_postal_address = { 'address': "address1", 'city': "City", 'state': "State", 'zip_code': "12345", 'country': 'HU' } f_username = "******" f_birth_date = "1974-05-23" f_fixture = { 'birth_date': f_birth_date, 'postal_address': PostalAddress(**f_postal_address.copy()), 'delivery_address': PostalAddress(**f_postal_address.copy()), 'user': User(username=f_username), } def __copyFixture(self): """ Deep copy of the fixture objects """ f = self.f_fixture.copy() f['postal_address'] = PostalAddress(**self.f_postal_address.copy()) f['delivery_address'] = PostalAddress(**self.f_postal_address.copy()) return f # ------------------------------------------------------------------------- def testBlankBirthDate(self): """ Must raise ValidationError. """ f = self.__copyFixture() f['birth_date'] = '' with self.assertRaises(ValidationError): UserProfile(**f) # ------------------------------------------------------------------------- def testValidBirthDate(self): # Must not raise exception up = UserProfile(**self.f_fixture) dt = parser.parse(self.f_birth_date) self.assertEqual(dt.date(), up.birth_date) # ------------------------------------------------------------------------- def testTooYoungClient(self): f = self.__copyFixture() f['birth_date'] = "%d-01-01" % datetime.date.today().year # Must raise exception with self.assertRaises(ValidationError) as cm: up = UserProfile(**f) up.full_clean() err = cm.exception self.assertIn(_(u"You must be min"), err.messages[0]) # ------------------------------------------------------------------------- def testValidPostalAddresses(self): # Must not raise exception up = UserProfile(**self.f_fixture) self.assertEqual(self.f_postal_address['address'], up.postal_address.address) self.assertEqual(self.f_postal_address['address'], up.delivery_address.address) # ------------------------------------------------------------------------- def testInvalidPostalAddresses(self): for field in ['postal_address', 'delivery_address']: f = self.__copyFixture() f[field].address = "" # Must raise exception with self.assertRaises(ValidationError) as cm: up = UserProfile(**f) up.full_clean() err = cm.exception self.assertIn(_(u"This field cannot be blank"), err.messages[0])
def test_seen_defaults(self, filter): user = User(username='******') LastSeen.objects.when(user=user) filter.assert_called_with(user=user)