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 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