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)
