diff options
Diffstat (limited to 'tests/models/spectrum/test_survey.py')
| -rw-r--r-- | tests/models/spectrum/test_survey.py | 413 |
1 files changed, 413 insertions, 0 deletions
diff --git a/tests/models/spectrum/test_survey.py b/tests/models/spectrum/test_survey.py new file mode 100644 index 0000000..65dec60 --- /dev/null +++ b/tests/models/spectrum/test_survey.py @@ -0,0 +1,413 @@ +from datetime import timezone, datetime +from decimal import Decimal + + +class TestSpectrumCondition: + + def test_condition_create(self): + from generalresearch.models import LogicalOperator + from generalresearch.models.spectrum.survey import ( + SpectrumCondition, + ) + from generalresearch.models.thl.survey.condition import ConditionValueType + + c = SpectrumCondition.from_api( + { + "qualification_code": 212, + "range_sets": [ + {"units": 311, "to": 28, "from": 25}, + {"units": 311, "to": 42, "from": 40}, + ], + } + ) + assert ( + SpectrumCondition( + question_id="212", + values=["25-28", "40-42"], + value_type=ConditionValueType.RANGE, + negate=False, + logical_operator=LogicalOperator.OR, + ) + == c + ) + + # These equal each other b/c age ranges get automatically converted + assert ( + SpectrumCondition( + question_id="212", + values=["25", "26", "27", "28", "40", "41", "42"], + value_type=ConditionValueType.LIST, + negate=False, + logical_operator=LogicalOperator.OR, + ) + == c + ) + + c = SpectrumCondition.from_api( + { + "condition_codes": ["111", "117", "112", "113", "118"], + "qualification_code": 1202, + } + ) + assert ( + SpectrumCondition( + question_id="1202", + values=["111", "112", "113", "117", "118"], + value_type=ConditionValueType.LIST, + negate=False, + logical_operator=LogicalOperator.OR, + ) + == c + ) + + +class TestSpectrumQuota: + + def test_quota_create(self): + from generalresearch.models.spectrum.survey import ( + SpectrumCondition, + SpectrumQuota, + ) + + d = { + "quota_id": "a846b545-4449-4d76-93a2-f8ebdf6e711e", + "quantities": {"currently_open": 57, "remaining": 57, "achieved": 0}, + "criteria": [{"qualification_code": 211, "condition_codes": ["111"]}], + "crtd_on": 1716227282077, + "mod_on": 1716227284146, + "last_complete_date": None, + } + criteria = [SpectrumCondition.from_api(q) for q in d["criteria"]] + d["condition_hashes"] = [x.criterion_hash for x in criteria] + q = SpectrumQuota.from_api(d) + assert SpectrumQuota(remaining_count=57, condition_hashes=["c23c0b9"]) == q + assert q.is_open + + def test_quota_passes(self): + from generalresearch.models.spectrum.survey import ( + SpectrumQuota, + ) + + q = SpectrumQuota(remaining_count=57, condition_hashes=["a"]) + assert q.passes({"a": True}) + assert not q.passes({"a": False}) + assert not q.passes({}) + + # We have to match all + q = SpectrumQuota(remaining_count=57, condition_hashes=["a", "b", "c"]) + assert not q.passes({"a": True, "b": False}) + assert q.passes({"a": True, "b": True, "c": True}) + + # Quota must be open, even if we match + q = SpectrumQuota(remaining_count=0, condition_hashes=["a"]) + assert not q.passes({"a": True}) + + def test_quota_passes_soft(self): + from generalresearch.models.spectrum.survey import ( + SpectrumQuota, + ) + + q = SpectrumQuota(remaining_count=57, condition_hashes=["a", "b", "c"]) + # Pass if we match all + assert (True, set()) == q.matches_soft({"a": True, "b": True, "c": True}) + # Fail if we don't match any + assert (False, set()) == q.matches_soft({"a": True, "b": False, "c": None}) + # Unknown if any are unknown AND we don't fail any + assert (None, {"c", "b"}) == q.matches_soft({"a": True, "b": None, "c": None}) + assert (None, {"a", "c", "b"}) == q.matches_soft( + {"a": None, "b": None, "c": None} + ) + assert (False, set()) == q.matches_soft({"a": None, "b": False, "c": None}) + + +class TestSpectrumSurvey: + def test_survey_create(self): + from generalresearch.models import ( + LogicalOperator, + Source, + TaskCalculationType, + ) + from generalresearch.models.spectrum import SpectrumStatus + from generalresearch.models.spectrum.survey import ( + SpectrumCondition, + SpectrumQuota, + SpectrumSurvey, + ) + from generalresearch.models.thl.survey.condition import ConditionValueType + + # Note: d is the raw response after calling SpectrumAPI.preprocess_survey() on it! + d = { + "survey_id": 29333264, + "survey_name": "Exciting New Survey #29333264", + "survey_status": 22, + "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc), + "category": "Exciting New", + "category_code": 232, + "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc), + "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc), + "soft_launch": False, + "click_balancing": 0, + "price_type": 1, + "pii": False, + "buyer_message": "", + "buyer_id": 4726, + "incl_excl": 0, + "cpi": Decimal("1.20000"), + "last_complete_date": None, + "project_last_complete_date": None, + "survey_performance": { + "overall": {"ir": 40, "loi": 10}, + "last_block": {"ir": None, "loi": None}, + }, + "supplier_completes": { + "needed": 495, + "achieved": 0, + "remaining": 495, + "guaranteed_allocation": 0, + "guaranteed_allocation_remaining": 0, + }, + "pds": {"enabled": False, "buyer_name": None}, + "quotas": [ + { + "quota_id": "c2bc961e-4f26-4223-b409-ebe9165cfdf5", + "quantities": { + "currently_open": 491, + "remaining": 495, + "achieved": 0, + }, + "criteria": [ + { + "qualification_code": 212, + "range_sets": [{"units": 311, "to": 64, "from": 18}], + } + ], + "crtd_on": 1716227293496, + "mod_on": 1716229289847, + "last_complete_date": None, + } + ], + "qualifications": [ + { + "range_sets": [{"units": 311, "to": 64, "from": 18}], + "qualification_code": 212, + } + ], + "country_iso": "fr", + "language_iso": "fre", + "bid_ir": 0.4, + "bid_loi": 600, + "last_block_ir": None, + "last_block_loi": None, + "survey_exclusions": set(), + "exclusion_period": 0, + } + s = SpectrumSurvey.from_api(d) + expected_survey = SpectrumSurvey( + cpi=Decimal("1.20000"), + country_isos=["fr"], + language_isos=["fre"], + buyer_id="4726", + source=Source.SPECTRUM, + used_question_ids={"212"}, + survey_id="29333264", + survey_name="Exciting New Survey #29333264", + status=SpectrumStatus.LIVE, + field_end_date=datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc), + category_code="232", + calculation_type=TaskCalculationType.COMPLETES, + requires_pii=False, + survey_exclusions=set(), + exclusion_period=0, + bid_ir=0.40, + bid_loi=600, + last_block_loi=None, + last_block_ir=None, + overall_loi=None, + overall_ir=None, + project_last_complete_date=None, + country_iso="fr", + language_iso="fre", + include_psids=None, + exclude_psids=None, + qualifications=["77f493d"], + quotas=[SpectrumQuota(remaining_count=491, condition_hashes=["77f493d"])], + conditions={ + "77f493d": SpectrumCondition( + logical_operator=LogicalOperator.OR, + value_type=ConditionValueType.RANGE, + negate=False, + question_id="212", + values=["18-64"], + ) + }, + created_api=datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc), + modified_api=datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc), + updated=None, + ) + assert expected_survey.model_dump_json() == s.model_dump_json() + + def test_survey_properties(self): + from generalresearch.models.spectrum.survey import ( + SpectrumSurvey, + ) + + d = { + "survey_id": 29333264, + "survey_name": "#29333264", + "survey_status": 22, + "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc), + "category": "Exciting New", + "category_code": 232, + "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc), + "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc), + "soft_launch": False, + "click_balancing": 0, + "price_type": 1, + "pii": False, + "buyer_message": "", + "buyer_id": 4726, + "incl_excl": 0, + "cpi": Decimal("1.20000"), + "last_complete_date": None, + "project_last_complete_date": None, + "quotas": [ + { + "quota_id": "c2bc961e-4f26-4223-b409-ebe9165cfdf5", + "quantities": { + "currently_open": 491, + "remaining": 495, + "achieved": 0, + }, + "criteria": [ + { + "qualification_code": 214, + "range_sets": [{"units": 311, "to": 64, "from": 18}], + } + ], + } + ], + "qualifications": [ + { + "range_sets": [{"units": 311, "to": 64, "from": 18}], + "qualification_code": 212, + }, + {"condition_codes": ["111", "117", "112"], "qualification_code": 1202}, + ], + "country_iso": "fr", + "language_iso": "fre", + "overall_ir": 0.4, + "overall_loi": 600, + "last_block_ir": None, + "last_block_loi": None, + "survey_exclusions": set(), + "exclusion_period": 0, + } + s = SpectrumSurvey.from_api(d) + assert {"212", "1202", "214"} == s.used_question_ids + assert s.is_live + assert s.is_open + assert {"38cea5e", "83955ef", "77f493d"} == s.all_hashes + + def test_survey_eligibility(self): + from generalresearch.models.spectrum.survey import ( + SpectrumQuota, + SpectrumSurvey, + ) + + d = { + "survey_id": 29333264, + "survey_name": "#29333264", + "survey_status": 22, + "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc), + "category": "Exciting New", + "category_code": 232, + "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc), + "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc), + "soft_launch": False, + "click_balancing": 0, + "price_type": 1, + "pii": False, + "buyer_message": "", + "buyer_id": 4726, + "incl_excl": 0, + "cpi": Decimal("1.20000"), + "last_complete_date": None, + "project_last_complete_date": None, + "quotas": [], + "qualifications": [], + "country_iso": "fr", + "language_iso": "fre", + "overall_ir": 0.4, + "overall_loi": 600, + "last_block_ir": None, + "last_block_loi": None, + "survey_exclusions": set(), + "exclusion_period": 0, + } + s = SpectrumSurvey.from_api(d) + s.qualifications = ["a", "b", "c"] + s.quotas = [ + SpectrumQuota(remaining_count=10, condition_hashes=["a", "b"]), + SpectrumQuota(remaining_count=0, condition_hashes=["d"]), + SpectrumQuota(remaining_count=10, condition_hashes=["e"]), + ] + + assert s.passes_qualifications({"a": True, "b": True, "c": True}) + assert not s.passes_qualifications({"a": True, "b": True, "c": False}) + + # we do NOT match a full quota, so we pass + assert s.passes_quotas({"a": True, "b": True, "d": False}) + # We dont pass any + assert not s.passes_quotas({}) + # we only pass a full quota + assert not s.passes_quotas({"d": True}) + # we only dont pass a full quota, but we haven't passed any open + assert not s.passes_quotas({"d": False}) + # we pass a quota, but also pass a full quota, so fail + assert not s.passes_quotas({"e": True, "d": True}) + # we pass a quota, but are unknown in a full quota, so fail + assert not s.passes_quotas({"e": True}) + + # # Soft Pair + assert (True, set()) == s.passes_qualifications_soft( + {"a": True, "b": True, "c": True} + ) + assert (False, set()) == s.passes_qualifications_soft( + {"a": True, "b": True, "c": False} + ) + assert (None, set("c")) == s.passes_qualifications_soft( + {"a": True, "b": True, "c": None} + ) + + # we do NOT match a full quota, so we pass + assert (True, set()) == s.passes_quotas_soft({"a": True, "b": True, "d": False}) + # We dont pass any + assert (None, {"a", "b", "d", "e"}) == s.passes_quotas_soft({}) + # we only pass a full quota + assert (False, set()) == s.passes_quotas_soft({"d": True}) + # we only dont pass a full quota, but we haven't passed any open + assert (None, {"a", "b", "e"}) == s.passes_quotas_soft({"d": False}) + # we pass a quota, but also pass a full quota, so fail + assert (False, set()) == s.passes_quotas_soft({"e": True, "d": True}) + # we pass a quota, but are unknown in a full quota, so fail + assert (None, {"d"}) == s.passes_quotas_soft({"e": True}) + + assert s.determine_eligibility({"a": True, "b": True, "c": True, "d": False}) + assert not s.determine_eligibility( + {"a": True, "b": True, "c": False, "d": False} + ) + assert not s.determine_eligibility( + {"a": True, "b": True, "c": None, "d": False} + ) + assert (True, set()) == s.determine_eligibility_soft( + {"a": True, "b": True, "c": True, "d": False} + ) + assert (False, set()) == s.determine_eligibility_soft( + {"a": True, "b": True, "c": False, "d": False} + ) + assert (None, set("c")) == s.determine_eligibility_soft( + {"a": True, "b": True, "c": None, "d": False} + ) + assert (None, {"c", "d"}) == s.determine_eligibility_soft( + {"a": True, "b": True, "c": None, "d": None} + ) |