def test_queries_create_row_for_user_if_none_exits(self):
"""
Test to check that add_coins, remove_coins, and return_user_coins
create a row in UserCoins for the user if none exists
"""
new_user_1 = User(username="******",
email="*****@*****.**",
password="******")
new_user_1.save()
self.assertEqual(len(UserCoins.objects.filter(user=new_user_1)), 0)
add_coins(new_user_1, 100, 4)
self.assertEqual(len(UserCoins.objects.filter(user=new_user_1)), 1)
new_user_2 = User(username="******",
email="*****@*****.**",
password="******")
new_user_2.save()
self.assertEqual(len(UserCoins.objects.filter(user=new_user_2)), 0)
remove_coins(new_user_2, 200, 6)
self.assertEqual(len(UserCoins.objects.filter(user=new_user_2)), 1)
new_user_3 = User(username="******",
email="*****@*****.**",
password="******")
new_user_3.save()
self.assertEqual(len(UserCoins.objects.filter(user=new_user_3)), 0)
return_user_coins(new_user_3)
self.assertEqual(len(UserCoins.objects.filter(user=new_user_3)), 1)
def perform_create(self, serializer):
serializer.save()
sender = UserDetails(user=User(user_id=serializer.data['sender_id']))
recipient = UserDetails(user=User(
user_id=serializer.data['recipient_id']))
print(sender)
print(recipient)
try:
conversion = Conversation.objects.get(sender=sender,
recipient=recipient)
conversion.unseen_message += 1
conversion.save()
except Conversation.DoesNotExist as e:
conversion = Conversation(
sender=sender,
recipient=recipient,
last_message=serializer.data['message'],
)
conversion.save()
try:
conversion = Conversation.objects.get(sender=recipient,
recipient=sender)
conversion.unseen_message += 1
conversion.last_message = serializer.data['message']
conversion.save()
except Conversation.DoesNotExist as e:
conversation = Conversation(
sender=recipient,
recipient=sender,
last_message=serializer.data['message'],
unseen_message=1)
conversation.save()
def test_setup():
user1 = User(email="*****@*****.**", permission="ADMIN")
user1.set_password("123")
user1.save()
user2 = User(email="*****@*****.**", permission="MANAGER")
user2.set_password("123")
user2.save()
user3 = User(email="*****@*****.**", permission="USER")
user3.set_password("123")
user3.save()
meal1 = Meal.objects.create(user=user1,
description="Banana",
date="2020-01-01",
time="12:00:00",
calories=120)
meal2 = Meal.objects.create(user=user2,
description="Pasta",
date="2020-03-05",
time="18:20:00",
calories=400)
meal3 = Meal.objects.create(user=user3,
description="Cake",
date="2020-10-10",
time="22:50:00",
calories=380)
token1 = Token.objects.create(key="12345", user=user1)
token2 = Token.objects.create(key="56789", user=user2)
token3 = Token.objects.create(key="010101", user=user3)
def setUpTestData(cls):
user_1 = User(username="******")
user_1.save()
user_2 = User(username="******", email="*****@*****.**")
user_2.save()
user_3 = User(username="******", password="******", email="*****@*****.**")
user_3.save()
suggestion_1 = Suggestion(is_feature=True, user=user_1, title="Test Suggestion 1", details="Any old details",
delay_submission=False)
suggestion_1.save()
suggestion_2 = Suggestion(is_feature=True, user=user_2, title="Test Suggestion 2", details="Any old details",
delay_submission=True)
suggestion_2.save()
suggestion_3 = Suggestion.objects.create(is_feature=True, user=user_2, title="Test Suggestion 3",
details="Any old details", delay_submission=False)
suggestion_3.save()
user_1_usercoins = UserCoins(user=user_1, coins=100)
user_1_usercoins.save()
user_2_usercoins = UserCoins(user=user_2, coins=500)
user_2_usercoins.save()
user_3_usercoins = UserCoins(user=user_3, coins=0)
user_3_usercoins.save()
coins_purchase_1 = CoinsPurchase(name="coins purchase 1", coins_price=200)
coins_purchase_1.save()
coins_purchase_2 = CoinsPurchase(name="coins purchase 2", coins_price=500)
coins_purchase_2.save()
suggestion_coins_purchase = CoinsPurchase(name="Suggestion", coins_price=500)
suggestion_coins_purchase.save()
upvote_coins_purchase = CoinsPurchase(name="Upvote", coins_price=100)
upvote_coins_purchase.save()
promote_feature_purchase = CoinsPurchase(name="Feature Suggestion Promotion", coins_price=600)
promote_feature_purchase.save()
coins_store_item_500 = StoreItem(name="500 coins", price=0, delivery_required=False, is_coins=True,
coins_amount=500)
coins_store_item_500.save()
coins_store_item_200 = StoreItem(name="200 coins", price=2, delivery_required=False, is_coins=True,
coins_amount=200)
coins_store_item_200.save()
coins_store_item_1000 = StoreItem(name="1000 coins", price=10, delivery_required=False, is_coins=True,
coins_amount=1000)
coins_store_item_1000.save()
non_coins_store_item = StoreItem(name="not coins", price=5, delivery_required=True, is_coins=False)
non_coins_store_item.save()
non_coins_store_item_2 = StoreItem(name="not coins 2", price=10, delivery_required=True, is_coins=False)
non_coins_store_item_2.save()
non_coins_store_item_3 = StoreItem(name="not coins 3", price=99, delivery_required=True, is_coins=False)
non_coins_store_item_3.save()
order_1 = Order(user=user_1)
order_1.save()
order_2 = Order(user=user_2)
order_2.save()
order_3 = Order(user=user_3)
order_3.save()
def setUp(self):
self.orig_user = User(email='*****@*****.**')
self.user_list = List(owner=self.orig_user)
self.user_list.save()
self.second_user = User(email='*****@*****.**')
self.request = HttpRequest()
self.request.POST['shared_with'] = '*****@*****.**'
self.request.user = Mock()
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['message_list'] = UserMessage.objects.filter(Q(receiver=self.request.user,
sender=User(pk=self.kwargs.get('pk'))
)| Q(receiver=User(pk=self.kwargs.get('pk')),sender=self.request.user))
context['message_sender'] = self.request.user
context['message_receiver'] = User.objects.get(pk=self.kwargs.get('pk'))
return context
def authenticate(self):
self.john = User(username="******")
self.john.set_password("hunter2")
self.john.save()
self.alice = User(username="******")
self.alice.set_password("hunter2")
self.alice.save()
self.client_setup()
self.client.force_authenticate(user=self.john)
def create(self, validated_data):
"""
This method saves the new users info after the validation is done
Parameters:
-----------
validated_data: dic
It contains the same data as above method; but its validated at
this point.
Returns
--------
user: User type object
"""
user_type = validated_data['type']
user = User(username=validated_data['username'],type=validated_data\
['type'])
user.set_password(validated_data['password'])
#Saving the user would trigger a signal which then saves the same user
#to another model DonorProfile, FundRaiserProfile or MGOProfile, based
#on its type.
#CHANGES:This should be other way around and needs to be changed later.
user.save()
return user
def register(request):
if request.session.get('is_login'):
return HttpResponseRedirect(reverse('miunottingham:main_page'))
if request.method == "POST":
regform = RegisterForm(request.POST)
if regform.is_valid():
username = regform.cleaned_data['username']
password1 = regform.cleaned_data['password1']
password2 = regform.cleaned_data['password2']
email = regform.cleaned_data['email']
if User.objects.filter(username=username):
message = 'username already exists'
return render(request, 'accounts/register.html', locals())
else:
if User.objects.filter(email=email):
message = 'email address already exists'
return render(request, 'accounts/register.html', locals())
else:
if password1 != password2:
message = 'password does not match'
return render(request, 'accounts/register.html',
locals())
new_user = User()
new_user.username = username
# encrypt password
new_user.password = hash_code(password2)
new_user.email = email
new_user.has_confirmed = True
new_user.save()
return HttpResponseRedirect(reverse('accounts:login_test'))
regform = RegisterForm()
return render(request, 'accounts/register.html', locals())
def test_display_name(self):
"""Test that User.display_name uses first_name or username."""
bob = User(username='******')
self.assertEqual('bob', bob.display_name)
bob.first_name = 'Robert'
self.assertEqual('Robert', bob.display_name)
def safe_mutate(cls, root, info, **kwargs):
code = kwargs.pop('invitation_code', None)
host = None
if code:
try:
host = User.objects.get(invitation_code=code)
except User.DoesNotExist:
return cls.error(invitation_code=['کد نامعتبر است.'])
first_name = kwargs.get('first_name')
last_name = kwargs.get('last_name')
phone = kwargs.get('phone')
password = kwargs.get('password')
user = User(first_name=first_name,
last_name=last_name,
username=phone,
phone=phone,
password=password)
user.generate_code()
try:
user.full_clean()
except ValidationError as e:
e.error_dict.pop('username', None)
raise e
user.send_code_by_sms()
user.save()
if host:
Invitation(host, None).reward(user)
return cls(user=user)
def restore_object(self, attrs, instance=None):
if instance:
instance.username = attrs.get('username', instance.username)
instance.email = attrs.get('email', instance.email)
instance.mobile = attrs.get('mobile', instance.mobile)
return instance
return User(**attrs)
def create(self, validated_data):
password = validated_data.pop('password')
user = User(**validated_data)
user.username = validated_data.get('email')
user.set_password(password)
user.save()
return user
def student_create(request):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
major = Major.objects.get(name=body['major'])
level = Level.objects.get(level=body['level'])
modeOfEntry = ModeOfEntry.objects.get(name=body['modeOfEntry'])
dateBirth = body['dateBirth']
user = User()
user.username = body['username']
user.password = dateBirth
user.first_name = body['first_name']
user.last_name = body['last_name']
user.email = body['email']
user.type = '7'
user.sex = body['sex']
user.save()
student = Student()
student.user = user
student.major = major
student.level = level
student.modeOfEntry = modeOfEntry
student.status = '1'
student.dateBirth = dateBirth
student.save()
serial = StudentSerializer(student)
return JsonResponse(serial.data, safe=False, status=200)
def test_order_txn(self):
order = Order(full_name='Test',
phone_number='012345',
country='gb',
postcode='ab123')
order.save()
user = User(email='*****@*****.**', first_name='Test', last_name='Case')
user.save()
ticket = Ticket(requester=user, title='Title')
ticket.save()
transaction = OrderTransaction(order=order, ticket=ticket, cost=2.2)
transaction.save()
print('TestCheckoutModels: OrderTransaction - test_order_txn \n \
Expected: {0}, Actual: {1} \n \
Expected: {2}, Actual: {3} \n \
Expected: {4}, Actual: {5} \n \
Expected: {6}, Actual: {7} \n \
Expected: {8}, Actual: {9}'.format(
'Test', transaction.order.full_name, '012345',
transaction.order.phone_number, user, transaction.ticket.requester,
'Title', transaction.ticket.title, '2.2', transaction.cost))
self.assertEqual(transaction.order.full_name, 'Test')
self.assertEqual(transaction.order.phone_number, '012345')
self.assertEqual(transaction.ticket.requester, user)
self.assertEqual(transaction.ticket.title, 'Title')
self.assertEqual(transaction.cost, 2.2)
def create(self, *args, **kwargs):
serializer = self.serializer_class(data=self.request.data)
serializer.is_valid(raise_exception=True)
username = serializer.data.get('username')
phone = serializer.data.get('phone')
email = serializer.data.get('email')
dob = serializer.data.get('dob')
gender = serializer.data.get('gender')
image = serializer.validated_data.get('userImage')
user = User()
user.set_password(serializer.data.get('password'))
user.email = email
user.username = username
user.phone = phone
user.userImage = image
user.gender = gender
user.dob = dob
# ut.confirmation_email(email, user)
user.save()
token, created = Token.objects.get_or_create(user=user)
return Response(data={
'status': status.HTTP_200_OK,
'token': token.key
},
status=status.HTTP_200_OK)
def test_forum_comment(self):
user = User(email='*****@*****.**', first_name='Test', last_name='Case')
user.save()
topic = ForumTopic(topic_title='Test')
topic.save()
comment = ForumComment(forum_topic=topic,
author=user,
comment='my comment')
comment.save()
reply = ForumCommentReply(forum_comment=comment,
author=user,
comment='my reply')
reply.save()
print('TestForumModels: ForumComment - test_forum_comment \n \
Expected: {0}, Actual: {1} \n \
Expected: {2}, Actual: {3} \n \
Expected: {4}, Actual: {5} \n \
Expected: {6}, Actual: {7}'.format(
'Test', comment.forum_topic.topic_title, 'my comment',
comment.comment, '*****@*****.**', comment.author.email, 'my reply',
reply.comment))
self.assertEqual(comment.forum_topic.topic_title, 'Test')
self.assertEqual(comment.comment, 'my comment')
self.assertEqual(comment.author.email, '*****@*****.**')
self.assertEqual(reply.comment, 'my reply')
def post(self, request):
username_ = request.POST["username"]
email_ = request.POST["email"]
password_ = request.POST["password"]
password2_ = request.POST["confirmpassword"]
if password2_ != password_:
return JsonResponse({
"status": "fail!",
"message": "password not equal"
})
same = User.objects.filter(username=username_)
if same:
return JsonResponse({
"status": "fail!",
"message": "username repeated!"
})
new_user = User(username=username_, password=password_, email=email_)
new_user.image = request.FILES['image']
new_user.bio = request.POST['bio']
new_user.save()
token = Token.objects.create(user=new_user)
auth.login(request, new_user)
return JsonResponse({
"status": "True",
"message": f"welcome {username_} dear!",
'token': f'Token {token.key}'
})
def authenticate(self, token):
response_profile = requests.get(
'https://graph.facebook.com/me/',
params={
'access_token': token,
}
)
facebook_profile = response_profile.json()
if 'error' in facebook_profile:
return None
try:
user = User.objects.get(facebook_id=facebook_profile.get('id'))
except User.DoesNotExist:
user = User(facebook_id=facebook_profile.get('id'))
if facebook_profile.get('id') in settings.FACEBOOK_ADMINS:
user.is_staff = True
user.is_superuser = True
user.username = facebook_profile.get('id')
user.set_unusable_password()
user.facebook_access_token = token
user.email = facebook_profile.get('email', '')
user.first_name = facebook_profile.get('first_name')
user.last_name = facebook_profile.get('last_name')
user.save()
return user
def register(request):
if request.method == 'POST':
user_name = request.POST['UserName']
email = request.POST['Email']
Image = request.POST['Image']
password = request.POST['Password']
reenterpassword = request.POST['Reenter password']
if password == reenterpassword:
if User.objects.filter(user=user_name).exists():
messages.info(request, "user taken")
return redirect('accounts:register')
elif User.objects.filter(email=email).exists():
messages.info(request, "email taken")
return redirect('accounts:register')
else:
user = User(user=user_name, email=email, password=password)
user.save()
messages.info(request, 'user created')
else:
messages.info(request, "Password Incorrect")
return redirect('accounts:register')
return redirect(
'/') #here URL is same but by method identify GET or Post
else:
return render(request, 'accounts/signup.html')
def create(self, validated_data):
email = validated_data['email']
password = validated_data['password2']
first_name = validated_data['first_name']
last_name = validated_data['last_name']
user_type = validated_data['user_type']
user_obj = User(
email = email,
is_active = True,
first_name = first_name,
last_name=last_name,
user_type=user_type
)
user_obj.set_password(password)
user_obj.save()
if int(user_obj.user_type) == 3:
account = stripe.Account.create(
type='custom',
country='US'
)
event_profile_obj = EventProfile(
user=user_obj,
account_id = account.id
)
event_profile_obj.save()
return validated_data
def create(self, validated_data):
user_obj = User(name=validated_data.get('name'),
age=validated_data.get('age'),
image=validated_data.get('image'))
user_obj.set_password(validated_data.get('password'))
user_obj.save()
return user_obj
def test_login_success(client):
url = reverse('login')
url_check = reverse('my-profile')
# create user
password = '******'
email = '*****@*****.**'
user = User(email=email, username=email)
user.set_password(password)
user.save()
# 1 test that client does not have access to url_check resourse
response = client.get(url_check)
assert response.status_code == 302
# 2
payload = {
'username': email,
'password': password,
}
response = client.post(url, data=payload)
assert response.status_code == 302
# 3
response = client.get(url_check)
assert response.status_code == 200
def post(self, request, *args, **kwargs):
form = SignupForm(data=request.POST or None)
response_data = {}
if form.is_valid():
user_name = request.POST['user_name']
password = request.POST['password']
password_confirm = request.POST['password_confirm']
email = request.POST['email']
if password_confirm == password:
new_user = User(user_name=user_name, email=email)
new_user.set_password(password)
new_user.save()
# print('user_id',new_user.id)
response_data['success'] = 'yes'
response_data['success_msg'] = 'Successfully signed up'
login(request, new_user)
# return redirect('/home/')
else:
# print('password_confirm !== password')
response_data['success'] = 'no'
response_data['success_msg'] = 'password dont match'
else:
# print('form is not valid',form.errors)
response_data['success'] = 'no'
response_data['success_msg'] = 'form not valid'
return JsonResponse(response_data)
def test_user_string_representation(self):
user = User(email='*****@*****.**',
name='Someone',
password='******')
user.save()
self.assertEqual(str(user), user.email)
def post(self, request):
"""User registration view."""
email = request.data['email']
#email = User.normalize_email(request.data['email'])
if not email_is_valid(email):
return Response("Please use a different email address provider.",
status=status.HTTP_200_OK)
if User.objects.filter(email=email).exists():
return Response(
"Email already in use, please use a different email address.",
status=status.HTTP_200_OK)
now = timezone.now()
user = User(email=email,
first_name=request.data['first_name'],
last_name=request.data['last_name'],
is_active=True,
last_login=now,
date_joined=now)
user.set_password(request.data['password'])
user.save()
return Response("SUCCESS", status=status.HTTP_200_OK)
def post(self, request):
username = request.POST.get("username")
password = request.POST.get("password")
result = login_authenticate(username, password)
if result['status'] == 0:
if User.objects.filter(username=username).exists():
user = User.objects.get(username=username)
else:
user = User()
# 开启LDAP的认证通过后更新用户密码
if settings.ENABLE_LDAP:
if user.password != make_password(password):
user.password = make_password(password)
user.password2 = cryptor.encrypt(password)
user.save()
try:
# 添加到默认组，默认组设置最小权限
user = User.objects.get(username=username)
group = Group.objects.get(id=1)
user.groups.add(group)
except Exception:
print('无id=1的权限组，无法默认添加')
# 调用了django内置登录方法，防止管理后台二次登录
login(request, user)
else:
pass
return JsonResponse(result)
def create(self, validated_data):
password = validated_data.pop("password")
print(validated_data)
user = User(**validated_data)
user.set_password(password)
user.save()
return user
def test_can_increase_upvote_size(self):
"""
Test to check that add_suggestion/comment_upvote_to_database
increases the length of the upvote table by 1
"""
original_update_table = Upvote.objects.all()
original_update_table_length = len(original_update_table)
new_user = User(username="******",
email="*****@*****.**",
password="******")
new_user.save()
suggestions = Suggestion.objects.all()
suggestion = choice(suggestions)
add_suggestion_upvote_to_database(new_user, suggestion)
upvote_table_after_suggestion_upvote = Upvote.objects.all()
upvote_table_after_suggestion_upvote_length = len(
upvote_table_after_suggestion_upvote)
self.assertEqual((original_update_table_length + 1),
upvote_table_after_suggestion_upvote_length)
comments = Comment.objects.all()
comment = choice(comments)
add_comment_upvote_to_database(new_user, comment)
upvote_table_after_comment_upvote = Upvote.objects.all()
upvote_table_after_comment_upvote_length = len(
upvote_table_after_comment_upvote)
self.assertEqual((upvote_table_after_suggestion_upvote_length + 1),
upvote_table_after_comment_upvote_length)
def create_user(request):
if not request.method == 'POST':
return HttpResponseNotAllowed(['POST'])
post_params = json.loads(request.body)
form = UserRegistrationForm(data=post_params)
if form.is_valid():
user = User()
user.email = form.cleaned_data.get('email')
user.set_password(form.cleaned_data.get('password'))
with transaction.atomic():
user.save()
token = Token.create_token()
user.token_set.add(token)
logger.info("New user created. Email: %s", user.email)
user_dict = user.to_dict()
user_dict['access_token'] = token.token
data = json.dumps(user_dict)
return HttpResponse(data)
else:
logger.error("Invalid form to create new user. Errors: %s",
form.errors)
data = json.dumps(form.errors)
return HttpResponseBadRequest(data)
