def test_assess_character_user_as_main(self):
user = User(main_character_id=self.char.id)
user.save()
logger.debug("-----------------------------------------")
logger.debug(" test_assess_character_user_as_main")
logger.debug("-----------------------------------------")
assess_character_owner(self.char)
self.assertEqual(self.char.user, user)
def test_assess_character_user_with_bad_api(self):
logger.debug("-----------------------------------------")
logger.debug(" test_assess_character_user_with_bad_api")
logger.debug("-----------------------------------------")
self.api.is_valid=False
user = User(main_character_id=999999)
user.save()
self.api.owner = user
self.api.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def test_assess_character_user_with_bad_api(self):
logger.debug("-----------------------------------------")
logger.debug(" test_assess_character_user_with_bad_api")
logger.debug("-----------------------------------------")
self.api.is_valid = False
user = User(main_character_id=999999)
user.save()
self.api.owner = user
self.api.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def test_assess_character_user_change_as_main(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_as_main")
logger.debug("-----------------------------------------")
main_user = User(main_character_id=self.char.id)
main_user.save()
other_user = User(main_character_id=9999999)
other_user.save()
self.char.user = other_user
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, main_user)
def test_assess_character_user_change_as_main(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_as_main")
logger.debug("-----------------------------------------")
main_user = User(main_character_id=self.char.id)
main_user.save()
other_user = User(main_character_id=9999999)
other_user.save()
self.char.user = other_user
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, main_user)
def test_assess_character_user_with_good_api(self):
logger.debug("-----------------------------------------")
logger.debug(" test_assess_character_user_with_good_api")
logger.debug("-----------------------------------------")
self.api.is_valid = True
user = User(main_character_id=999999)
user.save()
self.api.owner = user
self.api.save()
self.api.characters.add(self.char)
assess_character_owner(self.char)
self.assertEqual(self.char.user, user)
def test_assess_character_user_with_good_api(self):
logger.debug("-----------------------------------------")
logger.debug(" test_assess_character_user_with_good_api")
logger.debug("-----------------------------------------")
self.api.is_valid=True
user = User(main_character_id=999999)
user.save()
self.api.owner = user
self.api.save()
self.api.characters.add(self.char)
assess_character_owner(self.char)
self.assertEqual(self.char.user, user)
def setUp(self):
self.client = APIClient()
self.token = None
mods.mock_query(self.client)
user_noadmin = User(email='*****@*****.**')
user_noadmin.set_password('qwerty')
user_noadmin.save()
user_admin = User(email='*****@*****.**', is_staff=True)
user_admin.set_password('qwerty')
user_admin.save()
def create(self, validated_data):
"""
Create and return user instance, given validate data
"""
user = User()
user.email = validated_data.get('email')
user.set_password(validated_data.get('password'))
user.phone_number = validated_data.get('phone_number')
user.username = validated_data.get('username')
user.is_active = False
user.save()
return user
class Login(BaseView, PhoneMixin):
def get_sms_code(self, request):
sms_code = request.POST.get('key')
user_sms_code = redis.get('nedviga_user_sms_{}'.format(self.phone))
if user_sms_code:
if int(user_sms_code) == int(sms_code):
if not User.objects.filter(phone=self.phone):
self.user = User()
self.user.phone = self.phone
self.user.set_password(DEFAULT_PASSWORD)
self.user.save()
else:
return self.render_internal_error('Invalid sms-code')
else:
return self.render_internal_error('Sms-code expired')
def post(self, request):
"""
:param request:
:param phone: номер телефона
:param sms_code: sms код проверки
:return:
Авторизует пользователя по номеру телефона и sms-коду
Варианты ошибок:
'User not registered' - пользователь с таким телефоном не зарегистрирован
'User is blocked' - пользователь заблокирован
'Invalid sms-code' - неверный sms-код авторизации
"""
result = self.get_phone(request)
if result:
return result
result = self.get_user(self.phone, False)
if result:
return result
result = self.get_sms_code(request)
if result:
return result
# еще раз вытаскиваем юзера, чтобы django его авторизировала, просто User передать нельзя
self.user = authenticate(phone=self.phone, password=DEFAULT_PASSWORD)
# удаляем все другие сессии этого пользователя, чтобы был залогинен всегда с одного устройства
my_old_sessions = Session.objects.all()
for row in my_old_sessions:
if row.get_decoded().get("_auth_user_id") == self.user.id:
row.delete()
# теперь спокойно логиним
login(request, self.user)
return self.render_json_response(data={'sessionid': request.session.session_key})
def generate_batch_wishes(self, n_propositions=10, n_students=168):
""" Creates a campaign with propositions, users, and 4 categories in which the students are distributed with
the probabilities 0.8, 0.1, 0.06, 0.04 """
np.random.seed(0)
campaign = Campaign(name="Batch campaign", manager_id="17bocquet")
campaign.save()
propositions = []
for i in range(n_propositions):
proposition = Proposition(
campaign_id=campaign.id,
name="proposition_{}".format(i),
# number_of_places=int(ceil(n_students / n_propositions)), TODO: remove this or restore it in the model.
)
proposition.save()
propositions.append(proposition)
categories = []
for name in ["category_{}".format(i) for i in range(4)]:
category = Category(name=name, campaign=campaign)
category.save()
categories.append(category)
user_campaigns = []
for i in range(n_students):
user = User(
id="19user{}".format(i),
first_name="firstname {}".format(i),
last_name="lastname {}".format(i),
year_of_entry=2019,
email="email{}@mpt.fr".format(i),
)
user.save()
category = np.random.choice(categories,
1,
p=[0.8, 0.1, 0.06, 0.04])[0]
uc = UserCampaign(user=user, campaign=campaign, category=category)
uc.save()
user_campaigns.append(uc)
if i < 157: # simulate that a few users didn't answer the form
for (rank, proposition) in enumerate(
np.random.permutation(propositions)):
wish = Wish(user_campaign=uc,
proposition=proposition,
rank=rank)
wish.save()
return campaign, propositions, categories, user_campaigns
def _get_client_with_user(self, username, with_token=False):
user = User(**{"username": username, "phone_number": "+77772537792", "password": "******"})
user.save()
client = APIClient()
if with_token:
token = Token.objects.create(user=user)
client.credentials(HTTP_AUTHORIZATION="Token " + token.key)
client.user = user
return client
def test_assess_character_user_on_last_api_invalid(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_on_last_api_invalid")
logger.debug("-----------------------------------------")
self.api.is_valid=False
self.api.characters.add(self.char)
user = User(main_character_id=99999999)
user.save()
self.api.owner = user
self.char.user = user
self.api.save()
self.char.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def test_assess_character_user_on_last_api_invalid(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_on_last_api_invalid")
logger.debug("-----------------------------------------")
self.api.is_valid = False
self.api.characters.add(self.char)
user = User(main_character_id=99999999)
user.save()
self.api.owner = user
self.char.user = user
self.api.save()
self.char.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def test_assess_character_user_on_api_invalid_as_main(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_on_api_invalid_as_main")
logger.debug("-----------------------------------------")
self.api.is_valid = False
self.api.characters.add(self.char)
user = User(main_character_id=self.char.id)
user.save()
self.api.owner = user
self.char.user = user
self.api.save()
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, user)
def test_add_voters_sex_fail_invalid_voting_id(self):
census_before = len(Census.objects.all().values_list('voting_id',
flat=True))
user1 = User(email='*****@*****.**',
password='******',
city='Madrid',
sex='M')
user1.save()
user2 = User(email='*****@*****.**',
password='******',
city="Lugo",
sex="M")
user2.save()
user3 = User(email='*****@*****.**',
password='******',
city="Palencia",
sex="W")
user3.save()
admin = User(email='*****@*****.**', password='******')
admin.is_staff = True
admin.save()
voting_id = "88"
self.client.force_login(admin)
response2 = self.client.get(
'/census/addAllBySex/?voting_id={}&sex={}'.format(voting_id, 'M'))
census_after = len(Census.objects.all().values_list('voting_id',
flat=True))
self.assertEqual(response2.status_code, 302)
self.assertTrue(census_before == census_after)
def test_assess_character_user_on_api_invalid_as_main(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_on_api_invalid_as_main")
logger.debug("-----------------------------------------")
self.api.is_valid=False
self.api.characters.add(self.char)
user = User(main_character_id=self.char.id)
user.save()
self.api.owner = user
self.char.user = user
self.api.save()
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, user)
def create_participants(self, meeting, participants, user):
for participant in participants:
try:
user = User.objects.get(email=participant)
meetingParticipant = MeetingParticipant(meeting=meeting,
participant=user)
meetingParticipant.save()
except:
user = User(username=participant,
email=participant,
password='')
user.save()
meetingParticipant = MeetingParticipant(meeting=meeting,
participant=user)
meetingParticipant.save()
def create_user(cls, username: str, email: str, first_name: str,
last_name: str, password: str) -> User:
if User.objects.filter(Q(username=username) | Q(email=email)).exists():
raise UserAlreadyExistsException
user = User(
username=username,
email=email,
first_name=first_name,
last_name=last_name,
)
user.set_password(password)
user.save()
return user
def create(self, validated_data):
user = User(
email=validated_data['email'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name']
)
user.set_password(validated_data['password'])
user.is_active = True
hunter = PyHunter(settings.HUNTER_API_KEY)
hunter.email_verifier(user.email)
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(hunter.email_verifier(user.email))
user.save()
return user
def create(self, validated_data):
if (User.objects.filter(
username=validated_data.get('email')).exists()):
return {'status': 'failed', 'message': 'Email already registered'}
profile_data = validated_data.pop('UserProfile')
password = validated_data.pop('password')
user = User(**validated_data)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user, **profile_data)
Dashboard.objects.create(user=user)
return user
def test_add_voters_registered(self):
census_before = len(Census.objects.all().values_list('voting_id',
flat=True))
admin = User(email='*****@*****.**', password='******')
admin.is_staff = True
admin.save()
voting_id = "40"
self.client.force_login(admin)
response2 = self.client.get(
'/census/addAllRegistered/?voting_id={}'.format(voting_id))
census_after = len(Census.objects.all().values_list('voting_id',
flat=True))
self.assertEqual(response2.status_code, 302)
self.assertTrue(census_before < census_after)
def git_check(request):
request_code = request.GET.get('code')
oauth_git = OAuthGitHub(settings.GITHUB_APP_ID, settings.GITHUB_KEY,
settings.GITHUB_CALLBACK_URL)
try:
access_token = oauth_git.get_access_token(
request_code) # 获取access token
time.sleep(0.1) # 此处需要休息一下，避免发送urlopen的10060错误
except Exception as e: # 获取令牌失败，反馈失败信息
print(e)
return redirect('home')
print('access_token: ', access_token)
infos = oauth_git.get_user_info() # 获取用户信息
nickname = infos.get('login', '')
image_url = infos.get('avatar_url', '')
open_id = str(oauth_git.openid)
signature = infos.get('bio', '')
if not signature:
signature = "无个性签名"
githubs = OAuth.objects.filter(openid=open_id,
type='1') # 查询是否该第三方账户已绑定本网站账号
if githubs: # 若已绑定，直接登录
auth_login(request, githubs[0].user)
return redirect('home')
else: # 否则尝试获取用户邮箱用于绑定账号
try:
email = oauth_git.get_email()
except Exception as e: # 若获取失败，则跳转到绑定用户界面，让用户手动输入邮箱
print(e)
return redirect('home')
users = User.objects.filter(email=email) # 若获取到邮箱，则查询是否存在本站用户
if users: # 若存在，则直接绑定
user = users[0]
else: # 若不存在，则新建本站用户
while User.objects.filter(username=nickname): # 防止用户名重复
nickname = nickname + '*'
user = User(username=nickname, email=email)
pwd = str(uuid.uuid1()) # 随机设置用户密码
user.set_password(pwd)
user.save()
oauth = OAuth(user=user, openid=open_id, type='1')
oauth.save() # 保存后登陆
auth_login(request, user)
return redirect('home')
def test_errors(self):
u = User(email=mock_user2["email"], username=mock_user2["username"])
u.set_password(mock_user2["password"])
u.save()
response = self.client.post('/api/v1/auth/login/',
data=json.dumps({
"email":
mock_user2["email"],
"password":
mock_user2["password"]
}),
content_type="application/json")
self.assertEquals(response.status_code, 200)
response = self.client.delete('/api/v1/posts/%s/' % self.post["id"])
self.assertEquals(response.status_code, 403)
response = self.client.put('/api/v1/posts/%s/' % self.post["id"],
data=json.dumps({"content": "new content"}),
content_type="application/json")
self.assertEquals(response.status_code, 403)
def signup(request):
response_dict = json.loads(request.body)
email = response_dict['email']
password = response_dict['password']
hashed_password = make_password(password)
if is_email_not_valid(email) or is_password_not_valid(password):
message = 'Either email or password are incorrect.'
response = JsonResponse({'status': False, 'message': message})
response.status_code = 400
return response
u = User(email=email, password=hashed_password)
u.save()
token = jwt.encode({'user_id': u.id}, 'secret', algorithm='HS256')
data = {'token': token.decode('utf-8'), 'user_id': u.id}
return JsonResponse(data)
def form_valid(self,form):
username=form.cleaned_data.get('username')
first_name =form.cleaned_data.get('first_name')
last_name=form.cleaned_data.get('last_name')
password=form.cleaned_data.get('password')
email=form.cleaned_data.get('email')
address=form.cleaned_data.get('address')
date_of_birth=form.cleaned_data.get('date_of_birth')
user=User(username=username, first_name=first_name, last_name=last_name, email=email, address=address, date_of_birth=date_of_birth)
if User.objects.filter(username=user.username).exists():
#check whether user is not already exist
messages.error(self.request,'Username already exist')
return redirect('forum:sign-up')
user.set_password(password)
user.save()
messages.success(self.request, 'User Register Successfully')
return redirect(self.success_url)
def post(self, request):
form = RegisterForm(request.POST)
# check whether it's valid:
if form.is_valid():
data = form.cleaned_data
user = User()
user.email = data['email']
user.set_password(data['password1'])
user.first_name = data['first_name']
user.last_name = data['last_name']
user.save()
group = Group.objects.get(name='Users')
user.groups.add(group)
user.save()
return redirect("index")
return render_to_response(self.template_name, {'form': form}, context_instance=RequestContext(request))
def test_assess_character_user_change_on_bad_api(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_on_bad_api")
logger.debug("-----------------------------------------")
good_user = User(main_character_id=8888888)
good_user.save()
bad_user = User(main_character_id=9999999)
bad_user.save()
self.api.characters.add(self.char)
self.api.owner = good_user
self.api.is_valid=True
bad_api = EVEApiKeyPair(id=99999999, vcode="test api please ignore", owner=bad_user)
bad_api.is_valid=False
self.char.user = bad_user
self.api.save()
bad_api.save()
bad_api.characters.add(self.char)
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, good_user)
def test_assess_character_user_change_on_new_api(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_on_new_api")
logger.debug("-----------------------------------------")
first_user = User(main_character_id=8888888)
first_user.save()
new_user = User(main_character_id=9999999)
new_user.save()
self.api.characters.add(self.char)
self.api.owner = first_user
self.api.is_valid=True
self.api.save()
other_api = EVEApiKeyPair(id=9999999, vcode="test api please ignore", owner=new_user)
other_api.is_valid=True
other_api.save()
other_api.characters.add(self.char)
self.char.user = first_user
self.char.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def test_add_voters_age(self):
census_before = len(Census.objects.all().values_list('voting_id',
flat=True))
admin = User(email='*****@*****.**', password='******')
admin.is_staff = True
admin.save()
user1 = User(email='*****@*****.**',
password='******',
city='sevilla',
sex='M',
birthdate=date(year=2000, month=1, day=1))
user1.save()
user2 = User(email='*****@*****.**',
password='******',
city='sevilla',
sex='M',
birthdate=date(year=1992, month=1, day=1))
user2.save()
voting_id = "40"
self.client.force_login(admin)
response2 = self.client.get(
'/census/addAllByAge/?voting_id={}&younger={}&older={}'.format(
voting_id, 18, 28))
census_after = len(Census.objects.all().values_list('voting_id',
flat=True))
self.assertEqual(response2.status_code, 302)
self.assertTrue(census_after - census_before == 2)
def test_assess_character_user_change_on_bad_api(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_on_bad_api")
logger.debug("-----------------------------------------")
good_user = User(main_character_id=8888888)
good_user.save()
bad_user = User(main_character_id=9999999)
bad_user.save()
self.api.characters.add(self.char)
self.api.owner = good_user
self.api.is_valid = True
bad_api = EVEApiKeyPair(id=99999999,
vcode="test api please ignore",
owner=bad_user)
bad_api.is_valid = False
self.char.user = bad_user
self.api.save()
bad_api.save()
bad_api.characters.add(self.char)
self.char.save()
assess_character_owner(self.char)
self.assertEqual(self.char.user, good_user)
def test_assess_character_user_change_on_new_api(self):
logger.debug("-----------------------------------------")
logger.debug("test_assess_character_user_change_on_new_api")
logger.debug("-----------------------------------------")
first_user = User(main_character_id=8888888)
first_user.save()
new_user = User(main_character_id=9999999)
new_user.save()
self.api.characters.add(self.char)
self.api.owner = first_user
self.api.is_valid = True
self.api.save()
other_api = EVEApiKeyPair(id=9999999,
vcode="test api please ignore",
owner=new_user)
other_api.is_valid = True
other_api.save()
other_api.characters.add(self.char)
self.char.user = first_user
self.char.save()
assess_character_owner(self.char)
self.assertFalse(self.char.user)
def mutate(cls, root, info, **kwargs):
if not isinstance(info.context.user, User):
raise UnauthorizedException()
if not info.context.user.is_superuser:
raise ForbiddenException()
user = User()
create_kwargs = dict(kwargs)
del create_kwargs['password']
for key, value in create_kwargs.items():
setattr(user, key, value)
user.set_password(kwargs.get('password'))
user.is_staff = user.is_superuser
user.save()
return CreateUser(user=user)
def setUp(self):
self.product_source = Product(
name="Coca-Cola Classic",
code="5449000000996",
nutriscore="e",
url="https://fr.openfoodfacts.org/produit/5449000000996/coca-cola",
popularity=2802)
self.product_source.save()
self.product_target = Product(
name="Coca-Cola Zero",
code="5449000133335",
nutriscore="b",
url=
"https://fr.openfoodfacts.org/produit/5449000133335/coca-cola-zero",
popularity=181)
self.product_target.save()
test_user = User(email='*****@*****.**',
password=None,
first_name='essai',
last_name='register')
test_user.set_password('blabla75')
test_user.save()
self.target_user = User.objects.get(email='*****@*****.**')
def handle(self, *args, **options):
pwd = os.path.dirname(__file__)
parsed_data = wxr_parser.parse(pwd + '/wordpress.xml')
site = Site.objects.get(pk=settings.SITE_ID)
for post in parsed_data['posts']:
if post['status'] and post['title'] and post['slug']:
username = post['creator']
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.save()
post_obj = Post(author=user,
slug=post['slug'],
title=post['title'],
text=post['content'],
published_date=post['pub_date'])
post_obj.save()
# Redirect.objects.create(
# site=site,
# old_path='/blog/' + post['slug'] + '/',
# new_path='/@' + username + '/' + post_obj.slug + '/')
self.stdout.write(self.style.SUCCESS('ok'))
def test_add_voters_registered_fail_votingId(self):
census_before = len(Census.objects.all().values_list('voting_id',
flat=True))
user1 = User(email='*****@*****.**',
password='******',
city='sevilla',
sex='M')
user1.save()
admin = User(email='*****@*****.**', password='******')
admin.is_staff = True
admin.save()
self.client.force_login(admin)
voting_id = "90"
response2 = self.client.get(
'/census/addAllRegistered/?voting_id={}'.format(voting_id))
census_after = len(Census.objects.all().values_list('voting_id',
flat=True))
self.assertEqual(response2.status_code, 302)
self.assertTrue(census_before == census_after)
def post(self, request):
data = google_request_oauth2(request.data.get("token"))
if 'error' in data:
content = {
'message':
'wrong google token / this google token is already expired.'
}
return Response(data=content, status=status.HTTP_401_UNAUTHORIZED)
# create user if not exist
try:
user = User.objects.get(email=data.get('email'))
except User.DoesNotExist:
user = User()
user.username = data.get('email')
# provider random default password
user.password = make_password(
CustomUserManager().make_random_password())
user.email = data.get('email')
user.first_name = data.get('given_name')
user.last_name = data.get('family_name')
user.is_google = True
user.save()
token = RefreshToken.for_user(
user) # generate token without username & password
response = {}
user_serializer = UserSerializer(user)
response['user'] = user_serializer.data
response['access'] = str(token.access_token)
response['refresh'] = str(token)
response['token_expire_at'] = token.access_token.get('exp')
response['refresh_token_expire_at'] = token.get('exp')
return Response(response)
def test_add_new_voters(self):
user1 = User(email='*****@*****.**',
id='60',
password='******',
city='sevilla',
sex='M')
user1.save()
user2 = User(email='*****@*****.**',
id='61',
password='******',
city="Murcia",
sex="N")
user2.save()
data = {'voting_id': 40, 'voters': [60, 61]}
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 201)
self.client.force_login(user1)
user3 = User(email='*****@*****.**',
id='62',
password='******',
city="Zaragoza",
sex="W")
user3.save()
data = {'voting_id': 40, 'voters': [62]}
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 201)
user4 = User(email='*****@*****.**',
id='63',
password='******',
city="Tarragona",
sex="W")
user4.save()
self.login()
data = {'voting_id': 40, 'voters': [63]}
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 201)
def test_add_voters_city_fail_not_staff(self):
census_before = len(Census.objects.all().values_list('voting_id',
flat=True))
user1 = User(email='*****@*****.**',
password='******',
city='sevilla',
sex='M')
user1.save()
user2 = User(email='*****@*****.**',
password='******',
city="Murcia",
sex="N")
user2.save()
user3 = User(email='*****@*****.**',
password='******',
city="Albacete",
sex="W")
user3.save()
admin = User(email='*****@*****.**', password='******')
admin.is_staff = False
admin.save()
voting_id = "40"
self.client.force_login(admin)
response2 = self.client.get(
'/census/addAllInCity/?voting_id={}&city={}'.format(
voting_id, 'Sevilla'))
census_after = len(Census.objects.all().values_list('voting_id',
flat=True))
self.assertEqual(response2.status_code, 302)
self.assertTrue(census_before == census_after)
def save_user(email, name_surname, password):
user = User(email=email, name_surname= name_surname, password=password)
user.save()
return user
class VersionAdminTest(TestCase):
urls = "reversion.tests"
def setUp(self):
self.user = User(
username = "******",
is_staff = True,
is_superuser = True,
)
self.user.set_password("bar")
self.user.save()
self.client.login(username="******", password="******")
def testAutoRegisterWorks(self):
self.assertTrue(reversion.is_registered(ChildTestAdminModel))
self.assertTrue(reversion.is_registered(ParentTestAdminModel))
def testRevisionSavedOnPost(self):
self.assertEqual(ChildTestAdminModel.objects.count(), 0)
# Create an instance via the admin.
response = self.client.post("/admin/auth/childtestadminmodel/add/", {
"parent_name": "parent instance1 version1",
"child_name": "child instance1 version1",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
obj_pk = response["Location"].split("/")[-2]
obj = ChildTestAdminModel.objects.get(id=obj_pk)
# Check that a version is created.
versions = reversion.get_for_object(obj)
self.assertEqual(versions.count(), 1)
self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version1")
self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version1")
# Save a new version.
response = self.client.post("/admin/auth/childtestadminmodel/%s/" % obj_pk, {
"parent_name": "parent instance1 version2",
"child_name": "child instance1 version2",
"_continue": 1,
})
self.assertEqual(response.status_code, 302)
# Check that a version is created.
versions = reversion.get_for_object(obj)
self.assertEqual(versions.count(), 2)
self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version2")
self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version2")
# Check that the versions can be listed.
response = self.client.get("/admin/auth/childtestadminmodel/%s/history/" % obj_pk)
self.assertContains(response, "child instance1 version2")
self.assertContains(response, "child instance1 version1")
# Check that a version can be rolled back.
response = self.client.post("/admin/auth/childtestadminmodel/%s/history/%s/" % (obj_pk, versions[1].pk), {
"parent_name": "parent instance1 version3",
"child_name": "child instance1 version3",
})
self.assertEqual(response.status_code, 302)
# Check that a version is created.
versions = reversion.get_for_object(obj)
self.assertEqual(versions.count(), 3)
self.assertEqual(versions[0].field_dict["parent_name"], "parent instance1 version3")
self.assertEqual(versions[0].field_dict["child_name"], "child instance1 version3")
# Check that a deleted version can be viewed.
obj.delete()
response = self.client.get("/admin/auth/childtestadminmodel/recover/")
self.assertContains(response, "child instance1 version3")
# Check that a deleted version can be recovered.
response = self.client.post("/admin/auth/childtestadminmodel/recover/%s/" % versions[0].pk, {
"parent_name": "parent instance1 version4",
"child_name": "child instance1 version4",
})
obj = ChildTestAdminModel.objects.get(id=obj_pk)
def tearDown(self):
self.client.logout()
self.user.delete()
del self.user
ChildTestAdminModel.objects.all().delete()
def setUpClassData(cls):
u = User(email=mock_user1["email"], username=mock_user1["username"])
u.set_password(mock_user1["password"])
u.save()
