def test_put(self):
""" Test that you can put """
us = User(email="test@localhost", password=crypt('tset'))
db_sess = get_session()
db_sess.add(us)
db_sess.commit()
entry = Entry(userid=us.userid,
title="test",
completed=True,
description="test desc")
db_sess.add(entry)
db_sess.commit()
response = self.session.post(self._route("/auth/login"),
json={
'email': us.email,
'password': "******"
})
self.assertEqual(response.status_code, 200, response.text)
new_entry = Entry(userid=us.userid,
title="test_updated",
completed=False,
description="test desc updated")
response = self.session.put(self._route("/todo/entry/{}".format(
entry.entryid)),
json={
'title': new_entry.title,
'completed': new_entry.completed,
'description': new_entry.description
})
db_sess.refresh(entry)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(entry.as_dict(), response.json(), response.text)
db_sess.close()
def setUp(self):
"""
Define the test client and other test variables
"""
user = User.objects.create(username="******")
self.entry_content = "Dear Diary, I wrote tests today"
self.entry = Entry(content=self.entry_content, owner=user)
def add_entry():
data = get_data(request)
date = data.get("date") # in millisecs
distance = data.get("distance")
time = data.get("time")
if not date or not distance or not time:
return get_error("date, distance, time must be provided"), 400
try:
date = int(date)
date = datetime.utcfromtimestamp(date // 1000)
except ValueError: # year is out of range for example
return get_error("date is maybe too big."), 400
try:
distance = float(distance)
time = float(time)
except ValueError:
return get_error("distance and time must use international float format, for ex: 1.2, 1.34E4"), 400
entry = Entry(user=g.user, date=date, distance=distance, time=time)
entry.create()
logger.info("Create new entry:%s", entry)
return jsonify(get_entry_info(entry)), 201
def add_entry():
data = get_data(request)
date = data.get("date") # in millisecs
distance = data.get("distance")
time = data.get("time")
if not date or not distance or not time:
return get_error("date, distance, time must be provided"), 400
try:
date = int(date)
date = datetime.utcfromtimestamp(date // 1000)
except ValueError: # year is out of range for example
return get_error("date is maybe too big."), 400
try:
distance = float(distance)
time = float(time)
except ValueError:
return get_error(
"distance and time must use international float format, for ex: 1.2, 1.34E4"
), 400
entry = Entry(user=g.user, date=date, distance=distance, time=time)
entry.create()
logger.info("Create new entry:%s", entry)
return jsonify(get_entry_info(entry)), 201
def test_post_detail_non_relation(self):
new_entry = Entry(body='test', title='test', user=User.objects.get(id=1))
new_entry.save()
headers = {'Content-Type': 'application/json',}
request_url = self.live_server_url + '/api/v1/user/2/entries/%s/' % new_entry.id
data = {'body': "hello, this is the body"}
result = requests.put(request_url, data=simplejson.dumps(data), headers=headers)
self.assertEqual(result.status_code, 400)
def test_get_list_filter(self):
user = User.objects.get(id=2)
e = Entry(user=user, title='filter_me')
e.save()
result = requests.get(self.live_server_url + '/api/v1/user/2/entries/?title__startswith=filter')
self.assertEqual(result.status_code, 200)
self.assertEqual(len(simplejson.loads(result.text)['objects']), 1)
result = requests.get(self.live_server_url + '/api/v1/user/2/entries/')
self.assertEqual(result.status_code, 200)
self.assertEqual(len(simplejson.loads(result.text)['objects']), 2)
class ModelTestCase(TestCase):
"""This class defines the test suite for the entry model."""
def setUp(self):
"""Define the test client and other test variables."""
self.entry_text = "Write code for BuJo API"
self.user = User.objects.create_user(username='******', password='******')
self.entry = Entry(text=self.entry_text, user=self.user)
def test_model_can_create_an_entry(self):
"""Test the entry model can create an entry."""
old_count = Entry.objects.count()
self.entry.save()
new_count = Entry.objects.count()
self.assertNotEqual(old_count, new_count)
def mutate(self, info, date, distance, time, **kwargs):
id = kwargs.get('id')
if id is not None:
entry = Entry.objects.get(pk=id)
entry.date = date
entry.distance = distance
entry.time = time
else:
username = kwargs.get('user')
user = User.objects.get(username=username).id
entry = Entry(user=User.objects.get(pk=user),
date=date,
distance=distance,
time=time)
entry.save()
ok = True
return CreateEntry(entry=entry)
class ModelTestCase(TestCase):
"""
This class defines the test suite for the Entry model
"""
def setUp(self):
"""
Define the test client and other test variables
"""
user = User.objects.create(username="******")
self.entry_content = "Dear Diary, I wrote tests today"
self.entry = Entry(content=self.entry_content, owner=user)
def test_model_can_create_an_entry(self):
"""
Test that the Entry model can create a diary entry
"""
old_count = Entry.objects.count()
self.entry.save()
new_count = Entry.objects.count()
self.assertNotEqual(old_count, new_count)
def test_list(self):
""" Test that you can list """
us = User(email="test@localhost", password=crypt('tset'))
db_sess = get_session()
db_sess.add(us)
db_sess.commit()
e_a = Entry(userid=us.userid,
title="test",
completed=True,
description="test desc")
e_b = Entry(userid=us.userid,
title="test2",
completed=False,
description="test2 desc")
db_sess.add(e_a)
db_sess.add(e_b)
db_sess.commit()
response = self.session.post(self._route("/auth/login"),
json={
'email': us.email,
'password': "******"
})
self.assertEqual(response.status_code, 200, response.text)
response = self.session.get(self._route("/todo/entry"), )
expected = [e_a.as_dict(), e_b.as_dict()]
db_sess.close()
self.assertEqual(response.json(), expected, response.text)
self.assertEqual(response.status_code, 200, response.text)
def post(self):
"""
Creates a new entry
:return: The created entry
"""
args = entry_parser.parse_args()
# Python black magic: unpacks the arguments by name.
# Equivalent to Entry(customer='customer_name',...)
entry = Entry(**args)
db.session.add(entry)
db.session.commit()
return entry, 201
def post_handler():
""" Post todo entries for logged in user """
try:
body = request.json
title = body.pop('title')
completed = body.pop('completed', None)
description = body.pop('description')
if body:
abort(400)
user = current_user
entry = Entry(title=title,
completed=completed,
description=description,
userid=user.userid)
session = get_session()
session.add(entry)
session.commit()
except (KeyError):
abort(400)
response = make_response(json.dumps(entry.as_dict()), 201)
session.close()
return response
def handle(self, *args, **options):
data = requests.get(
'https://www.arb-silva.de/fileadmin/silva_databases/release_128/Exports/SILVA_128_LSURef_tax_silva.fasta.gz'
)
fasta = gzip.decompress(data.content).decode()
entries = fasta.split('>')[1:5001]
_labels_ = set()
for e in entries:
fasta_parser = FastaParser(e)
sequence = fasta_parser.sequence
access_id = fasta_parser.access_id
kingdom_label = fasta_parser.kingdom
species_label = fasta_parser.species
if not kingdom_label in _labels_:
_labels_.add(kingdom_label)
kingdom = Kingdom(label=kingdom_label)
kingdom.save()
else:
kingdom = Kingdom.objects.get(label=kingdom_label)
if not species_label in _labels_:
_labels_.add(species_label)
species = Species(label=species_label)
species.save()
else:
species = Species.objects.get(label=species_label)
e = Entry(access_id=access_id,
kingdom=kingdom,
species=species,
sequence=sequence)
e.save()
def post(self, request):
entry = Entry()
# form = UploadFileForm(request.POST, request.FILES)
files = request.FILES.getlist('fileupload') # 获得多个文件上传进来的文件列表。
# if form.is_valid(): # 表单数据如果合法
if request.data['description']:
entry.description = request.data['description']
if request.data['tags']:
entry.tags = request.data['tags']
if request.data['name']:
entry.name = request.data['name']
img_list = []
if files:
for f in files:
img = Img(file=f)
img.save()
img_list.append(img.get_id())
entry.imgs = img_list
entry.save()
# generating json response array
result = [{
"id": entry.id.__str__(),
"name": entry.name,
"imgs": entry.imgs,
"description": entry.description,
"tags": entry.tags,
"modified": entry.modified,
}]
response_data = json.dumps(result, cls=DjangoJSONEncoder)
# checking for json data type
# big thanks to Guy Shapiro
# if noajax:
# if request.META['HTTP_REFERER']:
# redirect(request.META['HTTP_REFERER'])
if "application/json" in request.META['HTTP_ACCEPT_ENCODING']:
content_type = 'application/json'
else:
content_type = 'text/plain'
return HttpResponse(response_data, content_type=content_type)
def test_get_json_access_url_params(self):
user = User(self.username, '*****@*****.**', self.hashed_password)
db.session.add(user)
entry = Entry(self.test_key, self.test_value, 1)
db.session.add(entry)
db.session.commit()
#wrong username
response = self.app.get(
'/get/some_value?username={}&api_key=wrong_pass'.format(
self.username))
self.assertEqual(
json.loads(str(response.get_data(as_text=True))),
{'value': 'Your username or api_token url params are invalid '})
#wrong password
response = self.app.get(
'/get/some_value?username=wrong_user&api_key={}'.format(
self.password))
self.assertEqual(
json.loads(response.get_data(as_text=True)),
{'value': 'Your username or api_token url params are invalid '})
#no value
response = self.app.get(
'/get/some_value?username={}&api_key={}'.format(
self.username, self.password))
self.assertEqual(json.loads(response.get_data(as_text=True)),
{'value': 'No value with this key in db'})
#get key with success
response = self.app.get('/get/{}?username={}&api_key={}'.format(
self.test_key, self.username, self.password))
self.assertEqual(json.loads(response.get_data(as_text=True)), {
'key': self.test_key,
'user_id': user.id,
'value': self.test_value
})
def test_delete(self):
""" Test that you can delete """
us = User(email="test@localhost", password=crypt('tset'))
db_sess = get_session()
db_sess.add(us)
db_sess.commit()
entry = Entry(userid=us.userid,
title="test",
completed=True,
description="test desc")
db_sess.add(entry)
db_sess.commit()
response = self.session.post(self._route("/auth/login"),
json={
'email': us.email,
'password': "******"
})
self.assertEqual(response.status_code, 200, response.text)
response = self.session.delete(
self._route("/todo/entry/{}".format(entry.entryid)))
self.assertEqual(response.status_code, 200, response.text)
db_sess.close()
def test_set_json_access_url_params(self):
user = User(self.username, '*****@*****.**', self.hashed_password)
db.session.add(user)
entry = Entry(self.test_key, self.test_value, 1)
db.session.add(entry)
db.session.commit()
#wrong username
response = self.app.post(
'/set/?username={}&api_key=wrong_pass'.format(self.username),
data=json.dumps(dict(key=self.test_key, value=self.test_value)),
content_type='application/json')
self.assertEqual(
json.loads(str(response.get_data(as_text=True))),
{'value': 'Your username or api_token url params are invalid '})
#wrong password
response = self.app.post(
'/set/?username=wrong_user&api_key={}'.format(self.password),
data=json.dumps(dict(key=self.test_key, value=self.test_value)),
content_type='application/json')
self.assertEqual(
json.loads(response.get_data(as_text=True)),
{'value': 'Your username or api_token url params are invalid '})
#set key with success
response = self.app.post(
'/set/?username={}&api_key={}'.format(self.username,
self.password),
data=json.dumps(dict(key=self.test_key_2, value=self.test_value)),
content_type='application/json')
self.assertEqual(
json.loads(response.get_data(as_text=True)), {
'value':
'The entry with key {} was succesfully created'.format(
self.test_key_2)
})
#reassign existing key
response = self.app.post(
'/set/?username={}&api_key={}'.format(self.username,
self.password),
data=json.dumps(dict(key=self.test_key_2, value=self.test_value)),
content_type='application/json')
self.assertEqual(
json.loads(response.get_data(as_text=True)), {
'value':
'The entry {} already existed and was succesfully reassigned'.
format(self.test_key_2)
})
#success get key with user that created it
response = self.app.get('/get/{}?username={}&api_key={}'.format(
self.test_key_2, self.username, self.password))
self.assertEqual(json.loads(response.get_data(as_text=True)), {
'key': self.test_key_2,
'user_id': user.id,
'value': self.test_value
})
user2 = User('new_user', '*****@*****.**', self.hashed_password)
db.session.add(user2)
db.session.commit()
#fail get key old key with new user
response = self.app.get('/get/{}?username={}&api_key={}'.format(
self.test_key_2, 'new_user', self.password))
self.assertEqual(json.loads(response.get_data(as_text=True)),
{'value': 'No value with this key in db'})
def setUp(self):
"""Define the test client and other test variables."""
self.entry_text = "Write code for BuJo API"
self.user = User.objects.create_user(username='******', password='******')
self.entry = Entry(text=self.entry_text, user=self.user)
