def test_fix_jumped_tanks(self):
# simulate accidentally recording group in wrong tank and correcting:
# ie A->B, C->D (fish is in both B and D) ->E should correct this
tank_a = BioFactoryFloor.TankFactory(name="A")
tank_a.facic_id = self.evnt.facic_id
tank_a.save()
tank_b = BioFactoryFloor.TankFactory(name="B")
tank_b.facic_id = self.evnt.facic_id
tank_b.save()
tank_c = BioFactoryFloor.TankFactory(name="C")
tank_c.facic_id = self.evnt.facic_id
tank_c.save()
tank_d = BioFactoryFloor.TankFactory(name="D")
tank_d.facic_id = self.evnt.facic_id
tank_d.save()
tank_e = BioFactoryFloor.TankFactory(name="E")
tank_e.facic_id = self.evnt.facic_id
tank_e.save()
# need three dates to ensure unique moving events, to keep django test env happy
move_a_date = (datetime.now() - timedelta(days=2)).date()
move_b_date = (datetime.now() - timedelta(days=1)).date()
move_c_date = datetime.now().date()
utils.create_movement_evnt(tank_a, tank_b, self.cleaned_data, move_a_date, grp_pk=self.grp.pk)
utils.create_movement_evnt(tank_c, tank_d, self.cleaned_data, move_b_date, grp_pk=self.grp.pk)
self.assertIn(tank_b, self.grp.current_cont())
self.assertIn(tank_d, self.grp.current_cont())
utils.create_movement_evnt(None, tank_e, self.cleaned_data, move_c_date, grp_pk=self.grp.pk)
self.assertIn(tank_e, self.grp.current_cont())
self.assertNotIn(tank_c, self.grp.current_cont())
self.assertNotIn(tank_d, self.grp.current_cont())
def setUp(self):
super().setUp() # used to import fixtures
coldbrook_facic = models.FacilityCode.objects.filter(
name="Coldbrook").get()
self.electrofishing_evntc = models.EventCode.objects.filter(
name="Electrofishing").get()
self.tagging_evntc = models.EventCode.objects.filter(
name="PIT Tagging").get()
self.measuring_evntc = models.EventCode.objects.filter(
name="Measuring").get()
self.dist_evntc = models.EventCode.objects.filter(
name="Distribution").get()
# used to get the full path from the static directory
self.electrofishing_test_data = finders.find(
"test\\parser_test_files\\test-electrofishing-cb.xlsx")
self.tagging_test_data = finders.find(
"test\\parser_test_files\\test-tagging-cb.xlsx")
self.electrofishing_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.electrofishing_evntc, facic_id=coldbrook_facic)
self.tagging_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.tagging_evntc, facic_id=coldbrook_facic)
self.cleaned_data = {
"facic_id": coldbrook_facic,
"evnt_id": self.electrofishing_evnt,
"evntc_id": self.electrofishing_evntc,
"data_csv": self.electrofishing_test_data,
"created_by": self.electrofishing_evnt.created_by,
"created_date": self.electrofishing_evnt.created_date,
}
def test_invalid_val(self):
# cannot use values outside of anidc min-max range
invalid_data = self.data.copy()
test_anidc = BioFactoryFloor.AnidcFactory(max_val=(invalid_data['det_val'] - 1))
invalid_data['anidc_id'] = test_anidc.pk
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data = self.data.copy()
test_anidc = BioFactoryFloor.AnidcFactory(min_val=(invalid_data['det_val'] + 1))
invalid_data['anidc_id'] = test_anidc.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def test_invalid_indv(self):
# cannot use invalid individual code
invalid_data = self.data.copy()
non_valid_indv = BioFactoryFloor.IndvFactory()
non_valid_indv.indv_valid = False
non_valid_indv.save()
invalid_data['indv_id'] = non_valid_indv.pk
self.assert_form_invalid(self.Form, data=invalid_data)
# cannot use individual code with null pit tag
invalid_data = self.data.copy()
non_valid_indv = BioFactoryFloor.IndvFactory(pit_tag=None)
invalid_data['indv_id'] = non_valid_indv.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def test_invalid_val(self):
# cannot use values outside of envc min-max range
invalid_data = self.data.copy()
test_envc = BioFactoryFloor.EnvcFactory()
test_envc.max_val = invalid_data['env_val'] - 1
test_envc.save()
invalid_data['envc_id'] = test_envc.pk
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data = self.data.copy()
test_envc = BioFactoryFloor.EnvcFactory()
test_envc.min_val = invalid_data['env_val'] + 1
test_envc.save()
invalid_data['envc_id'] = test_envc.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def test_null_unique(self):
instance = BioFactoryFloor.CntdFactory(adsc_id=None)
invalid_data = model_to_dict(instance)
del invalid_data["id"]
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data["adsc_id"] = 1
self.assert_form_valid(self.Form, data=invalid_data)
def test_null_unique(self):
instance = BioFactoryFloor.ContxFactory(tank_id=None, trof_id=None, tray_id=None, heat_id=None, draw_id=None)
invalid_data = model_to_dict(instance)
del invalid_data["id"]
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data["tank_id"] = 1
self.assert_form_valid(self.Form, data=invalid_data)
def setUp(self):
super().setUp() # used to import fixtures
mactaquac_facic = models.FacilityCode.objects.filter(
name="Mactaquac").get()
self.electrofishing_evntc = models.EventCode.objects.filter(
name="Electrofishing").get()
self.tagging_evntc = models.EventCode.objects.filter(
name="PIT Tagging").get()
self.measuring_evntc = models.EventCode.objects.filter(
name="Measuring").get()
self.dist_evntc = models.EventCode.objects.filter(
name="Distribution").get()
# used to get the full path from the static directory
self.electrofishing_test_data = finders.find(
"test\\parser_test_files\\test-electrofishing.xlsx")
self.tagging_test_data = finders.find(
"test\\parser_test_files\\test-tagging.xlsx")
self.measuring_test_data = finders.find(
"test\\parser_test_files\\test-generic-group.xlsx")
self.measuring_indv_test_data = finders.find(
"test\\parser_test_files\\test-generic-indv.xlsx")
self.dist_indv_test_data = finders.find(
"test\\parser_test_files\\test-indv-distribution.xlsx")
self.electrofishing_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.electrofishing_evntc, facic_id=mactaquac_facic)
self.tagging_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.tagging_evntc, facic_id=mactaquac_facic)
self.measuring_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.measuring_evntc, facic_id=mactaquac_facic)
self.grp_measuring_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.measuring_evntc, facic_id=mactaquac_facic)
self.dist_evnt = BioFactoryFloor.EvntFactory(evntc_id=self.dist_evntc,
facic_id=mactaquac_facic)
self.cleaned_data = {
"facic_id": mactaquac_facic,
"evnt_id": self.electrofishing_evnt,
"evntc_id": self.electrofishing_evntc,
"adsc_id": [],
"anidc_id": [],
"anidc_subj_id": [],
"data_csv": self.electrofishing_test_data,
"created_by": self.electrofishing_evnt.created_by,
"created_date": self.electrofishing_evnt.created_date,
}
def test_null_unique(self):
instance = BioFactoryFloor.LocFactory(subr_id=None)
invalid_data = model_to_dict(instance)
invalid_data["start_date"] = invalid_data["loc_date"].date()
del invalid_data["id"]
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data["subr_id"] = 1
self.assert_form_valid(self.Form, data=invalid_data)
def test_point_in_different_relc(self):
# test that with a relc declared and a point in a different relc, the relc is not replaced
self.loc.relc_id = self.relc
new_relc = BioFactoryFloor.RelcFactory()
self.loc.loc_lat = new_relc.min_lat
self.loc.loc_lon = new_relc.min_lon
self.loc.save()
self.assertEqual(self.loc.relc_id, self.relc)
def test_invalid_perc(self):
# cannot use invalid personnel code
invalid_data = self.data.copy()
non_valid_perc = BioFactoryFloor.PercFactory(perc_valid=False)
invalid_data['perc_id'] = non_valid_perc.pk
try:
self.assert_form_invalid(self.Form, data=invalid_data)
except PersonnelCode.DoesNotExist:
pass
def test_invalid_prog(self):
# cannot use invalid program
invalid_data = self.data.copy()
non_valid_prog = BioFactoryFloor.ProgFactory(valid=False)
invalid_data['prog_id'] = non_valid_prog.pk
try:
self.assert_form_invalid(self.Form, data=invalid_data)
except Program.DoesNotExist:
pass
def test_invalid_indv(self):
# cannot use invalid individual code
invalid_data = self.data.copy()
non_valid_indv = BioFactoryFloor.IndvFactory(indv_valid=False)
invalid_data['indv_id'] = non_valid_indv.pk
try:
self.assert_form_invalid(self.Form, data=invalid_data)
except Individual.DoesNotExist:
pass
# cannot use individual code with null pit_tag
invalid_data = self.data.copy()
non_valid_indv = BioFactoryFloor.IndvFactory(pit_tag=None)
invalid_data['indv_id'] = non_valid_indv.pk
try:
self.assert_form_invalid(self.Form, data=invalid_data)
except Individual.DoesNotExist:
pass
def test_makes_invalid(self):
# test that previous details with same code are made invalid
initial_instance = BioFactoryFloor.IndvdFactory(adsc_id=None)
initial_id = initial_instance.pk
initial_instance.pk = None
initial_instance.detail_date = datetime.strptime(initial_instance.detail_date, "%Y-%m-%d") + timedelta(days=1)
self.assertTrue(models.IndividualDet.objects.filter(pk=initial_id).get().indvd_valid)
initial_instance.save()
self.assertFalse(models.IndividualDet.objects.filter(pk=initial_id).get().indvd_valid)
def setUp(self):
super().setUp() # used to import fixtures
# create group, tank and evnt
self.grp = BioFactoryFloor.GrpFactory()
self.evnt = BioFactoryFloor.EvntFactory()
self.tank = BioFactoryFloor.TankFactory()
self.tank.facic_id = self.evnt.facic_id
self.tank.save()
self.final_tank = BioFactoryFloor.TankFactory()
self.final_tank.facic_id = self.evnt.facic_id
self.final_tank.save()
self.cleaned_data = {
"facic_id": self.evnt.facic_id,
"evnt_id": self.evnt,
"created_by": self.evnt.created_by,
"created_date": self.evnt.created_date,
}
def test_two_grps_one_tank(self):
# put two grps into a single tank, make sure both are located:
second_grp = BioFactoryFloor.GrpFactory()
utils.enter_contx(self.tank, self.cleaned_data, True, grp_pk=self.grp.pk)
utils.enter_contx(self.tank, self.cleaned_data, True, grp_pk=second_grp.pk)
indv_list, grp_list = self.tank.fish_in_cont()
self.assertEqual(len(grp_list), 2)
self.assertIn(self.grp, grp_list)
self.assertIn(second_grp, grp_list)
def setUp(self):
super().setUp() # used to import fixtures
# create group, put them in a tank:
self.grp = BioFactoryFloor.GrpFactory()
self.evnt = BioFactoryFloor.EvntFactory()
self.tank = BioFactoryFloor.TankFactory()
self.tank.facic_id = self.evnt.facic_id
self.tank.save()
self.final_tank = BioFactoryFloor.TankFactory()
self.final_tank.facic_id = self.evnt.facic_id
self.final_tank.save()
self.cleaned_data = {
"facic_id": self.evnt.facic_id,
"evnt_id": self.evnt,
"created_by": self.evnt.created_by,
"created_date": self.evnt.created_date,
}
self.contx = utils.enter_contx(self.tank, self.cleaned_data, True, grp_pk=self.grp.pk, return_contx=True)
def setUp(self):
super().setUp() # used to import fixtures
self.grp = BioFactoryFloor.GrpFactory()
self.trof = BioFactoryFloor.TrofFactory(name='-1')
self.trof_two = BioFactoryFloor.TrofFactory(
name='-2', facic_id=self.trof.facic_id)
self.evnt_date = utils.naive_to_aware(datetime.today() -
timedelta(days=100))
self.evnt = BioFactoryFloor.EvntFactory(start_datetime=self.evnt_date,
facic_id=self.trof.facic_id)
self.cleaned_data = {
"facic_id": self.evnt.facic_id,
"evnt_id": self.evnt,
"created_by": self.evnt.created_by,
"created_date": self.evnt.created_date,
}
self.contx, data_entered = utils.enter_contx(self.trof,
self.cleaned_data,
None,
return_contx=True)
self.contx_two, data_entered = utils.enter_contx(self.trof_two,
self.cleaned_data,
None,
return_contx=True)
temp_envc = models.EnvCode.objects.filter(name="Temperature").get()
# add ten days worth of temp data to the trough
for temp in range(0, 10):
env_date = utils.naive_to_aware(self.evnt.start_date +
timedelta(days=temp))
utils.enter_env(temp,
env_date,
self.cleaned_data,
temp_envc,
contx=self.contx)
for temp in range(10, 20):
env_date = utils.naive_to_aware(self.evnt.start_date +
timedelta(days=temp))
utils.enter_env(temp,
env_date,
self.cleaned_data,
temp_envc,
contx=self.contx_two)
def test_null_unique(self):
instance = BioFactoryFloor.EnvFactory()
instance.contx_id = None
instance.start_datetime = datetime.strptime(instance.start_datetime.strftime("%Y%m%d%H%M"), "%Y%m%d%H%M").replace(tzinfo=pytz.UTC)
instance.save()
invalid_data = model_to_dict(instance)
invalid_data["start_date"] = invalid_data["start_datetime"].date()
invalid_data["start_time"] = invalid_data["start_datetime"].time().strftime("%H:%M")
del invalid_data["id"]
self.assert_form_invalid(self.Form, data=invalid_data)
invalid_data["contx_id"] = 1
self.assert_form_valid(self.Form, data=invalid_data)
def test_aboslute_cnt(self):
# take eggs from a group and then record absolute count the following day.
init_cnt = randint(300, 500)
cnt_one_val = randint(5, 100)
cnt_final_val = randint(0, 5)
next_day_evnt = BioFactoryFloor.EvntFactory()
next_day_evnt.facic_id = self.evnt.facic_id
next_day_evnt.start_datetime = self.evnt.start_datetime + datetime.timedelta(days=1)
next_day_evnt.save()
new_cleaned_data = self.cleaned_data.copy()
new_cleaned_data["evnt_id"] = next_day_evnt
end_contx = utils.enter_contx(self.tank, new_cleaned_data, None, grp_pk=self.grp.pk, return_contx=True)
utils.enter_cnt(self.cleaned_data, init_cnt, self.contx.pk, cnt_code="Eggs Added")
cnt = utils.enter_cnt(self.cleaned_data, 0, self.contx.pk, cnt_code="Eggs Removed")
utils.enter_cnt_det(self.cleaned_data, cnt, cnt_one_val, "Program Group", "EQU")
utils.enter_cnt(new_cleaned_data, cnt_final_val, end_contx.pk, cnt_code="Egg Count")
self.assertEqual(self.grp.count_fish_in_group(), cnt_final_val)
def setUp(self):
super().setUp() # used to import fixtures
mactaquac_facic = models.FacilityCode.objects.filter(
name="Mactaquac").get()
self.water_quality_evntc = models.EventCode.objects.filter(
name="Water Quality Record").get()
# used to get the full path from the static directory
self.water_qaulity_test_data = finders.find(
"test\\parser_test_files\\test-water_quality_record.xlsx")
self.water_quality_evnt = BioFactoryFloor.EvntFactory(
evntc_id=self.water_quality_evntc, facic_id=mactaquac_facic)
self.cleaned_data = {
"facic_id": mactaquac_facic,
"evnt_id": self.water_quality_evnt,
"evntc_id": self.water_quality_evntc,
"data_csv": self.water_qaulity_test_data,
"created_by": self.water_quality_evnt.created_by,
"created_date": self.water_quality_evnt.created_date,
}
def setUp(self):
super().setUp()
self.object_verbose = 'Individual'
self.object_data = BioFactoryFloor.IndvFactory()
def test_invalid_grp(self):
# cannot use invalid group code
invalid_data = self.data.copy()
non_valid_grp = BioFactoryFloor.GrpFactory(grp_valid=False)
invalid_data['grp_id'] = non_valid_grp.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def test_invalid_prot(self):
# cannot use invalid protocol
invalid_data = self.data.copy()
non_valid_prot = BioFactoryFloor.ProtFactory(valid=False)
invalid_data['prot_id'] = non_valid_prot.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def test_invalid_pair(self):
# cannot use invalid pair code
invalid_data = self.data.copy()
non_valid_pair = BioFactoryFloor.PairFactory(valid=False)
invalid_data['pair_id'] = non_valid_pair.pk
self.assert_form_invalid(self.Form, data=invalid_data)
def setUp(self):
super().setUp() # used to import fixtures
self.loc = BioFactoryFloor.LocFactory()
self.loc.relc_id = None
models.ReleaseSiteCode.objects.all().delete()
self.relc = BioFactoryFloor.RelcFactory()
def setUp(self):
super().setUp()
self.prot_data = BioFactoryFloor.ProtFactory(valid=True)
self.prot_data.prog_id.valid = True
