def test_404_delete_nonexistent_order(self):
'''
create and insert customer and item to be included in mock order.
insert mock order, assign mock order's id to variable<br>
and then delete mock order prior to the test to ensure<br>
that order pending delete does not exist
'''
customer = Customer(name='test_name', email='test_email')
item = Item(name='test_name', brand='test_brand', price=1)
customer.insert()
item.insert()
mock_order = Orders(customer_id=customer.id,
item_id=item.id,
quantity=1)
mock_order.insert()
nonexistent_order_id = mock_order.id
mock_order.delete()
# after mock order is deleted delete customer and item too
customer.delete()
item.delete()
# attempt to delete nonexistent order
res = self.client().delete(
'/delete_order/{}'.format(nonexistent_order_id),
headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
def test_422_submit_order_with_unavailable_item(self):
# create and insert customer to be included in order
customer = Customer(name='test_name', email='test_email')
# create and insert item that is unavailable to be included in order
unavailable_item = Item(name='unavailable item',
brand='unavailable brand',
price=100,
available=False)
customer.insert()
unavailable_item.insert()
# attempt to submit order with unavailable item
res = self.client().post('/submit_order',
headers=manager_jwt,
json={
'customer_id': customer.id,
'item_id': unavailable_item.id,
'quantity': 5
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertFalse(data['success'])
# delete customer and item after test is completed
customer.delete()
unavailable_item.delete()
def test_submit_order(self):
# create a customer to be inserted into database
customer = Customer(name=self.new_customer['name'],
email=self.new_customer['email'])
customer.insert()
# create an item to be inserted into database
item = Item(name=self.new_item['name'],
brand=self.new_item['brand'],
price=self.new_item['price'])
item.insert()
'''
assign the created customer and item id's to the created order.<br>
The created customer and order were implemented to esure that<br>
the tests are self sufficient in order to provide a<br>
predictable outcome and confirm that the units being tested do exist.
'''
res = self.client().post('/submit_order',
headers=manager_jwt,
json={
'customer_id': customer.id,
'item_id': item.id,
'quantity': 10
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
self.assertTrue(data['order_id'])
order = Orders.query.filter_by(id=data['order_id']).one_or_none()
# after tests are passed delete all mock data(order, customer, item)
order.delete()
customer.delete()
item.delete()
def test_delete_order(self):
# create customer, item and order and insert into<br>
# database pending deletion request
customer = Customer(name=self.new_customer['name'],
email=self.new_customer['email'])
customer.insert()
item = Item(name=self.new_item['name'],
brand=self.new_item['brand'],
price=self.new_item['price'])
item.insert()
order = Orders(customer_id=customer.id, item_id=item.id, quantity=10)
order.insert()
# assign order id to variable prior to deletion for testing purposes
order_id = order.id
# delete order that was currently created
res = self.client().delete('/delete_order/{}'.format(order.id),
headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
# verify that deleted order id matched id included in request
self.assertEqual(data['deleted_order_id'], order_id)
self.assertEqual(data['current_orders'], (data['previous_orders'] - 1))
# delete customer and item
customer.delete()
item.delete()
def setup_class(cls):
super(TestSearchItems, cls).setup_class()
Item.delete().execute()
for name in NAMES:
test_utils.add_item(
name=name,
description='random description',
category='',
)
pass
def test_delete_an_item(self):
""" Delete an Item """
item = Item(wishlist_id=1,
product_id=1,
name="toothpaste",
description="toothpaste for 2")
item.save()
self.assertEqual(len(Item.all()), 1)
item.delete()
self.assertEqual(len(Item.all()), 0)
def test_delete_an_item(self):
""" Delete an Item """
item = Item(order_id=1,
product_id=1,
name="wrench",
quantity=1,
price=10.50)
item.save()
self.assertEqual(len(Item.all()), 1)
item.delete()
self.assertEqual(len(Item.all()), 0)
def commit_deleting(c):
dot = c.data.find('.')
list_id = int(c.data[3:dot])
list_ = List.get_by_id(list_id)
spt_s = c.data[dot + 1:]
spotted = [int(i) for i in spt_s.split(',')]
Item.delete().where(Item.id.in_(spotted)).execute()
for sub in List.select().where(List.subscribed_by == list_.subscribed_by):
bot.edit_message_reply_markup(sub.owner.id,
sub.last_message_id,
reply_markup=mps.list_mp(sub.id))
def test_model_item(self):
"Test item model"
type = ItemType(name='test')
type.save()
status = ItemStatus(name='test')
status.save()
obj = Item(name='test', item_type=type, status=status)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_item(self):
"Test item model"
type = ItemType(name='test')
type.save()
status = ItemStatus(name='test')
status.save()
obj = Item(name='test', item_type=type, status=status)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def seed():
# Delete the table data.
Item.delete().execute()
ItemList.delete().execute()
# Create the initial item list
item_list = ItemList(name='Main List')
item_list.save()
ItemList(name='Secondary List').save()
# Create items under the item list
Item(name='Clean the room', item_list=item_list.id).save()
Item(name='Take out the trash', item_list=item_list.id).save()
Item(name='Sweep the floors', item_list=item_list.id).save()
def items(request, item_id=None):
if request.method == 'POST':
data = request.POST
item = Item(name=data.get('name'), quantity=data.get('quantity'))
item.add()
if request.method == 'DELETE':
item = Item.objects.get(pk=item_id)
item.delete()
if request.method == 'PUT':
data = simplejson.loads(request.body)
item = Item.objects.get(pk=data.get('id'))
item.purchased = data.get('purchased')
item.save()
data = [dict(i) for i in Item.objects.all().values('id', 'name', 'quantity', 'purchased')]
return JsonResponse({'items': data})
def test_404_delete_non_existent_item(self):
'''
insert mock item, assign mock item's id to variable and<br>
then delete mock item prior to the test to ensure that<br>
item pending delete does not exist
'''
mock_item = Item(name='test_name', brand='test_brand', price=10)
mock_item.insert()
nonexistent_item_id = mock_item.id
mock_item.delete()
# send delete request for nonexistent item
res = self.client().delete(
'/delete_item/{}'.format(nonexistent_item_id), headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
def test_update_item(self):
# create and insert item to be updated
item = Item(name=self.new_item['name'],
brand=self.new_item['brand'],
price=self.new_item['price'])
item.insert()
# send request to update item
res = self.client().patch('/update_item/{}'.format(item.id),
headers=manager_jwt,
json={'name': 'updated item'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
# verify that item_name matched updated name entered
self.assertEqual(data['item_name'], 'updated item')
# delete item once tests have been passed
item.delete()
def api_item(request, item_pk=None):
created = False
if item_pk:
item = Item.objects.get(pk=item_pk)
if not item.created_by == request.user:
import pdb
pdb.set_trace()
return HttpResponse(status=403)
else:
item = Item()
item.created_by = request.user
created = True
if request.POST.get('delete'):
item.delete()
else:
expense = Expense.objects.get(pk=request.POST.get('expense'))
if not expense.created_by == request.user:
return HttpResponse(status=403)
item.expense = expense
item.description = request.POST.get('description')
item.amount = request.POST.get('amount')
item.save()
user_pks = request.POST.getlist('users')
item.users.clear()
for pk in user_pks:
user = User.objects.get(pk=pk)
item.users.add(user)
if request.is_ajax():
return HttpResponse(json.dumps({
'type': 'item',
'item_pk': item.pk,
'item_created': created,
'item_form': render_to_response('item_form.html', {'expense':item.expense, 'item':item}, context_instance = RequestContext(request)).content,
'empty_form': render_to_response('item_form.html', {'expense':item.expense}, context_instance = RequestContext(request)).content
}))
return HttpResponseRedirect("/%s" % item.expense_id)
def post(self):
upload_files = self.get_uploads() # 'file' is file upload field in the form
blob_info = upload_files[0]
#self.redirect('/serve/%s' % blob_info.key())
blob_key = blob_info.key()
blob_reader = blobstore.BlobReader(blob_key)
document = blob_reader.read()
#self.response.out.write(document)
dom = xml.dom.minidom.parseString(document)
names = dom.getElementsByTagName("NAME")
xml_cat_name = names[0].toxml()
xml_cat_name = xml_cat_name.replace("<NAME>", "")
xml_cat_name = xml_cat_name.replace("</NAME>", "")
xml_item_names = []
for i in range(1, len(names)):
name = names[i].toxml()
name = name.replace("<NAME>", "")
name = name.replace("</NAME>", "")
xml_item_names.append(name)
currt_user = users.get_current_user()
account_key = db.Key.from_path('Account', currt_user.nickname())
account = db.get(account_key)
categories = Category.all()
categories.ancestor(account_key)
cat_names = []
for category in categories.run():
cat_names.append(category.cat_name)
### if category exists
if xml_cat_name in cat_names:
items = Item.all()
category = categories.filter("cat_name =", xml_cat_name)
category = category.get()
category_key = category.key()
items = items.ancestor(category_key)
item_names = []
for item in items:
item_names.append(item.item_name)
### add new items
for item_name in xml_item_names:
if item_name not in item_names:
item = Item(key_name=item_name, parent=category, item_name=item_name)
item.win = 0
item.lose = 0
item.put()
### delete old items
for item_name in item_names:
if item_name not in xml_item_names:
items = Item.all()
items = items.ancestor(category_key)
items.filter("item_name =", item_name)
item = items.get()
item.delete()
### if new category
else:
cat = Category(key_name=xml_cat_name, parent=account, cat_name=xml_cat_name)
cat.put()
for xml_item_name in xml_item_names:
item = Item(key_name=xml_item_name, parent=cat, item_name=xml_item_name)
item.win = 0
item.lose = 0
item.put()
self.redirect("/option?option=manage")
def tearDown(self):
self.assertIsNone(Item.delete(self.item.id))
def setup_method(self):
Item.delete().execute()
def teardown_class(cls):
Item.delete().execute()
def finalizeItem(batch_id, item_id, item_tasks_count):
item_tasks = []
for task_order in range(0, item_tasks_count):
item_tasks.append(Task(batch_id, item_id, task_order))
# the task with highest id for the specific item has all item data
last_task = item_tasks[-1]
item_data = last_task.item_data
item_data['timestamp'] = datetime.utcnow().isoformat("T") + "Z"
if item_data.has_key('status') and item_data['status'] == 'deleted':
whole_item_delete = True
else:
whole_item_delete = False
try:
old_item = Item(item_id)
except:
old_item = None
if old_item:
if not whole_item_delete:
item_data['image_meta'] = old_item.image_meta
else:
item_data['image_meta'] = {}
error = False
if not whole_item_delete:
for task in item_tasks:
if task.status == 'pending' or task.status == 'error':
error = True
# modification tasks never changes image_meta
elif task.type == 'mod':
pass
elif task.status == 'deleted':
# if the image is being really deleted not only being reshuffled
if not task.url in item_data['url']:
item_data['image_meta'].pop(task.url, None)
elif task.status == 'ok':
item_data['image_meta'][task.url] = task.image_meta
if not error:
if not (old_item and whole_item_delete):
item = Item(item_id, item_data)
ordered_image_meta = []
for url in item.url:
tmp = item.image_meta[url]
tmp['url'] = url
ordered_image_meta.append(tmp)
if CLOUDSEARCH_ITEM_DOMAIN is not None:
try:
cloudsearch = getCloudSearch(CLOUDSEARCH_ITEM_DOMAIN, 'document')
if old_item and whole_item_delete:
cloudsearch.delete(hashlib.sha512(item_id).hexdigest()[:128])
else:
cloudsearch.add(hashlib.sha512(item_id).hexdigest()[:128], {'id': item.id, 'title': item.title, 'creator': item.creator, 'source': item.source, 'institution': item.institution, 'institution_link': item.institution_link, 'license': item.license, 'description': item.description, 'url': json.dumps(item.url), 'timestamp': item.timestamp, 'image_meta': json.dumps(ordered_image_meta)})
cloudsearch.commit()
except:
if last_task.attempts < MAX_TASK_REPEAT * 2:
print '\nFailed Cloud Search attempt numb.: %s\nItem: %s\nError message:\n###\n%s###' % (last_task.attempts + 1, task.item_id, traceback.format_exc())
last_task.attempts += 1
last_task.status = 'pending'
last_task.type = 'cloud_search'
last_task.save()
rand = (last_task.attempts * 60) + random.randint(last_task.attempts * 60, last_task.attempts * 60 * 2)
return ingestQueue.apply_async(args=[batch_id, item_id, last_task.task_id], countdown=rand)
else:
last_task.status = 'error'
last_task.message = ERR_MESSAGE_CLOUDSEARCH
last_task.save()
if last_task.status == 'error':
cleanErrItem(item_id, len(item_data['image_meta']))
print "Item '%s' failed" % item_id
elif old_item and whole_item_delete:
old_item.delete()
print "Item '%s' deleted" % item_id
else:
item.save()
print "Item '%s' finalized" % item_id
else:
cleanErrItem(item_id, len(item_data['image_meta']))
print "Item '%s' failed" % item_id
return
def delete_item(self, item_id):
"""Delete item with given ID"""
Item.delete().where(Item.id == item_id).execute()
return # Return nothing
