test: add observed var tests

harryle95 · harryle95 · commit 77355ba997e0 · 2024-05-31T16:54:50.000+09:30
diff --git a/tests/router/method/fixture.py b/tests/router/method/fixture.py
@@ -20,15 +20,16 @@ class MethodReferenceResponse:
 
 @dataclass
 class MethodResponse:
-    method_reference_response: Response
     method_response: Response
     device_response: Response | None = None
+    method_reference_response: Response | None = None
 
 
 @dataclass
 class AllMethodFixtureResponse:
     day_to_anthesis: MethodResponse
     projected_shoot_area: MethodResponse
+    zn_concentration: MethodResponse
     method_reference: MethodReferenceResponse
 
 
@@ -55,16 +56,20 @@ class AllMethodFixtureResponse:
     "comprising two side views and a view from above. The imaging data was prepared using the SET method "
     "check reference for the computations.",
 )
+ZN_CONCENTRATION_METHOD = Method(
+    name="calculate zn concentration using Inductive Coupled plansma",
+    description="concentration of zinc(2+) measured by Inductively Coupled Plasma method",
+)
 
 
 async def get_method_fixture(
     data: Method,
-    reference: Response,
     test_client: AsyncTestClient,
     id: UUID | None = None,
     device: Response | None = None,
+    reference: Response | None = None,
 ) -> MethodResponse:
-    method_reference_id = reference.json()["id"]
+    method_reference_id = reference.json()["id"] if reference else None
     send_data = Method(method_reference_id=method_reference_id, **data.to_dict())
     if id is None:
         response = await post_fixture(PATH, send_data, test_client)
@@ -88,13 +93,30 @@ async def setup_method_reference(test_client: AsyncTestClient) -> AsyncGenerator
 async def setup_method(
     setup_method_reference: MethodReferenceResponse, setup_device: DeviceResponse, test_client: AsyncTestClient
 ) -> AsyncGenerator[AllMethodFixtureResponse, None]:
-    method = setup_method_reference
-    day_to_anthesis = await get_method_fixture(DAY_TO_ANTHESIS_METHOD, method.day_to_anthesis, test_client)
+    method_reference = setup_method_reference
+    day_to_anthesis = await get_method_fixture(
+        DAY_TO_ANTHESIS_METHOD,
+        test_client,
+        None,
+        None,
+        method_reference.day_to_anthesis,
+    )
     projected_shoot_area = await get_method_fixture(
-        PROJECTED_SHOOT_AREA_METHOD, method.projected_shoot_area, test_client, None, setup_device.device_response
+        PROJECTED_SHOOT_AREA_METHOD,
+        test_client,
+        None,
+        setup_device.device_response,
+        method_reference.projected_shoot_area,
+    )
+    zn_concentration = await get_method_fixture(
+        ZN_CONCENTRATION_METHOD,
+        test_client,
     )
     yield AllMethodFixtureResponse(
-        day_to_anthesis=day_to_anthesis, projected_shoot_area=projected_shoot_area, method_reference=method
+        day_to_anthesis=day_to_anthesis,
+        projected_shoot_area=projected_shoot_area,
+        method_reference=method_reference,
+        zn_concentration=zn_concentration,
     )
     await delete_fixture(PATH, day_to_anthesis.method_response.json()["id"], test_client)
     await delete_fixture(PATH, projected_shoot_area.method_response.json()["id"], test_client)
diff --git a/tests/router/method/test_method.py b/tests/router/method/test_method.py
@@ -10,6 +10,7 @@
     DAY_TO_ANTHESIS_METHOD,
     PATH,
     PROJECTED_SHOOT_AREA_METHOD,
+    ZN_CONCENTRATION_METHOD,
     AllMethodFixtureResponse,
     MethodResponse,
 )
@@ -20,13 +21,15 @@ class MethodFixture:
     id: UUID
     response: Response
     data: Method
-    method_reference_id: UUID
+    method_reference_id: UUID | None
     device_id: UUID | None = None
 
 
 def get_method_fixture(response: MethodResponse, data: Method) -> MethodFixture:
     method_response = response.method_response
-    method_reference_id = response.method_reference_response.json()["id"]
+    method_reference_id = (
+        response.method_reference_response.json()["id"] if response.method_reference_response else None
+    )
     device_id = response.device_response.json()["id"] if response.device_response else None
     fixture = Method(method_reference_id=method_reference_id, **data.to_dict())
     return MethodFixture(
@@ -44,3 +47,6 @@ async def test_methods_created(setup_method: AllMethodFixtureResponse, test_clie
 
     fixture = get_method_fixture(setup_method.day_to_anthesis, DAY_TO_ANTHESIS_METHOD)
     await validate_post(PATH, fixture.data, test_client, fixture.response)
+
+    fixture = get_method_fixture(setup_method.zn_concentration, ZN_CONCENTRATION_METHOD)
+    await validate_post(PATH, fixture.data, test_client, fixture.response)
diff --git a/tests/router/observed_variable/fixture.py b/tests/router/observed_variable/fixture.py
@@ -9,24 +9,18 @@
 from src.model.observed_variable import ObservedVariable, ObservedVariableDataclass
 from src.model.vocabulary import Vocabulary
 from tests.helpers import delete_fixture, post_fixture, put_fixture
+from tests.router.method.fixture import AllMethodFixtureResponse
 from tests.router.study.fixture import AllStudyFixtureResponse
+from tests.router.unit.fixture import AllUnitFixtureResponse
 
 
 @dataclass
 class ObservedVariableResponse:
+    trait_response: Response
     observed_variable_response: Response
     study_response: list[Response]
-
-
-@dataclass
-class AllObservedVariableFixtureResponse:
-    projected_shoot_area: ObservedVariableResponse
-    zn_concentration: ObservedVariableResponse
-
-
-@dataclass
-class VariableReferenceResponse:
-    anthesis: Response
+    method_response: Response
+    unit_response: Response
 
 
 @dataclass
@@ -37,76 +31,159 @@ class VariableTraitResponse:
     zn_concentration: Response
 
 
-PATH = "observed_variable"
+@dataclass
+class AllObservedVariableFixtureResponse:
+    anthesis: ObservedVariableResponse
+    reproductive_growth_time: ObservedVariableResponse
+    projected_shoot_area: ObservedVariableResponse
+    zn_concentration: ObservedVariableResponse
+    trait_response: VariableTraitResponse
+    study_response: AllStudyFixtureResponse
+    method_response: AllMethodFixtureResponse
+    unit_response: AllUnitFixtureResponse
+
+
+PATH = "observedVariable"
 ANTHESIS_TRAIT = Vocabulary(title="Anthesis time", accession_number="CO_322:0000030")
 REPRODUCTIVE_GROWTH_TIME_TRAIT = Vocabulary(title="Reproductive growth time", accession_number="TO:0000366")
 PROJECTED_SHOOT_AREA_TRAIT = Vocabulary(title="Projected shoot area")
 ZN_CONCENTRATION_TRAIT = Vocabulary(title="Zn concentration", accession_number="CDNO_0200170")
 
-ANTHESIS_VARIABLE = ObservedVariable(title="Ant_Cmp_Cday", description="Anthesis computed in growing degree days")
+ANTHESIS_VARIABLE = ObservedVariable(
+    title="Ant_Cmp_Cday",
+    description="Anthesis computed in growing degree days",
+    time_interval="day",
+)
+REPRODUCTIVE_GROWTH_TIME_VARIABLE = ObservedVariable(
+    title="Reproductive Growth Time",
+    description="Reproductive growth time",
+    time_interval="day",
+)
 PROJECTED_SHOOT_AREA_VARIABLE = ObservedVariable(title="PSA_img_kpixels")
 ZN_CONCENTRATION_VARIABLE = ObservedVariable(title="Zn_conc")
 
 
 async def get_observed_variable_fixture(
-    data: ObservedVariable, studies: list[Response], test_client: AsyncTestClient, id: UUID | None = None
+    data: ObservedVariable,
+    studies: list[Response],
+    method: Response,
+    trait: Response,
+    unit: Response,
+    test_client: AsyncTestClient,
+    id: UUID | None = None,
 ) -> ObservedVariableResponse:
     study_id = [item.json()["id"] for item in studies]
-    send_data = ObservedVariableDataclass(study_id=study_id, **data.to_dict())
+    method_id = method.json()["id"]
+    trait_reference_id = trait.json()["id"]
+    unit_id = unit.json()["id"]
+    send_data = ObservedVariableDataclass(
+        method_id=method_id,
+        trait_reference_id=trait_reference_id,
+        study_id=study_id,
+        unit_id=unit_id,
+        **data.to_dict(),
+    )
     if id is None:
         send_data.updated_at = None
         response = await post_fixture(PATH, send_data, test_client)
     else:
         response = await put_fixture(PATH, send_data, test_client, id)
-    return ObservedVariableResponse(study_response=studies, observed_variable_response=response)
+    return ObservedVariableResponse(
+        study_response=studies,
+        method_response=method,
+        unit_response=unit,
+        trait_response=trait,
+        observed_variable_response=response,
+    )
+
+
+@pytest.fixture(scope="function")
+async def setup_trait(test_client: AsyncTestClient) -> AsyncGenerator[VariableTraitResponse, None]:
+    PATH = "vocabulary"
+    anthesis_trait = await post_fixture(PATH, ANTHESIS_TRAIT, test_client)
+    projected_shoot_area_trait = await post_fixture(PATH, PROJECTED_SHOOT_AREA_TRAIT, test_client)
+    zn_concentration_trait = await post_fixture(PATH, ZN_CONCENTRATION_TRAIT, test_client)
+    reproductive_growth_time_trait = await post_fixture(PATH, REPRODUCTIVE_GROWTH_TIME_TRAIT, test_client)
+    yield VariableTraitResponse(
+        anthesis=anthesis_trait,
+        reproductive_growth_time=reproductive_growth_time_trait,
+        projected_shoot_area=projected_shoot_area_trait,
+        zn_concentration=zn_concentration_trait,
+    )
+    await delete_fixture(PATH, anthesis_trait.json()["id"], test_client)
+    await delete_fixture(PATH, reproductive_growth_time_trait.json()["id"], test_client)
+    await delete_fixture(PATH, projected_shoot_area_trait.json()["id"], test_client)
+    await delete_fixture(PATH, zn_concentration_trait.json()["id"], test_client)
 
 
 @pytest.fixture(scope="function")
 async def setup_observed_variable(
-    setup_study: AllStudyFixtureResponse, test_client: AsyncTestClient
+    setup_study: AllStudyFixtureResponse,
+    setup_method: AllMethodFixtureResponse,
+    setup_unit: AllUnitFixtureResponse,
+    setup_trait: VariableTraitResponse,
+    test_client: AsyncTestClient,
 ) -> AsyncGenerator[AllObservedVariableFixtureResponse, None]:
+    first_study = setup_study.first.study_response
     maize_study = setup_study.maize.study_response
-    barley_study = setup_study.barley.study_response
-    maize_sowing_density = await get_observed_variable_fixture(
-        MAIZE_SOWING_DENSITY, [maize_study, barley_study], test_client
+    barley_study = setup_study.maize.study_response
+
+    projected_shoot_area_method = setup_method.projected_shoot_area.method_response
+    zn_concentration_method = setup_method.zn_concentration.method_response
+    day_to_anthesis_method = setup_method.day_to_anthesis.method_response
+
+    growing_degree_day = setup_unit.degree_day.unit_response
+    kilopixel = setup_unit.kilo_pixel.unit_response
+    microgram = setup_unit.microgram.unit_response
+
+    anthesis_trait = setup_trait.anthesis
+    projected_shoot_area_trait = setup_trait.projected_shoot_area
+    zn_concentration_trait = setup_trait.zn_concentration
+    reproductive_growth_time_trait = setup_trait.reproductive_growth_time
+
+    anthesis_variable = await get_observed_variable_fixture(
+        data=ANTHESIS_VARIABLE,
+        studies=[first_study],
+        method=day_to_anthesis_method,
+        trait=anthesis_trait,
+        unit=growing_degree_day,
+        test_client=test_client,
+    )
+    reproductive_growth_time_variable = await get_observed_variable_fixture(
+        data=REPRODUCTIVE_GROWTH_TIME_VARIABLE,
+        studies=[maize_study],
+        method=day_to_anthesis_method,
+        trait=reproductive_growth_time_trait,
+        unit=growing_degree_day,
+        test_client=test_client,
     )
-    maize_rooting_medium = await get_observed_variable_fixture(MAIZE_ROOTING_MEDIUM, [maize_study], test_client)
-    maize_ph = await get_observed_variable_fixture(MAIZE_PH, [maize_study], test_client)
-    barley_sowing_density = await get_observed_variable_fixture(BARLEY_SOWING_DENSITY, [barley_study], test_client)
-    barley_rooting_medium = await get_observed_variable_fixture(BARLEY_ROOTING_MEDIUM, [barley_study], test_client)
-    barley_ferterlizer = await get_observed_variable_fixture(BARLEY_FERTILIZER, [barley_study], test_client)
-    barley_watering_exposure = await get_observed_variable_fixture(
-        BARLEY_WATERING_EXPOSURE, [barley_study], test_client
+    projected_shoot_area_variable = await get_observed_variable_fixture(
+        data=PROJECTED_SHOOT_AREA_VARIABLE,
+        studies=[barley_study],
+        method=projected_shoot_area_method,
+        trait=projected_shoot_area_trait,
+        unit=kilopixel,
+        test_client=test_client,
     )
-    barley_light_intensity = await get_observed_variable_fixture(BARLEY_LIGHT_INTENSITY, [barley_study], test_client)
-    barley_relative_humidity = await get_observed_variable_fixture(
-        BARLEY_RELATIVE_HUMIDITY, [barley_study], test_client
+    zn_concentration_variable = await get_observed_variable_fixture(
+        data=ZN_CONCENTRATION_VARIABLE,
+        studies=[barley_study],
+        method=zn_concentration_method,
+        trait=zn_concentration_trait,
+        unit=microgram,
+        test_client=test_client,
     )
-    barley_temperature = await get_observed_variable_fixture(BARLEY_TEMPERATURE, [barley_study], test_client)
 
     yield AllObservedVariableFixtureResponse(
-        maize_sowing_density=maize_sowing_density,
-        maize_rooting_medium=maize_rooting_medium,
-        maize_ph=maize_ph,
-        barley_sowing_density=barley_sowing_density,
-        barley_rooting_medium=barley_rooting_medium,
-        barley_fertilizer=barley_ferterlizer,
-        barley_watering_exposure=barley_watering_exposure,
-        barley_light_intensity=barley_light_intensity,
-        barley_relative_humidity=barley_relative_humidity,
-        barley_temperature=barley_temperature,
+        reproductive_growth_time=reproductive_growth_time_variable,
+        projected_shoot_area=projected_shoot_area_variable,
+        zn_concentration=zn_concentration_variable,
+        anthesis=anthesis_variable,
         study_response=setup_study,
+        method_response=setup_method,
+        trait_response=setup_trait,
+        unit_response=setup_unit,
     )
-    await delete_fixture(PATH, maize_sowing_density.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, maize_rooting_medium.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, maize_ph.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_sowing_density.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_rooting_medium.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_ferterlizer.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_watering_exposure.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_light_intensity.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_relative_humidity.observed_variable_response.json()["id"], test_client)
-    await delete_fixture(PATH, barley_temperature.observed_variable_response.json()["id"], test_client)
 
 
 @pytest.fixture(scope="function")
@@ -115,9 +192,15 @@ async def update_observed_variable(
 ) -> AsyncGenerator[AllObservedVariableFixtureResponse, None]:
     all_responses = setup_observed_variable
     maize_study = all_responses.study_response.maize.study_response
-    maize_sowing_density = all_responses.maize_sowing_density
-    maize_sowing_density_response = await get_observed_variable_fixture(
-        MAIZE_SOWING_DENSITY, [maize_study], test_client, maize_sowing_density.observed_variable_response.json()["id"]
+    anthesis = all_responses.anthesis
+    anthesis_response = await get_observed_variable_fixture(
+        data=ANTHESIS_VARIABLE,
+        studies=[maize_study],
+        test_client=test_client,
+        id=anthesis.observed_variable_response.json()["id"],
+        method=anthesis.method_response,
+        trait=anthesis.trait_response,
+        unit=anthesis.unit_response,
     )
-    all_responses.maize_sowing_density = maize_sowing_density_response
+    all_responses.anthesis = anthesis_response
     yield all_responses
diff --git a/tests/router/observed_variable/test_observed_variable.py b/tests/router/observed_variable/test_observed_variable.py
