def item_listing(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
response = self.app.get('/{}/items'.format(self.resource_id))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(len(response.json['data']),
len(self.initial_data['items']))
response = self.app.post_json('/{}/items'.format(self.resource_id),
headers=self.access_header,
params={'data': self.initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
response = self.app.get('/{}/items'.format(self.resource_id))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(len(response.json['data']),
len(self.initial_data['items']) + 1)
def create_or_patch_decision_in_not_allowed_status(self):
self.app.authorization = ('Basic', ('broker', ''))
self.initial_status = 'draft'
self.create_resource()
check_patch_status_200(self, '/{}'.format(self.resource_id), 'composing',
self.access_header)
lot = add_lot_decision(self, self.resource_id, self.access_header)
add_lot_related_process(self, self.resource_id, self.access_header)
add_auctions(self, lot, self.access_header)
check_patch_status_200(self, '/{}'.format(self.resource_id),
'verification', self.access_header)
decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': 'decisionLotID'
}
response = self.app.post_json('/{}/decisions'.format(self.resource_id),
{"data": decision_data},
headers=self.access_header,
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'Can\'t update decisions in current (verification) lot status')
def auctionPeriod_endDate_blacklisted(self):
response = self.app.get('/{}/auctions'.format(self.resource_id))
auctions = sorted(response.json['data'], key=lambda a: a['tenderAttempts'])
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
english = auctions[0]
# Change auctionPeriod
data = {
'auctionPeriod': {
'startDate': (datetime.now(TZ) + timedelta(1)).isoformat(),
'endDate': (datetime.now(TZ) + timedelta(10)).isoformat()
}
}
response = self.app.patch_json('/{}/auctions/{}'.format(
self.resource_id, english['id']),
headers=self.access_header,
params={'data': data})
self.assertEqual(response.json['data']['auctionPeriod']['startDate'],
data['auctionPeriod']['startDate'])
self.assertNotIn('endDate', response.json['data']['auctionPeriod'])
def patch_auctions_with_lot(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
self.app.authorization = ('Basic', ('broker', ''))
response = create_single_lot(self, self.initial_data)
lot = response.json['data']
token = response.json['access']['token']
access_header = {'X-Access-Token': str(token)}
# Move from 'draft' to 'pending' status
check_patch_status_200(self, '/{}'.format(lot['id']), 'composing',
access_header)
lot = add_lot_decision(self, lot['id'], access_header)
add_lot_related_process(self, lot['id'], access_header)
add_auctions(self, lot, access_header)
check_patch_status_200(self, '/{}'.format(lot['id']), 'verification',
access_header)
self.app.authorization = ('Basic', ('concierge', ''))
check_patch_status_200(self, '/{}'.format(lot['id']), 'verification')
add_decisions(self, lot)
check_patch_status_200(self,
'/{}'.format(lot['id']),
'pending',
extra={'items': [test_loki_item_data]})
self.app.authorization = ('Basic', ('broker', ''))
data = deepcopy(lot)
del data['decisions']
del data['status']
data['auctions'][0]['tenderAttempts'] = 3
data['auctions'][0]['procurementMethodType'] = 'sellout.insider'
response = self.app.patch_json(
'/{}'.format(lot['id']),
headers=access_header,
params={'data': data},
)
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['auctions'][0]['tenderAttempts'], 1)
self.assertEqual(
response.json['data']['auctions'][0]['procurementMethodType'],
'sellout.english')
response = self.app.get('/{}/auctions'.format(lot['id']))
auctions = sorted(response.json['data'], key=lambda a: a['tenderAttempts'])
english = auctions[0]
self.assertEqual(english['tenderAttempts'], 1)
self.assertEqual(english['procurementMethodType'], 'sellout.english')
def rectificationPeriod_auction_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(
rectificationPeriod.startDate, timedelta(1), None)
data = deepcopy(self.initial_auctions_data)
lot = self.create_resource()
# Change rectification period in db
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
fromdb = self.db.get(lot['id'])
fromdb = Lot(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, lot['id'])
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
response = self.app.get('/{}/auctions'.format(self.resource_id))
auctions = sorted(response.json['data'], key=lambda a: a['tenderAttempts'])
english = auctions[0]
response = self.app.patch_json('/{}/auctions/{}'.format(
lot['id'], english['id']),
headers=self.access_header,
params={'data': data['english']},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change auctions after rectification period')
self.app.authorization = ('Basic', ('concierge', ''))
response = self.app.patch_json('/{}/auctions/{}'.format(
lot['id'], english['id']),
headers=self.access_header,
params={'data': data['english']},
status=200)
self.assertEqual(response.status, '200 OK')
self.app.authorization = ('Basic', ('convoy', ''))
response = self.app.patch_json('/{}/auctions/{}'.format(
lot['id'], english['id']),
headers=self.access_header,
params={'data': data['english']},
status=200)
self.assertEqual(response.status, '200 OK')
def procurementMethodDetails_check_with_sandbox(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
# Test procurementMethodDetails after creating lot
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
english = response.json['data']['auctions'][0]
second_english = response.json['data']['auctions'][1]
insider = response.json['data']['auctions'][2]
self.assertNotIn('procurementMethodDetails', english)
self.assertNotIn('procurementMethodDetails', second_english)
self.assertNotIn('procurementMethodDetails', insider)
auction_param_with_procurementMethodDetails = {
'procurementMethodDetails': 'quick'
}
# Test procurementMethodDetails after update second english
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], second_english['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header)
self.assertEqual(
response.json['data']['procurementMethodDetails'],
auction_param_with_procurementMethodDetails['procurementMethodDetails']
)
# Test procurementMethodDetails after update insider
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], insider['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header)
self.assertEqual(
response.json['data']['procurementMethodDetails'],
auction_param_with_procurementMethodDetails['procurementMethodDetails']
)
# Test procurementMethodDetails after update english
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], english['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header)
self.assertEqual(
response.json['data']['procurementMethodDetails'],
auction_param_with_procurementMethodDetails['procurementMethodDetails']
)
def update_items_in_forbidden(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
response = self.app.post_json('/{}/items'.format(self.resource_id),
headers=self.access_header,
params={'data': self.initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
data = self.initial_item_data
data['quantity'] = 99.9999
for status in self.forbidden_item_statuses_modification:
self.set_status(status)
response = self.app.patch_json('/{}/items/{}'.format(
self.resource_id, item_id),
headers=self.access_header,
params={"data": data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(
response.json['errors'][0]["description"],
"Can't update item in current ({}) {} status".format(
status, self.resource_name[:-1]))
for status in self.forbidden_item_statuses_modification:
self.set_status(status)
response = self.app.post_json('/{}/items'.format(self.resource_id),
headers=self.access_header,
params={"data": self.initial_item_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(
response.json['errors'][0]["description"],
"Can't update item in current ({}) {} status".format(
status, self.resource_name[:-1]))
def patch_decisions_with_lot_by_concierge(self):
self.app.authorization = ('Basic', ('broker', ''))
self.initial_status = 'draft'
self.create_resource()
decision_data = [{
'decisionID': 'decID',
'decisionDate': get_now().isoformat(),
'relatedItem': '1' * 32,
'decisionOf': 'asset'
}]
decision_data = {'decisions': decision_data}
check_patch_status_200(self, '/{}'.format(self.resource_id), 'composing',
self.access_header)
add_lot_decision(self, self.resource_id, self.access_header)
lot = add_lot_related_process(self, self.resource_id, self.access_header)
add_auctions(self, lot, self.access_header)
check_patch_status_200(self, '/{}'.format(self.resource_id),
'verification', self.access_header)
self.app.authorization = ('Basic', ('concierge', ''))
response = self.app.patch_json('/{}'.format(self.resource_id),
params={'data': decision_data},
headers=self.access_header)
decision = response.json['data']['decisions'][0]
self.assertEqual(decision['decisionID'],
decision_data['decisions'][0]['decisionID'])
self.assertEqual(decision['decisionDate'],
decision_data['decisions'][0]['decisionDate'])
self.assertEqual(decision['relatedItem'],
decision_data['decisions'][0]['relatedItem'])
self.assertEqual(decision['decisionOf'],
decision_data['decisions'][0]['decisionOf'])
decision_id = decision['id']
response = self.app.get('/{}/decisions/{}'.format(self.resource_id,
decision_id))
self.assertEqual(response.json['data']['id'], decision_id)
self.assertEqual(response.json['data']['decisionID'],
decision_data['decisions'][0]['decisionID'])
self.assertEqual(response.json['data']['decisionDate'],
decision_data['decisions'][0]['decisionDate'])
self.assertEqual(response.json['data']['relatedItem'],
decision_data['decisions'][0]['relatedItem'])
self.assertEqual(response.json['data']['decisionOf'],
decision_data['decisions'][0]['decisionOf'])
def patch_auction_by_concierge(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
data = deepcopy(self.initial_auctions_data)
response = self.app.get('/{}/auctions'.format(self.resource_id))
auctions = sorted(response.json['data'], key=lambda a: a['tenderAttempts'])
english = auctions[0]
data['english']['minimalStep']['amount'] = 99
response = self.app.patch_json('/{}/auctions/{}'.format(
self.resource_id, english['id']),
headers=self.access_header,
params={'data': data['english']})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['id'], english['id'])
self.assertEqual(response.json['data']['tenderAttempts'], 1)
self.assertEqual(response.json['data']['value'], data['english']['value'])
self.assertEqual(response.json['data']['minimalStep'],
data['english']['minimalStep'])
self.assertEqual(response.json['data']['auctionPeriod'],
data['english']['auctionPeriod'])
self.assertEqual(response.json['data']['guarantee'],
data['english']['guarantee'])
self.assertNotIn('dutchSteps', response.json['data']['auctionParameters'])
self.app.authorization = ('Basic', ('concierge', ''))
response = self.app.patch_json('/{}/auctions/{}'.format(
self.resource_id, english['id']),
headers=self.access_header,
params={
'data': {
'status': 'unsuccessful',
'auctionID': 'someAuctionID',
'relatedProcessID': '1' * 32
}
})
self.assertEqual(response.json['data']['status'], 'unsuccessful')
self.assertEqual(response.json['data']['auctionID'], 'someAuctionID')
self.assertEqual(response.json['data']['relatedProcessID'], '1' * 32)
def patch_decision(self):
self.app.authorization = ('Basic', ('broker', ''))
self.initial_status = 'draft'
self.create_resource()
check_patch_status_200(self, '/{}'.format(self.resource_id), 'composing',
self.access_header)
add_lot_decision(self, self.resource_id, self.access_header)
lot = add_lot_related_process(self, self.resource_id, self.access_header)
add_auctions(self, lot, self.access_header)
check_patch_status_200(self, '/{}'.format(self.resource_id),
'verification', self.access_header)
self.app.authorization = ('Basic', ('concierge', ''))
add_decisions(self, lot)
check_patch_status_200(self,
'/{}'.format(self.resource_id),
'pending',
extra={'items': [test_loki_item_data]})
self.app.authorization = ('Basic', ('broker', ''))
decisions = self.app.get('/{}/decisions'.format(
self.resource_id)).json['data']
asset_decision_id = filter(lambda d: d['decisionOf'] == 'asset',
decisions)[0]['id']
lot_decision_id = filter(lambda d: d['decisionOf'] == 'lot',
decisions)[0]['id']
decision_data = {'title': 'Some Title'}
response = self.app.patch_json('/{}/decisions/{}'.format(
self.resource_id, asset_decision_id),
params={'data': decision_data},
status=403,
headers=self.access_header)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'Can edit only decisions which have decisionOf equal to \'lot\'.')
response = self.app.patch_json('/{}/decisions/{}'.format(
self.resource_id, lot_decision_id),
params={'data': decision_data},
headers=self.access_header)
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot_decision_id)
self.assertEqual(response.json['data']['title'], decision_data['title'])
def rectificationPeriod_document_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(
rectificationPeriod.startDate, timedelta(1), None)
lot = self.create_resource()
response = self.app.post_json('/{}/documents'.format(self.resource_id),
headers=self.access_header,
params={'data': self.initial_document_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
doc_id = response.json["data"]['id']
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
# Change rectification period in db
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
fromdb = self.db.get(lot['id'])
fromdb = Lot(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, lot['id'])
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
response = self.app.post_json('/{}/documents'.format(lot['id']),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'You can add only document with cancellationDetails after rectification period'
)
response = self.app.patch_json('/{}/documents/{}'.format(
lot['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
response = self.app.put_json('/{}/documents/{}'.format(lot['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
test_document_data = {
# 'url': self.generate_docservice_url(),
'title': u'укр.doc',
'hash': 'md5:' + '0' * 32,
'format': 'application/msword',
'documentType': 'cancellationDetails'
}
test_document_data['url'] = self.generate_docservice_url()
response = self.app.post_json('/{}/documents'.format(lot['id']),
headers=self.access_header,
params={'data': test_document_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
doc_id = response.json["data"]['id']
response = self.app.patch_json('/{}/documents/{}'.format(
lot['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
response = self.app.put_json('/{}/documents/{}'.format(lot['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
def rectificationPeriod_item_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(
rectificationPeriod.startDate, timedelta(1), None)
lot = self.create_resource()
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
response = self.app.post_json('/{}/items'.format(lot['id']),
headers=self.access_header,
params={'data': self.initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
item_id = response.json['data']['id']
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
# Change rectification period in db
fromdb = self.db.get(lot['id'])
fromdb = Lot(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, lot['id'])
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
response = self.app.post_json('/{}/items'.format(lot['id']),
headers=self.access_header,
params={'data': self.initial_item_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change items after rectification period')
response = self.app.patch_json('/{}/items/{}'.format(lot['id'], item_id),
headers=self.access_header,
params={'data': self.initial_item_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change items after rectification period')
def patch_items_with_lot(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
# Create lot in 'draft' status and move it to 'pending'
initial_item_data = deepcopy(self.initial_item_data)
del initial_item_data['id']
response = create_single_lot(self, self.initial_data)
lot = response.json['data']
token = response.json['access']['token']
access_header = {'X-Access-Token': str(token)}
response = self.app.get('/{}'.format(lot['id']), headers=access_header)
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data'], lot)
# Move from 'draft' to 'pending' status
check_patch_status_200(self, '/{}'.format(lot['id']), 'composing',
access_header)
add_lot_decision(self, lot['id'], access_header)
lot = add_lot_related_process(self, lot['id'], access_header)
add_auctions(self, lot, access_header)
check_patch_status_200(self, '/{}'.format(lot['id']), 'verification',
access_header)
self.app.authorization = ('Basic', ('concierge', ''))
check_patch_status_200(self, '/{}'.format(lot['id']), 'verification')
add_decisions(self, lot)
check_patch_status_200(self,
'/{}'.format(lot['id']),
'pending',
extra={'items': [test_loki_item_data]})
self.app.authorization = ('Basic', ('broker', ''))
# Move from 'pending' to 'pending' status
check_patch_status_200(self, '/{}'.format(lot['id']), 'pending',
access_header)
response = self.app.post_json('/{}/items'.format(lot['id']),
headers=access_header,
params={'data': initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
response = self.app.post_json('/{}/items'.format(lot['id']),
headers=access_header,
params={'data': initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(len(response.json['data']['items']), 3)
data = {'items': [initial_item_data]}
response = self.app.patch_json('/{}'.format(lot['id']),
headers=access_header,
params={'data': data})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(len(response.json['data']['items']), 1)
item_data = deepcopy(self.initial_item_data)
item_data['id'] = uuid4().hex
data = {'items': [item_data, item_data]}
response = self.app.patch_json('/{}'.format(lot['id']),
headers=access_header,
params={'data': data},
status=422)
self.assertEqual(response.status, '422 Unprocessable Entity')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['errors'][0]['description'][0],
u'Item id should be uniq for all items')
data = {'items': [item_data]}
response = self.app.patch_json('/{}'.format(lot['id']),
headers=access_header,
params={'data': data})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertNotEqual(response.json['data']['id'], item_data['id'])
def patch_item(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
response = self.app.post_json('/{}/items'.format(self.resource_id),
headers=self.access_header,
params={'data': self.initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
response = self.app.patch_json(
'/{}/items/{}'.format(self.resource_id, item_id),
headers=self.access_header,
params={
"data": {
"description":
"new item description",
"registrationDetails":
self.initial_item_data['registrationDetails'],
"unit":
self.initial_item_data['unit'],
"address":
self.initial_item_data['address'],
"quantity":
self.initial_item_data['quantity'],
"classification":
self.initial_item_data['classification'],
}
})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(item_id, response.json["data"]["id"])
self.assertEqual(response.json["data"]["description"],
'new item description')
# Test partial update
response = self.app.patch_json('/{}/items/{}'.format(
self.resource_id, item_id),
headers=self.access_header,
params={
"data": {
"description":
"partial item update",
"additionalClassifications": []
}
})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(item_id, response.json["data"]["id"])
self.assertEqual(response.json["data"]["description"],
'partial item update')
self.assertNotIn('additionalClassifications', response.json['data'])
def procurementMethodDetails_check_without_sandbox(self):
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
# Test procurementMethodDetails after creating lot
response = self.app.get('/{}'.format(self.resource_id))
lot = response.json['data']
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
english = response.json['data']['auctions'][0]
second_english = response.json['data']['auctions'][1]
insider = response.json['data']['auctions'][2]
self.assertNotIn(
'procurementMethodDetails',
response.json['data']['auctions'][0],
)
self.assertNotIn(
'procurementMethodDetails',
response.json['data']['auctions'][1],
)
self.assertNotIn(
'procurementMethodDetails',
response.json['data']['auctions'][2],
)
auction_param_with_procurementMethodDetails = {
'procurementMethodDetails': 'quick'
}
# Test procurementMethodDetails error while updating english
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], english['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header,
status=422)
self.assertEqual(response.status, '422 Unprocessable Entity')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['errors'][0]['description'], u'Rogue field')
self.assertEqual(response.json['errors'][0]['name'],
'procurementMethodDetails')
# Test procurementMethodDetails error while updating english
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], second_english['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header,
status=422)
self.assertEqual(response.status, '422 Unprocessable Entity')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['errors'][0]['description'], u'Rogue field')
self.assertEqual(response.json['errors'][0]['name'],
'procurementMethodDetails')
# Test procurementMethodDetails error while updating english
response = self.app.patch_json(
'/{}/auctions/{}'.format(lot['id'], insider['id']),
{'data': auction_param_with_procurementMethodDetails},
headers=self.access_header,
status=422)
self.assertEqual(response.status, '422 Unprocessable Entity')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['errors'][0]['description'], u'Rogue field')
self.assertEqual(response.json['errors'][0]['name'],
'procurementMethodDetails')
def rectificationPeriod_document_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(rectificationPeriod.startDate,
timedelta(1),
None)
lot = self.create_resource()
response = self.app.get('/{}/auctions'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
auction_id = response.json["data"][0]['id']
response = self.app.post_json('/{}/auctions/{}/documents'.format(lot['id'], auction_id),
headers=self.access_header,
params={'data': self.initial_document_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
doc_id = response.json["data"]['id']
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
# Change rectification period in db
self.set_status('draft')
add_auctions(self, lot, access_header=self.access_header)
self.set_status('pending')
fromdb = self.db.get(lot['id'])
fromdb = Lot(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, lot['id'])
response = self.app.get('/{}'.format(lot['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], lot['id'])
response = self.app.post_json('/{}/auctions/{}/documents'.format(lot['id'], auction_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403
)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'You can\'t add documents to auction after rectification period'
)
response = self.app.patch_json('/{}/auctions/{}/documents/{}'.format(lot['id'], auction_id, doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403
)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'], 'You can\'t change documents after rectification period')
response = self.app.put_json('/{}/auctions/{}/documents/{}'.format(lot['id'], auction_id, doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403
)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'], 'You can\'t change documents after rectification period')
