def test_deleted_metric(self, request):
"""Post an measurement for a deleted metric."""
self.database.measurements.find_one.return_value = dict(_id="id", sources=[])
self.report["subjects"][SUBJECT_ID]["metrics"] = {}
request.json = dict(metric_uuid=METRIC_ID, sources=[])
self.assertEqual(dict(ok=False), post_measurement(self.database))
self.database.measurements.update_one.assert_not_called()
def test_ignored_measurement_entities_and_failed_measurement(
self, request):
"""Post a measurement where the last successful one has ignored entities."""
self.database.measurements.find_one.side_effect = [
dict(
_id="id1",
count=dict(status=None, status_start="2018-12-01"),
sources=[self.source()],
),
dict(
_id="id2",
status="target_met",
sources=[
self.source(
entities=[dict(key="entity1")],
entity_user_data=dict(entity1=dict(
status="false_positive", rationale="Rationale")),
)
],
),
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="entity1")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="target_met", value="0"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_entity_key(self, request):
"""Post a measurement whose value and entities are the same, except for a changed entity key."""
self.old_measurement["sources"] = [
self.source(entities=[dict(key="a")],
entity_user_data=dict(a=dict(status="confirmed")))
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(old_key="a", key="b")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once_with(
dict(
metric_uuid=METRIC_ID,
sources=[
self.source(
entities=[dict(key="b", old_key="a")],
entity_user_data=dict(b=dict(status="confirmed")))
],
count=dict(
value="1",
status="near_target_met",
status_start="2019-01-01",
direction="<",
target="0",
near_target="10",
debt_target=None,
),
start="2019-01-01",
end="2019-01-01",
))
def test_first_measurement(self, request):
"""Post the first measurement for a metric."""
self.database.measurements.find_one.return_value = None
self.database.measurements.find.return_value = []
request.json = dict(metric_uuid=METRIC_ID, sources=[])
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_value(self, request):
"""Post a changed measurement for a metric."""
self.posted_measurement["sources"].append(self.source())
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_new_source(self, request):
"""Post a measurement for a new source."""
del self.old_measurement["sources"][0]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="entity1")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_value(self, request):
"""Post a changed measurement for a metric."""
measurement = self.database.measurements.find_one.return_value = dict(
_id="id", metric_uuid=METRIC_ID, status="target_met",
sources=[dict(source_uuid=SOURCE_ID, value="0", entities=[])])
self.database.measurements.find.return_value = [measurement]
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", total=None, parse_error=None, connection_error=None, entities=[]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_technical_debt_off(self, request):
"""Test that a new measurement is added when technical debt has been turned off."""
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID]["debt_target"] = "100"
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID]["accept_debt"] = False
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", parse_error=None, connection_error=None, entities=[]))
self.database.measurements.find_one.return_value = dict(
_id="id", metric_uuid=METRIC_ID, sources=self.sources,
count=dict(value="1", status="debt_target_met", target="0", near_target="10", debt_target="100"))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_ignored_measurement_entities(self, request):
"""Post a measurement where the old one has ignored entities."""
self.database.measurements.find_one.return_value = dict(
_id="id", status="target_met",
sources=[
dict(value="1", parse_error=None, connection_error=None,
entity_user_data=dict(entity1=dict(status="false_positive", rationale="Rationale")),
entities=[dict(key="entity1")])])
self.sources.append(dict(value="1", parse_error=None, connection_error=None, entities=[dict(key="entity1")]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.assertEqual(dict(ok=True), post_measurement(self.database))
self.database.measurements.update_one.assert_called_once_with(
filter={'_id': 'id'}, update={'$set': {'end': '2019-01-01'}})
def test_all_previous_measurements_were_failed_measurements(self, request):
"""Post a measurement without a last successful one."""
self.database.measurements.find_one.side_effect = [
dict(_id="id1",
count=dict(status=None),
sources=[self.source(connection_error="Error")]),
None,
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="entity1")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_entities(self, request):
"""Post a measurement whose value is the same, but with different entities."""
measurement = self.database.measurements.find_one.return_value = dict(
_id="id", metric_uuid=METRIC_ID, status="target_met",
sources=[
dict(source_uuid=SOURCE_ID, value="1", entities=[dict(key="a")],
entity_user_data=dict(a="attributes"))])
self.database.measurements.find.return_value = [measurement]
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", total=None, parse_error=None, connection_error=None,
entities=[dict(key="b")]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_all_previous_measurements_were_failed_measurements(self, request):
"""Post a measurement without a last successful one."""
self.database.measurements.find_one.side_effect = [
dict(
_id="id1",
status=None,
sources=[
dict(source_uuid=SOURCE_ID, value=None, parse_error=None, connection_error="Error", entities=[])]),
None]
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", parse_error=None, connection_error=None,
entities=[dict(key="entity1")]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_technical_debt_off(self, request):
"""Test that a new measurement is added when technical debt has been turned off."""
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID][
"debt_target"] = "100"
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID][
"accept_debt"] = False
self.posted_measurement["sources"].append(self.source())
self.old_measurement["count"] = dict(value="1",
status="debt_target_met",
target="0",
near_target="10",
debt_target="100")
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_ignored_measurement_entities(self, request):
"""Post a measurement where the old one has ignored entities."""
self.old_measurement["sources"] = [
self.source(
entities=[dict(key="entity1")],
entity_user_data=dict(entity1=dict(status="false_positive",
rationale="Rationale")),
)
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="entity1")]))
request.json = self.posted_measurement
self.assertEqual(dict(ok=True), post_measurement(self.database))
self.database.measurements.update_one.assert_called_once_with(
filter={"_id": "id"}, update={"$set": {
"end": "2019-01-01"
}})
def test_expired_technical_debt(self, request):
"""Test that a new measurement is added when technical debt expires."""
debt_end_date = date.today() - timedelta(days=1)
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID][
"debt_end_date"] = debt_end_date.isoformat()
self.report["subjects"][SUBJECT_ID]["metrics"][METRIC_ID][
"debt_target"] = "100"
self.posted_measurement["sources"].append(self.source())
self.old_measurement["count"] = dict(value="1",
status="debt_target_met",
target="0",
near_target="10",
debt_target="100")
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_entities(self, request):
"""Post a measurement whose value is the same, but with different entities."""
self.old_measurement["count"] = dict(status="near_target_met",
status_start="2018-01-01",
value="1")
self.old_measurement["sources"] = [
self.source(entities=[dict(key="a")],
entity_user_data=dict(a="attributes"))
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="b")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met",
status_start="2018-01-01",
value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_ignored_measurement_entities_and_failed_measurement(self, request):
"""Post a measurement where the last successful one has ignored entities."""
self.database.measurements.find_one.side_effect = [
dict(
_id="id1", status=None,
sources=[
dict(source_uuid=SOURCE_ID, value=None, parse_error=None, connection_error="Error", entities=[])]),
dict(
_id="id2", status="target_met",
sources=[
dict(source_uuid=SOURCE_ID, value="1", parse_error=None, connection_error=None,
entity_user_data=dict(entity1=dict(status="false_positive", rationale="Rationale")),
entities=[dict(key="entity1")])])]
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", parse_error=None, connection_error=None,
entities=[dict(key="entity1")]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="target_met", value="0"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
def test_changed_measurement_entity_key(self, request):
"""Post a measurement whose value and entities are the same, except for a changed entity key."""
measurement = self.database.measurements.find_one.return_value = dict(
_id="id", metric_uuid=METRIC_ID, status="target_met",
sources=[
dict(source_uuid=SOURCE_ID, value="1", entities=[dict(key="a")],
entity_user_data=dict(a=dict(status="confirmed")))])
self.database.measurements.find.return_value = [measurement]
self.sources.append(
dict(source_uuid=SOURCE_ID, value="1", total=None, parse_error=None, connection_error=None,
entities=[dict(old_key="a", key="b")]))
request.json = dict(metric_uuid=METRIC_ID, sources=self.sources)
self.new_measurement["count"].update(dict(status="near_target_met", value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once_with(
dict(
metric_uuid=METRIC_ID,
sources=[
dict(source_uuid=SOURCE_ID, value="1", total=None, parse_error=None, connection_error=None,
entities=[dict(key="b", old_key="a")], entity_user_data=dict(b=dict(status="confirmed")))],
count=dict(
value="1", status="near_target_met", direction="<", target="0", near_target="10", debt_target=None),
start="2019-01-01", end="2019-01-01"))
def test_unchanged_measurement(self, request):
"""Post an unchanged measurement for a metric."""
self.posted_measurement["sources"] = self.old_measurement["sources"]
request.json = self.posted_measurement
self.assertEqual(dict(ok=True), post_measurement(self.database))
self.database.measurements.update_one.assert_called_once()
def test_unchanged_measurement(self, request):
"""Post an unchanged measurement for a metric."""
self.database.measurements.find_one.return_value = dict(_id="id", sources=[])
request.json = dict(metric_uuid=METRIC_ID, sources=[])
self.assertEqual(dict(ok=True), post_measurement(self.database))
self.database.measurements.update_one.assert_called_once()
def test_changed_measurement_entities(self, request):
"""Post a measurement whose value is the same, but with different entities.
Entity user data will be changed as follows:
- Entity data belonging to entities still present is simply copied.
- Entity data no longer belonging to an entity because the entity disappeared will be marked as orphaned.
- Entity data that was orphaned recently will still be orphaned.
- Entity data that was orphaned long ago will be deleted.
- Entity data that was orphaned, but whose entity reappears, will no longer be orphaned.
"""
self.old_measurement["count"] = dict(status="near_target_met",
status_start="2018-01-01",
value="1")
self.old_measurement["sources"] = [
self.source(
entities=[dict(key="a")],
entity_user_data=dict(
a=dict(status="confirmed"), # Will be newly orphaned
b=dict(status="confirmed", orphaned_since="2021-01-01"
), # Will be reunited with its entity
c=dict(
status="confirmed",
orphaned_since="2021-01-01"), # Will still be orphaned
d=dict(status="confirmed", orphaned_since="2020-01-01"
), # Orphaned too long, will be deleted
),
)
]
self.posted_measurement["sources"].append(
self.source(entities=[dict(key="b")]))
request.json = self.posted_measurement
self.new_measurement["count"].update(
dict(status="near_target_met",
status_start="2018-01-01",
value="1"))
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once_with(
dict(
metric_uuid=METRIC_ID,
sources=[
self.source(
entities=[dict(key="b")],
entity_user_data=dict(
a=dict(
status="confirmed",
orphaned_since="2020-01-01"), # Newly orphaned
b=dict(status="confirmed"), # No longer orphaned
c=dict(
status="confirmed",
orphaned_since="2021-01-01"), # Still orphaned
),
)
],
count=dict(
value="1",
status="near_target_met",
status_start="2018-01-01",
direction="<",
target="0",
near_target="10",
debt_target=None,
),
start="2019-01-01",
end="2019-01-01",
))
def test_deleted_metric(self, request):
"""Post a measurement for a deleted metric."""
self.report["subjects"][SUBJECT_ID]["metrics"] = {}
request.json = self.posted_measurement
self.assertEqual(dict(ok=False), post_measurement(self.database))
self.database.measurements.update_one.assert_not_called()
def test_first_measurement(self, request):
"""Post the first measurement for a metric."""
self.database.measurements.find_one.return_value = None
request.json = self.posted_measurement
self.assertEqual(self.new_measurement, post_measurement(self.database))
self.database.measurements.insert_one.assert_called_once()
