def test_user(self):
client = APIClient()
response = client.get('/user/profile/' + str(self.user_uuid),
format='json')
print(response.json())
print(self.user_uuid)
assert response.json()['user_id'] == str(self.user_uuid)
def delete_model(self, request: HttpRequest, obj) -> None:
response = requests.post(config.url + 'forget-person/',
json={'id': obj.id})
print(response.json())
if response.json()['is_success']:
# obj.user.active = False
# obj.user.save()
obj.user.delete()
return super().delete_model(request, obj)
def test_get_one_user_member(self):
"""测试 查询用户附带队员信息"""
url = reverse('user-member-detail', args=[self.m2.user.email])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertFalse('member' in response.json())
self.login('m1')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue('member' in response.json())
def test_search_hotels_view_returns_hotels_of_multiple_matching_cities(
self):
chosen_cities = {'city': 'b'}
response = self.client.get(reverse('search_hotels'), chosen_cities)
cities = [city['city'] for city in response.json()['data']]
hotels = [
hotel for city in response.json()['data']
for hotel in city['hotels']
]
self.assertEquals(response.status_code, 200)
self.assertEquals(cities, ['Berlin', 'Barcelona'])
self.assertEquals(hotels, ['Berlin Hotel', 'Barcelona Hotel'])
def test_search_hotels_view_returns_right_hotels_of_one_matching_city(
self):
chosen_city = {'city': 'antw'}
response = self.client.get(reverse('search_hotels'), chosen_city)
cities = [city['city'] for city in response.json()['data']]
hotels = [
hotel for city in response.json()['data']
for hotel in city['hotels']
]
self.assertEquals(response.status_code, 200)
self.assertEquals(cities, ['Antwerpen'])
self.assertEquals(hotels, ['Hotel Ant', 'Second Hotel Ant'])
def test_KeyError_code_not_requested(self):
send_to = {'': '0000000000'}
client = Client()
response = client.post("/user/smscoderequest",
json.dumps(send_to),
content_type='application/json')
self.assertEqual(response.json().get('message'), 'KEY_ERROR')
def test_succecss_signin(self):
user = {'email': '*****@*****.**', 'password': '******'}
client = Client()
response = client.post("/user/signin",
json.dumps(user),
content_type='application/json')
self.assertEqual(response.json().get('message'), 'SUCCESS_SIGNIN')
def test_success_signup(self):
client = Client()
user = {'email': '*****@*****.**', 'password': '******'}
response = client.post("/user/signup",
json.dumps(user),
content_type='application/json')
self.assertEqual(response.json(), {'message': 'SUCCESS_SIGNUP'})
def test_fail_signup_password_form(self):
client = Client()
user = {'email': '*****@*****.**', 'password': '******'}
response = client.post("/user/signup",
json.dumps(user),
content_type='application/json')
self.assertEqual(response.json(), {'message': 'ERROR_PASSWORD_FORM'})
def test_fail_signup_email_exist(self):
client = Client()
user = {'email': '*****@*****.**', 'password': '******'}
response = client.post("/user/signup",
json.dumps(user),
content_type='application/json')
self.assertEqual(response.json(), {'message': 'ERROR_EMAIL_EXISTS'})
def test_KEY_ERROR_signup(self):
client = Client()
user = {'': '*****@*****.**', 'password': '******'}
response = client.post("/user/signup",
json.dumps(user),
content_type='application/json')
self.assertEqual(response.json(), {'message': 'KEY_ERROR'})
def list(request):
response = requests.get(
'https://akash-portfolio-21.herokuapp.com/api/project-list/')
data = response.json()
context = {
'data': data,
}
return render(request, 'project/list.html', context)
def home(request):
response = requests.get('http://127.0.0.1:8000/api/shubham/')
geodata = response.json()
# return render(request, 'core/home.html', {
# 'ip': geodata['ip'],
# 'country': geodata['country_name']
# })
return HttpResponse(geodata)
def test_signup_invalid_key(self):
client = Client()
user = {'email': '*****@*****.**', 'password': '******'}
response = client.post('/user/signup',
json.dumps(user),
content_type='application/json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {'message': 'KEY_ERROR'})
def test_fail_code_not_requested(self, mocked_response):
send_to = {'auth_phone': '0000000000'}
client = Client()
res = mocked_response.return_value
res.status_code != 202
response = client.post("/user/smscoderequest",
json.dumps(send_to),
content_type='application/json')
self.assertEqual(response.json().get('message'), 'CODE_NOT_SENT')
def test_convert_view_with_wrong_input(self):
response = self.__client.get('/getCurr/', self.__wrongInput)
res_json = response.json()
expected_json = {
"status":
"error",
"msg":
"Either supplied value is not a valid currency or the field is empty"
}
self.assertDictEqual(res_json, expected_json)
def home(request):
response = requests.get('http://freegeoip.app/json')
geodata = response.json()
context = {
'ip': geodata['ip'],
'country': geodata['country_name'],
'city': geodata['city'],
'region_name': geodata['region_name']
}
return render(request, 'geo_location/home.html', context)
def test_faceted_search(self):
url = reverse("general-search")
response = self.client.get(
url, {
'query': 'python',
'source': ['tweets', 'github'],
'language': ['Python', 'Ruby']
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIsNotNone(response.json()['docs'])
def test_fail_auth_not_matched(self):
hased_random_code = bcrypt.hashpw("4321".encode('utf-8'),
bcrypt.gensalt()).decode('utf-8')
codes = {"auth_code": "1234", "hased_random_code": hased_random_code}
client = Client()
response = client.post("/user/smscodecheck",
json.dumps(codes),
content_type='application/json')
self.assertEqual(response.json().get('message'),
'ERROR_CODE_NOT_MATCHED')
def test_KeyError_code_check(self):
random_code = str(random.randint(1000, 9999))
hased_random_code = bcrypt.hashpw(random_code.encode('utf-8'),
bcrypt.gensalt()).decode('utf-8')
codes = {"": random_code, "hased_random_code": hased_random_code}
client = Client()
response = client.post("/user/smscodecheck",
json.dumps(codes),
content_type='application/json')
self.assertEqual(response.json().get('message'), 'KEY_ERROR')
def test_form(request):
if request.method == "POST":
site = request.POST.get("site_url")
print({"site": site})
form = SiteUrl(request.POST)
# site = 'www.google.com'
url = "https://similarweb2.p.rapidapi.com/pageoverview"
querystring = {"website": "https://" + site}
headers = {
"x-rapidapi-host": "similarweb2.p.rapidapi.com",
"x-rapidapi-key": "23a1830e2amshb300f3a2bac9a56p1793d1jsn2b8cb9b48d12",
}
# ##########This gets the data from the api
response = requests.request("GET", url, headers=headers, params=querystring)
# test_response = requests.request("GET",'https://' + site)
if response.status_code == 200:
print("works")
else:
mssg = 'Input a website with the format "www.example.com"'
return render(request, "index.html",{'error':mssg})
####Convert the api response to json
context = response.json()
# from the json data, we get whatever data we need
description = context["siteDescription"]
rank = context["categoryRank"]["rank"]
screenshot = context["pageScreenshot"]
print(response.text)
######Here, we render the data to the html template
return render(
request,
"page_data.html",
{
"site": site,
# 'response':context,
"" "rank": rank,
"description": description,
"screenshot": screenshot,
},
)
else:
mssg = 'Input a website with the format "www.example.com"'
return render(request, "index.html",{'error':mssg})
def test_JSONDecodeError_code_check(self):
random_code = str(random.randint(1000, 9999))
hased_random_code = bcrypt.hashpw(random_code.encode('utf-8'),
bcrypt.gensalt()).decode('utf-8')
codes = {
"auth_code": random_code,
"hased_random_code": hased_random_code
}
client = Client()
response = client.post("/user/smscodecheck", codes)
self.assertEqual(response.json().get('message'), 'JSONDecodeError')
def api(request):
api_key ='306cf1684a42e4be5ec0a1c60362c2ef'
name='npm'
api_url="https://libraries.io/api/search?q={}&api_key={}".format(name ,api_key)
response=requests.get(api_url)
response_dict = response.json()
return render(request, 'api.html',{'api': response_dict, }
)
def test_login_does_not_exist(self):
client = Client()
user = {
'email': '*****@*****.**',
'password': '******',
'name': '최왓더'
}
response = client.post('/user/login',
json.dumps(user),
content_type='application/json')
self.assertEqual(response.status_code, 401)
self.assertEqual(response.json(), {'message': 'INVALID_USER'})
def test_signup_password_format_validation(self):
client = Client()
user = {
'email': '*****@*****.**',
'password': '******',
'name': 'inah',
}
response = client.post('/user/signup',
json.dumps(user),
content_type='application/json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {'message': 'INVALID_VALUE'})
def test_success_auth_matched(self):
random_code = str(random.randint(1000, 9999))
hased_random_code = bcrypt.hashpw(random_code.encode('utf-8'),
bcrypt.gensalt()).decode('utf-8')
codes = {
"auth_code": random_code,
"hased_random_code": hased_random_code
}
client = Client()
response = client.post("/user/smscodecheck",
json.dumps(codes),
content_type='application/json')
self.assertEqual(response.json().get('message'),
'SUCCESS_CODE_MATCHED')
def test_signup_email_exists(self):
client = Client()
user = {
'email': '*****@*****.**',
'password': '******',
'name': 'inah',
'maketing_is_agreed': True,
}
response = client.post('/user/signup',
json.dumps(user),
content_type='application/json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {'message': 'ALREADY_EXISTS'})
def test_get_one_team(self):
"""测试查询一个队伍"""
team = self.create_a_team_and_join(self.m1)
url = reverse('team-detail', args=[team.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
data: dict = response.json()
del data['members'] # 太多了不测了
self.assertEqual(data, {
'id': team.id,
'name_ch': team.name_ch,
'name_en': team.name_en,
})
team.delete()
def execute_spotify_api_request(session_id, endpoint, post_=False, put_=False):
tokens = get_user_tokens(session_id)
headers = {"Content-Type": "application/json",
"Authorization": "Bearer " + tokens.access_token}
if post_:
post(BASE_URL_SPOTIFY + endpoint, headers=headers)
if put_:
put(BASE_URL_SPOTIFY + endpoint, headers=headers)
response = get(BASE_URL_SPOTIFY + endpoint, {}, headers=headers)
try:
return response.json()
except:
return {"Error": "Issue with request"}
def password_forgot(request):
fp_form = PasswordResetFormUnique()
form = PasswordResetFormUnique()
success = request.session.pop('success', None)
error_email = request.session.pop('error_email', None)
if request.method == 'GET':
return render(
request, 'base.html', {
'form': form,
'fpform': fp_form,
'success': success,
'error_email': error_email,
})
elif request.method == 'POST':
user_json = {}
form = PasswordResetFormUnique(request.POST)
if form.is_valid():
data = {'email': request.POST.get('email')}
response = requests.post(url=API_DOMAIN + API_URL +
'reset-password/',
data=data)
try:
result = response.json()
except:
result = []
try:
email_msg = result['email']
except:
email_msg = None
try:
status = result['status']
except:
status = None
if status == 'OK':
user_json[
'success'] = "We have sent a link to change your password. Kindly check your email."
elif email_msg:
user_json[
'error_email'] = "There is no active user associated with this e-mail address."
else:
user_json['error_email'] = "Failed, Please Try Again"
return JsonResponse(user_json)
else:
user_json['error_email'] = request.POST
return JsonResponse(user_json)
