fix: reporter tests

Author: aaxelb

osf/metrics/es8_metrics.py

@@ -508,6 +508,7 @@ class MonthlyPublicItemUsageReportEs8(djelme.CyclicRecord):
     # https://cop5.projectcounter.org/en/5.1/appendices/a-glossary-of-terms.html
     # https://coprd.countermetrics.org/en/1.0.1/appendices/a-glossary.html
     item_osfid: str
+    # fields built from aggregations -- more than one value unlikely, but possible
     item_type: list[str]           # counter:Data-Type
     provider_id: list[str]         # counter:Database(?)
     platform_iri: list[str]        # counter:Platform

osf/metrics/reporters/public_item_usage.py

@@ -64,22 +64,37 @@ def report(self, **report_kwargs):
             if _guid is None or _guid.referent is None:
                 raise _SkipItem
             _obj = _guid.referent
-            _reports = self._init_report(_obj)
-            for _report in _reports:
-                self._fill_report_counts(_report, _obj)
-                if not any((
-                    _report.view_count,
-                    _report.view_session_count,
-                    _report.download_count,
-                    _report.download_session_count,
-                )):
-                    raise _SkipItem
-            return _reports
+            _report = self._init_report(_obj)
+            self._fill_report_counts(_report, _obj)
+            if not any((
+                _report.view_count,
+                _report.view_session_count,
+                _report.download_count,
+                _report.download_session_count,
+            )):
+                raise _SkipItem
+            _report_es6 = PublicItemUsageReport(
+                item_osfid=_report.item_osfid,
+                item_type=list(_report.item_type),
+                provider_id=list(_report.provider_id),
+                platform_iri=list(_report.platform_iri),
+                view_count=_report.view_count,
+                view_session_count=_report.view_session_count,
+                download_count=_report.download_count,
+                download_session_count=_report.download_session_count,
+            )
+            return [_report, _report_es6]
         except _SkipItem:
-            return None
+            return []
 
     def followup_task(self, report):
-        _is_last_month = report.report_yearmonth.next() == YearMonth.from_date(datetime.date.today())
+        _last_month = YearMonth.from_date(datetime.date.today()).prior()
+        if isinstance(report, MonthlyPublicItemUsageReportEs8):
+            _is_last_month = (report.cycle_coverage == cycle_coverage_yearmonth(_last_month))
+        elif isinstance(report, PublicItemUsageReport):
+            _is_last_month = (report.report_yearmonth == _last_month)
+        else:
+            raise ValueError(report)
         if _is_last_month:
             from api.share.utils import task__update_share
             return task__update_share.signature(
@@ -135,27 +150,17 @@ def _preprintdownload_osfids(self, after_osfid: str | None) -> typing.Iterator[s
         )
         return _iter_composite_bucket_keys(_search, 'agg_osfid', 'osfid', after=after_osfid)
 
-    def _init_report(self, osf_obj) -> typing.List[PublicItemUsageReport | MonthlyPublicItemUsageReportEs8]:
+    def _init_report(self, osf_obj) -> MonthlyPublicItemUsageReportEs8:
         if not _is_item_public(osf_obj):
             raise _SkipItem
-        reports = []
-        report_es8 = MonthlyPublicItemUsageReportEs8(
+        return MonthlyPublicItemUsageReportEs8(
             cycle_coverage=cycle_coverage_yearmonth(self.yearmonth),
             item_osfid=osf_obj._id,
             item_type=[get_item_type(osf_obj)],
             provider_id=[get_provider_id(osf_obj)],
             platform_iri=[website_settings.DOMAIN],
-        )
-        reports.append(report_es8)
-        report = PublicItemUsageReport(
-            item_osfid=report_es8.item_osfid,
-            item_type=report_es8.item_type,
-            provider_id=report_es8.provider_id,
-            platform_iri=report_es8.platform_iri,
             # leave counts null; will be set if there's data
         )
-        reports.append(report)
-        return reports
 
     def _fill_report_counts(self, report, osf_obj):
         if (

osf_tests/management_commands/test_monthly_reporters_go.py

@@ -1,9 +1,22 @@
+import datetime
+
 from django.core.management import call_command
 from django.test import TestCase
 from elasticsearch_metrics.tests.util import djelme_test_backends
 
 from framework.celery_tasks import app as celery_app
+from osf.metrics import reports as es6_reports
+from osf.metrics.es8_metrics import (
+    MonthlyInstitutionSummaryReportEs8,
+    MonthlyInstitutionalUserReportEs8,
+    MonthlyPrivateSpamMetricsReportEs8,
+    MonthlyPublicItemUsageReportEs8,
+    MonthlySpamSummaryReportEs8,
+)
+from osf.metrics.counted_usage import CountedAuthUsage
+from osf.metrics.utils import YearMonth
 from osf_tests import factories
+from website import settings as website_settings
 
 
 class TestMonthlyReportersGo(TestCase):
@@ -13,12 +26,55 @@ def setUp(self):
             'task_always_eager': True,
             'task_eager_propagates': True,
         })
-        # set up data, so each reporter outputs something
+        self._report_yearmonth = YearMonth.from_date(datetime.date.today())
+        # set up for institutional-user report
         _inst = factories.InstitutionFactory()
         _user = factories.UserFactory()
         _user.add_or_update_affiliated_institution(_inst)
-        factories.PreprintFactory()
+        # set up for public item usage report
+        _reg = factories.RegistrationFactory(is_public=True)
+        CountedAuthUsage.record(
+            platform_iri=website_settings.DOMAIN,
+            item_guid=_reg._id,
+            session_id='blarg',
+            user_is_authenticated=True,
+            action_labels=['view', 'web'],
+        )
+        CountedAuthUsage._get_connection().indices.refresh(CountedAuthUsage._template_pattern)
+        # TODO when switching to use es8 data
+        # OsfCountedUsageEvent.record(
+        #     item_osfid=_preprint._id,
+        #     action_labels=['view', 'web'],
+        #     user_id=_user._id,
+        # )
+        # OsfCountedUsageEvent.refresh()
 
     def test_for_smoke(self):
-        call_command('monthly_reporters_go')
-        # TODO: assert more specifically
+        self._assert_count(MonthlyInstitutionSummaryReportEs8, 0)
+        self._assert_count(MonthlyInstitutionalUserReportEs8, 0)
+        self._assert_count(MonthlyPrivateSpamMetricsReportEs8, 0)
+        self._assert_count(MonthlyPublicItemUsageReportEs8, 0)
+        self._assert_count(MonthlySpamSummaryReportEs8, 0)
+        self._assert_count(es6_reports.SpamSummaryReport, 0)
+        self._assert_count(es6_reports.InstitutionalUserReport, 0)
+        self._assert_count(es6_reports.InstitutionMonthlySummaryReport, 0)
+        self._assert_count(es6_reports.PublicItemUsageReport, 0)
+        self._assert_count(es6_reports.PrivateSpamMetricsReport, 0)
+        call_command('monthly_reporters_go', yearmonth=str(self._report_yearmonth))
+        self._assert_count(MonthlyInstitutionSummaryReportEs8, 1)
+        self._assert_count(MonthlyInstitutionalUserReportEs8, 1)
+        self._assert_count(MonthlyPrivateSpamMetricsReportEs8, 1)
+        self._assert_count(MonthlyPublicItemUsageReportEs8, 1)
+        self._assert_count(MonthlySpamSummaryReportEs8, 1)
+        self._assert_count(es6_reports.SpamSummaryReport, 1)
+        self._assert_count(es6_reports.InstitutionalUserReport, 1)
+        self._assert_count(es6_reports.InstitutionMonthlySummaryReport, 1)
+        self._assert_count(es6_reports.PublicItemUsageReport, 1)
+        self._assert_count(es6_reports.PrivateSpamMetricsReport, 1)
+
+    def _assert_count(self, recordtype, expected_count):
+        if hasattr(recordtype, 'refresh'):
+            recordtype.refresh()
+        else:  # elasticsearch_metrics.imps.elastic6
+            recordtype._get_connection().indices.refresh(recordtype._template_pattern)
+        self.assertEqual(recordtype.search().count(), expected_count)

osf_tests/metrics/reporters/_testutils.py

@@ -2,7 +2,7 @@
 from osf.metrics.reports import MonthlyReport
 
 
-def list_monthly_reports(reporter: MonthlyReporter) -> list[MonthlyReport]:
+def list_monthly_reports(reporter: MonthlyReporter, *, flat=False) -> list[MonthlyReport]:
     _each_reports_list = (
         reporter.report(**_kwargs)
         for _kwargs in reporter.iter_report_kwargs()

osf_tests/metrics/reporters/test_institutional_summary_reporter.py

@@ -3,7 +3,6 @@
 import logging
 from django.test import TestCase
 from osf.metrics.reporters import InstitutionalSummaryMonthlyReporter
-from osf.metrics.reports import InstitutionMonthlySummaryReport
 from osf.metrics.utils import YearMonth
 from osf_tests.factories import (
     InstitutionFactory,
@@ -80,10 +79,9 @@ def _create_active_user(cls, institution, date_confirmed):
 
     def test_report_generation(self):
         reporter = InstitutionalSummaryMonthlyReporter(self._yearmonth)
-        reports_raw = list_monthly_reports(reporter)
-        self.assertEqual(len(reports_raw[0]), 2)
-
-        report = next(r for r in reports_raw[0] if isinstance(r, InstitutionMonthlySummaryReport))
+        reports = list_monthly_reports(reporter)
+        self.assertEqual(len(reports), 1)
+        report = reports[0]
         self.assertEqual(report.institution_id, self._institution._id)
         self.assertEqual(report.user_count, 2)  # _logged_in_user and _active_user
         self.assertEqual(report.public_project_count, 1)
@@ -116,8 +114,7 @@ def test_report_generation_multiple_institutions(self):
 
         # Run the reporter for the current month (February 2018)
         reporter = InstitutionalSummaryMonthlyReporter(self._yearmonth)
-        reports_raw = list_monthly_reports(reporter)
-        reports = [item for sublist in reports_raw for item in sublist if isinstance(item, InstitutionMonthlySummaryReport)]
+        reports = list_monthly_reports(reporter)
         self.assertEqual(len(reports), 3)  # Reports for self._institution, institution2, institution3
 
         # Extract reports by institution
@@ -266,8 +263,7 @@ def test_high_counts_multiple_institutions(self):
         if enable_benchmarking:
             reporter_start_time = time.time()
         reporter = InstitutionalSummaryMonthlyReporter(self._yearmonth)
-        reports_raw = list_monthly_reports(reporter)
-        reports = [item for sublist in reports_raw for item in sublist if isinstance(item, InstitutionMonthlySummaryReport)]
+        reports = list_monthly_reports(reporter)
         assert len(reports) == additional_institution_count + 1
 
         if enable_benchmarking:

osf_tests/metrics/reporters/test_public_item_usage_reporter.py

@@ -174,10 +174,8 @@ def test_no_data(self, ym_empty):
 
     def test_reporter(self, ym_empty, ym_sparse, ym_busy, sparse_month_usage, busy_month_item0, busy_month_item1, busy_month_item2, item0):
         _empty = list_monthly_reports(PublicItemUsageReporter(ym_empty))
-        _sparse_raw = list_monthly_reports(PublicItemUsageReporter(ym_sparse))
-        _sparse = [item for sublist in _sparse_raw for item in sublist if isinstance(item, PublicItemUsageReport)]
-        _busy_raw = list_monthly_reports(PublicItemUsageReporter(ym_busy))
-        _busy = [item for sublist in _busy_raw for item in sublist if isinstance(item, PublicItemUsageReport)]
+        _sparse = list_monthly_reports(PublicItemUsageReporter(ym_sparse))
+        _busy = list_monthly_reports(PublicItemUsageReporter(ym_busy))
 
         # empty month:
         assert _empty == []