def test_generate_recurrent_orders_report_with_params_wrong(self):
self.create_recurrent_order_false_params()
with self.assertRaises(WrongInputValue):
self.generate_report(
format_date_short(datetime.today() - timedelta(days=5)),
format_date_short(datetime.today()), 'False', 'wrong')
def test_generate_no_orders_report(self):
report = self.generate_report(
format_date_short(datetime.today() + timedelta(days=5)),
format_date_short(datetime.today() + timedelta(days=10)))
response = self.view_report(report.id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
with self.assertRaises(CanNotDownloadReportError):
self.download_report(report.id, file_format=FILE_FORMAT_JSON)
report.refresh_from_db()
report.status = INTERNAL_REPORT_STATUS_READY
report.save()
with self.assertRaises(ReportDataError):
self.download_report(report.id, file_format=FILE_FORMAT_JSON)
with self.assertRaises(WrongFileFormat):
self.download_report(report.id, file_format='fake')
report.refresh_from_db()
report.data = None
report.save()
with self.assertRaises(ReportDataError):
self.download_report(report.id, file_format=FILE_FORMAT_JSON)
def generate_report(self,
start_date=format_date_short(datetime.now() -
timedelta(days=90)),
end_date=format_date_short(datetime.now()),
consecutive_days=10,
amount_to_validate=50):
response = self.send_request(start_date, end_date, consecutive_days,
amount_to_validate)
report_id = response.data['id']
internal_report = InternalReport.objects.get(pk=report_id)
generator = ReporterActiveUsersList(
context=self.context,
start_date=start_date,
end_date=end_date,
consecutive_days=consecutive_days,
amount_to_validate=amount_to_validate)
generator.internal_report = internal_report
generator.run(internal_report)
internal_report.refresh_from_db()
return internal_report
def prepare_active_user_data(average_portfolio_value,
portfolio_history,
portfolio_history_dates,
user,
consecutive_days_data,
average_value_of_consecutive_days):
"""
Prepare dict with data for each user
:param average_portfolio_value: average portfolio value for current user
:param portfolio_history: portfolio history
:param portfolio_history_dates: list with dates from portfolio history
:param user: user object
:param consecutive_days_data: list with consecutive days data consist of
date and daily_portfolio_value for each day
:param average_value_of_consecutive_days:
:return:
"""
return dict(
personid=user.app_uid,
position_start_date=format_date_short(consecutive_days_data[0]['date']),
position_start_value=round(
consecutive_days_data[0]['daily_portfolio_value'], 2),
position_average_value=round(average_portfolio_value, 2),
position_end_date=format_date_short(portfolio_history_dates[-1]),
position_end_value=calc_daily_portfolio_value(
portfolio_history.get(portfolio_history_dates[-1])['components']),
consecutive_days=len(consecutive_days_data),
average_value_of_consecutive_days=round(
average_value_of_consecutive_days, 2),
first_date_reported=format_date_short(portfolio_history_dates[0]),
position_first_date_reported=calc_daily_portfolio_value(
portfolio_history.get(portfolio_history_dates[0])['components']),
error=None
)
def generate_active_users_list(self, request):
"""
Start report generating with active users
:param request: Request from client side
:return: Response with active users
"""
context = request.user.appcontextmembers.context
parameters = request.query_params
start_date = get_date(parameters.get(
'start_date', None), 'start_date')
end_date = get_date(parameters.get(
'end_date', None), 'end_date')
consecutive_days = get_required_int_value(parameters.get(
'consecutive_days', None), 'consecutive_days')
amount_to_validate = get_required_int_value(parameters.get(
'amount_to_validate', None), 'amount_to_validate')
return start_report_generating(
context,
INTERNAL_REPORT_ACTIVE_USERS,
input_data=dict(
start_date=format_date_short(start_date),
end_date=format_date_short(end_date),
consecutive_days=consecutive_days,
amount_to_validate=amount_to_validate
)
)
def validate(self):
"""
Validate quarter report data
:return: dict of invalid data
"""
if self.portfolio_creating_date > self.end_date:
return
self.prepare_data()
if not self.is_report_data_valid():
self.summary.pop('flow_per_asset')
last_sell_date = self.summary['last_sell_date']
if last_sell_date:
last_sell_date = format_date_short(last_sell_date)
self.summary['last_sell_date'] = last_sell_date
return dict(
user_id=self.user_mapping.app_uid,
start_date=format_date_short(self.start_date),
end_date=format_date_short(self.end_date),
context=self.user_mapping.app_context.name,
revenue_is_valid=self.revenue_is_valid,
start_values_are_valid=self.start_valid,
end_values_are_valid=self.end_valid,
transaction_and_revenue_valid=self.trans_and_revenue_valid,
is_cash_component_valid=self.vs_valid,
revenue_per_asset_valid=self.revenue_per_asset_valid,
**self.summary)
def test_check_endpoint_wrong_dates_order(self):
start_date = format_date_short(datetime.now().date())
end_date = format_date_short(datetime.now().date() -
timedelta(days=10))
with self.assertRaises(WrongParameterError):
self.send_request(start_date=start_date, end_date=end_date)
def test_generate_orders_report_with_date_range(self):
report = self.generate_report(
format_date_short(datetime.today() - timedelta(days=5)),
format_date_short(datetime.today()))
response = self.view_report(report.id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.download_report(report.id,
file_format=FILE_FORMAT_JSON)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_generate_recurrent_orders_report_with_params_false(self):
self.create_recurrent_order_false_params()
report = self.generate_report(
format_date_short(datetime.today() - timedelta(days=5)),
format_date_short(datetime.today()), 'False', 'False')
response = self.view_report(report.id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.download_report(report.id,
file_format=FILE_FORMAT_JSON)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_endpoint_broken_report(self):
InternalReport.objects.create(context=self.context,
type=INTERNAL_REPORT_ACTIVE_USERS,
status=INTERNAL_REPORT_STATUS_GENERATING,
input_data=json.dumps({}),
generated=datetime.now() -
timedelta(hours=48))
start_date = format_date_short(datetime.now().date() -
timedelta(hours=72))
end_date = format_date_short(datetime.now().date())
response = self.send_request(start_date=start_date, end_date=end_date)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_endpoint_correct_dates(self):
date = format_date_short(datetime.now().date())
response = self.send_request(start_date=date, end_date=date)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def format_date_short_or_none(date):
"""
Format date to format YYYY-MM-DD if it's present
:param date: date object
:return: formatted string or None
"""
if date:
return format_date_short(date)
return None
def get_portfolio_history(*_, **__):
temp_date = start_date
target_date = datetime.today() - timedelta(days=30)
data = list()
while temp_date <= end_date:
if temp_date <= target_date:
price = 20
else:
price = 10
components = [
dict(isin=FAKE_ISIN_1,
name=FAKE_FUND_NAME_1,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=FAKE_ISIN_2,
name=FAKE_FUND_NAME_2,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=FAKE_ISIN_3,
name=FAKE_FUND_NAME_3,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=ISIN_CASH_COMPONENT,
name=INVESTMENT_CASH_COMPONENT,
quantity=1,
price=1,
price_eur=1,
fx_rate=None,
ffill_used=False)
]
data.append(
dict(date=format_date_short(temp_date),
components=components))
temp_date += timedelta(days=1)
return data
def test_generate_goals_report_with_end_date_only(self):
create_goal(self.user_mapping)
report = self.generate_report(None,
format_date_short(datetime.today()))
response = self.view_report(report.id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.download_report(report.id,
file_format=FILE_FORMAT_JSON)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def send_request(self, end_date=None):
request = self.factory.get(reverse('internal:validate-quarter-data'))
request.user = self.service_c_user
request.query_params = dict()
if end_date:
request.query_params.update(
dict(end_date=format_date_short(end_date)))
view = QuarterDataValidationView()
return view.validate_quarter_data(request=request)
def get_portfolio_history(*_, **__):
target_date = datetime.today() - timedelta(days=30)
return [{
'date':
format_date_short(target_date),
'components': [{}, {}, {}, {
'ffill_used': False,
'fx_rate': None,
'isin': 'XF0000000EUR',
'name': 'Prospery Invest cash artificial account',
'price': 1,
'price_eur': 1,
'quantity': 0
}],
}]
def generate_report(self, end_date=None):
response = self.send_request(end_date=end_date)
report_id = response.data['id']
internal_report = InternalReport.objects.get(pk=report_id)
generator = ReporterInvalidQuarterData(
context=self.context, end_date=format_date_short(end_date))
generator.internal_report = internal_report
generator.run(internal_report)
internal_report.refresh_from_db()
return internal_report
def validate_quarter_data(self, request):
"""
Start report generating with invalid quarter reports
:param request: Request from client side
:return: Response with data for users who did not pass validation
---
"""
parameters = request.query_params
end_date = get_end_date_from_request(parameters)
context = request.user.appcontextmembers.context
return start_report_generating(
context,
INTERNAL_REPORT_QUARTER_VALIDATION,
input_data=dict(
end_date=format_date_short(end_date)
)
)
def test_generate_active_users_list_with_specific_history(self):
end_date = datetime.today()
start_date = end_date - timedelta(days=60)
def get_portfolio_history(*_, **__):
temp_date = start_date
target_date = datetime.today() - timedelta(days=30)
data = list()
while temp_date <= end_date:
if temp_date <= target_date:
price = 20
else:
price = 10
components = [
dict(isin=FAKE_ISIN_1,
name=FAKE_FUND_NAME_1,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=FAKE_ISIN_2,
name=FAKE_FUND_NAME_2,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=FAKE_ISIN_3,
name=FAKE_FUND_NAME_3,
quantity=1,
price=None,
price_eur=price,
fx_rate=None,
ffill_used=True),
dict(isin=ISIN_CASH_COMPONENT,
name=INVESTMENT_CASH_COMPONENT,
quantity=1,
price=1,
price_eur=1,
fx_rate=None,
ffill_used=False)
]
data.append(
dict(date=format_date_short(temp_date),
components=components))
temp_date += timedelta(days=1)
return data
with patch('pdf.utils.get_portfolio_history', get_portfolio_history):
report = self.generate_report(
consecutive_days=1,
amount_to_validate=50,
start_date=format_date_short(start_date),
end_date=format_date_short(end_date))
response = self.view_report(report.id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_endpoint_with_dates(self):
with self.assertRaises(RequiredParameters):
self.send_request(
start_date=format_date_short(datetime.now().date()),
end_date=format_date_short(datetime.now().date()))
def test_check_endpoint_dates_in_future(self):
date = format_date_short(datetime.now().date() + timedelta(days=100))
with self.assertRaises(WrongParameterError):
self.send_request(start_date=date, end_date=date)
