def __init__(self, report_id, created, results, file_manager=None):
"""
TODO: Add dependency injection for the file_manager,
we are passing it on the constructor for easier testing
but the object should come from the application context
Parameters:
report_id : identifier of the report, needed to find
directory to write to if report is recurrent
created : date report was created, used to identify a single run of
a recurrent report
results : data to write to disk
file_manager: PublicReportFileManager, adding to constructor
for easy testing.
"""
self.report_id = report_id
self.created_string = format_date_for_public_report_file(created)
self.results = json_string(results)
self.file_manager = file_manager or PublicReportFileManager(
task_logger, get_absolute_path())
# there should not be a need to call these functions more than once
self.path = self.file_manager.get_public_report_path(self.report_id,
recurrent=True,
create=True)
# TODO use file manager to get function when function is available
self.filepath = os.path.join(self.path, self.created_string)
def test_save_public_report(self):
fake_path = "fake_path"
file_manager = PublicReportFileManager(self.logger,
'/some/fake/absolute/path')
file_manager.write_data = Mock()
file_manager.remove_file = Mock()
file_manager.get_public_report_path = MagicMock(return_value=fake_path)
with file_manager_set(app, file_manager):
desired_responses = [{
'name': 'Edits - test',
'cohort': {
'id': self.cohort.id,
'name': self.cohort.name,
},
'metric': {
'name': 'NamespaceEdits',
'timeseries': 'month',
'namespaces': [0, 1, 2],
'start_date': '2013-01-01 00:00:00',
'end_date': '2013-05-01 00:00:00',
'individualResults': True,
'aggregateResults': True,
'aggregateSum': False,
'aggregateAverage': True,
'aggregateStandardDeviation': False,
},
}]
json_to_post = json.dumps(desired_responses)
response = self.client.post('/reports/create/',
data=dict(responses=json_to_post))
# Wait a second for the task to get processed
time.sleep(1)
# Check that the task has been created
response = self.client.get('/reports/list/')
parsed = json.loads(response.data)
result_key = parsed['reports'][-1]['result_key']
task, report = get_celery_task(result_key)
assert_true(task and report)
# Make the report publically accessible (save it to static/public)
response = self.client.post('/reports/set-public/{}'.format(
report.id))
assert_true(response.status_code == 200)
assert_equal(file_manager.write_data.call_count, 1)
# Now make the report private (remove it from static/public)
response = self.client.post('/reports/unset-public/{}'.format(
report.id))
assert_true(response.status_code == 200)
file_manager.remove_file.assert_called_with(fake_path)
assert_equal(file_manager.remove_file.call_count, 1)
def setUp(self):
logger = Mock(spec=RootLogger)
self.results = {'results': 'good'}
self.fake_path = '/fake/fake/path/'
file_manager = PublicReportFileManager(logger, '/some/fake/absolute/path')
file_manager.write_data = Mock()
file_manager.remove_file = Mock()
file_manager.get_public_report_path = MagicMock(return_value=self.fake_path)
file_manager.coalesce_recurrent_reports = MagicMock(return_value=self.results)
file_manager.remove_old_report_files = MagicMock()
self.file_manager = file_manager
def setup_filemanager():
if request.endpoint is not None:
if request.path.startswith('/reports'):
file_manager = getattr(g, 'file_manager', None)
if file_manager is None:
g.file_manager = PublicReportFileManager(
app.logger,
app.absolute_path_to_app_root)
cohort_service = getattr(g, 'cohort_service', None)
centralauth_service = getattr(g, 'centralauth_service', None)
if cohort_service is None:
g.cohort_service = CohortService()
if centralauth_service is None:
g.centralauth_service = CentralAuthService()
def test_public_report_state_change_error(self):
"""
Persistent Report should propagate IO errors from
PublicReportFileManager
"""
self.app = Mock()
self.logger = Mock(spec=RootLogger)
file_manager = PublicReportFileManager(self.logger,
'/some/fake/absolute/path')
file_manager.write_data = Mock(
side_effect=PublicReportIOError('Boom!'))
# do not write anything to disk
file_manager.get_public_report_path = Mock()
ReportStore.make_report_public(self.reports[0].id,
self.reports[0].user_id, file_manager,
'testing data')
def setUp(self):
# setup mock logger
self.logger = Mock(spec=RootLogger)
self.api = PublicReportFileManager(self.logger, './wikimetrics/')
self.test_report_path = os.path.join(get_absolute_path(), os.pardir,
'tests')
