> response = controller.versionInformation();
+
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ assertTrue(response.getBody().containsKey("buildTimestamp"));
+ assertTrue(response.getBody().containsKey("version"));
+ assertTrue(response.getBody().containsKey("branch"));
+ assertTrue(response.getBody().containsKey("commitHash"));
+ }
+
+ @Test
+ @DisplayName("versionInformation should answer the same stamp on every call")
+ void versionInformation_shouldAnswerConsistently() {
+ assertEquals(controller.versionInformation().getBody(), controller.versionInformation().getBody());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/controller/villageMaster/VillageMasterControllerTest.java b/src/test/java/com/iemr/admin/controller/villageMaster/VillageMasterControllerTest.java
new file mode 100644
index 0000000..f56006e
--- /dev/null
+++ b/src/test/java/com/iemr/admin/controller/villageMaster/VillageMasterControllerTest.java
@@ -0,0 +1,177 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.controller.villageMaster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONObject;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.locationmaster.DistrictBranchMapping;
+import com.iemr.admin.service.villageMaster.VillageMasterServiceImpl;
+import com.iemr.admin.utils.response.OutputResponse;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * The village screen keeps the villages of a taluk and the details each one is
+ * addressed by.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("VillageMasterController Test Suite")
+class VillageMasterControllerTest {
+
+ private static final Integer BLOCK_ID = 3011;
+
+ @Mock
+ private VillageMasterServiceImpl villageMasterServiceImpl;
+
+ @InjectMocks
+ private VillageMasterController controller;
+
+ private static DistrictBranchMapping village() {
+ DistrictBranchMapping village = new DistrictBranchMapping();
+ village.setDistrictBranchID(30111);
+ village.setVillageName("Attibele");
+ village.setPinCode("562107");
+ return village;
+ }
+
+ private static int statusCodeOf(String response) {
+ return new JSONObject(response).getInt("statusCode");
+ }
+
+ private static void assertSuccessContaining(String response, String expected) {
+ assertEquals(OutputResponse.SUCCESS, statusCodeOf(response), response);
+ assertTrue(response.contains(expected), response);
+ }
+
+ @Test
+ @DisplayName("saveVillageDetails should answer the villages it added")
+ void save_shouldAnswerAddedVillages() {
+ when(villageMasterServiceImpl.storeVillageDetails(anyList()))
+ .thenReturn(new ArrayList<>(List.of(village())));
+
+ assertSuccessContaining(controller.saveVillageDetails(
+ "{\"districtBranchMapping\":[{\"villageName\":\"Attibele\",\"blockID\":3011}]}"), "Attibele");
+ }
+
+ @Test
+ @DisplayName("saveVillageDetails should report the failure when the village cannot be added")
+ void save_shouldReportStorageFailure() {
+ when(villageMasterServiceImpl.storeVillageDetails(anyList()))
+ .thenThrow(new RuntimeException("village already on file"));
+
+ assertEquals(OutputResponse.GENERIC_FAILURE, statusCodeOf(controller.saveVillageDetails(
+ "{\"districtBranchMapping\":[{\"villageName\":\"Attibele\"}]}")));
+ }
+
+ @Test
+ @DisplayName("getVillages should answer the villages of the taluk asked about")
+ void get_shouldAnswerVillagesOfTaluk() {
+ when(villageMasterServiceImpl.getAvailableVillages(BLOCK_ID))
+ .thenReturn(new ArrayList<>(List.of(village())));
+
+ assertSuccessContaining(controller.getVillages("{\"blockID\":3011}"), "Attibele");
+ }
+
+ @Test
+ @DisplayName("getVillages should report the failure when the villages cannot be answered")
+ void get_shouldReportLookupFailure() {
+ when(villageMasterServiceImpl.getAvailableVillages(any()))
+ .thenThrow(new RuntimeException("query timed out"));
+
+ assertEquals(OutputResponse.GENERIC_FAILURE, statusCodeOf(controller.getVillages("{\"blockID\":3011}")));
+ }
+
+ @Test
+ @DisplayName("deleteVillage should confirm the retirement it recorded")
+ void delete_shouldConfirmRetirement() {
+ when(villageMasterServiceImpl.updateVillageStatus(any(DistrictBranchMapping.class))).thenReturn(1);
+
+ assertSuccessContaining(
+ controller.deleteVillage("{\"districtBranchID\":30111,\"deleted\":true,\"modifiedBy\":\"admin\"}"),
+ "status updated successfully");
+ }
+
+ @Test
+ @DisplayName("deleteVillage should say so when no village was retired")
+ void delete_shouldSaySoWhenNothingRetired() {
+ when(villageMasterServiceImpl.updateVillageStatus(any(DistrictBranchMapping.class))).thenReturn(0);
+
+ assertSuccessContaining(controller.deleteVillage("{\"districtBranchID\":-1,\"deleted\":true}"),
+ "Failed to update the status");
+ }
+
+ @Test
+ @DisplayName("deleteVillage should report the failure when the retirement cannot be recorded")
+ void delete_shouldReportStorageFailure() {
+ when(villageMasterServiceImpl.updateVillageStatus(any(DistrictBranchMapping.class)))
+ .thenThrow(new RuntimeException("row is locked"));
+
+ assertEquals(OutputResponse.GENERIC_FAILURE,
+ statusCodeOf(controller.deleteVillage("{\"districtBranchID\":30111}")));
+ }
+
+ @Test
+ @DisplayName("updateVillageData should confirm the change it recorded")
+ void update_shouldConfirmRecordedChange() {
+ when(villageMasterServiceImpl.updateVillageData(any(DistrictBranchMapping.class))).thenReturn(1);
+
+ assertSuccessContaining(controller.updateVillageData(
+ "{\"districtBranchID\":30111,\"villageName\":\"Attibele\",\"pinCode\":\"562107\","
+ + "\"modifiedBy\":\"admin\"}"),
+ "status updated successfully");
+ }
+
+ @Test
+ @DisplayName("updateVillageData should say so when no village was changed")
+ void update_shouldSaySoWhenNothingChanged() {
+ when(villageMasterServiceImpl.updateVillageData(any(DistrictBranchMapping.class))).thenReturn(0);
+
+ assertSuccessContaining(controller.updateVillageData("{\"districtBranchID\":-1}"),
+ "Failed to update the status");
+ }
+
+ @Test
+ @DisplayName("updateVillageData should report the failure when the change cannot be recorded")
+ void update_shouldReportStorageFailure() {
+ when(villageMasterServiceImpl.updateVillageData(any(DistrictBranchMapping.class)))
+ .thenThrow(new RuntimeException("row is locked"));
+
+ assertEquals(OutputResponse.GENERIC_FAILURE,
+ statusCodeOf(controller.updateVillageData("{\"districtBranchID\":30111}")));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/controller/zonemaster/ZoneMasterControllerTest.java b/src/test/java/com/iemr/admin/controller/zonemaster/ZoneMasterControllerTest.java
new file mode 100644
index 0000000..ed87be6
--- /dev/null
+++ b/src/test/java/com/iemr/admin/controller/zonemaster/ZoneMasterControllerTest.java
@@ -0,0 +1,287 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.controller.zonemaster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONObject;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.zonemaster.M_Zone;
+import com.iemr.admin.data.zonemaster.M_ZoneDistrictMap;
+import com.iemr.admin.service.zonemaster.ZoneMasterServiceImpl;
+import com.iemr.admin.utils.response.OutputResponse;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The zone endpoints group the districts a provider operates in, and a zone that
+ * is retired has to take its district mappings with it.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ZoneMasterController Test Suite")
+class ZoneMasterControllerTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer ZONE_ID = 61;
+
+ @Mock
+ private ZoneMasterServiceImpl zoneMasterServiceImpl;
+
+ @InjectMocks
+ private ZoneMasterController controller;
+
+ private static M_Zone zone(Integer id, String name) {
+ return new M_Zone(id, name, "Northern districts", "Main Road", PSM_ID, Boolean.FALSE, 1, "India",
+ 29, "Karnataka", 301, "Bengaluru Urban", 401, "North block", 501, "Hosur", null, 3,
+ "Tele Medicine");
+ }
+
+ private static M_ZoneDistrictMap districtMapping(Integer id) {
+ return new M_ZoneDistrictMap(id, ZONE_ID, "North zone", 301, PSM_ID, Boolean.FALSE, 29, "Karnataka",
+ "Bengaluru Urban", 3, "Tele Medicine", Boolean.FALSE);
+ }
+
+ private static int statusCodeOf(String response) {
+ return new JSONObject(response).getInt("statusCode");
+ }
+
+ private static void assertSuccessContaining(String response, String fragment) {
+ assertEquals(OutputResponse.SUCCESS, statusCodeOf(response), response);
+ assertTrue(response.contains(fragment), response);
+ }
+
+ private static void assertGenericFailure(String response) {
+ assertEquals(OutputResponse.GENERIC_FAILURE, statusCodeOf(response), response);
+ }
+
+ private static void assertCodeException(String response) {
+ assertEquals(OutputResponse.CODE_EXCEPTION, statusCodeOf(response), response);
+ }
+
+ @Test
+ @DisplayName("saveZone should answer the zones the service stored")
+ void saveZone_shouldAnswerStoredZones() throws Exception {
+ when(zoneMasterServiceImpl.createZone(anyList()))
+ .thenReturn(new ArrayList<>(List.of(zone(ZONE_ID, "North zone"))));
+
+ assertSuccessContaining(controller.saveZone("{\"zones\":[{\"zoneName\":\"North zone\"}]}"), "North zone");
+ }
+
+ @Test
+ @DisplayName("saveZone should answer an error envelope when the store fails")
+ void saveZone_shouldAnswerErrorEnvelopeOnFailure() throws Exception {
+ when(zoneMasterServiceImpl.createZone(any())).thenThrow(new IllegalStateException("no connection"));
+
+ assertGenericFailure(controller.saveZone("{\"zones\":[{\"zoneName\":\"North zone\"}]}"));
+ }
+
+ @Test
+ @DisplayName("getZones should answer the zones of the provider")
+ void getZones_shouldAnswerProviderZones() {
+ when(zoneMasterServiceImpl.getAvailableZones(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(zone(ZONE_ID, "North zone"))));
+
+ assertSuccessContaining(controller.getZones("{\"providerServiceMapID\":4001}"), "North zone");
+ }
+
+ @Test
+ @DisplayName("getZones should ask the caller for a provider when the request names none")
+ void getZones_shouldAskForProvider() {
+ assertSuccessContaining(controller.getZones("{}"), "Provide providerServiceMapID.");
+ verify(zoneMasterServiceImpl, never()).getAvailableZones(anyInt());
+ }
+
+ @Test
+ @DisplayName("getZones should stay at its default for a provider id of zero")
+ void getZones_shouldStayAtDefaultForZeroProvider() {
+ assertGenericFailure(controller.getZones("{\"providerServiceMapID\":0}"));
+ }
+
+ @Test
+ @DisplayName("getZones should answer an error envelope for a body it cannot read")
+ void getZones_shouldAnswerErrorEnvelopeForMalformedBody() {
+ assertEquals(OutputResponse.OBJECT_FAILURE, statusCodeOf(controller.getZones("not json")));
+ }
+
+ @Test
+ @DisplayName("mapZoneWithDistrict should answer the mappings the service stored")
+ void mapZoneWithDistrict_shouldAnswerStoredMappings() throws Exception {
+ when(zoneMasterServiceImpl.createZoneDistrictMapping(anyList()))
+ .thenReturn(new ArrayList<>(List.of(districtMapping(9001))));
+
+ assertSuccessContaining(controller.mapZoneWithDistrict(
+ "{\"zoneDistrictMappings\":[{\"zoneID\":61,\"districtID\":301}]}"), "9001");
+ }
+
+ @Test
+ @DisplayName("mapZoneWithDistrict should answer an error envelope when the store fails")
+ void mapZoneWithDistrict_shouldAnswerErrorEnvelopeOnFailure() throws Exception {
+ when(zoneMasterServiceImpl.createZoneDistrictMapping(any()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertGenericFailure(controller.mapZoneWithDistrict("{\"zoneDistrictMappings\":[{}]}"));
+ }
+
+ @Test
+ @DisplayName("editZoneDistrict should copy the edits onto the stored mapping")
+ void editZoneDistrict_shouldCopyEdits() throws Exception {
+ M_ZoneDistrictMap stored = districtMapping(9001);
+ when(zoneMasterServiceImpl.editZoneDistrictMapping(9001)).thenReturn(stored);
+ when(zoneMasterServiceImpl.saveeditedData(stored)).thenReturn(stored);
+
+ String response = controller.editZoneDistrict("{\"zoneDistrictMapID\":9001,\"zoneID\":62,"
+ + "\"districtID\":302,\"providerServiceMapID\":4001,\"modifiedBy\":\"admin\"}");
+
+ assertSuccessContaining(response, "9001");
+ assertEquals(62, stored.getZoneID());
+ assertEquals(302, stored.getDistrictID());
+ }
+
+ @Test
+ @DisplayName("editZoneDistrict should answer an error envelope for a mapping that does not exist")
+ void editZoneDistrict_shouldAnswerErrorEnvelopeForUnknownMapping() throws Exception {
+ when(zoneMasterServiceImpl.editZoneDistrictMapping(9001)).thenReturn(null);
+
+ assertCodeException(controller.editZoneDistrict("{\"zoneDistrictMapID\":9001}"));
+ }
+
+ @Test
+ @DisplayName("getZoneDistrictMappings should answer the district mappings of the provider")
+ void getZoneDistrictMappings_shouldAnswerProviderMappings() {
+ when(zoneMasterServiceImpl.getAvailableZoneDistrictMappings(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(districtMapping(9001))));
+
+ assertSuccessContaining(
+ controller.getZoneDistrictMappings("{\"providerServiceMapID\":4001}"), "9001");
+ }
+
+ @Test
+ @DisplayName("getZoneDistrictMappings should ask the caller for a provider when the request names none")
+ void getZoneDistrictMappings_shouldAskForProvider() {
+ assertSuccessContaining(controller.getZoneDistrictMappings("{}"), "Provide serviceProviderID.");
+ }
+
+ @Test
+ @DisplayName("deleteZone should report whether the zone was actually retired")
+ void deleteZone_shouldReportOutcome() throws Exception {
+ when(zoneMasterServiceImpl.updateZoneStatus(any())).thenReturn(1);
+ assertSuccessContaining(controller.deleteZone("{\"zoneID\":61,\"deleted\":true}"),
+ "status updated successfully");
+
+ when(zoneMasterServiceImpl.updateZoneStatus(any())).thenReturn(0);
+ assertSuccessContaining(controller.deleteZone("{\"zoneID\":61,\"deleted\":true}"),
+ "Failed to update the status");
+ }
+
+ @Test
+ @DisplayName("deleteZone should answer an error envelope when the change fails")
+ void deleteZone_shouldAnswerErrorEnvelopeOnFailure() throws Exception {
+ when(zoneMasterServiceImpl.updateZoneStatus(any())).thenThrow(new IllegalStateException("no connection"));
+
+ assertGenericFailure(controller.deleteZone("{\"zoneID\":61,\"deleted\":true}"));
+ }
+
+ @Test
+ @DisplayName("updateZoneData should copy the edits onto the stored zone")
+ void updateZoneData_shouldCopyEdits() throws Exception {
+ M_Zone stored = zone(ZONE_ID, "old name");
+ when(zoneMasterServiceImpl.getzoneByID(ZONE_ID)).thenReturn(stored);
+ when(zoneMasterServiceImpl.updateZoneData(stored)).thenReturn(stored);
+
+ String response = controller.updateZoneData("{\"zoneID\":61,\"zoneName\":\"North zone\","
+ + "\"zoneDesc\":\"Northern districts\",\"zoneHQAddress\":\"Main Road\",\"stateID\":29,"
+ + "\"districtID\":301,\"districtBlockID\":401,\"districtBranchID\":501,"
+ + "\"modifiedBy\":\"admin\"}");
+
+ assertSuccessContaining(response, "North zone");
+ assertEquals("Northern districts", stored.getZoneDesc());
+ assertEquals(29, stored.getStateID());
+ assertEquals("admin", stored.getModifiedBy());
+ }
+
+ @Test
+ @DisplayName("updateZoneData should answer an error envelope for a zone that does not exist")
+ void updateZoneData_shouldAnswerErrorEnvelopeForUnknownZone() throws Exception {
+ when(zoneMasterServiceImpl.getzoneByID(ZONE_ID)).thenReturn(null);
+
+ assertCodeException(controller.updateZoneData("{\"zoneID\":61}"));
+ }
+
+ @Test
+ @DisplayName("getMappedDistrictByZoneID should answer the districts mapped to the zone")
+ void getMappedDistrictByZoneID_shouldAnswerMappedDistricts() {
+ when(zoneMasterServiceImpl.editZoneDistrictMapping1(ZONE_ID))
+ .thenReturn(new ArrayList<>(List.of(districtMapping(9001))));
+
+ assertSuccessContaining(controller.getMappedDistrictByZoneID("{\"zoneID\":61}"), "9001");
+ }
+
+ @Test
+ @DisplayName("getMappedDistrictByZoneID should answer an error envelope when the lookup fails")
+ void getMappedDistrictByZoneID_shouldAnswerErrorEnvelopeOnFailure() {
+ when(zoneMasterServiceImpl.editZoneDistrictMapping1(anyInt()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertGenericFailure(controller.getMappedDistrictByZoneID("{\"zoneID\":61}"));
+ }
+
+ @Test
+ @DisplayName("deleteZoneDistrictMapping should report whether the mapping changed")
+ void deleteZoneDistrictMapping_shouldReportOutcome() throws Exception {
+ when(zoneMasterServiceImpl.updateZoneDistrictMappingStatus(any())).thenReturn(0);
+ assertSuccessContaining(
+ controller.deleteZoneDistrictMapping("{\"zoneDistrictMapID\":9001,\"deleted\":true}"),
+ "status updated successfully");
+
+ when(zoneMasterServiceImpl.updateZoneDistrictMappingStatus(any())).thenReturn(1);
+ assertSuccessContaining(
+ controller.deleteZoneDistrictMapping("{\"zoneDistrictMapID\":9001,\"deleted\":true}"),
+ "Failed to update the status");
+ }
+
+ @Test
+ @DisplayName("deleteZoneDistrictMapping should answer an error envelope when the change fails")
+ void deleteZoneDistrictMapping_shouldAnswerErrorEnvelopeOnFailure() throws Exception {
+ when(zoneMasterServiceImpl.updateZoneDistrictMappingStatus(any()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertGenericFailure(
+ controller.deleteZoneDistrictMapping("{\"zoneDistrictMapID\":9001,\"deleted\":true}"));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/data/BeanContract.java b/src/test/java/com/iemr/admin/data/BeanContract.java
new file mode 100644
index 0000000..379b493
--- /dev/null
+++ b/src/test/java/com/iemr/admin/data/BeanContract.java
@@ -0,0 +1,245 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.data;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.math.BigInteger;
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Reflective checks for the accessors, equality and string representation of the
+ * plain data carriers this service exchanges over its APIs.
+ *
+ * The carriers are mostly Lombok {@code @Data} entities, so the generated
+ * {@code equals}, {@code hashCode} and {@code toString} are exercised alongside
+ * every readable/writable property. A carrier that cannot be built through a
+ * no-argument constructor is reported by {@link #isVerifiable(Class)} so the
+ * calling suite can skip it rather than fail.
+ */
+public final class BeanContract {
+
+ private BeanContract() {
+ }
+
+ /** Answers whether the type can be exercised through the reflective contract. */
+ public static boolean isVerifiable(Class type) {
+ if (type.isInterface() || type.isEnum() || type.isAnnotation()
+ || Modifier.isAbstract(type.getModifiers())
+ || type.isMemberClass() && !Modifier.isStatic(type.getModifiers())) {
+ return false;
+ }
+ try {
+ type.getDeclaredConstructor();
+ return true;
+ } catch (NoSuchMethodException e) {
+ return false;
+ }
+ }
+
+ public static void verify(Class type) throws Exception {
+ Object left = newInstance(type);
+ Object right = newInstance(type);
+ copyFields(type, left, right);
+
+ assertNotNull(left.toString(), type.getSimpleName() + " must render a string form");
+ assertTrue(left.equals(left), type.getSimpleName() + " must equal itself");
+ assertFalse(left.equals(null), type.getSimpleName() + " must never equal null");
+ assertFalse(left.equals(new Object()), type.getSimpleName() + " must never equal an unrelated type");
+ left.hashCode();
+
+ if (left.equals(right)) {
+ assertEquals(left.hashCode(), right.hashCode(),
+ type.getSimpleName() + " must hash consistently with equals");
+ }
+
+ verifyProperties(type, left, right);
+ }
+
+ private static Object newInstance(Class type) throws Exception {
+ java.lang.reflect.Constructor constructor = type.getDeclaredConstructor();
+ constructor.setAccessible(true);
+ return constructor.newInstance();
+ }
+
+ private static void verifyProperties(Class type, Object left, Object right) throws Exception {
+ for (Field field : type.getDeclaredFields()) {
+ if (Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())) {
+ continue;
+ }
+ Method getter = findGetter(type, field);
+ Method setter = findSetter(type, field);
+ if (getter == null || setter == null) {
+ continue;
+ }
+ Object value = sampleValue(field.getType());
+ if (value == null) {
+ continue;
+ }
+
+ setter.invoke(left, value);
+ assertEquals(value, getter.invoke(left),
+ type.getSimpleName() + "." + field.getName() + " must round-trip through its accessors");
+
+ setter.invoke(right, value);
+ assertEquals(getter.invoke(left), getter.invoke(right),
+ type.getSimpleName() + "." + field.getName() + " must read back the same on both instances");
+ }
+ assertNotNull(left.toString(), type.getSimpleName() + " must render a populated string form");
+ left.hashCode();
+ left.equals(right);
+ }
+
+ private static void copyFields(Class type, Object from, Object to) throws Exception {
+ for (Field field : type.getDeclaredFields()) {
+ if (Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())) {
+ continue;
+ }
+ field.setAccessible(true);
+ field.set(to, field.get(from));
+ }
+ }
+
+ private static Method findGetter(Class type, Field field) {
+ String suffix = capitalise(field.getName());
+ for (String prefix : new String[] { "get", "is" }) {
+ try {
+ Method candidate = type.getMethod(prefix + suffix);
+ if (candidate.getParameterCount() == 0) {
+ return candidate;
+ }
+ } catch (NoSuchMethodException ignored) {
+ // try the next accessor style
+ }
+ }
+ return null;
+ }
+
+ private static Method findSetter(Class type, Field field) {
+ try {
+ return type.getMethod("set" + capitalise(field.getName()), field.getType());
+ } catch (NoSuchMethodException e) {
+ return null;
+ }
+ }
+
+ private static String capitalise(String name) {
+ return Character.toUpperCase(name.charAt(0)) + name.substring(1);
+ }
+
+ private static Object sampleValue(Class type) {
+ if (type == String.class) {
+ return "sample";
+ }
+ if (type == Long.class || type == long.class) {
+ return 7L;
+ }
+ if (type == Integer.class || type == int.class) {
+ return 7;
+ }
+ if (type == Short.class || type == short.class) {
+ return (short) 7;
+ }
+ if (type == Double.class || type == double.class) {
+ return 7.5d;
+ }
+ if (type == Float.class || type == float.class) {
+ return 7.5f;
+ }
+ if (type == Character.class || type == char.class) {
+ return 'y';
+ }
+ if (type == Byte.class || type == byte.class) {
+ return (byte) 7;
+ }
+ if (type == Boolean.class || type == boolean.class) {
+ return Boolean.TRUE;
+ }
+ if (type == java.math.BigDecimal.class) {
+ return java.math.BigDecimal.valueOf(7.5d);
+ }
+ if (type == BigInteger.class) {
+ return BigInteger.valueOf(7L);
+ }
+ if (type == Timestamp.class) {
+ return Timestamp.valueOf("2026-02-17 09:30:00");
+ }
+ if (type == Date.class) {
+ return Date.valueOf("2026-02-17");
+ }
+ if (type == Time.class) {
+ return Time.valueOf("09:30:00");
+ }
+ if (type == java.util.Date.class) {
+ return new java.util.Date(1_771_286_400_000L);
+ }
+ if (type == LocalDate.class) {
+ return LocalDate.of(2026, 2, 17);
+ }
+ if (type == LocalTime.class) {
+ return LocalTime.of(9, 30);
+ }
+ if (type == LocalDateTime.class) {
+ return LocalDateTime.of(2026, 2, 17, 9, 30);
+ }
+ if (type == List.class) {
+ return new ArrayList<>(List.of("first", "second"));
+ }
+ if (type == Set.class) {
+ return new HashSet<>(Set.of("first"));
+ }
+ if (type == Map.class) {
+ return new HashMap<>(Map.of("key", "value"));
+ }
+ if (type == Object.class) {
+ return "sample";
+ }
+ if (type.isPrimitive() || type.isEnum() || type.isArray() || type.isInterface()) {
+ return null;
+ }
+ try {
+ java.lang.reflect.Constructor constructor = type.getDeclaredConstructor();
+ constructor.setAccessible(true);
+ return constructor.newInstance();
+ } catch (ReflectiveOperationException | SecurityException e) {
+ // A carrier that needs arguments is simply left at its default value.
+ return null;
+ }
+ }
+}
diff --git a/src/test/java/com/iemr/admin/data/ClassScanner.java b/src/test/java/com/iemr/admin/data/ClassScanner.java
new file mode 100644
index 0000000..7eb63b0
--- /dev/null
+++ b/src/test/java/com/iemr/admin/data/ClassScanner.java
@@ -0,0 +1,64 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.data;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
+import org.springframework.core.type.filter.RegexPatternTypeFilter;
+
+/** Finds every concrete class published under a package, for suite-wide contract checks. */
+public final class ClassScanner {
+
+ private ClassScanner() {
+ }
+
+ public static List> classesUnder(String... packages) {
+ ClassPathScanningCandidateComponentProvider provider =
+ new ClassPathScanningCandidateComponentProvider(false) {
+ @Override
+ protected boolean isCandidateComponent(
+ org.springframework.beans.factory.annotation.AnnotatedBeanDefinition definition) {
+ return definition.getMetadata().isIndependent()
+ && !definition.getMetadata().isAnnotation();
+ }
+ };
+ provider.addIncludeFilter(new RegexPatternTypeFilter(Pattern.compile(".*")));
+
+ List> found = new ArrayList<>();
+ for (String packageName : packages) {
+ for (BeanDefinition definition : provider.findCandidateComponents(packageName)) {
+ try {
+ found.add(Class.forName(definition.getBeanClassName()));
+ } catch (ClassNotFoundException | NoClassDefFoundError e) {
+ // A class the test classpath cannot resolve is not part of the contract.
+ }
+ }
+ }
+ found.sort(Comparator.comparing(Class::getName));
+ return found;
+ }
+}
diff --git a/src/test/java/com/iemr/admin/data/DataCarrierContractTest.java b/src/test/java/com/iemr/admin/data/DataCarrierContractTest.java
new file mode 100644
index 0000000..1fe9016
--- /dev/null
+++ b/src/test/java/com/iemr/admin/data/DataCarrierContractTest.java
@@ -0,0 +1,71 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.data;
+
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Exercises every data carrier the service exchanges - the JPA entities, the
+ * transfer objects and the small model holders - against the accessor, equality
+ * and string contract their callers rely on.
+ */
+@DisplayName("Data carrier contract Test Suite")
+class DataCarrierContractTest {
+
+ private static final String[] CARRIER_PACKAGES = {
+ "com.iemr.admin.data",
+ "com.iemr.admin.to",
+ "com.iemr.admin.model" };
+
+ static List> carriers() {
+ return ClassScanner.classesUnder(CARRIER_PACKAGES).stream()
+ .filter(type -> !type.getName().endsWith("Test"))
+ .filter(type -> !type.getSimpleName().equals("BeanContract"))
+ .filter(type -> !type.getSimpleName().equals("ClassScanner"))
+ .filter(BeanContract::isVerifiable)
+ .toList();
+ }
+
+ @Test
+ @DisplayName("the scan should discover the carriers rather than silently pass on an empty set")
+ void carrierScan_shouldDiscoverCarriers() {
+ List> carriers = carriers();
+ assertFalse(carriers.isEmpty(), "no data carriers were discovered on the test classpath");
+ assertTrue(carriers.size() > 100,
+ "expected the full carrier set, found only " + carriers.size());
+ }
+
+ @ParameterizedTest(name = "{0} honours the accessor, equality and string contract")
+ @DisplayName("every data carrier should honour its accessor, equality and string contract")
+ @MethodSource("carriers")
+ void dataCarrier_shouldHonourBeanContract(Class type) throws Exception {
+ BeanContract.verify(type);
+ }
+}
diff --git a/src/test/java/com/iemr/admin/mapper/emailconfig/InstituteEmailConfigMapperTest.java b/src/test/java/com/iemr/admin/mapper/emailconfig/InstituteEmailConfigMapperTest.java
new file mode 100644
index 0000000..a80f1de
--- /dev/null
+++ b/src/test/java/com/iemr/admin/mapper/emailconfig/InstituteEmailConfigMapperTest.java
@@ -0,0 +1,260 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.mapper.emailconfig;
+
+import java.sql.Timestamp;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import com.iemr.admin.data.emailconfig.AuthorityEmail;
+import com.iemr.admin.model.emailconfig.AuthEmailRequest;
+import com.iemr.admin.model.emailconfig.AuthEmailResponse;
+import com.iemr.admin.model.emailconfig.CreateAuthEmailRequestModel;
+import com.iemr.admin.model.emailconfig.CreateNodalEmailRequestModel;
+import com.iemr.admin.model.emailconfig.NodalEmailResponse;
+import com.iemr.admin.model.emailconfig.UpdateAuthEmailRequest;
+import com.iemr.admin.model.emailconfig.UpdateNodalEmailRequest;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * The escalation emails a nodal officer receives are addressed from these
+ * records, so the mapper must carry every contact field across rather than drop
+ * one silently.
+ */
+@DisplayName("InstituteEmailConfigMapper Test Suite")
+class InstituteEmailConfigMapperTest {
+
+ private final InstituteEmailConfigMapper mapper = InstituteEmailConfigMapper.INSTANCE;
+
+ private static AuthorityEmail storedRecord() {
+ AuthorityEmail stored = new AuthorityEmail();
+ stored.setAuthorityEmailID(9001);
+ stored.setStateID(29);
+ stored.setDistrictID(301);
+ stored.setBlockID(401);
+ stored.setDistrictBranchMappingID(501);
+ stored.setDesignationID(7);
+ stored.setAuthorityName("Dr Asha Rao");
+ stored.setEmailID("asha.rao@example.org");
+ stored.setContactNo("9000000001");
+ stored.setProviderServiceMapID(4001);
+ stored.setCreatedBy("admin");
+ stored.setCreatedDate(Timestamp.valueOf("2026-02-17 09:30:00"));
+ stored.setModifiedBy("admin");
+ stored.setDeleted(Boolean.FALSE);
+ return stored;
+ }
+
+ private static CreateAuthEmailRequestModel createAuthorityRequest() {
+ CreateAuthEmailRequestModel request = new CreateAuthEmailRequestModel();
+ request.setStateID(29);
+ request.setDistrictID(301);
+ request.setBlockID(401);
+ request.setDistrictBranchMappingID(501);
+ request.setDesignationID(7);
+ request.setAuthorityName("Dr Asha Rao");
+ request.setEmailID("asha.rao@example.org");
+ request.setContactNo("9000000001");
+ request.setProviderServiceMapID(4001);
+ request.setCreatedBy("admin");
+ return request;
+ }
+
+ private static CreateNodalEmailRequestModel createNodalRequest() {
+ CreateNodalEmailRequestModel request = new CreateNodalEmailRequestModel();
+ request.setStateID(29);
+ request.setDistrictID(301);
+ request.setDesignationID(7);
+ request.setAuthorityName("Dr Asha Rao");
+ request.setEmailID("asha.rao@example.org");
+ request.setContactNo("9000000001");
+ request.setMobileNo("9000000002");
+ request.setProviderServiceMapID(4001);
+ request.setCreatedBy("admin");
+ return request;
+ }
+
+ @Test
+ @DisplayName("requestToInstituteEmailConf should carry the search request onto the record")
+ void requestToInstituteEmailConf_shouldCarrySearchRequest() {
+ AuthEmailRequest request = new AuthEmailRequest();
+ request.setAuthorityEmailID(9001);
+ request.setStateID(29);
+ request.setDistrictID(301);
+ request.setBlockID(401);
+ request.setDistrictBranchMappingID(501);
+ request.setDesignationID(7);
+ request.setProviderServiceMapID(4001);
+ request.setDeleted(Boolean.FALSE);
+
+ AuthorityEmail mapped = mapper.requestToInstituteEmailConf(request);
+
+ assertEquals(9001, mapped.getAuthorityEmailID());
+ assertEquals(29, mapped.getStateID());
+ assertEquals(501, mapped.getDistrictBranchMappingID());
+ assertEquals(4001, mapped.getProviderServiceMapID());
+ }
+
+ @Test
+ @DisplayName("requestToInstituteEmailConf should map a whole batch of search requests")
+ void requestToInstituteEmailConf_shouldMapBatch() {
+ AuthEmailRequest request = new AuthEmailRequest();
+ request.setStateID(29);
+
+ List mapped = mapper.requestToInstituteEmailConf(List.of(request));
+
+ assertEquals(1, mapped.size());
+ assertEquals(29, mapped.get(0).getStateID());
+ }
+
+ @Test
+ @DisplayName("createRequestToInstituteEmailConf should carry every contact field onto the new record")
+ void createRequestToInstituteEmailConf_shouldCarryContactFields() {
+ AuthorityEmail mapped = mapper.createRequestToInstituteEmailConf(createAuthorityRequest());
+
+ assertEquals("Dr Asha Rao", mapped.getAuthorityName());
+ assertEquals("asha.rao@example.org", mapped.getEmailID());
+ assertEquals("9000000001", mapped.getContactNo());
+ assertEquals("admin", mapped.getCreatedBy());
+ }
+
+ @Test
+ @DisplayName("createRequestToInstituteEmailConfig should carry the nodal officer's mobile number too")
+ void createRequestToInstituteEmailConfig_shouldCarryMobileNumber() {
+ AuthorityEmail mapped = mapper.createRequestToInstituteEmailConfig(createNodalRequest());
+
+ assertEquals("Dr Asha Rao", mapped.getAuthorityName());
+ assertEquals("asha.rao@example.org", mapped.getEmailID());
+ }
+
+ @Test
+ @DisplayName("the create mappers should each map a whole batch")
+ void createMappers_shouldMapBatches() {
+ assertEquals(1, mapper.createRequestToInstituteEmailConf(List.of(createAuthorityRequest())).size());
+ assertEquals(1, mapper.createRequestToInstituteEmailConfig(List.of(createNodalRequest())).size());
+ }
+
+ @Test
+ @DisplayName("updateRequestToInstituteEmailConf should carry the edited fields onto the record")
+ void updateRequestToInstituteEmailConf_shouldCarryEditedFields() {
+ UpdateAuthEmailRequest request = new UpdateAuthEmailRequest();
+ request.setAuthorityEmailID(9001);
+ request.setAuthorityName("Dr Ravi Kumar");
+ request.setEmailID("ravi.kumar@example.org");
+ request.setContactNo("9000000003");
+ request.setModifiedBy("admin");
+ request.setDeleted(Boolean.FALSE);
+
+ AuthorityEmail mapped = mapper.updateRequestToInstituteEmailConf(request);
+
+ assertEquals(9001, mapped.getAuthorityEmailID());
+ assertEquals("Dr Ravi Kumar", mapped.getAuthorityName());
+ assertEquals("admin", mapped.getModifiedBy());
+ }
+
+ @Test
+ @DisplayName("updateRequestToInstituteNodalEmailConf should carry the edited nodal fields onto the record")
+ void updateRequestToInstituteNodalEmailConf_shouldCarryEditedFields() {
+ UpdateNodalEmailRequest request = new UpdateNodalEmailRequest();
+ request.setAuthorityEmailID(9001);
+ request.setAuthorityName("Dr Ravi Kumar");
+ request.setMobileNo("9000000004");
+ request.setModifiedBy("admin");
+
+ AuthorityEmail mapped = mapper.updateRequestToInstituteNodalEmailConf(request);
+
+ assertEquals(9001, mapped.getAuthorityEmailID());
+ assertEquals("Dr Ravi Kumar", mapped.getAuthorityName());
+ }
+
+ @Test
+ @DisplayName("updateRequestToInstituteEmailConf should map a whole batch of edits")
+ void updateRequestToInstituteEmailConf_shouldMapBatch() {
+ UpdateAuthEmailRequest request = new UpdateAuthEmailRequest();
+ request.setAuthorityEmailID(9001);
+
+ assertEquals(1, mapper.updateRequestToInstituteEmailConf(List.of(request)).size());
+ }
+
+ @Test
+ @DisplayName("resultToInstTypeEmailResponse should publish the stored record back to the caller")
+ void resultToInstTypeEmailResponse_shouldPublishStoredRecord() {
+ AuthEmailResponse published = mapper.resultToInstTypeEmailResponse(storedRecord());
+
+ assertEquals(9001, published.getAuthorityEmailID());
+ assertEquals("Dr Asha Rao", published.getAuthorityName());
+ assertEquals("asha.rao@example.org", published.getEmailID());
+ assertEquals(Timestamp.valueOf("2026-02-17 09:30:00"), published.getCreatedDate());
+ }
+
+ @Test
+ @DisplayName("the nodal response mappers should publish the stored record back to the caller")
+ void nodalResponseMappers_shouldPublishStoredRecord() {
+ NodalEmailResponse published = mapper.resultToInstTypeNodalEmailResponse(storedRecord());
+ NodalEmailResponse alsoPublished = mapper.resultInstType(storedRecord());
+
+ assertEquals("Dr Asha Rao", published.getAuthorityName());
+ assertEquals("Dr Asha Rao", alsoPublished.getAuthorityName());
+ assertEquals(4001, published.getProviderServiceMapID());
+ }
+
+ @Test
+ @DisplayName("the response mappers should publish a whole batch of stored records")
+ void responseMappers_shouldPublishBatches() {
+ List stored = List.of(storedRecord(), storedRecord());
+
+ assertEquals(2, mapper.resultToInstTypeEmailResponse(stored).size());
+ assertEquals(2, mapper.resultToInstTypeEmailResponses(stored).size());
+ }
+
+ @Test
+ @DisplayName("the mappers should answer nothing rather than an empty record for a missing input")
+ void mappers_shouldAnswerNothingForMissingInput() {
+ assertNull(mapper.requestToInstituteEmailConf((AuthEmailRequest) null));
+ assertNull(mapper.requestToInstituteEmailConf((List) null));
+ assertNull(mapper.createRequestToInstituteEmailConf((CreateAuthEmailRequestModel) null));
+ assertNull(mapper.createRequestToInstituteEmailConf((List) null));
+ assertNull(mapper.createRequestToInstituteEmailConfig((CreateNodalEmailRequestModel) null));
+ assertNull(mapper.createRequestToInstituteEmailConfig((List) null));
+ assertNull(mapper.updateRequestToInstituteEmailConf((UpdateAuthEmailRequest) null));
+ assertNull(mapper.updateRequestToInstituteEmailConf((List) null));
+ assertNull(mapper.updateRequestToInstituteNodalEmailConf(null));
+ assertNull(mapper.resultToInstTypeEmailResponse((AuthorityEmail) null));
+ assertNull(mapper.resultToInstTypeEmailResponse((List) null));
+ assertNull(mapper.resultToInstTypeNodalEmailResponse(null));
+ assertNull(mapper.resultInstType(null));
+ assertNull(mapper.resultToInstTypeEmailResponses(null));
+ }
+
+ @Test
+ @DisplayName("the batch mappers should answer an empty batch for an empty input")
+ void batchMappers_shouldAnswerEmptyBatchForEmptyInput() {
+ assertTrue(mapper.requestToInstituteEmailConf(List.of()).isEmpty());
+ assertTrue(mapper.resultToInstTypeEmailResponse(List.of()).isEmpty());
+ assertTrue(mapper.resultToInstTypeEmailResponses(List.of()).isEmpty());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/mapper/parkingplacetalukmapping/ParkingPlaceTalukMappingMapperTest.java b/src/test/java/com/iemr/admin/mapper/parkingplacetalukmapping/ParkingPlaceTalukMappingMapperTest.java
new file mode 100644
index 0000000..6b63657
--- /dev/null
+++ b/src/test/java/com/iemr/admin/mapper/parkingplacetalukmapping/ParkingPlaceTalukMappingMapperTest.java
@@ -0,0 +1,134 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.mapper.parkingplacetalukmapping;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import com.iemr.admin.data.locationmaster.DistrictBlock;
+import com.iemr.admin.data.locationmaster.M_District;
+import com.iemr.admin.data.parkingPlace.M_Parkingplace;
+import com.iemr.admin.data.parkingPlace.ParkingplaceTalukMapping;
+import com.iemr.admin.data.parkingPlace.ParkingplaceTalukMappingTO;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * The mapper flattens a stored taluk mapping and the three records it points at
+ * into the single carrier the parking place screens read.
+ */
+@DisplayName("ParkingPlaceTalukMappingMapper Test Suite")
+class ParkingPlaceTalukMappingMapperTest {
+
+ private final ParkingPlaceTalukMappingMapper mapper = ParkingPlaceTalukMappingMapper.INSTANCE;
+
+ private static ParkingplaceTalukMapping fullMapping() {
+ ParkingplaceTalukMapping mapping = new ParkingplaceTalukMapping();
+ mapping.setPpSubDistrictMapID(7001);
+ mapping.setParkingPlaceID(31);
+ mapping.setDistrictID(301);
+ mapping.setDistrictBlockID(3011);
+ mapping.setProviderServiceMapID(4001);
+ mapping.setDeleted(Boolean.FALSE);
+ mapping.setProcessed("N");
+ mapping.setCreatedBy("admin");
+ mapping.setModifiedBy("supervisor");
+
+ M_Parkingplace parkingplace = new M_Parkingplace();
+ parkingplace.setParkingPlaceName("Hosur parking");
+ parkingplace.setDeleted(Boolean.FALSE);
+ mapping.setParkingplace(parkingplace);
+
+ M_District district = new M_District();
+ district.setDistrictName("Bengaluru Urban");
+ district.setDeleted(Boolean.FALSE);
+ mapping.setM_district(district);
+
+ DistrictBlock block = new DistrictBlock();
+ block.setBlockName("Anekal");
+ block.setDeleted(Boolean.FALSE);
+ mapping.setDistrictBlock(block);
+ return mapping;
+ }
+
+ @Test
+ @DisplayName("should carry the names of the parking place, district and taluk onto one carrier")
+ void shouldFlattenNamesOntoOneCarrier() {
+ ParkingplaceTalukMappingTO published = mapper.getParkingplaceTalukMappingMap(fullMapping());
+
+ assertEquals(7001, published.getPpSubDistrictMapID());
+ assertEquals("Hosur parking", published.getParkingPlaceName());
+ assertEquals("Bengaluru Urban", published.getDistrictName());
+ assertEquals("Anekal", published.getDistrictBlockName());
+ assertEquals(4001, published.getProviderServiceMapID());
+ assertEquals("admin", published.getCreatedBy());
+ assertEquals("supervisor", published.getModifiedBy());
+ assertEquals("N", published.getProcessed());
+ assertEquals(Boolean.FALSE, published.getDeleted());
+ assertEquals(Boolean.FALSE, published.getParkingPlaceDeleted());
+ assertEquals(Boolean.FALSE, published.getDistrictDeleted());
+ assertEquals(Boolean.FALSE, published.getDistrictBlockDeleted());
+ }
+
+ @Test
+ @DisplayName("should leave the names empty when the mapping points at nothing")
+ void shouldLeaveNamesEmptyWhenNothingPointedAt() {
+ ParkingplaceTalukMapping mapping = new ParkingplaceTalukMapping();
+ mapping.setPpSubDistrictMapID(7002);
+
+ ParkingplaceTalukMappingTO published = mapper.getParkingplaceTalukMappingMap(mapping);
+
+ assertEquals(7002, published.getPpSubDistrictMapID());
+ assertNull(published.getParkingPlaceName());
+ assertNull(published.getDistrictName());
+ assertNull(published.getDistrictBlockName());
+ assertNull(published.getParkingPlaceDeleted());
+ }
+
+ @Test
+ @DisplayName("should answer nothing for a mapping that is not there at all")
+ void shouldAnswerNothingForAbsentMapping() {
+ assertNull(mapper.getParkingplaceTalukMappingMap(null));
+ assertNull(mapper.getParkingplaceTalukMappingMapList(null));
+ }
+
+ @Test
+ @DisplayName("should publish one carrier per mapping in the list")
+ void shouldPublishOneCarrierPerMapping() {
+ List published = mapper
+ .getParkingplaceTalukMappingMapList(List.of(fullMapping(), fullMapping()));
+
+ assertEquals(2, published.size());
+ assertEquals("Anekal", published.get(0).getDistrictBlockName());
+ }
+
+ @Test
+ @DisplayName("should publish an empty list when there is no mapping to publish")
+ void shouldPublishEmptyListForNoMappings() {
+ assertTrue(mapper.getParkingplaceTalukMappingMapList(new ArrayList<>()).isEmpty());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/apiman/ApimanServiceImplTest.java b/src/test/java/com/iemr/admin/service/apiman/ApimanServiceImplTest.java
new file mode 100644
index 0000000..98e4d15
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/apiman/ApimanServiceImplTest.java
@@ -0,0 +1,261 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.apiman;
+
+import java.util.HashMap;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import com.iemr.admin.data.apiman.ApimanClient;
+import com.iemr.admin.data.apiman.ApimanRegister;
+import com.iemr.admin.utils.http.HttpUtils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The apiman service registers a new service line as a client of the API
+ * gateway and signs it up to the API contracts that service line needs.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ApimanServiceImpl Test Suite")
+class ApimanServiceImplTest {
+
+ private static final String BASE_URL = "https://gateway.example.org";
+ private static final String CLIENT_ID = "client-104";
+
+ @Mock
+ private HttpUtils httpUtils;
+
+ private HttpUtils originalHttpUtils;
+
+ private ApimanServiceImpl service;
+
+ @BeforeEach
+ @DisplayName("Stand in for the gateway and point the service at stub addresses")
+ void setUp() {
+ originalHttpUtils = (HttpUtils) ReflectionTestUtils.getField(ApimanServiceImpl.class, "httpUtils");
+ ReflectionTestUtils.setField(ApimanServiceImpl.class, "httpUtils", httpUtils);
+ service = new ApimanServiceImpl();
+ ReflectionTestUtils.setField(service, "apimanBaseURL", BASE_URL);
+ ReflectionTestUtils.setField(service, "clientURL", "APIMAN_URL/clients");
+ ReflectionTestUtils.setField(service, "contractURL", "APIMAN_URL/clients/CLIENT_ID/contracts");
+ ReflectionTestUtils.setField(service, "registerURL", "APIMAN_URL/register");
+ ReflectionTestUtils.setField(service, "getClientKey", "APIMAN_URL/clients/CLIENT_ID/apikey");
+ ReflectionTestUtils.setField(service, "auth", "Bearer gateway-token");
+ ReflectionTestUtils.setField(service, "apimanplanID", "plan");
+ ReflectionTestUtils.setField(service, "apimanorgID", "org");
+ ReflectionTestUtils.setField(service, "apimanCommonApiID", "common");
+ ReflectionTestUtils.setField(service, "apiman1097apiID", "api1097");
+ ReflectionTestUtils.setField(service, "apimanMMUapiID", "mmu");
+ ReflectionTestUtils.setField(service, "apimanInventoryapiID", "inventory");
+ ReflectionTestUtils.setField(service, "apiman104apiID", "api104");
+ ReflectionTestUtils.setField(service, "apimanTMapiID", "tm");
+ ReflectionTestUtils.setField(service, "apimanSchedulingapiID", "scheduling");
+ ReflectionTestUtils.setField(service, "apimanMCTSapiID", "mcts");
+ }
+
+ @AfterEach
+ @DisplayName("Put the real gateway client back so no other suite sees the stand-in")
+ void tearDown() {
+ ReflectionTestUtils.setField(ApimanServiceImpl.class, "httpUtils", originalHttpUtils);
+ }
+
+ private static ApimanClient client() {
+ ApimanClient client = new ApimanClient();
+ client.setId(CLIENT_ID);
+ client.setName("104 Helpline");
+ client.setInitialVersion("1.0");
+ return client;
+ }
+
+ @Test
+ @DisplayName("createClient should answer the client the gateway registered")
+ void createClient_shouldAnswerRegisteredClient() throws Exception {
+ when(httpUtils.post(anyString(), anyString(), any()))
+ .thenReturn("{\"id\":\"client-104\",\"name\":\"104 Helpline\"}");
+
+ ApimanClient registered = service.createClient(client());
+
+ assertEquals(CLIENT_ID, registered.getId());
+ assertEquals("104 Helpline", registered.getName());
+ }
+
+ @Test
+ @DisplayName("createClient should send the client to the gateway with the configured credentials")
+ void createClient_shouldSendWithConfiguredCredentials() throws Exception {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{\"id\":\"client-104\"}");
+ ArgumentCaptor url = ArgumentCaptor.forClass(String.class);
+ ArgumentCaptor> header = ArgumentCaptor.forClass(HashMap.class);
+
+ service.createClient(client());
+
+ verify(httpUtils).post(url.capture(), anyString(), header.capture());
+ assertEquals(BASE_URL + "/clients", url.getValue());
+ assertEquals("Bearer gateway-token", header.getValue().get("Authorization"));
+ assertEquals("application/json", header.getValue().get("Content-Type"));
+ }
+
+ @Test
+ @DisplayName("createClient should give up when the gateway answers something that is not a client")
+ void createClient_shouldGiveUpOnUnreadableReply() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("null");
+
+ assertThrows(RuntimeException.class, () -> service.createClient(client()));
+ }
+
+ @Test
+ @DisplayName("createClientContract should sign a helpline service line up to its own API as well as the shared one")
+ void createClientContract_shouldSignUpHelplineApis() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+
+ service.createClientContract(1, CLIENT_ID);
+
+ ArgumentCaptor body = ArgumentCaptor.forClass(String.class);
+ verify(httpUtils, times(3)).post(anyString(), body.capture(), any());
+ assertTrue(body.getAllValues().stream().anyMatch(sent -> sent.contains("api1097")), body.getAllValues()
+ .toString());
+ assertTrue(body.getAllValues().stream().filter(sent -> sent.contains("common")).count() == 2,
+ "both versions of the shared API must be contracted");
+ }
+
+ @Test
+ @DisplayName("createClientContract should sign a mobile unit service line up to its stock APIs too")
+ void createClientContract_shouldSignUpMobileUnitApis() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+
+ service.createClientContract(2, CLIENT_ID);
+
+ ArgumentCaptor body = ArgumentCaptor.forClass(String.class);
+ verify(httpUtils, times(4)).post(anyString(), body.capture(), any());
+ List sent = body.getAllValues();
+ assertTrue(sent.stream().anyMatch(one -> one.contains("mmu")), sent.toString());
+ assertTrue(sent.stream().anyMatch(one -> one.contains("inventory")), sent.toString());
+ }
+
+ @Test
+ @DisplayName("createClientContract should sign a telemedicine service line up to its scheduling API")
+ void createClientContract_shouldSignUpTelemedicineApis() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+
+ service.createClientContract(4, CLIENT_ID);
+
+ ArgumentCaptor body = ArgumentCaptor.forClass(String.class);
+ verify(httpUtils, times(4)).post(anyString(), body.capture(), any());
+ assertTrue(body.getAllValues().stream().anyMatch(one -> one.contains("scheduling")),
+ body.getAllValues().toString());
+ }
+
+ @Test
+ @DisplayName("createClientContract should contract only the shared API for a service line with no API of its own")
+ void createClientContract_shouldContractOnlySharedApi() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+
+ service.createClientContract(5, CLIENT_ID);
+
+ verify(httpUtils, times(2)).post(anyString(), anyString(), any());
+ }
+
+ @Test
+ @DisplayName("createClientContract should contract only the shared API for a service line it does not recognise")
+ void createClientContract_shouldContractOnlySharedApiForUnknownServiceLine() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+
+ service.createClientContract(99, CLIENT_ID);
+
+ verify(httpUtils, times(2)).post(anyString(), anyString(), any());
+ }
+
+ @Test
+ @DisplayName("createClientContract should address the client whose contracts are being signed")
+ void createClientContract_shouldAddressTheClient() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+ ArgumentCaptor url = ArgumentCaptor.forClass(String.class);
+
+ service.createClientContract(3, CLIENT_ID);
+
+ verify(httpUtils, times(3)).post(url.capture(), anyString(), any());
+ assertEquals(BASE_URL + "/clients/" + CLIENT_ID + "/contracts", url.getValue());
+ }
+
+ @Test
+ @DisplayName("registerClient should publish the registration to the gateway")
+ void registerClient_shouldPublishRegistration() {
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{}");
+ ApimanRegister registration = new ApimanRegister();
+ registration.setType("client");
+ registration.setEntityId(CLIENT_ID);
+ ArgumentCaptor url = ArgumentCaptor.forClass(String.class);
+
+ assertNull(service.registerClient(registration), "registration answers nothing back to the caller");
+ verify(httpUtils).post(url.capture(), anyString(), any());
+ assertEquals(BASE_URL + "/register", url.getValue());
+ }
+
+ @Test
+ @DisplayName("getClientKey should answer the API key the gateway issued")
+ void getClientKey_shouldAnswerIssuedKey() {
+ when(httpUtils.get(anyString(), any())).thenReturn("{\"apiKey\":\"key-abc-123\"}");
+
+ assertEquals("key-abc-123", service.getClientKey(CLIENT_ID));
+ }
+
+ @Test
+ @DisplayName("getClientKey should give up when the gateway does not answer a key")
+ void getClientKey_shouldGiveUpWithoutKey() {
+ when(httpUtils.get(anyString(), any())).thenReturn("{\"result\":\"unknown client\"}");
+
+ assertThrows(RuntimeException.class, () -> service.getClientKey(CLIENT_ID));
+ }
+
+ @Test
+ @DisplayName("the gateway should still be reached when no credentials are configured")
+ void gatewayCalls_shouldStillBeReachedWithoutCredentials() throws Exception {
+ ReflectionTestUtils.setField(service, "auth", null);
+ when(httpUtils.post(anyString(), anyString(), any())).thenReturn("{\"id\":\"client-104\"}");
+ ArgumentCaptor> header = ArgumentCaptor.forClass(HashMap.class);
+
+ service.createClient(client());
+
+ verify(httpUtils).post(anyString(), anyString(), header.capture());
+ assertNull(header.getValue().get("Authorization"), "no credentials must be sent when none are configured");
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/blocking/BlockingServiceTest.java b/src/test/java/com/iemr/admin/service/blocking/BlockingServiceTest.java
new file mode 100644
index 0000000..39711d1
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/blocking/BlockingServiceTest.java
@@ -0,0 +1,309 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.blocking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.blocking.M_Providerservicemapping_Blocking;
+import com.iemr.admin.data.blocking.M_Serviceprovider_Blocking;
+import com.iemr.admin.data.blocking.M_Status1;
+import com.iemr.admin.data.blocking.T_Providerservicemappingdetail;
+import com.iemr.admin.data.blocking.T_Serviceproviderdetail;
+import com.iemr.admin.data.blocking.T_Userdetail;
+import com.iemr.admin.data.blocking.UserForBlocking;
+import com.iemr.admin.data.blocking.V_Showproviderservicemapping;
+import com.iemr.admin.repo.blocking.MProviderservicemappingBlockingRepo;
+import com.iemr.admin.repo.blocking.MServiceproviderBlockingRepo;
+import com.iemr.admin.repo.blocking.MStatusRepo;
+import com.iemr.admin.repo.blocking.T_ProviderservicemappingdetailRepo;
+import com.iemr.admin.repo.blocking.T_ServiceproviderdetailRepo;
+import com.iemr.admin.repo.blocking.T_UserDetailRepo;
+import com.iemr.admin.repo.blocking.UserBlockingRepo;
+import com.iemr.admin.repo.blocking.V_ShowproviderservicemappingRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The blocking service turns each request to suspend a provider into the right
+ * repository update, and reports how far a CTI campaign mapping got.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("Blocking_Service Test Suite")
+class BlockingServiceTest {
+
+ private static final Integer PROVIDER_ID = 77;
+ private static final Integer SERVICE_ID = 3;
+ private static final Integer STATE_ID = 29;
+
+ @Mock
+ private V_ShowproviderservicemappingRepo v_ShowproviderservicemappingRepo;
+
+ @Mock
+ private T_UserDetailRepo t_UserDetailRepo;
+
+ @Mock
+ private MStatusRepo mStatusRepo;
+
+ @Mock
+ private UserBlockingRepo userBlockingRepo;
+
+ @Mock
+ private T_ProviderservicemappingdetailRepo t_ProviderservicemappingdetailRepo;
+
+ @Mock
+ private MProviderservicemappingBlockingRepo mProviderservicemappingBlockingRepo;
+
+ @Mock
+ private T_ServiceproviderdetailRepo t_ServiceproviderdetailRepo;
+
+ @Mock
+ private MServiceproviderBlockingRepo mServiceproviderBlockingRepo;
+
+ @InjectMocks
+ private Blocking_Service service;
+
+ private static M_Providerservicemapping_Blocking mapping(Integer mapId) {
+ M_Providerservicemapping_Blocking mapping = new M_Providerservicemapping_Blocking();
+ mapping.setProviderServiceMapID(mapId);
+ mapping.setServiceProviderID(PROVIDER_ID);
+ mapping.setServiceID(SERVICE_ID);
+ mapping.setStateID(STATE_ID);
+ mapping.setcTI_CampaignName("104");
+ return mapping;
+ }
+
+ @Test
+ @DisplayName("getProviderDetailsById should hand back what the repository holds")
+ void getProviderDetailsById_shouldHandBackRepositoryContents() {
+ M_Serviceprovider_Blocking stored = new M_Serviceprovider_Blocking();
+ when(mServiceproviderBlockingRepo.getProviderDetailsByID(PROVIDER_ID)).thenReturn(stored);
+
+ assertSame(stored, service.getProviderDetailsById(PROVIDER_ID));
+ }
+
+ @Test
+ @DisplayName("blockServiceProvider should answer the provider the repository stored")
+ void blockServiceProvider_shouldAnswerStoredProvider() {
+ M_Serviceprovider_Blocking stored = new M_Serviceprovider_Blocking();
+ when(mServiceproviderBlockingRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.blockServiceProvider(stored));
+ }
+
+ @Test
+ @DisplayName("saveData should answer the audit row the repository stored")
+ void saveData_shouldAnswerStoredAuditRow() {
+ T_Serviceproviderdetail stored = new T_Serviceproviderdetail();
+ when(t_ServiceproviderdetailRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.saveData(stored));
+ }
+
+ @Test
+ @DisplayName("the status updates should each reach their own repository query")
+ void statusUpdates_shouldReachTheirOwnQuery() {
+ service.blockProviderByService(PROVIDER_ID, STATE_ID, SERVICE_ID, 2);
+ service.blockProviderByState(PROVIDER_ID, STATE_ID, 2);
+ service.blockProvider(PROVIDER_ID, 2);
+ service.blockProviderByProviderIdAndServiceId(PROVIDER_ID, SERVICE_ID, 2);
+ service.blockUser(3117, 2);
+
+ verify(mProviderservicemappingBlockingRepo).blockProviderByService(PROVIDER_ID, STATE_ID, SERVICE_ID, 2);
+ verify(mProviderservicemappingBlockingRepo).blockProviderByState(PROVIDER_ID, STATE_ID, 2);
+ verify(mProviderservicemappingBlockingRepo).blockProvider(PROVIDER_ID, 2);
+ verify(mProviderservicemappingBlockingRepo)
+ .blockProviderByProviderIdAndServiceId(PROVIDER_ID, SERVICE_ID, 2);
+ verify(userBlockingRepo).blockUser(3117, 2);
+ }
+
+ @Test
+ @DisplayName("the mapping lookups should each reach their own repository query")
+ void mappingLookups_shouldReachTheirOwnQuery() {
+ M_Providerservicemapping_Blocking stored = mapping(4001);
+ ArrayList storedList = new ArrayList<>(List.of(stored));
+ List stateList = List.of(stored);
+ when(mProviderservicemappingBlockingRepo.getProviderServiceMappingDetails(PROVIDER_ID, STATE_ID, SERVICE_ID))
+ .thenReturn(stored);
+ when(mProviderservicemappingBlockingRepo.getProviderStateMappingDetails(PROVIDER_ID, STATE_ID))
+ .thenReturn(stateList);
+ when(mProviderservicemappingBlockingRepo.getProviderStatus(PROVIDER_ID)).thenReturn(storedList);
+ when(mProviderservicemappingBlockingRepo.getProviderStatusByProviderAndServiceId(PROVIDER_ID, SERVICE_ID))
+ .thenReturn(storedList);
+ when(mProviderservicemappingBlockingRepo.findByProviderServiceMapID(4001)).thenReturn(stored);
+ when(mProviderservicemappingBlockingRepo.save(stored)).thenReturn(stored);
+ when(mProviderservicemappingBlockingRepo.saveAll(anyList())).thenReturn(storedList);
+
+ assertSame(stored, service.getProviderServiceMappingDetails(PROVIDER_ID, STATE_ID, SERVICE_ID));
+ assertSame(stateList, service.getProviderStateMappingDetails(PROVIDER_ID, STATE_ID));
+ assertSame(storedList, service.getProviderStatus(PROVIDER_ID));
+ assertSame(storedList, service.getProviderStatusByProviderAndServiceId(PROVIDER_ID, SERVICE_ID));
+ assertSame(stored, service.getDataByProviderServiceMapId(4001));
+ assertSame(stored, service.updateProviderData(stored));
+ assertSame(storedList, service.AddServiceProvider(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("the view lookups should each reach their own repository query")
+ void viewLookups_shouldReachTheirOwnQuery() {
+ ArrayList stored = new ArrayList<>(List.of(new V_Showproviderservicemapping()));
+ when(v_ShowproviderservicemappingRepo.getProviderStatus(PROVIDER_ID)).thenReturn(stored);
+ when(v_ShowproviderservicemappingRepo.getProviderStatus1(PROVIDER_ID)).thenReturn(stored);
+ when(v_ShowproviderservicemappingRepo.getProviderServiceMappingDetails1(PROVIDER_ID, STATE_ID, SERVICE_ID))
+ .thenReturn(stored);
+ when(v_ShowproviderservicemappingRepo.getProviderStateMappingDetails(PROVIDER_ID, STATE_ID))
+ .thenReturn(stored);
+ when(v_ShowproviderservicemappingRepo.getProviderStatusByProviderAndServiceId(PROVIDER_ID, SERVICE_ID))
+ .thenReturn(stored);
+
+ assertSame(stored, service.getProviderStatus1(PROVIDER_ID));
+ assertSame(stored, service.getProviderStatus2(PROVIDER_ID));
+ assertSame(stored, service.getProviderServiceMappingDetails2(PROVIDER_ID, STATE_ID, SERVICE_ID));
+ assertSame(stored, service.getProviderStateMappingDetails1(PROVIDER_ID, STATE_ID));
+ assertSame(stored, service.getProviderStatusByProviderAndServiceId2(PROVIDER_ID, SERVICE_ID));
+ }
+
+ @Test
+ @DisplayName("the audit writes should each reach their own repository")
+ void auditWrites_shouldReachTheirOwnRepository() {
+ T_Providerservicemappingdetail detail = new T_Providerservicemappingdetail();
+ ArrayList details = new ArrayList<>(List.of(detail));
+ T_Userdetail userDetail = new T_Userdetail();
+ when(t_ProviderservicemappingdetailRepo.save(detail)).thenReturn(detail);
+ when(t_ProviderservicemappingdetailRepo.saveAll(anyList())).thenReturn(details);
+ when(t_UserDetailRepo.save(userDetail)).thenReturn(userDetail);
+
+ assertSame(detail, service.savetpsdData(detail));
+ assertSame(details, service.savetpsmd(new ArrayList<>()));
+ assertSame(userDetail, service.saveUserDetails(userDetail));
+ }
+
+ @Test
+ @DisplayName("getUserDetailByUserId and getStatusData should hand back what the repositories hold")
+ void userLookups_shouldHandBackRepositoryContents() {
+ UserForBlocking user = new UserForBlocking();
+ ArrayList statuses = new ArrayList<>(List.of(new M_Status1()));
+ when(userBlockingRepo.getUserDetailByUserId(3117)).thenReturn(user);
+ when(mStatusRepo.getStatusData()).thenReturn(statuses);
+
+ assertSame(user, service.getUserDetailByUserId(3117));
+ assertSame(statuses, service.getStatusData());
+ }
+
+ @Test
+ @DisplayName("getServiceLiensUsingProvider should skip a row the query could not fill")
+ void getServiceLiensUsingProvider_shouldSkipUnfillableRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(null);
+ rows.add(new Object[] { 4001, PROVIDER_ID, SERVICE_ID, "Tele Medicine", Boolean.FALSE });
+ when(mProviderservicemappingBlockingRepo.getServiceLiensUsingProvider(PROVIDER_ID)).thenReturn(rows);
+
+ assertEquals(1, service.getServiceLiensUsingProvider(PROVIDER_ID).size());
+ }
+
+ @Test
+ @DisplayName("mapctidata should report a clean run when every mapping is written")
+ void mapctidata_shouldReportCleanRun() {
+ when(mProviderservicemappingBlockingRepo.createcitmapping(anyInt(), any())).thenReturn(1);
+
+ assertEquals("Mapping Successful", service.mapctidata(List.of(mapping(4001), mapping(4002))));
+ }
+
+ @Test
+ @DisplayName("mapctidata should report how far it got when a mapping is rejected")
+ void mapctidata_shouldReportHowFarItGot() {
+ when(mProviderservicemappingBlockingRepo.createcitmapping(4001, "104")).thenReturn(1);
+ when(mProviderservicemappingBlockingRepo.createcitmapping(4002, "104")).thenReturn(0);
+
+ String status = service.mapctidata(List.of(mapping(4001), mapping(4002)));
+
+ assertTrue(status.startsWith("Mapping Failed"), status);
+ assertTrue(status.contains("after 1 entries"), status);
+ }
+
+ @Test
+ @DisplayName("getServiceLiensUsingProvider1 should narrow by provider, service and state when all are named")
+ void getServiceLiensUsingProvider1_shouldNarrowByAllThree() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(new Object[] { 4001, PROVIDER_ID, SERVICE_ID, "Tele Medicine", STATE_ID, "Karnataka", "104",
+ Boolean.FALSE, "N", Boolean.FALSE });
+ when(mProviderservicemappingBlockingRepo.getServiceLiensUsingProvider1(PROVIDER_ID, SERVICE_ID, STATE_ID))
+ .thenReturn(rows);
+
+ assertEquals(1, service.getServiceLiensUsingProvider1(mapping(4001)).size());
+ }
+
+ @Test
+ @DisplayName("getServiceLiensUsingProvider1 should narrow by provider and service when no state is named")
+ void getServiceLiensUsingProvider1_shouldNarrowByProviderAndService() {
+ M_Providerservicemapping_Blocking request = mapping(4001);
+ request.setStateID(null);
+ when(mProviderservicemappingBlockingRepo.getServiceLiensUsingProvider1(PROVIDER_ID, SERVICE_ID))
+ .thenReturn(new ArrayList<>());
+
+ service.getServiceLiensUsingProvider1(request);
+
+ verify(mProviderservicemappingBlockingRepo).getServiceLiensUsingProvider1(PROVIDER_ID, SERVICE_ID);
+ }
+
+ @Test
+ @DisplayName("getServiceLiensUsingProvider1 should narrow by provider alone when no service is named")
+ void getServiceLiensUsingProvider1_shouldNarrowByProviderAlone() {
+ M_Providerservicemapping_Blocking request = mapping(4001);
+ request.setStateID(null);
+ request.setServiceID(null);
+ when(mProviderservicemappingBlockingRepo.getServiceLiensUsingProvider1(PROVIDER_ID))
+ .thenReturn(new ArrayList<>());
+
+ service.getServiceLiensUsingProvider1(request);
+
+ verify(mProviderservicemappingBlockingRepo).getServiceLiensUsingProvider1(PROVIDER_ID);
+ }
+
+ @Test
+ @DisplayName("getServiceLiensUsingProvider1 should answer every mapping when the request narrows nothing")
+ void getServiceLiensUsingProvider1_shouldAnswerEveryMapping() {
+ M_Providerservicemapping_Blocking request = new M_Providerservicemapping_Blocking();
+ when(mProviderservicemappingBlockingRepo.getServiceLiensUsingProvider1()).thenReturn(new ArrayList<>());
+
+ service.getServiceLiensUsingProvider1(request);
+
+ verify(mProviderservicemappingBlockingRepo).getServiceLiensUsingProvider1();
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/bulkRegistration/BulkRegistrationServiceImplTest.java b/src/test/java/com/iemr/admin/service/bulkRegistration/BulkRegistrationServiceImplTest.java
new file mode 100644
index 0000000..50bd3d1
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/bulkRegistration/BulkRegistrationServiceImplTest.java
@@ -0,0 +1,588 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.bulkRegistration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.bulkuser.BulkRegistrationError;
+import com.iemr.admin.data.bulkuser.Employee;
+import com.iemr.admin.data.bulkuser.EmployeeList;
+import com.iemr.admin.data.employeemaster.M_Community;
+import com.iemr.admin.data.employeemaster.M_Gender;
+import com.iemr.admin.data.employeemaster.M_Religion;
+import com.iemr.admin.data.employeemaster.M_Title;
+import com.iemr.admin.data.employeemaster.M_User1;
+import com.iemr.admin.data.employeemaster.M_Userqualification;
+import com.iemr.admin.data.locationmaster.M_District;
+import com.iemr.admin.data.rolemaster.StateMasterForRole;
+import com.iemr.admin.repo.employeemaster.V_ShowuserRepo;
+import com.iemr.admin.service.employeemaster.EmployeeMasterInter;
+import com.iemr.admin.service.locationmaster.LocationMasterServiceInter;
+import com.iemr.admin.service.rolemaster.Role_MasterInter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Bulk registration turns an uploaded spreadsheet into user records. A row that
+ * fails validation must be reported rather than half-saved, so the error log is
+ * as much a deliverable as the users it creates.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("BulkRegistrationServiceImpl Test Suite")
+class BulkRegistrationServiceImplTest {
+
+ /** Excel serial numbers, which is how the uploaded sheet carries its dates. */
+ private static final String DOB_SERIAL = "30000";
+ private static final String DOJ_SERIAL = "40000";
+
+ @Mock
+ private EmployeeMasterInter employeeMasterInter;
+
+ @Mock
+ private Role_MasterInter roleMasterInter;
+
+ @Mock
+ private V_ShowuserRepo showuserRepo;
+
+ @Mock
+ private LocationMasterServiceInter locationMasterServiceInter;
+
+ @Mock
+ private EmployeeXmlService employeeXmlService;
+
+ @InjectMocks
+ private BulkRegistrationServiceImpl service;
+
+ private Employee employee;
+
+ @BeforeEach
+ void setUp() throws Exception {
+ employee = validEmployee();
+
+ M_Title title = new M_Title();
+ title.setTitleID(1);
+ title.setTitleName("Ms.");
+ when(employeeMasterInter.getAllTitle()).thenReturn(new ArrayList<>(List.of(title)));
+
+ M_Gender gender = new M_Gender();
+ gender.setGenderID(2);
+ gender.setGenderName("Female");
+ when(employeeMasterInter.getAllGender()).thenReturn(new ArrayList<>(List.of(gender)));
+
+ M_Userqualification qualification = new M_Userqualification();
+ qualification.setQualificationID(5);
+ qualification.setName("MBBS");
+ when(employeeMasterInter.getQualification()).thenReturn(new ArrayList<>(List.of(qualification)));
+
+ M_Community community = new M_Community();
+ community.setCommunityID(3);
+ community.setCommunityType("General");
+ when(employeeMasterInter.getAllCommunity()).thenReturn(new ArrayList<>(List.of(community)));
+
+ M_Religion religion = new M_Religion();
+ religion.setReligionID(4);
+ religion.setReligionType("Hindu");
+ when(employeeMasterInter.getAllReligion()).thenReturn(new ArrayList<>(List.of(religion)));
+
+ StateMasterForRole state = new StateMasterForRole();
+ state.setStateID(29);
+ state.setStateName("Karnataka");
+ when(roleMasterInter.getAllState()).thenReturn(new ArrayList<>(List.of(state)));
+
+ M_District district = new M_District();
+ district.setDistrictID(301);
+ district.setDistrictName("Bengaluru Urban");
+ when(locationMasterServiceInter.getAllDistrictByStateId(29)).thenReturn(new ArrayList<>(List.of(district)));
+
+ when(employeeMasterInter.FindEmployeeName(anyString())).thenReturn("usernotexist");
+ when(employeeMasterInter.FindEmployeeContact(anyString())).thenReturn("contactnotexist");
+ when(employeeMasterInter.FindEmployeeAadhaar(anyString())).thenReturn("aadhaarnotexist");
+
+ M_User1 saved = new M_User1();
+ saved.setUserID(3117);
+ when(employeeMasterInter.saveBulkUserEmployee(any())).thenReturn(saved);
+ }
+
+ private static Employee validEmployee() {
+ Employee employee = new Employee();
+ employee.setTitle("Ms");
+ employee.setFirstName("Asha");
+ employee.setMiddleName("");
+ employee.setLastName("Rao");
+ employee.setGender("Female");
+ employee.setContactNo("9000000001");
+ employee.setDesignation("ASHA");
+ employee.setEmergencyContactNo("9000000002");
+ employee.setDob(DOB_SERIAL);
+ employee.setEmail("asha.rao@example.org");
+ employee.setAadhaarNo("111122223333");
+ employee.setPan("ABCDEFGH123");
+ employee.setQualification("MBBS");
+ employee.setFatherName("Ravi");
+ employee.setMotherName("Meera");
+ employee.setCommunity("General");
+ employee.setReligion("Hindu");
+ employee.setAddressLine1("Main Road");
+ employee.setState("Karnataka");
+ employee.setDistrict("Bengaluru Urban");
+ employee.setPincode("560001");
+ employee.setPermanentAddressLine1("Main Road");
+ employee.setPermanentState("Karnataka");
+ employee.setPermanentDistrict("Bengaluru Urban");
+ employee.setPermanentPincode("560001");
+ employee.setDateOfJoining(DOJ_SERIAL);
+ employee.setUserName("EMP-1");
+ employee.setPassword("plain-secret");
+ return employee;
+ }
+
+ private void uploadContains(Employee... employees) throws Exception {
+ EmployeeList list = new EmployeeList();
+ list.setEmployees(new ArrayList<>(List.of(employees)));
+ when(employeeXmlService.parseXml(anyString())).thenReturn(list);
+ }
+
+ @Nested
+ @DisplayName("registerBulkUser")
+ class RegisterBulkUserTests {
+
+ @Test
+ @DisplayName("should register a row that passes every rule")
+ void register_shouldRegisterValidRow() throws Exception {
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertEquals(1, service.totalEmployeeListSize);
+ assertEquals(1, service.m_bulkUser.size());
+ assertTrue(service.errorLogs.isEmpty(), service.errorLogs.toString());
+ verify(employeeMasterInter).saveBulkUserEmployee(any());
+ verify(employeeMasterInter).saveDemography(any());
+ }
+
+ @Test
+ @DisplayName("should carry the uploaded details onto the user it stores")
+ void register_shouldCarryDetailsOntoStoredUser() throws Exception {
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ M_User1 stored = service.m_bulkUser.get(0);
+ assertEquals("Asha", stored.getFirstName());
+ assertEquals("9000000001", stored.getUserName(), "the contact number is used as the sign-in name");
+ assertEquals("EMP-1", stored.getEmployeeID());
+ assertEquals(77, stored.getServiceProviderID());
+ assertEquals(2, stored.getStatusID());
+ assertFalse("plain-secret".equals(stored.getPassword()), "the password must be hashed before storing");
+ }
+
+ @Test
+ @DisplayName("should report a row that names no user")
+ void register_shouldReportRowWithoutUserName() throws Exception {
+ employee.setUserName("");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertEquals(1, service.errorLogs.size());
+ assertTrue(service.errorLogs.get(0).contains("Please Enter UserName"), service.errorLogs.toString());
+ verify(employeeMasterInter, never()).saveBulkUserEmployee(any());
+ }
+
+ @Test
+ @DisplayName("should report a row whose user name is already taken")
+ void register_shouldReportExistingUser() throws Exception {
+ when(employeeMasterInter.FindEmployeeName(anyString())).thenReturn("userexist");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("User Already exist"), service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report a row whose contact number is already taken")
+ void register_shouldReportExistingContact() throws Exception {
+ when(employeeMasterInter.FindEmployeeContact(anyString())).thenReturn("contactexist");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("Contact No Already exist"), service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report every rule a row breaks rather than only the first")
+ void register_shouldReportEveryBrokenRule() throws Exception {
+ employee.setTitle("");
+ employee.setFirstName("");
+ employee.setLastName("");
+ employee.setEmail("not-an-email");
+ employee.setContactNo("12345");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ String reported = service.errorLogs.get(0);
+ assertTrue(reported.contains("Title is missing."), reported);
+ assertTrue(reported.contains("First Name is missing."), reported);
+ assertTrue(reported.contains("Last Name is missing."), reported);
+ assertTrue(reported.contains("Invalid Email format."), reported);
+ assertTrue(reported.contains("Contact Number is invalid"), reported);
+ }
+
+ @Test
+ @DisplayName("should report a name that is a number rather than a name")
+ void register_shouldReportNumericName() throws Exception {
+ employee.setFirstName("12345");
+ employee.setLastName("67890");
+ employee.setMiddleName("42");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ String reported = service.errorLogs.get(0);
+ assertTrue(reported.contains("First name is invalid."), reported);
+ assertTrue(reported.contains("Last name is invalid."), reported);
+ assertTrue(reported.contains("Middle name is invalid."), reported);
+ }
+
+ @Test
+ @DisplayName("should report a name longer than the column can hold")
+ void register_shouldReportOverlongName() throws Exception {
+ String tooLong = "A".repeat(51);
+ employee.setFirstName(tooLong);
+ employee.setMiddleName(tooLong);
+ employee.setLastName(tooLong);
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ String reported = service.errorLogs.get(0);
+ assertTrue(reported.contains("First name is invalid."), reported);
+ assertTrue(reported.contains("Middle name is invalid."), reported);
+ assertTrue(reported.contains("Last name is invalid."), reported);
+ }
+
+ @Test
+ @DisplayName("should report a title the master does not know")
+ void register_shouldReportUnknownTitle() throws Exception {
+ employee.setTitle("Archduke");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("Title is invalid."), service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report a district the master does not know")
+ void register_shouldReportUnknownDistrict() throws Exception {
+ employee.setDistrict("Nowhere");
+ employee.setPermanentDistrict("Nowhere");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ String reported = service.errorLogs.get(0);
+ assertTrue(reported.contains("Current District is invalid."), reported);
+ assertTrue(reported.contains("Permanent District is invalid."), reported);
+ }
+
+ @Test
+ @DisplayName("should abandon the upload when a row names a state the master does not know")
+ void register_shouldAbandonUploadForUnknownState() throws Exception {
+ employee.setState("Atlantis");
+ employee.setPermanentState("Atlantis");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertEquals(List.of("Data is invalid or empty"), service.errorLogs,
+ "an unresolvable state leaves no districts to check against, so the upload is refused");
+ assertTrue(service.m_bulkUser.isEmpty());
+ }
+
+ @Test
+ @DisplayName("should report an Aadhaar number that is already on file")
+ void register_shouldReportDuplicateAadhaar() throws Exception {
+ when(employeeMasterInter.FindEmployeeAadhaar(anyString())).thenReturn("aadhaarexist");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("Duplicate aadhaar number found"),
+ service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report an Aadhaar number that is not twelve digits")
+ void register_shouldReportMalformedAadhaar() throws Exception {
+ employee.setAadhaarNo("1234");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("Aadhaar number is invalid"),
+ service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report a date of birth in the future")
+ void register_shouldReportFutureDateOfBirth() throws Exception {
+ employee.setDob("50000");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertTrue(service.errorLogs.get(0).contains("Date of Birth is invalid."),
+ service.errorLogs.toString());
+ }
+
+ @Test
+ @DisplayName("should report a row whose mandatory fields are simply blank")
+ void register_shouldReportBlankMandatoryFields() throws Exception {
+ employee.setGender("");
+ employee.setContactNo("");
+ employee.setDesignation("");
+ employee.setEmergencyContactNo("");
+ employee.setDob("");
+ employee.setEmail("");
+ employee.setPassword("");
+ employee.setQualification("");
+ employee.setState("");
+ employee.setDistrict("");
+ employee.setPermanentState("");
+ employee.setPermanentDistrict("");
+ employee.setDateOfJoining("");
+ uploadContains(employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ String reported = service.errorLogs.get(0);
+ assertTrue(reported.contains("Gender is missing"), reported);
+ assertTrue(reported.contains("Contact number missing"), reported);
+ assertTrue(reported.contains("Designation is missing"), reported);
+ assertTrue(reported.contains("Emergency contact number is missing"), reported);
+ assertTrue(reported.contains("Date of Birth is missing."), reported);
+ assertTrue(reported.contains("Email is missing."), reported);
+ assertTrue(reported.contains("Qualification is missing"), reported);
+ assertTrue(reported.contains("Date of Joining is missing."), reported);
+ }
+
+ @Test
+ @DisplayName("should report an upload that carries no rows at all")
+ void register_shouldReportEmptyUpload() throws Exception {
+ EmployeeList list = new EmployeeList();
+ list.setEmployees(new ArrayList<>());
+ when(employeeXmlService.parseXml(anyString())).thenReturn(list);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertEquals(List.of("Data is invalid or empty"), service.errorLogs);
+ }
+
+ @Test
+ @DisplayName("should report an upload it cannot read at all")
+ void register_shouldReportUnreadableUpload() throws Exception {
+ when(employeeXmlService.parseXml(anyString())).thenThrow(new IllegalStateException("not xml"));
+
+ service.registerBulkUser("not xml", "auth", "admin", 77);
+
+ assertEquals(List.of("Data is invalid or empty"), service.errorLogs);
+ }
+
+ @Test
+ @DisplayName("should keep going through the sheet after a row it cannot register")
+ void register_shouldKeepGoingAfterABadRow() throws Exception {
+ Employee bad = validEmployee();
+ bad.setUserName("");
+ uploadContains(bad, employee);
+
+ service.registerBulkUser("", "auth", "admin", 77);
+
+ assertEquals(2, service.totalEmployeeListSize);
+ assertEquals(1, service.m_bulkUser.size(), "the good row must still be registered");
+ assertEquals(1, service.errorLogs.size());
+ }
+ }
+
+ @Nested
+ @DisplayName("Master lookups")
+ class MasterLookupTests {
+
+ @Test
+ @DisplayName("getCommunityId should resolve a known community and answer zero for an unknown one")
+ void getCommunityId_shouldResolveKnownCommunity() {
+ assertEquals(3, service.getCommunityId("General"));
+ assertEquals(0, service.getCommunityId("Unknown"));
+ }
+
+ @Test
+ @DisplayName("getQualificationId should resolve a known qualification and answer zero for an unknown one")
+ void getQualificationId_shouldResolveKnownQualification() {
+ assertEquals(5, service.getQualificationId("MBBS"));
+ assertEquals(0, service.getQualificationId("Unknown"));
+ }
+
+ @Test
+ @DisplayName("getReligionStringId should resolve a known religion")
+ void getReligionStringId_shouldResolveKnownReligion() {
+ assertEquals(4, service.getReligionStringId("Hindu"));
+ assertEquals(0, service.getReligionStringId("Unknown"));
+ }
+
+ @Test
+ @DisplayName("getReligionStringId should treat an unstated religion as none")
+ void getReligionStringId_shouldTreatUnstatedAsNone() {
+ assertEquals(0, service.getReligionStringId("Not given"));
+ verify(employeeMasterInter, never()).getAllReligion();
+ }
+
+ @Test
+ @DisplayName("getStateId should resolve a known state and load its districts")
+ void getStateId_shouldResolveKnownStateAndLoadDistricts() {
+ assertEquals(29, service.getStateId("Karnataka"));
+ verify(locationMasterServiceInter).getAllDistrictByStateId(29);
+ }
+
+ @Test
+ @DisplayName("getStateId should answer zero for a state the master does not know")
+ void getStateId_shouldAnswerZeroForUnknownState() {
+ assertEquals(0, service.getStateId("Atlantis"));
+ verify(locationMasterServiceInter, never()).getAllDistrictByStateId(29);
+ }
+
+ @Test
+ @DisplayName("getDistrictId should resolve a district once its state has been resolved")
+ void getDistrictId_shouldResolveDistrictAfterState() {
+ service.getStateId("Karnataka");
+
+ assertEquals(301, service.getDistrictId("Bengaluru Urban"));
+ assertEquals(0, service.getDistrictId("Nowhere"));
+ }
+
+ @Test
+ @DisplayName("getDistrictId should answer zero when no district name is given")
+ void getDistrictId_shouldAnswerZeroWithoutAName() {
+ assertEquals(0, service.getDistrictId(""));
+ }
+
+ @Test
+ @DisplayName("getAllState should hand back what the role master holds")
+ void getAllState_shouldHandBackRoleMasterContents() {
+ assertEquals(1, service.getAllState().size());
+ }
+
+ @Test
+ @DisplayName("getDesignationId should answer the fixed designation the upload uses")
+ void getDesignationId_shouldAnswerFixedDesignation() {
+ assertEquals(20, service.getDesignationId("ASHA"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Helpers")
+ class HelperTests {
+
+ @Test
+ @DisplayName("escapeXmlSpecialChars should escape a bare ampersand and leave real entities alone")
+ void escape_shouldEscapeBareAmpersandOnly() {
+ assertEquals("Ram & Co", BulkRegistrationServiceImpl.escapeXmlSpecialChars("Ram & Co"));
+ assertEquals("Ram & Co", BulkRegistrationServiceImpl.escapeXmlSpecialChars("Ram & Co"));
+ assertEquals("<tag>", BulkRegistrationServiceImpl.escapeXmlSpecialChars("<tag>"));
+ }
+
+ @Test
+ @DisplayName("isNumeric should tell a number apart from a name")
+ void isNumeric_shouldTellNumberFromName() {
+ assertTrue(BulkRegistrationServiceImpl.isNumeric("12345"));
+ assertFalse(BulkRegistrationServiceImpl.isNumeric("Asha"));
+ }
+
+ @Test
+ @DisplayName("isValidAadhar should report anything that is not twelve digits")
+ void isValidAadhar_shouldReportNonTwelveDigitNumbers() {
+ assertFalse(BulkRegistrationServiceImpl.isValidAadhar("111122223333"));
+ assertTrue(BulkRegistrationServiceImpl.isValidAadhar("1234"));
+ assertTrue(BulkRegistrationServiceImpl.isValidAadhar("not-a-number"));
+ }
+
+ @Test
+ @DisplayName("convertStringIntoDate should read the spreadsheet's own date serial")
+ void convertStringIntoDate_shouldReadExcelSerial() {
+ assertEquals("1982-02-18", BulkRegistrationServiceImpl.convertStringIntoDate(DOB_SERIAL).toString());
+ }
+
+ @Test
+ @DisplayName("generateStrongPassword should answer a different hash each time it is called")
+ void generateStrongPassword_shouldSaltEachHash() throws Exception {
+ String first = service.generateStrongPassword("plain-secret");
+ String second = service.generateStrongPassword("plain-secret");
+
+ assertTrue(first.startsWith("1001:"), first);
+ assertFalse(first.equals(second), "each hash must carry its own salt");
+ }
+
+ @Test
+ @DisplayName("insertErrorLog should write one workbook row per reported row")
+ void insertErrorLog_shouldWriteOneRowPerReportedRow() {
+ BulkRegistrationError error = new BulkRegistrationError();
+ error.setRowNumber(1);
+ error.setUserName("EMP-1");
+ error.setError(List.of("Title is missing."));
+ service.bulkRegistrationErrors.add(error);
+
+ byte[] workbook = service.insertErrorLog();
+
+ assertNotNull(workbook);
+ assertTrue(workbook.length > 0, "a workbook with a reported row must not be empty");
+ }
+
+ @Test
+ @DisplayName("insertErrorLog should still answer a workbook when nothing was reported")
+ void insertErrorLog_shouldAnswerWorkbookWithoutErrors() {
+ assertTrue(service.insertErrorLog().length > 0);
+ }
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/bulkRegistration/EmployeeXmlServiceTest.java b/src/test/java/com/iemr/admin/service/bulkRegistration/EmployeeXmlServiceTest.java
new file mode 100644
index 0000000..cce6537
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/bulkRegistration/EmployeeXmlServiceTest.java
@@ -0,0 +1,58 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.bulkRegistration;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import com.iemr.admin.data.bulkuser.EmployeeList;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/** Reads the uploaded spreadsheet, which reaches the service as XML. */
+@DisplayName("EmployeeXmlService Test Suite")
+class EmployeeXmlServiceTest {
+
+ private final EmployeeXmlService service = new EmployeeXmlService();
+
+ @Test
+ @DisplayName("parseXml should read each employee row out of the uploaded document")
+ void parseXml_shouldReadEachEmployeeRow() throws Exception {
+ String xml = "AshaRao"
+ + "EMP-1"
+ + "RaviKumar"
+ + "EMP-2";
+
+ EmployeeList list = service.parseXml(xml);
+
+ assertEquals(2, list.getEmployees().size());
+ assertEquals("Asha", list.getEmployees().get(0).getFirstName());
+ assertEquals("EMP-2", list.getEmployees().get(1).getUserName());
+ }
+
+ @Test
+ @DisplayName("parseXml should raise rather than answer a half-read document")
+ void parseXml_shouldRaiseForMalformedDocument() {
+ assertThrows(Exception.class, () -> service.parseXml(""));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/calibration/CalibrationServiceImplTest.java b/src/test/java/com/iemr/admin/service/calibration/CalibrationServiceImplTest.java
new file mode 100644
index 0000000..79d51be
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/calibration/CalibrationServiceImplTest.java
@@ -0,0 +1,222 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.calibration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import com.iemr.admin.data.calibration.CalibrationStrip;
+import com.iemr.admin.repo.calibration.CalibrationRepo;
+import com.iemr.admin.utils.exception.IEMRException;
+import com.iemr.admin.utils.mapper.OutputMapper;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The calibration service keeps the test strip codes a provider calibrates
+ * against, refusing a code the provider already holds.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("CalibrationServiceImpl Test Suite")
+class CalibrationServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Long STRIP_ID = 6601L;
+ private static final String STRIP_CODE = "STRIP-77";
+
+ @Mock
+ private CalibrationRepo calibrationRepo;
+
+ @InjectMocks
+ private CalibrationServiceImpl service;
+
+ @BeforeEach
+ @DisplayName("Fix the page size the screens are served in and prime the shared output builder")
+ void setUp() {
+ ReflectionTestUtils.setField(service, "calibrationPageSize", 10);
+ new OutputMapper();
+ }
+
+ private static CalibrationStrip strip() {
+ CalibrationStrip strip = new CalibrationStrip();
+ strip.setCalibrationStripID(STRIP_ID);
+ strip.setStripCode(STRIP_CODE);
+ strip.setProviderServiceMapID(PSM_ID);
+ strip.setDeleted(Boolean.FALSE);
+ return strip;
+ }
+
+ private static CalibrationStrip request() {
+ CalibrationStrip request = new CalibrationStrip();
+ request.setStripCode(STRIP_CODE);
+ request.setProviderServiceMapID(PSM_ID);
+ return request;
+ }
+
+ @Test
+ @DisplayName("saveData should record a strip code the provider does not hold yet")
+ void save_shouldRecordNewStripCode() throws Exception {
+ when(calibrationRepo.checkIfAlreadyStripPresent(PSM_ID, STRIP_CODE)).thenReturn(new ArrayList<>());
+ when(calibrationRepo.save(any(CalibrationStrip.class))).thenReturn(strip());
+
+ assertEquals(1, service.saveData(request()));
+ }
+
+ @Test
+ @DisplayName("saveData should refuse a strip code the provider already holds")
+ void save_shouldRefuseDuplicateStripCode() {
+ when(calibrationRepo.checkIfAlreadyStripPresent(PSM_ID, STRIP_CODE))
+ .thenReturn(new ArrayList<>(List.of(strip())));
+
+ IEMRException refusal = assertThrows(IEMRException.class, () -> service.saveData(request()));
+
+ assertEquals("Strip code already exists", refusal.getMessage());
+ verify(calibrationRepo, never()).save(any(CalibrationStrip.class));
+ }
+
+ @Test
+ @DisplayName("saveData should refuse a strip the repository did not give an identity")
+ void save_shouldRefuseStripWithoutIdentity() {
+ when(calibrationRepo.checkIfAlreadyStripPresent(PSM_ID, STRIP_CODE)).thenReturn(new ArrayList<>());
+ when(calibrationRepo.save(any(CalibrationStrip.class))).thenReturn(new CalibrationStrip());
+
+ assertEquals("Error while saving data",
+ assertThrows(IEMRException.class, () -> service.saveData(request())).getMessage());
+ }
+
+ @Test
+ @DisplayName("saveData should record nothing when the request names no strip code")
+ void save_shouldRecordNothingWithoutStripCode() throws Exception {
+ assertEquals(0, service.saveData(new CalibrationStrip()));
+ verify(calibrationRepo, never()).save(any(CalibrationStrip.class));
+ }
+
+ @Test
+ @DisplayName("fetchData should answer one page of strips and how many pages there are")
+ void fetch_shouldAnswerOnePageAndPageCount() throws Exception {
+ CalibrationStrip request = request();
+ request.setPageNo(0);
+ Pageable pageable = PageRequest.of(0, 10);
+ Page page = new PageImpl<>(List.of(strip()), pageable, 1);
+ when(calibrationRepo.getCalibrationStripsWithPagination(PSM_ID, pageable)).thenReturn(page);
+
+ String answered = service.fetchData(request);
+
+ assertTrue(answered.contains(STRIP_CODE), answered);
+ assertTrue(answered.contains("pageCount"), answered);
+ }
+
+ @Test
+ @DisplayName("fetchData should answer every strip when the caller asks for no particular page")
+ void fetch_shouldAnswerEveryStripWithoutPaging() throws Exception {
+ when(calibrationRepo.getCalibrationStripsWithoutPagination(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(strip())));
+
+ String answered = service.fetchData(request());
+
+ assertTrue(answered.contains(STRIP_CODE), answered);
+ assertTrue(!answered.contains("pageCount"), "an unpaged answer carries no page count");
+ }
+
+ @Test
+ @DisplayName("fetchData should refuse a request that names no provider")
+ void fetch_shouldRefuseRequestWithoutProvider() {
+ assertThrows(IEMRException.class, () -> service.fetchData(new CalibrationStrip()));
+ }
+
+ @Test
+ @DisplayName("deleteData should report how many strips the retirement touched")
+ void delete_shouldReportRowsTouched() throws Exception {
+ CalibrationStrip request = strip();
+ request.setDeleted(Boolean.TRUE);
+ when(calibrationRepo.deleteCalibrationStrip(STRIP_ID, Boolean.TRUE)).thenReturn(1);
+
+ assertEquals(1, service.deleteData(request));
+ }
+
+ @Test
+ @DisplayName("deleteData should refuse a request that names no strip")
+ void delete_shouldRefuseRequestWithoutStrip() {
+ assertEquals("Invalid request",
+ assertThrows(IEMRException.class, () -> service.deleteData(new CalibrationStrip())).getMessage());
+ }
+
+ @Test
+ @DisplayName("deleteData should give up when the retirement cannot be recorded")
+ void delete_shouldGiveUpWhenStorageFails() {
+ CalibrationStrip request = strip();
+ request.setDeleted(Boolean.TRUE);
+ when(calibrationRepo.deleteCalibrationStrip(anyLong(), anyBoolean()))
+ .thenThrow(new RuntimeException("row is locked"));
+
+ assertThrows(IEMRException.class, () -> service.deleteData(request));
+ }
+
+ @Test
+ @DisplayName("updateData should record the change against the strip")
+ void update_shouldRecordChange() throws Exception {
+ when(calibrationRepo.save(any(CalibrationStrip.class))).thenReturn(strip());
+
+ assertEquals(1, service.updateData(request()));
+ }
+
+ @Test
+ @DisplayName("updateData should refuse a strip the repository did not give an identity")
+ void update_shouldRefuseStripWithoutIdentity() {
+ when(calibrationRepo.save(any(CalibrationStrip.class))).thenReturn(new CalibrationStrip());
+
+ assertEquals("Error while updating data",
+ assertThrows(IEMRException.class, () -> service.updateData(request())).getMessage());
+ }
+
+ @Test
+ @DisplayName("updateData should record nothing when the request names no strip code")
+ void update_shouldRecordNothingWithoutStripCode() throws Exception {
+ assertEquals(0, service.updateData(new CalibrationStrip()));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/drugstrangth/DrugStrangthServiceTest.java b/src/test/java/com/iemr/admin/service/drugstrangth/DrugStrangthServiceTest.java
new file mode 100644
index 0000000..b8b1632
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/drugstrangth/DrugStrangthServiceTest.java
@@ -0,0 +1,112 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.drugstrangth;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.drugstrangth.M_104DrugStrength;
+import com.iemr.admin.repo.blocking.DrugStrangthRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * The drug strength service keeps the strengths a drug can be dispensed in.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("DrugStrangthService Test Suite")
+class DrugStrangthServiceTest {
+
+ private static final Integer STRENGTH_ID = 33;
+
+ @Mock
+ private DrugStrangthRepo drugStrangthRepo;
+
+ @InjectMocks
+ private DrugStrangthService service;
+
+ private static M_104DrugStrength strength() {
+ M_104DrugStrength strength = new M_104DrugStrength();
+ strength.setDrugStrengthID(STRENGTH_ID);
+ strength.setDrugStrength("500 mg");
+ return strength;
+ }
+
+ @Test
+ @DisplayName("createDrugStrangth should answer the strengths the repository stored")
+ void create_shouldAnswerStoredStrengths() {
+ ArrayList stored = new ArrayList<>(List.of(strength()));
+ when(drugStrangthRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.createDrugStrangth(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("getDrugStrangth should answer every strength on file")
+ void get_shouldAnswerEveryStrength() {
+ when(drugStrangthRepo.findAll()).thenReturn(new ArrayList<>(List.of(strength())));
+
+ assertEquals(1, service.getDrugStrangth().size());
+ }
+
+ @Test
+ @DisplayName("getDrugStrangth should answer nothing when no strength is on file")
+ void get_shouldAnswerNothingWhenNoneOnFile() {
+ when(drugStrangthRepo.findAll()).thenReturn(new ArrayList());
+
+ assertTrue(service.getDrugStrangth().isEmpty());
+ }
+
+ @Test
+ @DisplayName("updateDrugStrangth and saveupdatedData should each reach their own repository query")
+ void singleRecordOperations_shouldReachTheirOwnQuery() {
+ M_104DrugStrength stored = strength();
+ when(drugStrangthRepo.findByDrugStrengthID(STRENGTH_ID)).thenReturn(stored);
+ when(drugStrangthRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.updateDrugStrangth(STRENGTH_ID));
+ assertSame(stored, service.saveupdatedData(stored));
+ }
+
+ @Test
+ @DisplayName("updateDrugStrangth should answer nothing when the strength is unknown")
+ void update_shouldAnswerNothingForUnknownStrength() {
+ when(drugStrangthRepo.findByDrugStrengthID(-1)).thenReturn(null);
+
+ assertNull(service.updateDrugStrangth(-1));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/drugtype/DrugtypeServiceImplTest.java b/src/test/java/com/iemr/admin/service/drugtype/DrugtypeServiceImplTest.java
new file mode 100644
index 0000000..bfdfebc
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/drugtype/DrugtypeServiceImplTest.java
@@ -0,0 +1,113 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.drugtype;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.drugtype.M_Drugtype;
+import com.iemr.admin.repo.drugtype.DrugtypeRepo;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * The drug type service keeps the dosage forms a provider stocks.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("DrugtypeServiceImpl Test Suite")
+class DrugtypeServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer DRUG_TYPE_ID = 21;
+
+ @Mock
+ private DrugtypeRepo drugtypeRepo;
+
+ @InjectMocks
+ private DrugtypeServiceImpl service;
+
+ private static M_Drugtype drugType() {
+ M_Drugtype drugType = new M_Drugtype();
+ drugType.setDrugTypeID(DRUG_TYPE_ID);
+ drugType.setDrugTypeName("Tablet");
+ drugType.setProviderServiceMapID(PSM_ID);
+ return drugType;
+ }
+
+ @Test
+ @DisplayName("createDrugtypeData should answer the drug types the repository stored")
+ void create_shouldAnswerStoredDrugTypes() {
+ ArrayList stored = new ArrayList<>(List.of(drugType()));
+ when(drugtypeRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.createDrugtypeData(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createDrugtypeData should answer nothing when the repository stored nothing")
+ void create_shouldAnswerNothingWhenNothingStored() {
+ when(drugtypeRepo.saveAll(anyList())).thenReturn(new ArrayList());
+
+ assertNull(service.createDrugtypeData(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("getDrugtypeData should answer the drug types the provider stocks")
+ void get_shouldAnswerProvidersDrugTypes() {
+ ArrayList stocked = new ArrayList<>(List.of(drugType()));
+ when(drugtypeRepo.getDrugtypeData(PSM_ID)).thenReturn(stocked);
+
+ assertSame(stocked, service.getDrugtypeData(PSM_ID));
+ }
+
+ @Test
+ @DisplayName("editDrugtypeData and saveeditDrugtype should each reach their own repository query")
+ void singleRecordOperations_shouldReachTheirOwnQuery() {
+ M_Drugtype stored = drugType();
+ when(drugtypeRepo.geteditedData(DRUG_TYPE_ID)).thenReturn(stored);
+ when(drugtypeRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.editDrugtypeData(DRUG_TYPE_ID));
+ assertSame(stored, service.saveeditDrugtype(stored));
+ }
+
+ @Test
+ @DisplayName("editDrugtypeData should answer nothing when the drug type is unknown")
+ void edit_shouldAnswerNothingForUnknownDrugType() {
+ when(drugtypeRepo.geteditedData(-1)).thenReturn(null);
+
+ assertNull(service.editDrugtypeData(-1));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/emailconfig/EmailConfigServiceImplTest.java b/src/test/java/com/iemr/admin/service/emailconfig/EmailConfigServiceImplTest.java
new file mode 100644
index 0000000..11b5b8b
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/emailconfig/EmailConfigServiceImplTest.java
@@ -0,0 +1,189 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.emailconfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.emailconfig.AuthorityEmail;
+import com.iemr.admin.mapper.emailconfig.InstituteEmailConfigMapper;
+import com.iemr.admin.model.emailconfig.AuthEmailRequest;
+import com.iemr.admin.model.emailconfig.AuthEmailResponse;
+import com.iemr.admin.model.emailconfig.CreateAuthEmailRequestModel;
+import com.iemr.admin.model.emailconfig.UpdateAuthEmailRequest;
+import com.iemr.admin.repository.emailconfig.InstituteEmailRepo;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.CriteriaQuery;
+import jakarta.persistence.criteria.Path;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The email config service keeps the authority mailboxes a complaint is copied
+ * to, narrowed by whichever parts of the location the caller names.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("EmailConfigServiceImpl Test Suite")
+class EmailConfigServiceImplTest {
+
+ @Mock
+ private EntityManager entityManager;
+
+ @Mock
+ private InstituteEmailRepo instituteRepo;
+
+ @Mock
+ private InstituteEmailConfigMapper instituteEmailConfigMapper;
+
+ @InjectMocks
+ private EmailConfigServiceImpl service;
+
+ private CriteriaQuery query;
+ private TypedQuery typedQuery;
+
+ @SuppressWarnings("unchecked")
+ @BeforeEach
+ @DisplayName("Stand in for the criteria query the service builds by hand")
+ void setUp() {
+ CriteriaBuilder builder = mock(CriteriaBuilder.class);
+ query = mock(CriteriaQuery.class);
+ Root root = mock(Root.class);
+ typedQuery = mock(TypedQuery.class);
+
+ when(entityManager.getCriteriaBuilder()).thenReturn(builder);
+ when(builder.createQuery(AuthorityEmail.class)).thenReturn(query);
+ when(query.from(AuthorityEmail.class)).thenReturn(root);
+ when(query.select(any())).thenReturn(query);
+ when(query.where(any(Predicate[].class))).thenReturn(query);
+ when(query.orderBy(any(jakarta.persistence.criteria.Order[].class))).thenReturn(query);
+ when(root.get(anyString())).thenReturn(mock(Path.class));
+ when(builder.equal(any(), any())).thenReturn(mock(Predicate.class));
+ when(entityManager.createQuery(query)).thenReturn(typedQuery);
+ }
+
+ private static AuthEmailRequest fullyNarrowedRequest() {
+ AuthEmailRequest request = new AuthEmailRequest();
+ request.setAuthorityEmailID(1);
+ request.setDeleted(false);
+ request.setDistrictID(301);
+ request.setDistrictBranchMappingID(30111);
+ request.setBlockID(3011);
+ request.setProviderServiceMapID(4001);
+ request.setStateID(29);
+ return request;
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should answer the mailboxes the query found, as the screens read them")
+ void getAll_shouldAnswerFoundMailboxes() {
+ List found = List.of(new AuthorityEmail());
+ List published = List.of(new AuthEmailResponse());
+ when(typedQuery.getResultList()).thenReturn(found);
+ when(instituteEmailConfigMapper.resultToInstTypeEmailResponse(found)).thenReturn(published);
+
+ assertSame(published, service.getAllEmailConfigs(fullyNarrowedRequest()));
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should narrow the query by every detail the caller named")
+ void getAll_shouldNarrowByEveryNamedDetail() {
+ when(typedQuery.getResultList()).thenReturn(new ArrayList<>());
+
+ service.getAllEmailConfigs(fullyNarrowedRequest());
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(Predicate[].class);
+ verify(query).where(captor.capture());
+ assertEquals(7, captor.getValue().length, "one narrowing per detail the caller named");
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should narrow by nothing when the caller names nothing")
+ void getAll_shouldNarrowByNothingForEmptyRequest() {
+ when(typedQuery.getResultList()).thenReturn(new ArrayList<>());
+
+ service.getAllEmailConfigs(new AuthEmailRequest());
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(Predicate[].class);
+ verify(query).where(captor.capture());
+ assertEquals(0, captor.getValue().length);
+ }
+
+ @Test
+ @DisplayName("saveEmailConfigs should store one mailbox per request and answer each as stored")
+ void save_shouldStoreEachRequestedMailbox() {
+ AuthorityEmail stored = new AuthorityEmail();
+ when(instituteEmailConfigMapper.createRequestToInstituteEmailConf(anyList()))
+ .thenReturn(List.of(stored, stored));
+ when(instituteRepo.save(stored)).thenReturn(stored);
+ when(instituteEmailConfigMapper.resultToInstTypeEmailResponse(stored))
+ .thenReturn(new AuthEmailResponse());
+
+ assertEquals(2, service.saveEmailConfigs(List.of(new CreateAuthEmailRequestModel())).size());
+ }
+
+ @Test
+ @DisplayName("saveEmailConfigs should store nothing when the caller asks for nothing")
+ void save_shouldStoreNothingForEmptyRequest() {
+ when(instituteEmailConfigMapper.createRequestToInstituteEmailConf(anyList()))
+ .thenReturn(new ArrayList<>());
+
+ assertTrue(service.saveEmailConfigs(new ArrayList<>()).isEmpty());
+ }
+
+ @Test
+ @DisplayName("updateEmailConfigs should answer the mailbox as it stands after the change")
+ void update_shouldAnswerChangedMailbox() {
+ AuthorityEmail stored = new AuthorityEmail();
+ AuthEmailResponse published = new AuthEmailResponse();
+ when(instituteEmailConfigMapper.updateRequestToInstituteEmailConf(any(UpdateAuthEmailRequest.class)))
+ .thenReturn(stored);
+ when(instituteRepo.save(stored)).thenReturn(stored);
+ when(instituteEmailConfigMapper.resultToInstTypeEmailResponse(stored)).thenReturn(published);
+
+ assertSame(published, service.updateEmailConfigs(new UpdateAuthEmailRequest()));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterServiceImplTest.java b/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterServiceImplTest.java
new file mode 100644
index 0000000..e70bfee
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterServiceImplTest.java
@@ -0,0 +1,1195 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.employeemaster;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.employeemaster.EmployeeSignature;
+import com.iemr.admin.data.employeemaster.M_Community;
+import com.iemr.admin.data.employeemaster.M_Gender;
+import com.iemr.admin.data.employeemaster.M_ProviderServiceMap1;
+import com.iemr.admin.data.employeemaster.M_Religion;
+import com.iemr.admin.data.employeemaster.M_Role;
+import com.iemr.admin.data.employeemaster.M_Title;
+import com.iemr.admin.data.employeemaster.M_User1;
+import com.iemr.admin.data.employeemaster.M_UserDemographics;
+import com.iemr.admin.data.employeemaster.M_UserLangMapping;
+import com.iemr.admin.data.employeemaster.M_UserServiceRoleMapping2;
+import com.iemr.admin.data.employeemaster.M_Userqualification;
+import com.iemr.admin.data.employeemaster.Showofficedetails1;
+import com.iemr.admin.data.employeemaster.Showuserdetailsfromuserservicerolemapping;
+import com.iemr.admin.data.employeemaster.V_Showuser;
+import com.iemr.admin.data.employeemaster.V_Userservicerolemapping;
+import com.iemr.admin.data.facilitytype.M_facilitytype;
+import com.iemr.admin.data.rolemaster.M_UserservicerolemappingForRoleProviderAdmin;
+import com.iemr.admin.data.rolemaster.UserRole;
+import com.iemr.admin.data.store.M_Facility;
+import com.iemr.admin.exceptionhandler.DataNotFound;
+import com.iemr.admin.repo.employeemaster.EmployeeMasterRepo;
+import com.iemr.admin.repo.employeemaster.EmployeeMasterRepoo;
+import com.iemr.admin.repo.employeemaster.EmployeeSignatureRepo;
+import com.iemr.admin.repo.employeemaster.M_CommunityRepo;
+import com.iemr.admin.repo.employeemaster.M_GenderRepo;
+import com.iemr.admin.repo.employeemaster.M_ProviderServiceMap1Repo;
+import com.iemr.admin.repo.employeemaster.M_QualificationRepo;
+import com.iemr.admin.repo.employeemaster.M_ReligionRepo;
+import com.iemr.admin.repo.employeemaster.M_TitleRepo;
+import com.iemr.admin.repo.employeemaster.M_UserDemographicsRepo;
+import com.iemr.admin.repo.employeemaster.M_UserLangMappingRepo;
+import com.iemr.admin.repo.employeemaster.RoleRepo;
+import com.iemr.admin.repo.employeemaster.Showofficedetails1Repo1;
+import com.iemr.admin.repo.employeemaster.ShowuserdetailsfromuserservicerolemappingRepo;
+import com.iemr.admin.repo.employeemaster.V_ShowuserRepo;
+import com.iemr.admin.repo.employeemaster.V_UserservicerolemappingRepo;
+import com.iemr.admin.repository.facilitytype.M_facilitytypeRepo;
+import com.iemr.admin.repository.rolemaster.M_UserservicerolemappingForRoleProviderAdminRepo;
+import com.iemr.admin.repository.store.MainStoreRepo;
+import com.iemr.admin.service.user.EncryptUserPassword;
+import com.iemr.admin.utils.response.OutputResponse;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The employee master service is where the rules about who may work where live:
+ * an ASHA must sit at a sub-centre, a role may not be mapped twice, and taking a
+ * role away has to take the supervisor mappings with it.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("EmployeeMasterServiceImpl Test Suite")
+class EmployeeMasterServiceImplTest {
+
+ private static final Integer USER_ID = 3117;
+ private static final Integer PSM_ID = 4001;
+
+ @Mock
+ private RoleRepo roleRepo;
+
+ @Mock
+ private EmployeeMasterRepo employeeMasterRepo;
+
+ @Mock
+ private EmployeeMasterRepoo employeeMasterRepo11;
+
+ @Mock
+ private EmployeeMasterRepoo employeeMasterRepoo;
+
+ @Mock
+ private M_UserDemographicsRepo m_UserDemographicsRepo;
+
+ @Mock
+ private M_UserLangMappingRepo m_UserLangMappingRepo;
+
+ @Mock
+ private M_TitleRepo m_TitleRepo;
+
+ @Mock
+ private M_GenderRepo m_GenderRepo;
+
+ @Mock
+ private ShowuserdetailsfromuserservicerolemappingRepo showuserdetailsfromuserservicerolemappingRepo;
+
+ @Mock
+ private V_ShowuserRepo v_ShowuserRepo;
+
+ @Mock
+ private V_UserservicerolemappingRepo v_UserservicerolemappingRepo;
+
+ @Mock
+ private M_QualificationRepo m_QualificationRepo;
+
+ @Mock
+ private Showofficedetails1Repo1 showofficedetails1Repo1;
+
+ @Mock
+ private M_ProviderServiceMap1Repo m_ProviderServiceMap1Repo;
+
+ @Mock
+ private MainStoreRepo mainStoreRepo;
+
+ @Mock
+ private M_facilitytypeRepo facilityTypeRepo;
+
+ @Mock
+ private EmployeeSignatureRepo employeeSignatureRepo;
+
+ @Mock
+ private M_CommunityRepo m_CommunityRepo;
+
+ @Mock
+ private M_ReligionRepo m_ReligionRepo;
+
+ @Mock
+ private M_UserservicerolemappingForRoleProviderAdminRepo userservicerolemappingForRoleProviderAdminRepo;
+
+ @Mock
+ private AshaSupervisorMappingService ashaSupervisorMappingService;
+
+ @Mock
+ private EncryptUserPassword encryptUserPassword;
+
+ @InjectMocks
+ private EmployeeMasterServiceImpl service;
+
+ private M_Role role;
+
+ @BeforeEach
+ void setUp() {
+ role = new M_Role();
+ role.setRoleID(11);
+ role.setRoleName("Counsellor");
+ when(roleRepo.findByRoleID(anyInt())).thenReturn(role);
+ }
+
+ private static M_UserServiceRoleMapping2 mapping(Integer id, Integer roleId) {
+ M_UserServiceRoleMapping2 mapping = new M_UserServiceRoleMapping2();
+ mapping.setuSRMappingID(id);
+ mapping.setUserID(USER_ID);
+ mapping.setRoleID(roleId);
+ mapping.setProviderServiceMapID(PSM_ID);
+ return mapping;
+ }
+
+ private void namedRole(String name) {
+ role.setRoleName(name);
+ }
+
+ private void activeFacility(Integer facilityId, Integer typeId, Integer levelValue, Integer maxLevel) {
+ M_Facility facility = new M_Facility();
+ facility.setFacilityID(facilityId);
+ facility.setFacilityTypeID(typeId);
+ when(mainStoreRepo.findByFacilityIDAndDeleted(facilityId, false)).thenReturn(facility);
+ M_facilitytype type = new M_facilitytype();
+ type.setFacilityTypeID(typeId);
+ type.setLevelValue(levelValue);
+ when(facilityTypeRepo.findByFacilityTypeID(typeId)).thenReturn(type);
+ when(facilityTypeRepo.findMaxLevelValueByProviderServiceMapID(PSM_ID)).thenReturn(maxLevel);
+ }
+
+ @Nested
+ @DisplayName("mapRole")
+ class MapRoleTests {
+
+ @Test
+ @DisplayName("should refuse an ASHA mapping that names no facility")
+ void mapRole_shouldRefuseAshaWithoutFacility() {
+ namedRole("ASHA");
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.mapRole(List.of(mapping(null, 11)), "auth"));
+
+ assertTrue(thrown.getMessage().contains("Facility (SC) is mandatory for ASHA role"),
+ thrown.getMessage());
+ verify(employeeMasterRepo, never()).saveAll(anyList());
+ }
+
+ @Test
+ @DisplayName("should refuse a mapping onto a facility that has been retired")
+ void mapRole_shouldRefuseRetiredFacility() {
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ toMap.setFacilityID(501);
+ when(mainStoreRepo.findByFacilityIDAndDeleted(501, false)).thenReturn(null);
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.mapRole(List.of(toMap), "auth"));
+
+ assertTrue(thrown.getMessage().contains("is no longer active"), thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("should refuse an ASHA mapped above sub-centre level")
+ void mapRole_shouldRefuseAshaAboveSubCentre() {
+ namedRole("ASHA");
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ toMap.setFacilityID(501);
+ activeFacility(501, 3, 2, 4);
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.mapRole(List.of(toMap), "auth"));
+
+ assertTrue(thrown.getMessage().contains("Sub-Centre (SC) level facility"), thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("should refuse a second active mapping for the same user, role and service line")
+ void mapRole_shouldRefuseDuplicateMapping() {
+ when(employeeMasterRepo.existsByUserIDAndRoleIDAndProviderServiceMapIDAndDeletedFalse(USER_ID, 11, PSM_ID))
+ .thenReturn(true);
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.mapRole(List.of(mapping(null, 11)), "auth"));
+
+ assertTrue(thrown.getMessage().contains("Duplicate mapping is not allowed"), thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("should refuse a second mapping for an ASHA supervisor at the same facility")
+ void mapRole_shouldRefuseDuplicateSupervisorMappingAtSameFacility() {
+ namedRole("ASHA Supervisor");
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ toMap.setFacilityID(501);
+ activeFacility(501, 3, 4, 4);
+ when(employeeMasterRepo
+ .existsByUserIDAndRoleIDAndProviderServiceMapIDAndFacilityIDAndDeletedFalse(
+ USER_ID, 11, PSM_ID, 501))
+ .thenReturn(true);
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.mapRole(List.of(toMap), "auth"));
+
+ assertTrue(thrown.getMessage().contains("active work location mapping for this facility"),
+ thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("should let an ASHA supervisor hold a second mapping at a different facility")
+ void mapRole_shouldAllowSupervisorAtDifferentFacility() throws Exception {
+ namedRole("ASHA Supervisor");
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ toMap.setFacilityID(502);
+ activeFacility(502, 3, 4, 4);
+ ArrayList stored = new ArrayList<>(List.of(toMap));
+ when(employeeMasterRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.mapRole(List.of(toMap), "auth"));
+ }
+
+ @Test
+ @DisplayName("should flatten the village lists onto the stored columns")
+ void mapRole_shouldFlattenVillageLists() throws Exception {
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ toMap.setVillageID(new String[] { "501", "502" });
+ toMap.setVillageName(new String[] { "Hosur", "Devanahalli" });
+ when(employeeMasterRepo.saveAll(anyList()))
+ .thenReturn(new ArrayList<>(List.of(toMap)));
+
+ service.mapRole(List.of(toMap), "auth");
+
+ assertEquals("501,502", toMap.getVillageidDb());
+ assertEquals("Hosur,Devanahalli", toMap.getVillageNameDb());
+ verify(employeeMasterRepo).save(toMap);
+ }
+
+ @Test
+ @DisplayName("should leave the village columns alone when the mapping names no villages")
+ void mapRole_shouldLeaveVillageColumnsAlone() throws Exception {
+ M_UserServiceRoleMapping2 toMap = mapping(null, 11);
+ when(employeeMasterRepo.saveAll(anyList())).thenReturn(new ArrayList<>(List.of(toMap)));
+
+ service.mapRole(List.of(toMap), "auth");
+
+ assertNull(toMap.getVillageidDb());
+ verify(employeeMasterRepo, never()).save(any());
+ }
+ }
+
+ @Nested
+ @DisplayName("saveRoleMappingeditedData")
+ class SaveRoleMappingTests {
+
+ @Test
+ @DisplayName("should refuse an ASHA edit that drops the facility")
+ void saveRoleMapping_shouldRefuseAshaWithoutFacility() {
+ namedRole("ASHA");
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> service.saveRoleMappingeditedData(mapping(9001, 11), "auth"));
+
+ assertTrue(thrown.getMessage().contains("Facility (SC) is mandatory for ASHA role"),
+ thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("should skip the facility rules when the mapping is only being deactivated")
+ void saveRoleMapping_shouldSkipRulesWhenDeactivating() throws Exception {
+ namedRole("ASHA");
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 11);
+ toSave.setDeleted(Boolean.TRUE);
+ M_UserServiceRoleMapping2 old = mapping(9001, 11);
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.of(old));
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ assertSame(toSave, service.saveRoleMappingeditedData(toSave, "auth"));
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+
+ @Test
+ @DisplayName("should clear the saved villages when the facility is above sub-centre level")
+ void saveRoleMapping_shouldClearVillagesAboveSubCentre() throws Exception {
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 11);
+ toSave.setFacilityID(501);
+ toSave.setVillageidDb("501,502");
+ toSave.setVillageNameDb("Hosur,Devanahalli");
+ activeFacility(501, 3, 2, 4);
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.empty());
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ service.saveRoleMappingeditedData(toSave, "auth");
+
+ assertNull(toSave.getVillageidDb(), "a non sub-centre posting keeps no village list");
+ assertNull(toSave.getVillageNameDb());
+ }
+
+ @Test
+ @DisplayName("should cascade the supervisor mappings when the role changes")
+ void saveRoleMapping_shouldCascadeWhenRoleChanges() throws Exception {
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 12);
+ M_UserServiceRoleMapping2 old = mapping(9001, 11);
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.of(old));
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ service.saveRoleMappingeditedData(toSave, "auth");
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+
+ @Test
+ @DisplayName("should cascade only this facility when a supervisor still works elsewhere")
+ void saveRoleMapping_shouldCascadeOnlyThisFacilityForBusySupervisor() throws Exception {
+ namedRole("ASHA Supervisor");
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 11);
+ toSave.setDeleted(Boolean.TRUE);
+ toSave.setFacilityID(501);
+ M_UserServiceRoleMapping2 old = mapping(9001, 11);
+ old.setFacilityID(501);
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.of(old));
+ when(employeeMasterRepo.countByUserIDAndRoleIDAndDeletedFalse(USER_ID, 11)).thenReturn(2L);
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ service.saveRoleMappingeditedData(toSave, "auth");
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByFacilityID(501, "Admin");
+ verify(ashaSupervisorMappingService, never()).cascadeDeleteByUserID(anyInt(), anyString());
+ }
+
+ @Test
+ @DisplayName("should cascade every mapping when the facility itself changes")
+ void saveRoleMapping_shouldCascadeWhenFacilityChanges() throws Exception {
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 11);
+ toSave.setFacilityID(502);
+ activeFacility(502, 3, 4, 4);
+ M_UserServiceRoleMapping2 old = mapping(9001, 11);
+ old.setFacilityID(501);
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.of(old));
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ service.saveRoleMappingeditedData(toSave, "auth");
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+
+ @Test
+ @DisplayName("should flatten the village lists onto the stored columns")
+ void saveRoleMapping_shouldFlattenVillageLists() throws Exception {
+ M_UserServiceRoleMapping2 toSave = mapping(9001, 11);
+ toSave.setVillageID(new String[] { "501", "502" });
+ toSave.setVillageName(new String[] { "Hosur", "Devanahalli" });
+ when(employeeMasterRepo.findById(9001)).thenReturn(Optional.empty());
+ when(employeeMasterRepo.save(toSave)).thenReturn(toSave);
+
+ service.saveRoleMappingeditedData(toSave, "auth");
+
+ assertEquals("501,502", toSave.getVillageidDb());
+ assertEquals("Hosur,Devanahalli", toSave.getVillageNameDb());
+ }
+ }
+
+ @Nested
+ @DisplayName("cascadeDeleteAshaMappingsForDeactivation")
+ class CascadeDeactivationTests {
+
+ @Test
+ @DisplayName("should retire only this facility when the supervisor still works elsewhere")
+ void cascade_shouldRetireOnlyThisFacility() {
+ namedRole("ASHA Supervisor");
+ M_UserServiceRoleMapping2 usrRole = mapping(9001, 11);
+ usrRole.setFacilityID(501);
+ when(employeeMasterRepo.countByUserIDAndRoleIDAndDeletedFalse(USER_ID, 11)).thenReturn(2L);
+
+ service.cascadeDeleteAshaMappingsForDeactivation(usrRole);
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserIDAndFacilityID(USER_ID, 501, "Admin");
+ verify(ashaSupervisorMappingService, never()).cascadeDeleteByUserID(anyInt(), anyString());
+ }
+
+ @Test
+ @DisplayName("should retire every mapping when this was the supervisor's last facility")
+ void cascade_shouldRetireEveryMappingOnLastFacility() {
+ namedRole("ASHA Supervisor");
+ M_UserServiceRoleMapping2 usrRole = mapping(9001, 11);
+ usrRole.setFacilityID(501);
+ when(employeeMasterRepo.countByUserIDAndRoleIDAndDeletedFalse(USER_ID, 11)).thenReturn(1L);
+
+ service.cascadeDeleteAshaMappingsForDeactivation(usrRole);
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+
+ @Test
+ @DisplayName("should retire every mapping for a role that is not a supervisor")
+ void cascade_shouldRetireEveryMappingForNonSupervisor() {
+ service.cascadeDeleteAshaMappingsForDeactivation(mapping(9001, 11));
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+
+ @Test
+ @DisplayName("cascadeDeleteAshaMappingsForUser should hand the user straight to the mapping service")
+ void cascadeForUser_shouldDelegate() {
+ service.cascadeDeleteAshaMappingsForUser(USER_ID);
+
+ verify(ashaSupervisorMappingService).cascadeDeleteByUserID(USER_ID, "Admin");
+ }
+ }
+
+ @Nested
+ @DisplayName("Employee lookups")
+ class LookupTests {
+
+ @Test
+ @DisplayName("getAllRole should rebuild each role from what the repository holds")
+ void getAllRole_shouldRebuildRoles() {
+ M_Role stored = new M_Role();
+ stored.setRoleID(11);
+ stored.setRoleName("Counsellor");
+ stored.setProviderServiceMapID(PSM_ID);
+ when(roleRepo.getAllRole()).thenReturn(new ArrayList<>(List.of(stored)));
+
+ ArrayList roles = service.getAllRole();
+
+ assertEquals(1, roles.size());
+ assertEquals("Counsellor", roles.get(0).getRoleName());
+ assertEquals(PSM_ID, roles.get(0).getProviderServiceMapID());
+ }
+
+ @Test
+ @DisplayName("getEmployeeDetails should skip a row the query could not fill")
+ void getEmployeeDetails_shouldSkipUnfillableRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(null);
+ rows.add(new Object[] { 9001, USER_ID, 11, PSM_ID, "a", "b", "c", "d", 1, "e", 2, "f", "g" });
+ when(employeeMasterRepo.getEmployeeDetails()).thenReturn(rows);
+
+ assertEquals(1, service.getEmployeeDetails().size());
+ }
+
+ @Test
+ @DisplayName("getAllTitle should rebuild each title from what the repository holds")
+ void getAllTitle_shouldRebuildTitles() {
+ M_Title stored = new M_Title();
+ stored.setTitleID(1);
+ stored.setTitleName("Dr");
+ when(m_TitleRepo.getAllTitle()).thenReturn(new ArrayList<>(List.of(stored)));
+
+ assertEquals("Dr", service.getAllTitle().get(0).getTitleName());
+ }
+
+ @Test
+ @DisplayName("getAllGender should rebuild each gender from what the repository holds")
+ void getAllGender_shouldRebuildGenders() {
+ M_Gender stored = new M_Gender();
+ stored.setGenderID(1);
+ stored.setGenderName("Female");
+ when(m_GenderRepo.getAllGender()).thenReturn(new ArrayList<>(List.of(stored)));
+
+ assertEquals("Female", service.getAllGender().get(0).getGenderName());
+ }
+
+ @Test
+ @DisplayName("FindEmployeeName should distinguish a taken user name from a free one")
+ void findEmployeeName_shouldDistinguishTakenFromFree() {
+ when(employeeMasterRepoo.findEmployeeByName("asha.rao")).thenReturn(new M_User1());
+ when(employeeMasterRepoo.findEmployeeByName("new.user")).thenReturn(null);
+
+ assertEquals("userexist", service.FindEmployeeName("asha.rao"));
+ assertEquals("usernotexist", service.FindEmployeeName("new.user"));
+ }
+
+ @Test
+ @DisplayName("FindEmployeeContact should distinguish a taken number from a free one")
+ void findEmployeeContact_shouldDistinguishTakenFromFree() {
+ when(employeeMasterRepoo.findEmployeeByContact("9000000001")).thenReturn(new M_User1());
+ when(employeeMasterRepoo.findEmployeeByContact("9000000002")).thenReturn(null);
+
+ assertEquals("contactexist", service.FindEmployeeContact("9000000001"));
+ assertEquals("contactnotexist", service.FindEmployeeContact("9000000002"));
+ }
+
+ @Test
+ @DisplayName("FindEmployeeAadhaar should distinguish a taken number from a free one")
+ void findEmployeeAadhaar_shouldDistinguishTakenFromFree() {
+ when(employeeMasterRepoo.findEmployeeAadhaarNo("111122223333")).thenReturn(new M_User1());
+ when(employeeMasterRepoo.findEmployeeAadhaarNo("444455556666")).thenReturn(null);
+
+ assertEquals("aadhaarexist", service.FindEmployeeAadhaar("111122223333"));
+ assertEquals("aadhaarnotexist", service.FindEmployeeAadhaar("444455556666"));
+ }
+
+ @Test
+ @DisplayName("FindEmployeeName1 should answer the user record itself")
+ void findEmployeeName1_shouldAnswerTheRecord() {
+ M_User1 stored = new M_User1();
+ when(employeeMasterRepoo.findEmployeeByName("asha.rao")).thenReturn(stored);
+
+ assertSame(stored, service.FindEmployeeName1("asha.rao"));
+ }
+
+ @Test
+ @DisplayName("checkingEmpDetails should report whether the identifiers are already in use")
+ void checkingEmpDetails_shouldReportWhetherIdentifiersAreTaken() {
+ when(employeeMasterRepoo.checkingEmpDetails("asha.rao", "1", "2", "3", "4")).thenReturn(new M_User1());
+ when(employeeMasterRepoo.checkingEmpDetails("new.user", "1", "2", "3", "4")).thenReturn(null);
+
+ assertTrue(service.checkingEmpDetails("asha.rao", "1", "2", "3", "4"));
+ assertFalse(service.checkingEmpDetails("new.user", "1", "2", "3", "4"));
+ }
+
+ @Test
+ @DisplayName("getQualification should hand back what the repository holds")
+ void getQualification_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>(List.of(new M_Userqualification()));
+ when(m_QualificationRepo.getAllQualification()).thenReturn(stored);
+
+ assertSame(stored, service.getQualification());
+ }
+
+ @Test
+ @DisplayName("getlocationByMapid2 should hand back what the repository holds")
+ void getlocationByMapid2_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>(List.of(new Showofficedetails1()));
+ when(showofficedetails1Repo1.getlocationByMapid(PSM_ID, 301)).thenReturn(stored);
+
+ assertSame(stored, service.getlocationByMapid2(PSM_ID, 301));
+ }
+
+ @Test
+ @DisplayName("getAllByMapId2 should hand back what the repository holds")
+ void getAllByMapId2_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>(List.of(new M_ProviderServiceMap1()));
+ when(m_ProviderServiceMap1Repo.getAllByMapId2(77, 29, 3)).thenReturn(stored);
+
+ assertSame(stored, service.getAllByMapId2(77, 29, 3));
+ }
+
+ @Test
+ @DisplayName("the narrowing searches should each reach their own repository query")
+ void narrowingSearches_shouldReachTheirOwnQuery() {
+ ArrayList stored =
+ new ArrayList<>(List.of(new Showuserdetailsfromuserservicerolemapping()));
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails2(77, 29)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails3(77, 11)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails4(77, 3)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails6(77, USER_ID)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails7(77, 29, 301)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails8(77, 29, 301, 401)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails9(77, 29, 11)).thenReturn(stored);
+ when(showuserdetailsfromuserservicerolemappingRepo.EmployeeDetails10(77, 29, 11, 3, "asha.rao", USER_ID))
+ .thenReturn(stored);
+
+ assertSame(stored, service.getEmployeeDetails2(77, 29));
+ assertSame(stored, service.getEmployeeDetails3(77, 11));
+ assertSame(stored, service.getEmployeeDetails4(77, 3));
+ assertSame(stored, service.getEmployeeDetails6(77, USER_ID));
+ assertSame(stored, service.getEmployeeDetails7(77, 29, 301));
+ assertSame(stored, service.getEmployeeDetails8(77, 29, 301, 401));
+ assertSame(stored, service.getEmployeeDetails9(77, 29, 11));
+ assertSame(stored, service.getEmployeeDetails10(77, 29, 11, 3, "asha.rao", USER_ID));
+ }
+
+ @Test
+ @DisplayName("getEmployeeDetails5 should hand back what the view holds")
+ void getEmployeeDetails5_shouldHandBackViewContents() {
+ ArrayList stored = new ArrayList<>(List.of(new V_Showuser()));
+ when(v_ShowuserRepo.EmployeeDetails5()).thenReturn(stored);
+
+ assertSame(stored, service.getEmployeeDetails5());
+ }
+
+ @Test
+ @DisplayName("getcompleteUserDetails should hand back what the view holds")
+ void getcompleteUserDetails_shouldHandBackViewContents() {
+ ArrayList stored = new ArrayList<>(List.of(new V_Showuser()));
+ when(v_ShowuserRepo.getAdminDetails()).thenReturn(stored);
+
+ assertSame(stored, service.getcompleteUserDetails());
+ }
+
+ @Test
+ @DisplayName("getAllReligion and getAllCommunity should hand back what the repositories hold")
+ void masters_shouldHandBackRepositoryContents() {
+ ArrayList religions = new ArrayList<>(List.of(new M_Religion()));
+ ArrayList communities = new ArrayList<>(List.of(new M_Community()));
+ when(m_ReligionRepo.findAll()).thenReturn(religions);
+ when(m_CommunityRepo.findAll()).thenReturn(communities);
+
+ assertEquals(1, service.getAllReligion().size());
+ assertEquals(1, service.getAllCommunity().size());
+ }
+ }
+
+ @Nested
+ @DisplayName("getEmployeeDetails4 by provider")
+ class EmployeeDetails4Tests {
+
+ @Test
+ @DisplayName("should mark a user locked out after failed sign-ins")
+ void getEmployeeDetails4_shouldMarkLockedOutUser() {
+ V_Showuser user = new V_Showuser();
+ user.setUserID(USER_ID);
+ M_User1 record = new M_User1();
+ record.setUserID(USER_ID);
+ record.setFailedAttempt(3);
+ record.setDeleted(Boolean.TRUE);
+ record.setLockTimestamp(Timestamp.valueOf("2026-02-17 09:30:00"));
+ when(v_ShowuserRepo.EmployeeDetails4(77)).thenReturn(new ArrayList<>(List.of(user)));
+ when(employeeMasterRepoo.findByUserIDIn(anyList())).thenReturn(new ArrayList<>(List.of(record)));
+
+ V_Showuser enriched = service.getEmployeeDetails4(77).get(0);
+
+ assertEquals(3, enriched.getFailedAttempt());
+ assertTrue(enriched.getLockedDueToFailedAttempts());
+ }
+
+ @Test
+ @DisplayName("should not mark a user locked out while their account is still active")
+ void getEmployeeDetails4_shouldNotMarkActiveUserLockedOut() {
+ V_Showuser user = new V_Showuser();
+ user.setUserID(USER_ID);
+ M_User1 record = new M_User1();
+ record.setUserID(USER_ID);
+ record.setDeleted(Boolean.FALSE);
+ record.setLockTimestamp(Timestamp.valueOf("2026-02-17 09:30:00"));
+ when(v_ShowuserRepo.EmployeeDetails4(77)).thenReturn(new ArrayList<>(List.of(user)));
+ when(employeeMasterRepoo.findByUserIDIn(anyList())).thenReturn(new ArrayList<>(List.of(record)));
+
+ V_Showuser enriched = service.getEmployeeDetails4(77).get(0);
+
+ assertEquals(0, enriched.getFailedAttempt());
+ assertFalse(enriched.getLockedDueToFailedAttempts());
+ }
+
+ @Test
+ @DisplayName("should answer an empty result without asking for user records")
+ void getEmployeeDetails4_shouldAnswerEmptyWithoutFurtherLookups() {
+ when(v_ShowuserRepo.EmployeeDetails4(77)).thenReturn(new ArrayList<>());
+
+ assertTrue(service.getEmployeeDetails4(77).isEmpty());
+ verify(employeeMasterRepoo, never()).findByUserIDIn(anyList());
+ }
+ }
+
+ @Nested
+ @DisplayName("Persistence")
+ class PersistenceTests {
+
+ @Test
+ @DisplayName("saveEmployee should answer the id of the stored user and encrypt its credentials")
+ void saveEmployee_shouldStoreAndEncrypt() {
+ M_User1 toSave = new M_User1();
+ M_User1 stored = new M_User1();
+ stored.setUserID(USER_ID);
+ when(employeeMasterRepo11.save(toSave)).thenReturn(stored);
+ when(encryptUserPassword.encryptUserCredentials(stored)).thenReturn(new OutputResponse());
+
+ assertEquals(USER_ID, service.saveEmployee(toSave));
+ verify(encryptUserPassword).encryptUserCredentials(stored);
+ }
+
+ @Test
+ @DisplayName("saveEditData should re-encrypt the credentials it saved")
+ void saveEditData_shouldReEncryptCredentials() {
+ M_User1 toSave = new M_User1();
+ when(employeeMasterRepo11.save(toSave)).thenReturn(toSave);
+
+ assertSame(toSave, service.saveEditData(toSave));
+ verify(encryptUserPassword).encryptUserCredentials(toSave);
+ }
+
+ @Test
+ @DisplayName("saveDemography should answer the id of the stored demographics")
+ void saveDemography_shouldAnswerStoredId() {
+ M_UserDemographics stored = new M_UserDemographics();
+ stored.setDemographicID(5001);
+ when(m_UserDemographicsRepo.save(any())).thenReturn(stored);
+
+ assertEquals(5001, service.saveDemography(new M_UserDemographics()));
+ assertEquals(5001, service.saveeditDemo(new M_UserDemographics()));
+ }
+
+ @Test
+ @DisplayName("saveeditlangdata should answer the id of the stored language mapping")
+ void saveeditlangdata_shouldAnswerStoredId() {
+ M_UserLangMapping stored = new M_UserLangMapping();
+ stored.setUserLangID(7001);
+ when(m_UserLangMappingRepo.save(any())).thenReturn(stored);
+
+ assertEquals(7001, service.saveeditlangdata(new M_UserLangMapping()));
+ }
+
+ @Test
+ @DisplayName("mapLanguage and mapRoleUpdation should hand their batches to the repositories")
+ void batches_shouldReachTheRepositories() {
+ ArrayList languages = new ArrayList<>();
+ ArrayList roles = new ArrayList<>();
+ when(m_UserLangMappingRepo.saveAll(anyList())).thenReturn(languages);
+ when(employeeMasterRepo.saveAll(anyList())).thenReturn(roles);
+
+ assertSame(languages, service.mapLanguage(new ArrayList<>()));
+ assertSame(roles, service.mapRoleUpdation(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("saveeditedData should clear the failed sign-in count for a reinstated user")
+ void saveeditedData_shouldClearFailedAttemptsOnReinstatement() {
+ M_User1 toSave = new M_User1();
+ toSave.setDeleted(Boolean.FALSE);
+ toSave.setFailedAttempt(3);
+ when(employeeMasterRepoo.save(toSave)).thenReturn(toSave);
+
+ service.saveeditedData(toSave);
+
+ assertEquals(0, toSave.getFailedAttempt());
+ }
+
+ @Test
+ @DisplayName("saveeditedData should leave the failed sign-in count alone for a deactivated user")
+ void saveeditedData_shouldLeaveFailedAttemptsAloneOnDeactivation() {
+ M_User1 toSave = new M_User1();
+ toSave.setDeleted(Boolean.TRUE);
+ toSave.setFailedAttempt(3);
+ when(employeeMasterRepoo.save(toSave)).thenReturn(toSave);
+
+ service.saveeditedData(toSave);
+
+ assertEquals(3, toSave.getFailedAttempt());
+ }
+
+ @Test
+ @DisplayName("createProviderAdmin should hash the password before it is stored")
+ void createProviderAdmin_shouldHashPassword() throws Exception {
+ M_User1 toCreate = new M_User1();
+ toCreate.setPassword("plain-secret");
+ ArrayList stored = new ArrayList<>(List.of(toCreate));
+ when(employeeMasterRepoo.saveAll(anyList())).thenReturn(stored);
+
+ service.createProviderAdmin(List.of(toCreate));
+
+ assertTrue(toCreate.getPassword().startsWith("1001:"),
+ "the stored password must be the salted hash, not the plain text");
+ }
+
+ @Test
+ @DisplayName("createProviderAdmin should refuse an admin with no password")
+ void createProviderAdmin_shouldRefuseWithoutPassword() {
+ assertThrows(Exception.class, () -> service.createProviderAdmin(List.of(new M_User1())));
+ }
+
+ @Test
+ @DisplayName("createNewUser should hash the password before it is stored")
+ void createNewUser_shouldHashPassword() throws Exception {
+ M_User1 toCreate = new M_User1();
+ toCreate.setPassword("plain-secret");
+ when(employeeMasterRepoo.saveAll(anyList())).thenReturn(new ArrayList<>(List.of(toCreate)));
+
+ service.createNewUser(List.of(toCreate));
+
+ assertFalse("plain-secret".equals(toCreate.getPassword()));
+ }
+
+ @Test
+ @DisplayName("createNewUser should refuse a user with no password")
+ void createNewUser_shouldRefuseWithoutPassword() {
+ assertThrows(Exception.class, () -> service.createNewUser(List.of(new M_User1())));
+ }
+
+ @Test
+ @DisplayName("generateStrongPassword should answer a different hash each time it is called")
+ void generateStrongPassword_shouldSaltEachHash() throws Exception {
+ String first = service.generateStrongPassword("plain-secret");
+ String second = service.generateStrongPassword("plain-secret");
+
+ assertNotNull(first);
+ assertFalse(first.equals(second), "each hash must carry its own salt");
+ }
+
+ @Test
+ @DisplayName("saveBulkUserEmployee should answer the record the repository stored")
+ void saveBulkUserEmployee_shouldAnswerStoredRecord() {
+ M_User1 stored = new M_User1();
+ stored.setUserID(USER_ID);
+ when(employeeMasterRepo11.save(any())).thenReturn(stored);
+
+ assertSame(stored, service.saveBulkUserEmployee(new M_User1()));
+ }
+
+ @Test
+ @DisplayName("the single-record lookups should each reach their own repository query")
+ void singleRecordLookups_shouldReachTheirOwnQuery() {
+ M_User1 user = new M_User1();
+ M_UserDemographics demographics = new M_UserDemographics();
+ M_UserLangMapping language = new M_UserLangMapping();
+ M_UserServiceRoleMapping2 roleMapping = mapping(9001, 11);
+ when(employeeMasterRepo11.editEmployee(USER_ID)).thenReturn(user);
+ when(employeeMasterRepoo.findByUserID(USER_ID)).thenReturn(user);
+ when(m_UserDemographicsRepo.mdedit(USER_ID)).thenReturn(demographics);
+ when(m_UserDemographicsRepo.findByUserID(USER_ID)).thenReturn(demographics);
+ when(m_UserDemographicsRepo.save(demographics)).thenReturn(demographics);
+ when(m_UserLangMappingRepo.ulangmapedit(USER_ID, 1)).thenReturn(language);
+ when(m_UserLangMappingRepo.findByUserLangID(7001)).thenReturn(language);
+ when(m_UserLangMappingRepo.save(language)).thenReturn(language);
+ when(employeeMasterRepo.uRoleMedit(USER_ID, 11)).thenReturn(roleMapping);
+ when(employeeMasterRepo.uRoledelte(9001)).thenReturn(roleMapping);
+ when(employeeMasterRepo.findByUSRMappingID(9001)).thenReturn(roleMapping);
+ when(employeeMasterRepo.save(roleMapping)).thenReturn(roleMapping);
+
+ assertSame(user, service.editEmployee(USER_ID));
+ assertSame(user, service.editData(USER_ID));
+ assertSame(user, service.getProviderAdminForEdit(USER_ID));
+ assertSame(demographics, service.mdedit(USER_ID));
+ assertSame(demographics, service.DataByUserID(USER_ID));
+ assertSame(demographics, service.saveeditedDemoData(demographics));
+ assertSame(language, service.ulangmapedit(USER_ID, 1));
+ assertSame(language, service.updateLangMapping(7001));
+ assertSame(language, service.saveUserLangEditedData(language));
+ assertSame(roleMapping, service.uRoleMedit(USER_ID, 11));
+ assertSame(roleMapping, service.uRoledelte(9001));
+ assertSame(roleMapping, service.getDataUsrId(9001));
+ assertSame(roleMapping, service.saveRoleEdit(roleMapping));
+ }
+
+ @Test
+ @DisplayName("SaveDemographics should hand its batch to the repository")
+ void saveDemographics_shouldHandBatchToRepository() {
+ ArrayList stored = new ArrayList<>();
+ when(m_UserDemographicsRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.SaveDemographics(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("getProviderAdmin should hand back what the repository holds")
+ void getProviderAdmin_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>(List.of(new M_User1()));
+ when(employeeMasterRepoo.getAllProviderAdminData()).thenReturn(stored);
+
+ assertSame(stored, service.getProviderAdmin());
+ }
+ }
+
+ @Nested
+ @DisplayName("ResetPassword")
+ class ResetPasswordTests {
+
+ @Test
+ @DisplayName("should report success when the credential service accepts the new password")
+ void resetPassword_shouldReportSuccess() {
+ OutputResponse accepted = new OutputResponse();
+ accepted.setResponse("done");
+ when(encryptUserPassword.encryptUserCredentials(any())).thenReturn(accepted);
+
+ assertEquals("Password reset successfully", service.ResetPassword(new M_User1()));
+ }
+
+ @Test
+ @DisplayName("should report failure when the credential service refuses the new password")
+ void resetPassword_shouldReportFailure() {
+ when(encryptUserPassword.encryptUserCredentials(any())).thenReturn(new OutputResponse());
+
+ assertEquals("Password Not Set Properly", service.ResetPassword(new M_User1()));
+ }
+ }
+
+ @Nested
+ @DisplayName("getMappedRole")
+ class GetMappedRoleTests {
+
+ @Test
+ @DisplayName("should split the stored village columns back into lists")
+ void getMappedRole_shouldSplitVillageColumns() {
+ V_Userservicerolemapping mapping = new V_Userservicerolemapping();
+ mapping.setuSRMappingID(9001);
+ mapping.setServiceID(3);
+ mapping.setStateID(29);
+ mapping.setWorkingDistrictID("301");
+ mapping.setVillageidDb("501,502");
+ mapping.setVillageNameDb("Hosur,Devanahalli");
+ when(v_UserservicerolemappingRepo.getAllRoleOfProvider(77))
+ .thenReturn(new ArrayList<>(List.of(mapping)));
+ when(employeeMasterRepo.getFacilityInfoByMappingIDs(anyList())).thenReturn(new ArrayList<>());
+
+ V_Userservicerolemapping answered = service.getMappedRole(77).get(0);
+
+ assertArrayEquals(new String[] { "501", "502" }, answered.getVillageID());
+ assertArrayEquals(new String[] { "Hosur", "Devanahalli" }, answered.getVillageName());
+ }
+
+ @Test
+ @DisplayName("should clear the block and village details for a mapping with no service line")
+ void getMappedRole_shouldClearBlockAndVillageWithoutService() {
+ V_Userservicerolemapping mapping = new V_Userservicerolemapping();
+ mapping.setuSRMappingID(9001);
+ mapping.setStateID(29);
+ mapping.setWorkingDistrictID("301");
+ mapping.setVillageidDb("501");
+ when(v_UserservicerolemappingRepo.getAllRoleOfProvider(77))
+ .thenReturn(new ArrayList<>(List.of(mapping)));
+ when(employeeMasterRepo.getFacilityInfoByMappingIDs(anyList())).thenReturn(new ArrayList<>());
+
+ V_Userservicerolemapping answered = service.getMappedRole(77).get(0);
+
+ assertNull(answered.getVillageID());
+ assertNull(answered.getVillageidDb());
+ assertNull(answered.getBlockID());
+ }
+
+ @Test
+ @DisplayName("should fill in the state and district the view could not resolve")
+ void getMappedRole_shouldFillInMissingStateAndDistrict() {
+ V_Userservicerolemapping mapping = new V_Userservicerolemapping();
+ mapping.setuSRMappingID(9001);
+ mapping.setServiceID(3);
+ when(v_UserservicerolemappingRepo.getAllRoleOfProvider(77))
+ .thenReturn(new ArrayList<>(List.of(mapping)));
+ when(employeeMasterRepo.getDirectStateDistrictByMappingIDs(anyList()))
+ .thenReturn(List.of(new Object[] { 9001, 29, "Karnataka", 301, "Bengaluru Urban", 401, "North" }));
+ when(employeeMasterRepo.getFacilityInfoByMappingIDs(anyList())).thenReturn(new ArrayList<>());
+
+ V_Userservicerolemapping answered = service.getMappedRole(77).get(0);
+
+ assertEquals(29, answered.getStateID());
+ assertEquals("Karnataka", answered.getStateName());
+ assertEquals("301", answered.getWorkingDistrictID());
+ assertEquals("North", answered.getBlockName());
+ }
+
+ @Test
+ @DisplayName("should attach the facility details the batch lookup resolves")
+ void getMappedRole_shouldAttachFacilityDetails() {
+ V_Userservicerolemapping mapping = new V_Userservicerolemapping();
+ mapping.setuSRMappingID(9001);
+ mapping.setServiceID(3);
+ mapping.setStateID(29);
+ mapping.setWorkingDistrictID("301");
+ when(v_UserservicerolemappingRepo.getAllRoleOfProvider(77))
+ .thenReturn(new ArrayList<>(List.of(mapping)));
+ when(employeeMasterRepo.getFacilityInfoByMappingIDs(anyList()))
+ .thenReturn(List.of(new Object[] { 9001, 501, "PHC North", 3, "Rural" }));
+
+ V_Userservicerolemapping answered = service.getMappedRole(77).get(0);
+
+ assertEquals(501, answered.getFacilityID());
+ assertEquals("PHC North", answered.getFacilityName());
+ assertEquals("Rural", answered.getRuralUrban());
+ }
+
+ @Test
+ @DisplayName("should answer an empty list when the view holds nothing")
+ void getMappedRole_shouldAnswerEmptyListForEmptyView() {
+ when(v_UserservicerolemappingRepo.getAllRoleOfProvider(77)).thenReturn(null);
+
+ assertTrue(service.getMappedRole(77).isEmpty());
+ }
+
+ @Test
+ @DisplayName("should search by user id when the caller sends no name")
+ void getMappedRole_shouldSearchByUserIdWithoutAName() {
+ ArrayList stored = new ArrayList<>();
+ when(v_UserservicerolemappingRepo.getDataByUserID(USER_ID)).thenReturn(stored);
+
+ assertSame(stored, service.getMappedRole("", USER_ID));
+ }
+
+ @Test
+ @DisplayName("should search by name when the caller sends no usable user id")
+ void getMappedRole_shouldSearchByNameWithoutAUserId() {
+ ArrayList stored = new ArrayList<>();
+ when(v_UserservicerolemappingRepo.getDataByName("Asha Rao")).thenReturn(stored);
+
+ assertSame(stored, service.getMappedRole("Asha Rao", 0));
+ }
+
+ @Test
+ @DisplayName("should refuse a search that names both a user and an id")
+ void getMappedRole_shouldRefuseAmbiguousSearch() {
+ assertThrows(DataNotFound.class, () -> service.getMappedRole("Asha Rao", USER_ID));
+ }
+ }
+
+ @Nested
+ @DisplayName("searchMappedLangugeByUserId")
+ class SearchMappedLanguageTests {
+
+ @Test
+ @DisplayName("should answer the languages mapped to a real user")
+ void searchMappedLanguage_shouldAnswerMappedLanguages() {
+ ArrayList stored = new ArrayList<>();
+ when(m_UserLangMappingRepo.getmappedlanguageData(USER_ID)).thenReturn(stored);
+
+ assertSame(stored, service.searchMappedLangugeByUserId(USER_ID));
+ }
+
+ @Test
+ @DisplayName("should refuse a search that names no user")
+ void searchMappedLanguage_shouldRefuseSearchWithoutUser() {
+ assertThrows(DataNotFound.class, () -> service.searchMappedLangugeByUserId(0));
+ }
+ }
+
+ @Nested
+ @DisplayName("getMappedLanguge")
+ class GetMappedLanguageTests {
+
+ @Test
+ @DisplayName("should rebuild one mapping per row the query answers")
+ void getMappedLanguge_shouldRebuildEachRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(null);
+ rows.add(new Object[] { 7001, USER_ID, 1, 5, "Kannada", "asha.rao", true, true, true, "n", false,
+ 5, 5, 5, false });
+ when(m_UserLangMappingRepo.getMappedLanguge(77)).thenReturn(rows);
+
+ assertEquals(1, service.getMappedLanguge(77).size());
+ }
+ }
+
+ @Nested
+ @DisplayName("getEmployeeByDesiganationID")
+ class EmployeeByDesignationTests {
+
+ @Test
+ @DisplayName("should mark a user whose signature is on file as active")
+ void byDesignation_shouldMarkActiveSignature() {
+ M_User1 user = new M_User1();
+ user.setUserID(USER_ID);
+ EmployeeSignature signature = new EmployeeSignature();
+ signature.setDeleted(Boolean.FALSE);
+ when(employeeMasterRepoo.getempByDesiganation(7, 77)).thenReturn(new ArrayList<>(List.of(user)));
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(signature);
+
+ assertEquals("Active", service.getEmployeeByDesiganationID(7, 77).get(0).getSignatureStatus());
+ }
+
+ @Test
+ @DisplayName("should mark a user whose signature has been retired as inactive")
+ void byDesignation_shouldMarkRetiredSignature() {
+ M_User1 user = new M_User1();
+ user.setUserID(USER_ID);
+ EmployeeSignature signature = new EmployeeSignature();
+ signature.setDeleted(Boolean.TRUE);
+ when(employeeMasterRepoo.getempByDesiganation(7, 77)).thenReturn(new ArrayList<>(List.of(user)));
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(signature);
+
+ assertEquals("InActive", service.getEmployeeByDesiganationID(7, 77).get(0).getSignatureStatus());
+ }
+
+ @Test
+ @DisplayName("should leave the signature status unset for a user with none on file")
+ void byDesignation_shouldLeaveStatusUnsetWithoutSignature() {
+ M_User1 user = new M_User1();
+ user.setUserID(USER_ID);
+ when(employeeMasterRepoo.getempByDesiganation(7, 77)).thenReturn(new ArrayList<>(List.of(user)));
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(null);
+
+ assertNull(service.getEmployeeByDesiganationID(7, 77).get(0).getSignatureStatus());
+ }
+ }
+
+ @Nested
+ @DisplayName("getUserRoleTM")
+ class UserRoleTmTests {
+
+ @Test
+ @DisplayName("should rebuild one role per row the query answers")
+ void getUserRoleTM_shouldRebuildEachRow() {
+ M_UserservicerolemappingForRoleProviderAdmin request =
+ new M_UserservicerolemappingForRoleProviderAdmin();
+ request.setUserID(USER_ID);
+ request.setProviderServiceMapID(PSM_ID);
+ ArrayList rows = new ArrayList<>();
+ rows.add(new Object[] { USER_ID, 11, "TC Specialist", false, 21, "Specialist screen", false });
+ when(userservicerolemappingForRoleProviderAdminRepo.getroleofuserTM(USER_ID, PSM_ID)).thenReturn(rows);
+
+ ArrayList roles = service.getUserRoleTM(request);
+
+ assertEquals(1, roles.size());
+ assertEquals("TC Specialist", roles.get(0).getRolename());
+ }
+
+ @Test
+ @DisplayName("should answer an empty list when the user holds no telemedicine role")
+ void getUserRoleTM_shouldAnswerEmptyListWithoutRoles() {
+ M_UserservicerolemappingForRoleProviderAdmin request =
+ new M_UserservicerolemappingForRoleProviderAdmin();
+ when(userservicerolemappingForRoleProviderAdminRepo.getroleofuserTM(any(), any()))
+ .thenReturn(new ArrayList<>());
+
+ assertTrue(service.getUserRoleTM(request).isEmpty());
+ }
+ }
+
+ @Nested
+ @DisplayName("createAgent")
+ class CreateAgentTests {
+
+ @Test
+ @DisplayName("should fill the agent and server placeholders into the configured URL")
+ void createAgent_shouldFillPlaceholders() {
+ com.iemr.admin.utils.config.ConfigProperties properties =
+ new com.iemr.admin.utils.config.ConfigProperties();
+ service.setConfigProperties(properties);
+
+ String url = service.createAgent("A-1", "asha.rao");
+
+ assertNotNull(url);
+ assertFalse(url.contains("AGENTID"), url);
+ }
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterSupportServicesTest.java b/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterSupportServicesTest.java
new file mode 100644
index 0000000..230e875
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/employeemaster/EmployeeMasterSupportServicesTest.java
@@ -0,0 +1,556 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.employeemaster;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.employeemaster.AshaSupervisorMapping;
+import com.iemr.admin.data.employeemaster.EmployeeSignature;
+import com.iemr.admin.data.employeemaster.M_Designation;
+import com.iemr.admin.data.employeemaster.M_UserServiceRoleMapping2;
+import com.iemr.admin.data.employeemaster.USRAgentMapping;
+import com.iemr.admin.data.store.M_Facility;
+import com.iemr.admin.repo.employeemaster.EmployeeMasterRepo;
+import com.iemr.admin.repo.employeemaster.EmployeeSignatureRepo;
+import com.iemr.admin.repo.employeemaster.M_DesignationRepo;
+import com.iemr.admin.repo.employeemaster.USRAgentMappingRepository;
+import com.iemr.admin.repository.store.MainStoreRepo;
+import com.iemr.admin.repository.user.AshaSupervisorMappingRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The supporting employee services: the supervisor mapping store, the signature
+ * store, the CTI agent-id pool and the designation master.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("Employee master support service Test Suite")
+class EmployeeMasterSupportServicesTest {
+
+ private static final Integer SUPERVISOR_ID = 3117;
+ private static final Integer ASHA_ID = 4001;
+ private static final Integer FACILITY_ID = 501;
+
+ @Mock
+ private AshaSupervisorMappingRepo ashaSupervisorMappingRepo;
+
+ @Mock
+ private EmployeeMasterRepo employeeMasterRepo;
+
+ @Mock
+ private MainStoreRepo mainStoreRepo;
+
+ @InjectMocks
+ private AshaSupervisorMappingServiceImpl ashaService;
+
+ @Mock
+ private EmployeeSignatureRepo employeeSignatureRepo;
+
+ @InjectMocks
+ private EmployeeSignatureServiceImpl signatureService;
+
+ @Mock
+ private USRAgentMappingRepository usrAgentMappingRepository;
+
+ @Mock
+ private M_DesignationRepo m_DesignationRepo;
+
+ @InjectMocks
+ private M_DesignationImpl designationService;
+
+ private static AshaSupervisorMapping mapping(Long id, Integer supervisorId, Integer ashaId) {
+ AshaSupervisorMapping mapping = new AshaSupervisorMapping();
+ mapping.setId(id);
+ mapping.setSupervisorUserID(supervisorId);
+ mapping.setAshaUserID(ashaId);
+ mapping.setFacilityID(FACILITY_ID);
+ mapping.setCreatedBy("admin");
+ return mapping;
+ }
+
+ private void activeFacility() {
+ M_Facility facility = new M_Facility();
+ facility.setFacilityID(FACILITY_ID);
+ when(mainStoreRepo.findByFacilityIDAndDeleted(FACILITY_ID, false)).thenReturn(facility);
+ }
+
+ @Nested
+ @DisplayName("AshaSupervisorMappingServiceImpl")
+ class AshaSupervisorMappingTests {
+
+ @Test
+ @DisplayName("saveAshaSupervisorMappings should refuse a mapping onto a retired facility")
+ void save_shouldRefuseRetiredFacility() {
+ when(mainStoreRepo.findByFacilityIDAndDeleted(FACILITY_ID, false)).thenReturn(null);
+
+ RuntimeException thrown = assertThrows(RuntimeException.class,
+ () -> ashaService.saveAshaSupervisorMappings(List.of(mapping(null, SUPERVISOR_ID, ASHA_ID))));
+
+ assertTrue(thrown.getMessage().contains("is no longer active"), thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("saveAshaSupervisorMappings should reuse a mapping that already exists")
+ void save_shouldReuseExistingMapping() {
+ activeFacility();
+ AshaSupervisorMapping existing = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ when(ashaSupervisorMappingRepo
+ .findBySupervisorUserIDAndAshaUserIDAndFacilityIDAndDeletedFalse(SUPERVISOR_ID, ASHA_ID,
+ FACILITY_ID))
+ .thenReturn(existing);
+
+ ArrayList saved =
+ ashaService.saveAshaSupervisorMappings(List.of(mapping(null, SUPERVISOR_ID, ASHA_ID)));
+
+ assertSame(existing, saved.get(0));
+ verify(ashaSupervisorMappingRepo, never()).save(any());
+ }
+
+ @Test
+ @DisplayName("saveAshaSupervisorMappings should retire the ASHA's mapping under a different supervisor")
+ void save_shouldRetireMappingUnderOtherSupervisor() {
+ activeFacility();
+ AshaSupervisorMapping other = mapping(2L, 3118, ASHA_ID);
+ AshaSupervisorMapping toSave = mapping(null, SUPERVISOR_ID, ASHA_ID);
+ when(ashaSupervisorMappingRepo
+ .findByAshaUserIDAndFacilityIDAndDeletedFalseAndSupervisorUserIDNot(ASHA_ID, FACILITY_ID,
+ SUPERVISOR_ID))
+ .thenReturn(new ArrayList<>(List.of(other)));
+ when(ashaSupervisorMappingRepo.save(toSave)).thenReturn(toSave);
+
+ ashaService.saveAshaSupervisorMappings(List.of(toSave));
+
+ assertTrue(other.getDeleted(), "an ASHA may report to only one supervisor at a facility");
+ assertEquals("admin", other.getModifiedBy());
+ verify(ashaSupervisorMappingRepo).save(other);
+ }
+
+ @Test
+ @DisplayName("getSupervisorMappingByFacility should hand back what the repository holds")
+ void getByFacility_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>();
+ when(ashaSupervisorMappingRepo.findActiveMappingsByFacilityID(FACILITY_ID)).thenReturn(stored);
+
+ assertSame(stored, ashaService.getSupervisorMappingByFacility(FACILITY_ID));
+ }
+
+ @Test
+ @DisplayName("getAshasByFacility should hand back what the repository holds")
+ void getAshas_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>();
+ when(employeeMasterRepo.findAshaUsersByFacilityIDs(anyList())).thenReturn(stored);
+
+ assertSame(stored, ashaService.getAshasByFacility(List.of(FACILITY_ID)));
+ }
+
+ @Test
+ @DisplayName("deleteMappings should retire each mapping it can resolve")
+ void deleteMappings_shouldRetireResolvedMappings() {
+ AshaSupervisorMapping stored = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ when(ashaSupervisorMappingRepo.findById(1L)).thenReturn(Optional.of(stored));
+ when(ashaSupervisorMappingRepo.findById(2L)).thenReturn(Optional.empty());
+
+ ashaService.deleteMappings(List.of(1L, 2L), "admin");
+
+ assertTrue(stored.getDeleted());
+ verify(ashaSupervisorMappingRepo).save(stored);
+ }
+
+ @Test
+ @DisplayName("restoreMappings should reinstate each mapping it can resolve")
+ void restoreMappings_shouldReinstateResolvedMappings() {
+ AshaSupervisorMapping stored = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ stored.setDeleted(Boolean.TRUE);
+ when(ashaSupervisorMappingRepo.findById(1L)).thenReturn(Optional.of(stored));
+ when(ashaSupervisorMappingRepo.findById(2L)).thenReturn(Optional.empty());
+
+ ashaService.restoreMappings(List.of(1L, 2L), "admin");
+
+ assertFalse(stored.getDeleted());
+ assertEquals("admin", stored.getModifiedBy());
+ }
+
+ @Test
+ @DisplayName("deleteBySupervisorAndFacilities should retire every mapping at the named facilities")
+ void deleteBySupervisorAndFacilities_shouldRetireEveryMapping() {
+ AshaSupervisorMapping stored = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ when(ashaSupervisorMappingRepo
+ .findBySupervisorUserIDAndFacilityIDInAndDeletedFalse(SUPERVISOR_ID, List.of(FACILITY_ID)))
+ .thenReturn(new ArrayList<>(List.of(stored)));
+
+ ashaService.deleteBySupervisorAndFacilities(SUPERVISOR_ID, List.of(FACILITY_ID), "admin");
+
+ assertTrue(stored.getDeleted());
+ }
+
+ @Test
+ @DisplayName("cascadeDeleteByUserID should retire the user's mappings on both sides of the relationship")
+ void cascadeByUser_shouldRetireBothSides() {
+ AshaSupervisorMapping asSupervisor = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ AshaSupervisorMapping asAsha = mapping(2L, 3118, SUPERVISOR_ID);
+ when(ashaSupervisorMappingRepo.findBySupervisorUserIDAndDeletedFalse(SUPERVISOR_ID))
+ .thenReturn(new ArrayList<>(List.of(asSupervisor)));
+ when(ashaSupervisorMappingRepo.findByAshaUserIDAndDeletedFalse(SUPERVISOR_ID))
+ .thenReturn(new ArrayList<>(List.of(asAsha)));
+
+ ashaService.cascadeDeleteByUserID(SUPERVISOR_ID, "admin");
+
+ assertTrue(asSupervisor.getDeleted());
+ assertTrue(asAsha.getDeleted());
+ }
+
+ @Test
+ @DisplayName("cascadeDeleteByFacilityID should retire every mapping at the facility")
+ void cascadeByFacility_shouldRetireEveryMapping() {
+ AshaSupervisorMapping stored = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ when(ashaSupervisorMappingRepo.findByFacilityIDAndDeletedFalse(FACILITY_ID))
+ .thenReturn(new ArrayList<>(List.of(stored)));
+
+ ashaService.cascadeDeleteByFacilityID(FACILITY_ID, "admin");
+
+ assertTrue(stored.getDeleted());
+ }
+
+ @Test
+ @DisplayName("cascadeDeleteByUserIDAndFacilityID should retire only that user's mappings at that facility")
+ void cascadeByUserAndFacility_shouldRetireBothSidesAtFacility() {
+ AshaSupervisorMapping asSupervisor = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ AshaSupervisorMapping asAsha = mapping(2L, 3118, SUPERVISOR_ID);
+ when(ashaSupervisorMappingRepo
+ .findBySupervisorUserIDAndFacilityIDAndDeletedFalse(SUPERVISOR_ID, FACILITY_ID))
+ .thenReturn(new ArrayList<>(List.of(asSupervisor)));
+ when(ashaSupervisorMappingRepo.findByAshaUserIDAndFacilityIDAndDeletedFalse(SUPERVISOR_ID, FACILITY_ID))
+ .thenReturn(new ArrayList<>(List.of(asAsha)));
+
+ ashaService.cascadeDeleteByUserIDAndFacilityID(SUPERVISOR_ID, FACILITY_ID, "admin");
+
+ assertTrue(asSupervisor.getDeleted());
+ assertTrue(asAsha.getDeleted());
+ }
+
+ @Test
+ @DisplayName("updateAshaMappingsAtomically should retire the old mappings before saving the new ones")
+ void updateAtomically_shouldRetireThenSave() {
+ activeFacility();
+ AshaSupervisorMapping old = mapping(1L, SUPERVISOR_ID, ASHA_ID);
+ AshaSupervisorMapping fresh = mapping(null, SUPERVISOR_ID, 4002);
+ when(ashaSupervisorMappingRepo
+ .findBySupervisorUserIDAndFacilityIDInAndDeletedFalse(SUPERVISOR_ID, List.of(FACILITY_ID)))
+ .thenReturn(new ArrayList<>(List.of(old)));
+ when(ashaSupervisorMappingRepo.save(fresh)).thenReturn(fresh);
+
+ ArrayList saved = ashaService.updateAshaMappingsAtomically(
+ SUPERVISOR_ID, List.of(FACILITY_ID), List.of(fresh), "admin");
+
+ assertTrue(old.getDeleted());
+ assertSame(fresh, saved.get(0));
+ }
+
+ @Test
+ @DisplayName("updateAshaMappingsAtomically should answer nothing when no new mappings are supplied")
+ void updateAtomically_shouldAnswerNothingWithoutNewMappings() {
+ when(ashaSupervisorMappingRepo
+ .findBySupervisorUserIDAndFacilityIDInAndDeletedFalse(anyInt(), anyList()))
+ .thenReturn(new ArrayList<>());
+
+ assertTrue(ashaService
+ .updateAshaMappingsAtomically(SUPERVISOR_ID, List.of(FACILITY_ID), null, "admin").isEmpty());
+ }
+ }
+
+ @Nested
+ @DisplayName("EmployeeSignatureServiceImpl")
+ class SignatureServiceTests {
+
+ @Test
+ @DisplayName("uploadSignature should overwrite the signature already on file")
+ void upload_shouldOverwriteExistingSignature() {
+ EmployeeSignature existing = new EmployeeSignature();
+ existing.setUserID(3117L);
+ existing.setUserSignatureID(9001L);
+ EmployeeSignature uploaded = new EmployeeSignature();
+ uploaded.setUserID(3117L);
+ uploaded.setFileName("new.png");
+ uploaded.setFileType("image/png");
+ uploaded.setSignature(new byte[] { 1, 2, 3 });
+ uploaded.setCreatedBy("admin");
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(existing);
+ when(employeeSignatureRepo.save(existing)).thenReturn(existing);
+
+ assertEquals(9001L, signatureService.uploadSignature(uploaded));
+ assertEquals("new.png", existing.getFileName());
+ assertEquals("admin", existing.getModifiedBy());
+ }
+
+ @Test
+ @DisplayName("uploadSignature should store a first signature for a user who has none")
+ void upload_shouldStoreFirstSignature() {
+ EmployeeSignature uploaded = new EmployeeSignature();
+ uploaded.setUserID(3117L);
+ uploaded.setUserSignatureID(9002L);
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(null);
+ when(employeeSignatureRepo.save(uploaded)).thenReturn(uploaded);
+
+ assertEquals(9002L, signatureService.uploadSignature(uploaded));
+ }
+
+ @Test
+ @DisplayName("fetchSignature should hand back what the repository holds")
+ void fetch_shouldHandBackRepositoryContents() {
+ EmployeeSignature stored = new EmployeeSignature();
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(stored);
+
+ assertSame(stored, signatureService.fetchSignature(3117L));
+ }
+
+ @Test
+ @DisplayName("existSignature should report whether any signature is on file")
+ void exist_shouldReportWhetherSignatureIsOnFile() {
+ when(employeeSignatureRepo.countByUserIDAndSignatureNotNull(3117L)).thenReturn(1L);
+ when(employeeSignatureRepo.countByUserIDAndSignatureNotNull(3118L)).thenReturn(0L);
+
+ assertTrue(signatureService.existSignature(3117L));
+ assertFalse(signatureService.existSignature(3118L));
+ }
+
+ @Test
+ @DisplayName("isSignatureActive should report whether the signature is still in use")
+ void isActive_shouldReportWhetherSignatureIsInUse() {
+ when(employeeSignatureRepo.countByUserIDAndSignatureNotNullAndDeletedFalse(3117L)).thenReturn(1L);
+ when(employeeSignatureRepo.countByUserIDAndSignatureNotNullAndDeletedFalse(3118L)).thenReturn(0L);
+
+ assertTrue(signatureService.isSignatureActive(3117L));
+ assertFalse(signatureService.isSignatureActive(3118L));
+ }
+
+ @Test
+ @DisplayName("updateUserSignatureStatus should retire a signature the caller deactivates")
+ void updateStatus_shouldRetireDeactivatedSignature() {
+ EmployeeSignature stored = new EmployeeSignature();
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(stored);
+ when(employeeSignatureRepo.save(stored)).thenReturn(stored);
+
+ signatureService.updateUserSignatureStatus("{\"userID\":3117,\"active\":false}");
+
+ assertTrue(stored.getDeleted());
+ }
+
+ @Test
+ @DisplayName("updateUserSignatureStatus should reinstate a signature the caller activates")
+ void updateStatus_shouldReinstateActivatedSignature() {
+ EmployeeSignature stored = new EmployeeSignature();
+ stored.setDeleted(Boolean.TRUE);
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(stored);
+ when(employeeSignatureRepo.save(stored)).thenReturn(stored);
+
+ signatureService.updateUserSignatureStatus("{\"userID\":3117,\"active\":true}");
+
+ assertFalse(stored.getDeleted());
+ }
+
+ @Test
+ @DisplayName("updateUserSignatureStatus should refuse a user who has no signature on file")
+ void updateStatus_shouldRefuseUserWithoutSignature() {
+ when(employeeSignatureRepo.findOneByUserID(3117L)).thenReturn(null);
+
+ IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
+ () -> signatureService.updateUserSignatureStatus("{\"userID\":3117,\"active\":true}"));
+
+ assertTrue(thrown.getMessage().contains("No signature found"), thrown.getMessage());
+ }
+ }
+
+ @Nested
+ @DisplayName("USRAgentMappingServiceImpl")
+ class UsrAgentMappingTests {
+
+ private USRAgentMappingServiceImpl agentService() {
+ USRAgentMappingServiceImpl service = new USRAgentMappingServiceImpl();
+ service.setUsrAgentMappingRepository(usrAgentMappingRepository);
+ return service;
+ }
+
+ private Set agentRow() {
+ Set rows = new LinkedHashSet<>();
+ rows.add(new Object[] { 1, 9001, null, 4001, null, "A-1", "secret", "104", Boolean.TRUE });
+ rows.add(new Object[] { 2 });
+ return rows;
+ }
+
+ @Test
+ @DisplayName("getAvailableAgentIds should rebuild the free agents and skip an unusable row")
+ void getAvailableAgentIds_shouldRebuildFreeAgents() throws Exception {
+ when(usrAgentMappingRepository.getFreeAgentIds("104", 4001)).thenReturn(agentRow());
+
+ List agents = agentService()
+ .getAvailableAgentIds("{\"cti_CampaignName\":\"104\",\"providerServiceMapID\":4001}");
+
+ assertEquals(1, agents.size());
+ assertEquals("A-1", agents.get(0).getAgentID());
+ }
+
+ @Test
+ @DisplayName("updateAgentIds should free the previous agent id before claiming the new one")
+ void updateAgentIds_shouldFreePreviousAgentId() throws Exception {
+ when(usrAgentMappingRepository.updateUSRMapping(any(), any(), any())).thenReturn(1);
+
+ Integer changed = agentService().updateAgentIds("{\"oldAgentID\":\"A-0\","
+ + "\"providerServiceMapID\":4001,\"isAvailable\":false,\"usrMappingID\":9001,"
+ + "\"usrAgentMappingID\":1}");
+
+ assertEquals(1, changed);
+ verify(usrAgentMappingRepository).updateUSRMapping(true, null, "A-0", 4001);
+ }
+
+ @Test
+ @DisplayName("updateAgentIds should leave the previous agent id alone when none is named")
+ void updateAgentIds_shouldLeavePreviousAgentIdAlone() throws Exception {
+ when(usrAgentMappingRepository.updateUSRMapping(any(), any(), any())).thenReturn(1);
+
+ agentService().updateAgentIds("{\"isAvailable\":true,\"usrAgentMappingID\":1}");
+
+ verify(usrAgentMappingRepository, never())
+ .updateUSRMapping(any(Boolean.class), any(), anyString(), anyInt());
+ }
+
+ @Test
+ @DisplayName("createUSRAgentMapping should skip an agent id the provider already holds")
+ void createUSRAgentMapping_shouldSkipExistingAgent() throws Exception {
+ when(usrAgentMappingRepository.getExistingAgent(4001, "A-1")).thenReturn(1L);
+ when(usrAgentMappingRepository.getExistingAgent(4001, "A-2")).thenReturn(0L);
+ when(usrAgentMappingRepository.save(any())).thenAnswer(call -> call.getArgument(0));
+
+ List created = agentService().createUSRAgentMapping(
+ "[{\"agentID\":\"A-1\",\"providerServiceMapID\":4001},"
+ + "{\"agentID\":\"A-2\",\"providerServiceMapID\":4001}]");
+
+ assertEquals(1, created.size());
+ assertEquals("A-2", created.get(0).getAgentID());
+ }
+
+ @Test
+ @DisplayName("getAvailableCampaigns should hand back what the repository holds")
+ void getAvailableCampaigns_shouldHandBackRepositoryContents() throws Exception {
+ when(usrAgentMappingRepository.getAvailableCampaigns(4001)).thenReturn(List.of("104", "1097"));
+
+ assertEquals(2, agentService().getAvailableCampaigns("{\"providerServiceMapID\":4001}").size());
+ }
+
+ @Test
+ @DisplayName("getAllAgentIds should look the agent up directly when the caller names one")
+ void getAllAgentIds_shouldLookUpNamedAgent() throws Exception {
+ when(usrAgentMappingRepository
+ .getUSRAgentMappingByAgentIDAndProviderServiceMapID("A-1", 4001)).thenReturn(agentRow());
+
+ List agents = agentService()
+ .getAllAgentIds("{\"agentID\":\"A-1\",\"providerServiceMapID\":4001}");
+
+ assertEquals(1, agents.size());
+ }
+
+ @Test
+ @DisplayName("getAllAgentIds should filter by availability when the caller asks for it")
+ void getAllAgentIds_shouldFilterByAvailability() throws Exception {
+ when(usrAgentMappingRepository.getAllAgentIds(4001, "104", true)).thenReturn(agentRow());
+
+ assertEquals(1, agentService().getAllAgentIds(
+ "{\"providerServiceMapID\":4001,\"cti_CampaignName\":\"104\",\"isAvailable\":true}").size());
+ }
+
+ @Test
+ @DisplayName("getAllAgentIds should filter by campaign alone when availability is not named")
+ void getAllAgentIds_shouldFilterByCampaignAlone() throws Exception {
+ when(usrAgentMappingRepository.getAllAgentId(4001, "104")).thenReturn(agentRow());
+
+ assertEquals(1, agentService()
+ .getAllAgentIds("{\"providerServiceMapID\":4001,\"cti_CampaignName\":\"104\"}").size());
+ }
+
+ @Test
+ @DisplayName("getAllAgentIds should answer every agent under the mapping when nothing is named")
+ void getAllAgentIds_shouldAnswerEveryAgent() throws Exception {
+ when(usrAgentMappingRepository.getAllAgentIds(4001)).thenReturn(agentRow());
+
+ assertEquals(1, agentService().getAllAgentIds("{\"providerServiceMapID\":4001}").size());
+ }
+
+ @Test
+ @DisplayName("updateCTICampaignNameMapping should answer how many mappings moved campaign")
+ void updateCTICampaignNameMapping_shouldAnswerChangedCount() throws Exception {
+ when(usrAgentMappingRepository.updateCTICampaignNameMapping("1097", 1)).thenReturn(1);
+
+ assertEquals(1, agentService()
+ .updateCTICampaignNameMapping("{\"cti_CampaignName\":\"1097\",\"usrAgentMappingID\":1}"));
+ }
+
+ @Test
+ @DisplayName("updateDeletedAgentIDStatus should free the agent id of a deleted user")
+ void updateDeletedAgentIDStatus_shouldFreeAgentId() {
+ when(usrAgentMappingRepository.updateDeletedAgentIDStatus("A-1")).thenReturn(1);
+
+ agentService().updateDeletedAgentIDStatus("A-1");
+
+ verify(usrAgentMappingRepository).updateDeletedAgentIDStatus("A-1");
+ }
+ }
+
+ @Nested
+ @DisplayName("M_DesignationImpl")
+ class DesignationServiceTests {
+
+ @Test
+ @DisplayName("getDesinationlist should hand back what the repository holds")
+ void getDesinationlist_shouldHandBackRepositoryContents() {
+ ArrayList stored = new ArrayList<>(List.of(new M_Designation()));
+ when(m_DesignationRepo.getDesinationlist()).thenReturn(stored);
+
+ assertSame(stored, designationService.getDesinationlist());
+ }
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/facilitytype/M_facilitytypeServiceImplTest.java b/src/test/java/com/iemr/admin/service/facilitytype/M_facilitytypeServiceImplTest.java
new file mode 100644
index 0000000..8551a78
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/facilitytype/M_facilitytypeServiceImplTest.java
@@ -0,0 +1,196 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.facilitytype;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.facilitytype.M_facilitytype;
+import com.iemr.admin.data.store.M_FacilityLevel;
+import com.iemr.admin.repository.facilitytype.M_FacilityLevelRepo;
+import com.iemr.admin.repository.facilitytype.M_facilitytypeRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The facility type service keeps the kinds of health facility a state runs,
+ * refusing a type name a state already has.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("M_facilitytypeServiceImpl Test Suite")
+class M_facilitytypeServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer STATE_ID = 29;
+ private static final Integer FACILITY_TYPE_ID = 12;
+
+ @Mock
+ private M_facilitytypeRepo m_facilitytypeRepo;
+
+ @Mock
+ private M_FacilityLevelRepo m_facilityLevelRepo;
+
+ @InjectMocks
+ private M_facilitytypeServiceImpl service;
+
+ private static M_facilitytype facilityType() {
+ M_facilitytype facilityType = new M_facilitytype();
+ facilityType.setFacilityTypeID(FACILITY_TYPE_ID);
+ facilityType.setFacilityTypeName("Primary Health Centre");
+ facilityType.setFacilityTypeCode("PHC");
+ facilityType.setProviderServiceMapID(PSM_ID);
+ facilityType.setStateID(STATE_ID);
+ return facilityType;
+ }
+
+ @Test
+ @DisplayName("getAllFicilityData should answer the facility types of the provider asked about")
+ void getAll_shouldAnswerProvidersFacilityTypes() {
+ ArrayList held = new ArrayList<>(List.of(facilityType()));
+ when(m_facilitytypeRepo.getAllFicilityData(PSM_ID)).thenReturn(held);
+
+ assertSame(held, service.getAllFicilityData(PSM_ID));
+ }
+
+ @Test
+ @DisplayName("getFacilityTypesByRuralUrban should narrow the types to the setting asked for")
+ void getByRuralUrban_shouldNarrowToSetting() {
+ when(m_facilitytypeRepo.findByProviderServiceMapIDAndRuralUrban(PSM_ID, "Rural"))
+ .thenReturn(List.of(facilityType()));
+
+ assertEquals(1, service.getFacilityTypesByRuralUrban(PSM_ID, "Rural").size());
+ }
+
+ @Test
+ @DisplayName("addAllFicilityData should store a facility type the state does not have yet")
+ void add_shouldStoreNewFacilityType() {
+ ArrayList stored = new ArrayList<>(List.of(facilityType()));
+ when(m_facilitytypeRepo.existsByFacilityTypeNameAndStateIDAndDeletedFalse(anyString(), anyInt()))
+ .thenReturn(false);
+ when(m_facilitytypeRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.addAllFicilityData(List.of(facilityType())));
+ }
+
+ @Test
+ @DisplayName("addAllFicilityData should refuse a facility type name the state already has")
+ void add_shouldRefuseDuplicateName() {
+ when(m_facilitytypeRepo.existsByFacilityTypeNameAndStateIDAndDeletedFalse("Primary Health Centre",
+ STATE_ID)).thenReturn(true);
+
+ RuntimeException refusal = assertThrows(RuntimeException.class,
+ () -> service.addAllFicilityData(List.of(facilityType())));
+
+ assertTrue(refusal.getMessage().contains("Primary Health Centre"), refusal.getMessage());
+ verify(m_facilitytypeRepo, never()).saveAll(anyList());
+ }
+
+ @Test
+ @DisplayName("editAllFicilityData and updateFacilityData should each reach their own repository query")
+ void singleRecordOperations_shouldReachTheirOwnQuery() {
+ M_facilitytype stored = facilityType();
+ when(m_facilitytypeRepo.findByFacilityTypeID(FACILITY_TYPE_ID)).thenReturn(stored);
+ when(m_facilitytypeRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.editAllFicilityData(FACILITY_TYPE_ID));
+ assertSame(stored, service.updateFacilityData(stored));
+ }
+
+ @Test
+ @DisplayName("editAllFicilityData should answer nothing when the facility type is unknown")
+ void edit_shouldAnswerNothingForUnknownFacilityType() {
+ when(m_facilitytypeRepo.findByFacilityTypeID(-1)).thenReturn(null);
+
+ assertNull(service.editAllFicilityData(-1));
+ }
+
+ @Test
+ @DisplayName("checkFacilityTypeCode should report whether the provider already uses the code")
+ void checkCode_shouldReportWhetherCodeIsUsed() {
+ when(m_facilitytypeRepo.findByFacilityTypeCodeAndProviderServiceMapID("PHC", PSM_ID))
+ .thenReturn(List.of(facilityType()));
+ assertTrue(service.checkFacilityTypeCode(facilityType()));
+
+ when(m_facilitytypeRepo.findByFacilityTypeCodeAndProviderServiceMapID("PHC", PSM_ID))
+ .thenReturn(new ArrayList<>());
+ assertFalse(service.checkFacilityTypeCode(facilityType()));
+ }
+
+ @Test
+ @DisplayName("getFacilityLevels should answer the levels still in use, named in order")
+ void getLevels_shouldAnswerLiveLevels() {
+ ArrayList levels = new ArrayList<>(List.of(new M_FacilityLevel()));
+ when(m_facilityLevelRepo.findByDeletedFalseOrderByLevelName()).thenReturn(levels);
+
+ assertSame(levels, service.getFacilityLevels());
+ }
+
+ @Test
+ @DisplayName("getFacilityTypesByBlock should answer the types run in the taluk asked about")
+ void getByBlock_shouldAnswerTypesOfTaluk() {
+ when(m_facilitytypeRepo.findFacilityTypesByBlock(3011)).thenReturn(List.of(facilityType()));
+
+ assertEquals(1, service.getFacilityTypesByBlock(3011).size());
+ }
+
+ @Test
+ @DisplayName("getFacilityTypesByState should answer the types run in the state asked about")
+ void getByState_shouldAnswerTypesOfState() {
+ when(m_facilitytypeRepo.findByStateID(STATE_ID)).thenReturn(List.of(facilityType()));
+
+ assertEquals(1, service.getFacilityTypesByState(STATE_ID).size());
+ }
+
+ @Test
+ @DisplayName("checkFacilityTypeNameExists should report whether the state already has the name")
+ void checkName_shouldReportWhetherNameIsUsed() {
+ when(m_facilitytypeRepo.existsByFacilityTypeNameAndStateIDAndDeletedFalse("Primary Health Centre",
+ STATE_ID)).thenReturn(true);
+ assertTrue(service.checkFacilityTypeNameExists("Primary Health Centre", STATE_ID));
+
+ when(m_facilitytypeRepo.existsByFacilityTypeNameAndStateIDAndDeletedFalse("Sub Centre", STATE_ID))
+ .thenReturn(false);
+ assertFalse(service.checkFacilityTypeNameExists("Sub Centre", STATE_ID));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/foetalmonitormaster/FoetalMonitorServiceImplTest.java b/src/test/java/com/iemr/admin/service/foetalmonitormaster/FoetalMonitorServiceImplTest.java
new file mode 100644
index 0000000..6731490
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/foetalmonitormaster/FoetalMonitorServiceImplTest.java
@@ -0,0 +1,420 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.foetalmonitormaster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.foetalmonitormaster.FoetalMonitorDeviceID;
+import com.iemr.admin.data.foetalmonitormaster.M_FoetalMonitor;
+import com.iemr.admin.repo.foetalmonitormaster.FoetalMonitorDeviceIDRepo;
+import com.iemr.admin.repo.foetalmonitormaster.FoetalMonitorRepository;
+import com.iemr.admin.repository.vanMaster.VanMasterRepository;
+import com.iemr.admin.utils.exception.IEMRException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * A fetosense device is attached to one van at a time, so the mapping rules here
+ * decide whether a foetal monitor reading can be traced back to the van it was
+ * taken in.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("FoetalMonitorServiceImpl Test Suite")
+class FoetalMonitorServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer VAN_ID = 71;
+ private static final Long VFD_ID = 9001L;
+
+ @Mock
+ private FoetalMonitorRepository foetalMonitorRepository;
+
+ @Mock
+ private VanMasterRepository masterVanRepo;
+
+ @Mock
+ private FoetalMonitorDeviceIDRepo foetalMonitorDeviceIDRepo;
+
+ @InjectMocks
+ private FoetalMonitorServiceImpl service;
+
+ private static M_FoetalMonitor test(Integer id, String name) {
+ M_FoetalMonitor test = new M_FoetalMonitor();
+ test.setFoetalMonitorTestID(id);
+ test.setTestName(name);
+ return test;
+ }
+
+ private static FoetalMonitorDeviceID device() {
+ FoetalMonitorDeviceID device = new FoetalMonitorDeviceID();
+ device.setVfdID(VFD_ID);
+ device.setDeviceID("FS-1");
+ device.setDeviceName("Fetosense 1");
+ device.setVanID(VAN_ID);
+ device.setVanTypeID(1);
+ device.setParkingPlaceID(31);
+ device.setVanName("MMU Van 1");
+ device.setProviderServiceMapID(PSM_ID);
+ device.setCreatedBy("admin");
+ device.setDeactivated(Boolean.FALSE);
+ device.setDeleted(Boolean.FALSE);
+ return device;
+ }
+
+ @Test
+ @DisplayName("createFoetalMonitorTestMaster should publish the tests it stored")
+ void createTestMaster_shouldPublishStoredTests() throws Exception {
+ when(foetalMonitorRepository.saveAll(anyList())).thenReturn(List.of(test(11, "Non stress test")));
+
+ String created = service.createFoetalMonitorTestMaster("[{\"testName\":\"Non stress test\"}]");
+
+ assertTrue(created.contains("Non stress test"), created);
+ }
+
+ @Test
+ @DisplayName("createFoetalMonitorTestMaster should answer nothing when it stored fewer than it was given")
+ void createTestMaster_shouldAnswerNothingOnPartialStore() throws Exception {
+ when(foetalMonitorRepository.saveAll(anyList())).thenReturn(new ArrayList());
+
+ assertNull(service.createFoetalMonitorTestMaster("[{\"testName\":\"Non stress test\"}]"));
+ }
+
+ @Test
+ @DisplayName("getFoetalMonitorTestMaster should publish the tests of the provider")
+ void getTestMaster_shouldPublishProviderTests() {
+ when(foetalMonitorRepository.getByProviderServiceMapID(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(test(11, "Non stress test"))));
+
+ assertTrue(service.getFoetalMonitorTestMaster(PSM_ID).contains("Non stress test"));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorTestMaster should publish the test once the edit lands")
+ void updateTestMaster_shouldPublishEditedTest() {
+ when(foetalMonitorRepository.updateFoetalMonitorDetails(11, "Non stress test", null, "admin")).thenReturn(1);
+ when(foetalMonitorRepository.getByFoetalMonitorTestID(11)).thenReturn(test(11, "Non stress test"));
+
+ String published = service.updateFoetalMonitorTestMaster(
+ "{\"foetalMonitorTestID\":11,\"testName\":\"Non stress test\",\"modifiedBy\":\"admin\"}");
+
+ assertTrue(published.contains("Non stress test"), published);
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorTestMaster should answer nothing for a request that names no test")
+ void updateTestMaster_shouldAnswerNothingWithoutTest() {
+ assertNull(service.updateFoetalMonitorTestMaster("{\"testName\":\"Non stress test\"}"));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorTestMaster should answer nothing when the edit changed nothing")
+ void updateTestMaster_shouldAnswerNothingWhenNothingChanged() {
+ when(foetalMonitorRepository.updateFoetalMonitorDetails(anyInt(), any(), any(), any())).thenReturn(0);
+
+ assertNull(service.updateFoetalMonitorTestMaster("{\"foetalMonitorTestID\":11}"));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorTestMasterStatus should publish the test once its status has changed")
+ void updateTestStatus_shouldPublishChangedTest() throws Exception {
+ when(foetalMonitorRepository.updateFoetalMonitorStatus(11, true)).thenReturn(1);
+ when(foetalMonitorRepository.getByFoetalMonitorTestID(11)).thenReturn(test(11, "Non stress test"));
+
+ assertTrue(service.updateFoetalMonitorTestMasterStatus(11, true).contains("Non stress test"));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorTestMasterStatus should answer nothing when no test changed")
+ void updateTestStatus_shouldAnswerNothingWhenNothingChanged() throws Exception {
+ when(foetalMonitorRepository.updateFoetalMonitorStatus(11, true)).thenReturn(0);
+
+ assertNull(service.updateFoetalMonitorTestMasterStatus(11, true));
+ }
+
+ @Test
+ @DisplayName("saveFoetalMonitorDeviceID should report the devices it stored")
+ void saveDeviceID_shouldReportStoredDevices() throws Exception {
+ when(foetalMonitorDeviceIDRepo.saveAll(anyList()))
+ .thenReturn(new ArrayList<>(List.of(device())));
+
+ assertEquals(1, service.saveFoetalMonitorDeviceID(new ArrayList<>(List.of(device()))));
+ }
+
+ @Test
+ @DisplayName("saveFoetalMonitorDeviceID should refuse a run that stored nothing")
+ void saveDeviceID_shouldRefuseEmptyStore() {
+ when(foetalMonitorDeviceIDRepo.saveAll(anyList())).thenReturn(new ArrayList());
+
+ assertThrows(IEMRException.class,
+ () -> service.saveFoetalMonitorDeviceID(new ArrayList<>(List.of(device()))));
+ }
+
+ @Test
+ @DisplayName("getFoetalMonitorDeviceID should publish the devices of the provider")
+ void getDeviceID_shouldPublishProviderDevices() throws Exception {
+ when(foetalMonitorDeviceIDRepo.getFoetalMonitorDeviceID(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(device())));
+
+ String published = service.getFoetalMonitorDeviceID(device());
+
+ assertTrue(published.contains("fetosenseDeviceIDs"), published);
+ assertTrue(published.contains("FS-1"), published);
+ }
+
+ @Test
+ @DisplayName("getFoetalMonitorDeviceID should report a lookup it could not run")
+ void getDeviceID_shouldReportFailedLookup() {
+ when(foetalMonitorDeviceIDRepo.getFoetalMonitorDeviceID(anyInt()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertThrows(IEMRException.class, () -> service.getFoetalMonitorDeviceID(device()));
+ }
+
+ @Test
+ @DisplayName("deleteFoetalMonitorDeviceID should release the van the device was attached to")
+ void deleteDeviceID_shouldReleaseVan() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ when(foetalMonitorDeviceIDRepo.save(request)).thenReturn(request);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(true, VAN_ID)).thenReturn(1);
+
+ assertEquals(1, service.deleteFoetalMonitorDeviceID(request));
+ verify(masterVanRepo).updateVanFoetalMonitorsmapping(true, VAN_ID);
+ }
+
+ @Test
+ @DisplayName("deleteFoetalMonitorDeviceID should mark the van unmapped when the device is retired")
+ void deleteDeviceID_shouldMarkVanUnmappedOnRetirement() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ request.setDeleted(Boolean.TRUE);
+ when(foetalMonitorDeviceIDRepo.save(request)).thenReturn(request);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(false, VAN_ID)).thenReturn(1);
+
+ assertEquals(1, service.deleteFoetalMonitorDeviceID(request));
+ verify(masterVanRepo).updateVanFoetalMonitorsmapping(false, VAN_ID);
+ }
+
+ @Test
+ @DisplayName("deleteFoetalMonitorDeviceID should refuse a device whose van could not be released")
+ void deleteDeviceID_shouldRefuseWhenVanCannotBeReleased() {
+ FoetalMonitorDeviceID request = device();
+ when(foetalMonitorDeviceIDRepo.save(request)).thenReturn(request);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(anyBoolean(), anyInt())).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.deleteFoetalMonitorDeviceID(request));
+ }
+
+ @Test
+ @DisplayName("deleteFoetalMonitorDeviceID should leave the vans alone for a device attached to none")
+ void deleteDeviceID_shouldLeaveVansAloneForUnattachedDevice() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ request.setVanID(null);
+ when(foetalMonitorDeviceIDRepo.save(request)).thenReturn(request);
+
+ assertEquals(1, service.deleteFoetalMonitorDeviceID(request));
+ verify(masterVanRepo, never()).updateVanFoetalMonitorsmapping(anyBoolean(), anyInt());
+ }
+
+ @Test
+ @DisplayName("getvanIDAndFoetalMonitorDeviceID should publish the vans and devices still free to pair")
+ void getVanAndDevice_shouldPublishFreePairs() throws Exception {
+ ArrayList vanRows = new ArrayList<>();
+ vanRows.add(new Object[] { VAN_ID, "MMU Van 1", "KA-01-AB-1234" });
+ when(masterVanRepo.getVanIDNotMappedWithDevice(1, 31, PSM_ID)).thenReturn(vanRows);
+ when(foetalMonitorDeviceIDRepo.getFoetalMonitorDeviceIDNotMapped(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(device())));
+
+ String published = service.getvanIDAndFoetalMonitorDeviceID(device());
+
+ assertTrue(published.contains("VanIDs"), published);
+ assertTrue(published.contains("MMU Van 1"), published);
+ assertTrue(published.contains("deviceIDs"), published);
+ }
+
+ @Test
+ @DisplayName("getvanIDAndFoetalMonitorDeviceID should report a lookup it could not run")
+ void getVanAndDevice_shouldReportFailedLookup() {
+ when(masterVanRepo.getVanIDNotMappedWithDevice(any(), any(), any()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertThrows(IEMRException.class, () -> service.getvanIDAndFoetalMonitorDeviceID(device()));
+ }
+
+ @Test
+ @DisplayName("vanIDAndDeviceIDMapping should attach the device and mark the van as carrying one")
+ void mapping_shouldAttachDeviceAndMarkVan() throws Exception {
+ when(foetalMonitorDeviceIDRepo.createMappingOfVanIDAndDeviceID(anyInt(), anyInt(), anyInt(), anyString(),
+ anyString(), anyString())).thenReturn(1);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(true, VAN_ID)).thenReturn(1);
+
+ assertEquals(1, service.vanIDAndDeviceIDMapping(device()));
+ }
+
+ @Test
+ @DisplayName("vanIDAndDeviceIDMapping should refuse a pairing the van could not be marked for")
+ void mapping_shouldRefuseWhenVanCannotBeMarked() {
+ when(foetalMonitorDeviceIDRepo.createMappingOfVanIDAndDeviceID(anyInt(), anyInt(), anyInt(), anyString(),
+ anyString(), anyString())).thenReturn(1);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(anyBoolean(), anyInt())).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.vanIDAndDeviceIDMapping(device()));
+ }
+
+ @Test
+ @DisplayName("vanIDAndDeviceIDMapping should refuse a pairing the device could not take")
+ void mapping_shouldRefuseWhenDeviceCannotTakePairing() {
+ when(foetalMonitorDeviceIDRepo.createMappingOfVanIDAndDeviceID(anyInt(), anyInt(), anyInt(), anyString(),
+ anyString(), anyString())).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.vanIDAndDeviceIDMapping(device()));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorDeviceID should report the device it saved")
+ void updateDeviceID_shouldReportSavedDevice() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ when(foetalMonitorDeviceIDRepo.save(request)).thenReturn(request);
+
+ assertEquals(1, service.updateFoetalMonitorDeviceID(request));
+ }
+
+ @Test
+ @DisplayName("updateFoetalMonitorDeviceID should refuse an edit the store did not take")
+ void updateDeviceID_shouldRefuseUntakenEdit() {
+ when(foetalMonitorDeviceIDRepo.save(any())).thenReturn(null);
+
+ assertThrows(IEMRException.class, () -> service.updateFoetalMonitorDeviceID(device()));
+ }
+
+ @Test
+ @DisplayName("getVanIDMappingWorklist should publish the pairings on record")
+ void getWorklist_shouldPublishPairings() throws Exception {
+ when(foetalMonitorDeviceIDRepo.getMappedWorklist(1, 31, PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(device())));
+
+ assertTrue(service.getVanIDMappingWorklist(device()).contains("FS-1"));
+ }
+
+ @Test
+ @DisplayName("getVanIDMappingWorklist should report a lookup it could not run")
+ void getWorklist_shouldReportFailedLookup() {
+ when(foetalMonitorDeviceIDRepo.getMappedWorklist(any(), any(), any()))
+ .thenThrow(new IllegalStateException("no connection"));
+
+ assertThrows(IEMRException.class, () -> service.getVanIDMappingWorklist(device()));
+ }
+
+ @Test
+ @DisplayName("updatingvanIDAndDeviceIDMapping should clear the old van before attaching the new one")
+ void updateMapping_shouldClearOldVanFirst() throws Exception {
+ when(foetalMonitorDeviceIDRepo.updateVanDetailsToNull(VFD_ID)).thenReturn(1);
+ when(foetalMonitorDeviceIDRepo.createMappingOfVanIDAndDeviceID(anyInt(), anyInt(), anyInt(), anyString(),
+ any(), anyString())).thenReturn(1);
+
+ assertEquals(1, service.updatingvanIDAndDeviceIDMapping(device()));
+ verify(foetalMonitorDeviceIDRepo).updateVanDetailsToNull(VFD_ID);
+ }
+
+ @Test
+ @DisplayName("updatingvanIDAndDeviceIDMapping should refuse an edit whose old van could not be cleared")
+ void updateMapping_shouldRefuseWhenOldVanCannotBeCleared() {
+ when(foetalMonitorDeviceIDRepo.updateVanDetailsToNull(VFD_ID)).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.updatingvanIDAndDeviceIDMapping(device()));
+ }
+
+ @Test
+ @DisplayName("updatingvanIDAndDeviceIDMapping should refuse an edit the new van could not take")
+ void updateMapping_shouldRefuseWhenNewVanCannotTake() {
+ when(foetalMonitorDeviceIDRepo.updateVanDetailsToNull(VFD_ID)).thenReturn(1);
+ when(foetalMonitorDeviceIDRepo.createMappingOfVanIDAndDeviceID(anyInt(), anyInt(), anyInt(), anyString(),
+ any(), anyString())).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.updatingvanIDAndDeviceIDMapping(device()));
+ }
+
+ @Test
+ @DisplayName("deleteVanIDAndDeviceIDMapping should release the pairing and free the van")
+ void deleteMapping_shouldReleasePairingAndFreeVan() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ request.setDeactivated(Boolean.TRUE);
+ when(foetalMonitorDeviceIDRepo.deleteMapping(true, VFD_ID)).thenReturn(1);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(false, VAN_ID)).thenReturn(1);
+
+ assertEquals(1, service.deleteVanIDAndDeviceIDMapping(request));
+ }
+
+ @Test
+ @DisplayName("deleteVanIDAndDeviceIDMapping should refuse to reinstate a van another device already holds")
+ void deleteMapping_shouldRefuseVanHeldByAnotherDevice() {
+ FoetalMonitorDeviceID request = device();
+ request.setDeactivated(Boolean.FALSE);
+ when(foetalMonitorDeviceIDRepo.getMappedVanDetails(VAN_ID)).thenReturn(1);
+
+ IEMRException thrown = assertThrows(IEMRException.class,
+ () -> service.deleteVanIDAndDeviceIDMapping(request));
+ assertTrue(thrown.getMessage().contains("already mapped with a device"), thrown.getMessage());
+ }
+
+ @Test
+ @DisplayName("deleteVanIDAndDeviceIDMapping should reinstate a pairing for a van that is free")
+ void deleteMapping_shouldReinstatePairingForFreeVan() throws Exception {
+ FoetalMonitorDeviceID request = device();
+ request.setDeactivated(Boolean.FALSE);
+ when(foetalMonitorDeviceIDRepo.getMappedVanDetails(VAN_ID)).thenReturn(0);
+ when(foetalMonitorDeviceIDRepo.deleteMapping(false, VFD_ID)).thenReturn(1);
+ when(masterVanRepo.updateVanFoetalMonitorsmapping(true, VAN_ID)).thenReturn(1);
+
+ assertEquals(1, service.deleteVanIDAndDeviceIDMapping(request));
+ }
+
+ @Test
+ @DisplayName("deleteVanIDAndDeviceIDMapping should refuse a pairing the store would not change")
+ void deleteMapping_shouldRefuseUnchangedPairing() {
+ FoetalMonitorDeviceID request = device();
+ request.setDeactivated(Boolean.TRUE);
+ when(foetalMonitorDeviceIDRepo.deleteMapping(anyBoolean(), any())).thenReturn(0);
+
+ assertThrows(IEMRException.class, () -> service.deleteVanIDAndDeviceIDMapping(request));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/health/HealthServiceTest.java b/src/test/java/com/iemr/admin/service/health/HealthServiceTest.java
new file mode 100644
index 0000000..b2e8176
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/health/HealthServiceTest.java
@@ -0,0 +1,472 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.health;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+
+import javax.sql.DataSource;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * The health endpoint is what the deployment's monitoring watches, so it has to
+ * tell a database that is merely slow apart from one that is unreachable.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("HealthService Test Suite")
+class HealthServiceTest {
+
+ @Mock
+ private DataSource dataSource;
+
+ @Mock
+ private RedisConnectionFactory redisConnectionFactory;
+
+ @Mock
+ private Connection connection;
+
+ @Mock
+ private Statement statement;
+
+ @Mock
+ private RedisConnection redisConnection;
+
+ @SuppressWarnings("unchecked")
+ private static ObjectProvider providerOf(T value) {
+ ObjectProvider provider = mock(ObjectProvider.class);
+ when(provider.getIfAvailable()).thenReturn(value);
+ return provider;
+ }
+
+ /**
+ * Builds the service without a data source so its constructor starts no background
+ * cycle, then attaches the stores under test. That keeps the diagnostics the tests
+ * drive from racing a scheduled cycle over the same mocks.
+ */
+ private HealthService serviceWith(DataSource ds, RedisConnectionFactory redis) {
+ HealthService service = new HealthService(providerOf(null), providerOf(redis));
+ ReflectionTestUtils.setField(service, "dataSource", ds);
+ ((AtomicLong) ReflectionTestUtils.getField(service, "lastDiagnosticRunAt")).set(0);
+ return service;
+ }
+
+ private void databaseAnswers() throws SQLException {
+ when(dataSource.getConnection()).thenReturn(connection);
+ when(connection.createStatement()).thenReturn(statement);
+ }
+
+ private void redisAnswers() {
+ when(redisConnectionFactory.getConnection()).thenReturn(redisConnection);
+ }
+
+ private static ResultSet countingResultSet(int count) throws SQLException {
+ ResultSet rs = mock(ResultSet.class);
+ when(rs.next()).thenReturn(true);
+ when(rs.getInt("cnt")).thenReturn(count);
+ return rs;
+ }
+
+ private static ResultSet statusResultSet(long value) throws SQLException {
+ ResultSet rs = mock(ResultSet.class);
+ when(rs.next()).thenReturn(true);
+ when(rs.getLong("Value")).thenReturn(value);
+ when(rs.getInt("Value")).thenReturn((int) value);
+ return rs;
+ }
+
+ @SuppressWarnings("unchecked")
+ private static String statusOf(Map health, String service) {
+ return (String) ((Map) health.get(service)).get("status");
+ }
+
+ @SuppressWarnings("unchecked")
+ private static String severityOf(Map health, String service) {
+ return (String) ((Map) health.get(service)).get("severity");
+ }
+
+ @Nested
+ @DisplayName("checkHealth")
+ class CheckHealthTests {
+
+ @Test
+ @DisplayName("should report the deployment up when both stores answer")
+ void checkHealth_shouldReportUpWhenBothStoresAnswer() throws Exception {
+ databaseAnswers();
+ redisAnswers();
+ HealthService service = serviceWith(dataSource, redisConnectionFactory);
+
+ Map health = service.checkHealth();
+
+ assertEquals("UP", health.get("status"));
+ assertEquals("UP", statusOf(health, "mysql"));
+ assertEquals("UP", statusOf(health, "redis"));
+ assertNotNull(health.get("checkedAt"));
+ }
+
+ @Test
+ @DisplayName("should report the deployment down when the database cannot be reached")
+ void checkHealth_shouldReportDownWhenDatabaseUnreachable() throws Exception {
+ when(dataSource.getConnection()).thenThrow(new SQLException("connection refused"));
+ redisAnswers();
+ HealthService service = serviceWith(dataSource, redisConnectionFactory);
+
+ Map health = service.checkHealth();
+
+ assertEquals("DOWN", health.get("status"));
+ assertEquals("DOWN", statusOf(health, "mysql"));
+ assertEquals("CRITICAL", severityOf(health, "mysql"));
+ }
+
+ @Test
+ @DisplayName("should report the deployment down when Redis cannot be reached")
+ void checkHealth_shouldReportDownWhenRedisUnreachable() throws Exception {
+ databaseAnswers();
+ when(redisConnectionFactory.getConnection())
+ .thenThrow(new IllegalStateException("connection refused"));
+ HealthService service = serviceWith(dataSource, redisConnectionFactory);
+
+ Map health = service.checkHealth();
+
+ assertEquals("DOWN", health.get("status"));
+ assertEquals("DOWN", statusOf(health, "redis"));
+ }
+
+ @Test
+ @DisplayName("should report a store that is not configured rather than call it down")
+ void checkHealth_shouldReportUnconfiguredStore() {
+ HealthService service = serviceWith(null, null);
+
+ Map health = service.checkHealth();
+
+ assertEquals("UP", health.get("status"),
+ "a deployment without these stores is not itself unhealthy");
+ assertEquals("NOT_CONFIGURED", statusOf(health, "mysql"));
+ assertEquals("INFO", severityOf(health, "mysql"));
+ assertEquals("NOT_CONFIGURED", statusOf(health, "redis"));
+ }
+
+ @Test
+ @DisplayName("should report a degraded database as still up but flagged")
+ void checkHealth_shouldReportDegradedDatabase() throws Exception {
+ databaseAnswers();
+ redisAnswers();
+ HealthService service = serviceWith(dataSource, redisConnectionFactory);
+ ReflectionTestUtils.invokeMethod(
+ ReflectionTestUtils.getField(service, "cachedDbSeverity"), "set", "WARNING");
+
+ Map health = service.checkHealth();
+
+ assertEquals("UP", health.get("status"), "a degraded database is still serving requests");
+ assertEquals("DEGRADED", statusOf(health, "mysql"));
+ }
+
+ @Test
+ @DisplayName("should report a critically degraded database as down")
+ void checkHealth_shouldReportCriticalDatabaseAsDown() throws Exception {
+ databaseAnswers();
+ redisAnswers();
+ HealthService service = serviceWith(dataSource, redisConnectionFactory);
+ ReflectionTestUtils.invokeMethod(
+ ReflectionTestUtils.getField(service, "cachedDbSeverity"), "set", "CRITICAL");
+
+ assertEquals("DOWN", service.checkHealth().get("status"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Background diagnostics")
+ class DiagnosticTests {
+
+ private HealthService diagnosingService() throws SQLException {
+ databaseAnswers();
+ return serviceWith(dataSource, redisConnectionFactory);
+ }
+
+ private String severityAfterDiagnostics(HealthService service) {
+ ((AtomicLong) ReflectionTestUtils.getField(service, "lastDiagnosticRunAt")).set(0);
+ ReflectionTestUtils.invokeMethod(service, "runAdvancedMySQLDiagnostics");
+ return (String) ReflectionTestUtils.invokeMethod(
+ ReflectionTestUtils.getField(service, "cachedDbSeverity"), "get");
+ }
+
+ private void everyCheckClean() throws SQLException {
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+ }
+
+ @Test
+ @DisplayName("should report a healthy database when every check is clean")
+ void diagnostics_shouldReportHealthyDatabase() throws Exception {
+ HealthService service = diagnosingService();
+ everyCheckClean();
+
+ assertEquals("OK", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should warn when more processes are stuck than the threshold allows")
+ void diagnostics_shouldWarnOnStuckProcesses() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("PROCESSLIST")) {
+ return countingResultSet(10);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("WARNING", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should stay healthy when a few processes are stuck but under the threshold")
+ void diagnostics_shouldStayHealthyUnderStuckThreshold() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("PROCESSLIST")) {
+ return countingResultSet(2);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("OK", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should escalate to critical when several transactions run long")
+ void diagnostics_shouldEscalateOnManyLongTransactions() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("INNODB_TRX")) {
+ return countingResultSet(6);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("CRITICAL", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should warn when a single transaction runs long")
+ void diagnostics_shouldWarnOnOneLongTransaction() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("INNODB_TRX")) {
+ return countingResultSet(2);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("WARNING", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should warn when new deadlocks have happened since the previous cycle")
+ void diagnostics_shouldWarnOnNewDeadlocks() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("Innodb_deadlocks")) {
+ return statusResultSet(3);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("WARNING", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should warn when new slow queries have been logged since the previous cycle")
+ void diagnostics_shouldWarnOnNewSlowQueries() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("Slow_queries")) {
+ return statusResultSet(7);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("WARNING", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should escalate to critical when the connection pool is nearly exhausted")
+ void diagnostics_shouldEscalateOnExhaustedPool() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("Threads_connected")) {
+ return statusResultSet(490);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("CRITICAL", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should warn when connection usage is high but not yet exhausted")
+ void diagnostics_shouldWarnOnHighConnectionUsage() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenAnswer(call -> {
+ String sql = call.getArgument(0);
+ if (sql.contains("Threads_connected")) {
+ return statusResultSet(450);
+ }
+ if (sql.contains("max_connections")) {
+ return statusResultSet(500);
+ }
+ if (sql.startsWith("SHOW")) {
+ return statusResultSet(0);
+ }
+ return countingResultSet(0);
+ });
+
+ assertEquals("WARNING", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should report critical when it cannot open a connection to diagnose at all")
+ void diagnostics_shouldReportCriticalWhenConnectionCannotBeOpened() throws Exception {
+ HealthService service = diagnosingService();
+ when(dataSource.getConnection()).thenThrow(new SQLException("connection refused"));
+
+ assertEquals("CRITICAL", severityAfterDiagnostics(service));
+ }
+
+ @Test
+ @DisplayName("should keep the previous verdict when a cycle is asked for too soon")
+ void diagnostics_shouldKeepPreviousVerdictWhenAskedTooSoon() throws Exception {
+ HealthService service = diagnosingService();
+ everyCheckClean();
+ severityAfterDiagnostics(service);
+ ReflectionTestUtils.invokeMethod(
+ ReflectionTestUtils.getField(service, "cachedDbSeverity"), "set", "WARNING");
+ ReflectionTestUtils.invokeMethod(service, "runAdvancedMySQLDiagnostics");
+
+ assertEquals("WARNING",
+ ReflectionTestUtils.invokeMethod(
+ ReflectionTestUtils.getField(service, "cachedDbSeverity"), "get"),
+ "a cycle inside the guard window must not overwrite the standing verdict");
+ }
+
+ @Test
+ @DisplayName("should survive a check whose query the database refuses")
+ void diagnostics_shouldSurviveRefusedQuery() throws Exception {
+ HealthService service = diagnosingService();
+ when(statement.executeQuery(anyString())).thenThrow(new SQLException("access denied"));
+
+ assertEquals("OK", severityAfterDiagnostics(service),
+ "a check that cannot run must not by itself condemn the database");
+ }
+ }
+
+ @Test
+ @DisplayName("shutdownDiagnostics should stop the background cycle")
+ void shutdownDiagnostics_shouldStopBackgroundCycle() throws Exception {
+ databaseAnswers();
+ HealthService service = new HealthService(providerOf(dataSource), providerOf(redisConnectionFactory));
+
+ service.shutdownDiagnostics();
+
+ java.util.concurrent.ExecutorService scheduler = (java.util.concurrent.ExecutorService)
+ ReflectionTestUtils.getField(service, "diagnosticScheduler");
+ assertEquals(true, scheduler.isShutdown());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/item/ItemServiceImplTest.java b/src/test/java/com/iemr/admin/service/item/ItemServiceImplTest.java
new file mode 100644
index 0000000..4fa9c95
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/item/ItemServiceImplTest.java
@@ -0,0 +1,284 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.item;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.items.CodeChecker;
+import com.iemr.admin.data.items.ItemMaster;
+import com.iemr.admin.data.items.M_ItemCategory;
+import com.iemr.admin.data.items.M_ItemForm;
+import com.iemr.admin.data.items.M_Route;
+import com.iemr.admin.repository.item.ItemCategoryRepo;
+import com.iemr.admin.repository.item.ItemFormRepo;
+import com.iemr.admin.repository.item.ItemRepo;
+import com.iemr.admin.repository.item.RouteRepo;
+import com.iemr.admin.repository.itemfacilitymapping.M_itemfacilitymappingRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The item service maintains the inventory catalogue and the codes that keep
+ * each entry unique within a provider.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ItemServiceImpl Test Suite")
+class ItemServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+
+ @Mock
+ private ItemRepo itemRepo;
+
+ @Mock
+ private ItemCategoryRepo itemCategoryRepo;
+
+ @Mock
+ private RouteRepo routeRepo;
+
+ @Mock
+ private ItemFormRepo itemFormRepo;
+
+ @Mock
+ private M_itemfacilitymappingRepo itemfacilitymappingRepo;
+
+ @InjectMocks
+ private ItemServiceImpl service;
+
+ private static M_ItemCategory category(Integer id) {
+ M_ItemCategory category = new M_ItemCategory();
+ category.setItemCategoryID(id);
+ return category;
+ }
+
+ @Test
+ @DisplayName("getItemCategory should read the whole catalogue when retired categories are wanted too")
+ void getItemCategory_shouldReadWholeCatalogue() {
+ List stored = List.of(category(31));
+ when(itemCategoryRepo.findByProviderServiceMapIDOrderByItemCategoryName(PSM_ID)).thenReturn(stored);
+
+ assertSame(stored, service.getItemCategory(true, PSM_ID));
+ }
+
+ @Test
+ @DisplayName("getItemCategory should read only the live categories when retired ones are excluded")
+ void getItemCategory_shouldReadLiveCategories() {
+ List stored = List.of(category(31));
+ when(itemCategoryRepo.findByDeletedAndProviderServiceMapIDOrderByItemCategoryName(false, PSM_ID))
+ .thenReturn(stored);
+
+ assertSame(stored, service.getItemCategory(false, PSM_ID));
+ }
+
+ @Test
+ @DisplayName("getItemCategory should answer nothing when the caller names no provider")
+ void getItemCategory_shouldAnswerNothingWithoutProvider() {
+ assertTrue(service.getItemCategory(true, null).isEmpty());
+ verify(itemCategoryRepo, never()).findByProviderServiceMapIDOrderByItemCategoryName(anyInt());
+ }
+
+ @Test
+ @DisplayName("the item lookups should each reach their own repository query")
+ void itemLookups_shouldReachTheirOwnQuery() {
+ ItemMaster item = new ItemMaster();
+ List items = List.of(item);
+ when(itemRepo.save(item)).thenReturn(item);
+ when(itemRepo.saveAll(anyList())).thenReturn(items);
+ when(itemRepo.findByProviderServiceMapIDOrderByItemName(PSM_ID)).thenReturn(items);
+ when(itemRepo.findByItemID(101)).thenReturn(item);
+ when(itemRepo.findDetailOne(101)).thenReturn(item);
+ when(itemRepo.getItemMasters(PSM_ID, 31)).thenReturn(items);
+ when(itemRepo.deleteItemMaster(101, true)).thenReturn(1);
+ when(itemRepo.discontinueItemMaster(101, true)).thenReturn(1);
+ when(itemCategoryRepo.findByItemCategoryID(31)).thenReturn(category(31));
+ when(routeRepo.getAll()).thenReturn(List.of(new M_Route()));
+ when(itemFormRepo.getAll()).thenReturn(List.of(new M_ItemForm()));
+
+ assertSame(item, service.createItemMaster(item));
+ assertSame(items, service.addAllItemMaster(new ArrayList<>()));
+ assertSame(items, service.getItemMaster(PSM_ID));
+ assertSame(item, service.getItemMasterByID(101));
+ assertSame(item, service.getItemMasterCatByID(101));
+ assertSame(items, service.getItemMasters(PSM_ID, 31));
+ assertEquals(1, service.blockItemMaster(101, true));
+ assertEquals(1, service.discontinueItemMaster(101, true));
+ assertEquals(31, service.getItemCategory(31).getItemCategoryID());
+ assertEquals(1, service.getItemRouteProviderServiceMapID(PSM_ID).size());
+ assertEquals(1, service.getItemFormProviderServiceMapID(PSM_ID).size());
+ }
+
+ @Test
+ @DisplayName("updateItemIssueConfig should count only the categories that name an issue type")
+ void updateItemIssueConfig_shouldCountOnlyComplete() {
+ M_ItemCategory complete = category(31);
+ complete.setIssueType("FIFO");
+ M_ItemCategory incomplete = category(32);
+ when(itemCategoryRepo.updateIssueConfig(31, "FIFO")).thenReturn(1);
+
+ assertEquals(1, service.updateItemIssueConfig(List.of(complete, incomplete)));
+ verify(itemCategoryRepo, never()).updateIssueConfig(32, null);
+ }
+
+ @Test
+ @DisplayName("updateExpiryAlert should count only the categories that name an alert window")
+ void updateExpiryAlert_shouldCountOnlyComplete() {
+ M_ItemCategory complete = category(31);
+ complete.setAlertBeforeDays(30);
+ M_ItemCategory incomplete = category(32);
+ when(itemCategoryRepo.updateExpiryAlert(31, 30)).thenReturn(1);
+
+ assertEquals(1, service.updateExpiryAlert(List.of(complete, incomplete)));
+ }
+
+ @Test
+ @DisplayName("createItemCategories should answer the id of the first category it stored")
+ void createItemCategories_shouldAnswerFirstStoredId() {
+ when(itemCategoryRepo.saveAll(anyList())).thenReturn(List.of(category(31)));
+
+ assertEquals(31, service.createItemCategories(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createItemCategories should answer zero when nothing was stored")
+ void createItemCategories_shouldAnswerZeroWhenNothingStored() {
+ when(itemCategoryRepo.saveAll(anyList())).thenReturn(new ArrayList<>());
+
+ assertEquals(0, service.createItemCategories(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createItemForms should answer the id of the first form it stored")
+ void createItemForms_shouldAnswerFirstStoredId() {
+ M_ItemForm form = new M_ItemForm();
+ form.setItemFormID(11);
+ when(itemFormRepo.saveAll(anyList())).thenReturn(List.of(form));
+
+ assertEquals(11, service.createItemForms(new ArrayList<>()));
+ when(itemFormRepo.saveAll(anyList())).thenReturn(new ArrayList<>());
+ assertEquals(0, service.createItemForms(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createRoutes should answer the id of the first route it stored")
+ void createRoutes_shouldAnswerFirstStoredId() {
+ M_Route route = new M_Route();
+ route.setRouteID(21);
+ when(routeRepo.saveAll(anyList())).thenReturn(List.of(route));
+
+ assertEquals(21, service.createRoutes(new ArrayList<>()));
+ when(routeRepo.saveAll(anyList())).thenReturn(new ArrayList<>());
+ assertEquals(0, service.createRoutes(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("the edit and block calls should each reach their own repository query")
+ void editAndBlockCalls_shouldReachTheirOwnQuery() {
+ M_ItemCategory cat = category(31);
+ cat.setItemCategoryDesc("Drugs");
+ cat.setModifiedBy("admin");
+ cat.setDeleted(Boolean.TRUE);
+ M_ItemForm form = new M_ItemForm();
+ form.setItemFormID(11);
+ form.setItemFormDesc("Tablet");
+ form.setModifiedBy("admin");
+ form.setDeleted(Boolean.TRUE);
+ M_Route route = new M_Route();
+ route.setRouteID(21);
+ route.setRouteDesc("Oral");
+ route.setModifiedBy("admin");
+ route.setDeleted(Boolean.TRUE);
+ when(itemCategoryRepo.updateItemCategoryDetails(31, "Drugs", "admin")).thenReturn(1);
+ when(itemCategoryRepo.blockItemCategory(31, Boolean.TRUE, "admin")).thenReturn(1);
+ when(itemFormRepo.updateItemFormDetails(11, "Tablet", "admin")).thenReturn(1);
+ when(itemFormRepo.blockItemForm(11, Boolean.TRUE, "admin")).thenReturn(1);
+ when(routeRepo.updateRouteDetails(21, "Oral", "admin")).thenReturn(1);
+ when(routeRepo.blockRoute(21, Boolean.TRUE, "admin")).thenReturn(1);
+
+ assertEquals(1, service.editItemCategory(cat));
+ assertEquals(1, service.blockItemCategory(cat));
+ assertEquals(1, service.editItemForm(form));
+ assertEquals(1, service.blockItemForm(form));
+ assertEquals(1, service.editRoute(route));
+ assertEquals(1, service.blockRoute(route));
+ }
+
+ @Test
+ @DisplayName("the code checks should report a code the provider already uses")
+ void codeChecks_shouldReportUsedCode() {
+ CodeChecker checker = new CodeChecker();
+ checker.setCode("CODE-1");
+ checker.setProviderServiceMapID(PSM_ID);
+ when(itemCategoryRepo.findByItemCategoryCodeAndProviderServiceMapID("CODE-1", PSM_ID))
+ .thenReturn(List.of(category(31)));
+ when(itemFormRepo.findByItemFormCodeAndProviderServiceMapID("CODE-1", PSM_ID))
+ .thenReturn(List.of(new M_ItemForm()));
+ when(itemRepo.findByItemCodeAndProviderServiceMapID("CODE-1", PSM_ID))
+ .thenReturn(List.of(new ItemMaster()));
+ when(routeRepo.findByRouteCodeAndProviderServiceMapID("CODE-1", PSM_ID))
+ .thenReturn(List.of(new M_Route()));
+
+ assertTrue(service.checkCodeCategory(checker));
+ assertTrue(service.checkCodeForm(checker));
+ assertTrue(service.checkCodeItem(checker));
+ assertTrue(service.checkCodeRoute(checker));
+ }
+
+ @Test
+ @DisplayName("the code checks should clear a code nobody uses yet")
+ void codeChecks_shouldClearFreeCode() {
+ CodeChecker checker = new CodeChecker();
+ checker.setCode("CODE-2");
+ checker.setProviderServiceMapID(PSM_ID);
+ when(itemCategoryRepo.findByItemCategoryCodeAndProviderServiceMapID("CODE-2", PSM_ID))
+ .thenReturn(new ArrayList<>());
+ when(itemFormRepo.findByItemFormCodeAndProviderServiceMapID("CODE-2", PSM_ID))
+ .thenReturn(new ArrayList<>());
+ when(itemRepo.findByItemCodeAndProviderServiceMapID("CODE-2", PSM_ID)).thenReturn(new ArrayList<>());
+ when(routeRepo.findByRouteCodeAndProviderServiceMapID("CODE-2", PSM_ID)).thenReturn(new ArrayList<>());
+
+ assertFalse(service.checkCodeCategory(checker));
+ assertFalse(service.checkCodeForm(checker));
+ assertFalse(service.checkCodeItem(checker));
+ assertFalse(service.checkCodeRoute(checker));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/itemfacilitymapping/M_itemfacilitymappingImplTest.java b/src/test/java/com/iemr/admin/service/itemfacilitymapping/M_itemfacilitymappingImplTest.java
new file mode 100644
index 0000000..6d8cbb5
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/itemfacilitymapping/M_itemfacilitymappingImplTest.java
@@ -0,0 +1,195 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.itemfacilitymapping;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.itemfacilitymapping.M_itemfacilitymapping;
+import com.iemr.admin.data.itemfacilitymapping.V_fetchItemFacilityMap;
+import com.iemr.admin.data.items.ItemInStore;
+import com.iemr.admin.repo.stockEntry.ItemStockEntryRepo;
+import com.iemr.admin.repository.itemfacilitymapping.M_itemfacilitymappingRepo;
+import com.iemr.admin.repository.itemfacilitymapping.V_fetchItemFacilityMapRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * The item facility service records which items a store is allowed to hold, and
+ * answers what each store currently has on its shelves.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("M_itemfacilitymappingImpl Test Suite")
+class M_itemfacilitymappingImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer FACILITY_ID = 9001;
+ private static final Integer MAP_ID = 3301;
+ private static final Integer ITEM_ID = 501;
+
+ @Mock
+ private V_fetchItemFacilityMapRepo v_fetchItemFacilityMapRepo;
+
+ @Mock
+ private M_itemfacilitymappingRepo m_itemfacilitymappingRepo;
+
+ @Mock
+ private ItemStockEntryRepo itemStockEntryRepo;
+
+ @InjectMocks
+ private M_itemfacilitymappingImpl service;
+
+ private static M_itemfacilitymapping mapping() {
+ M_itemfacilitymapping mapping = new M_itemfacilitymapping();
+ mapping.setItemStoreMapID(MAP_ID);
+ mapping.setItemID(ITEM_ID);
+ mapping.setFacilityID(FACILITY_ID);
+ mapping.setDeleted(Boolean.FALSE);
+ return mapping;
+ }
+
+ @Test
+ @DisplayName("mapItemtoStore should answer the mappings the repository stored")
+ void map_shouldAnswerStoredMappings() {
+ ArrayList stored = new ArrayList<>(List.of(mapping()));
+ when(m_itemfacilitymappingRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.mapItemtoStore(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("editdata and saveEditedItem should each reach their own repository query")
+ void singleRecordOperations_shouldReachTheirOwnQuery() {
+ M_itemfacilitymapping stored = mapping();
+ when(m_itemfacilitymappingRepo.findByItemFacilityMapID(MAP_ID)).thenReturn(stored);
+ when(m_itemfacilitymappingRepo.save(stored)).thenReturn(stored);
+
+ assertSame(stored, service.editdata(MAP_ID));
+ assertSame(stored, service.saveEditedItem(stored));
+ }
+
+ @Test
+ @DisplayName("editdata should answer nothing when the mapping is unknown")
+ void edit_shouldAnswerNothingForUnknownMapping() {
+ when(m_itemfacilitymappingRepo.findByItemFacilityMapID(-1)).thenReturn(null);
+
+ assertNull(service.editdata(-1));
+ }
+
+ @Test
+ @DisplayName("getsubitemforsubStote should rebuild one item per row the query answers")
+ void getSubItems_shouldRebuildEachRow() {
+ when(m_itemfacilitymappingRepo.getItemforSubstore(PSM_ID, FACILITY_ID))
+ .thenReturn(new ArrayList<>(List.of(
+ new Object[] { ITEM_ID, "Paracetamol 500", Boolean.FALSE, 7 })));
+
+ ArrayList items = service.getsubitemforsubStote(PSM_ID, FACILITY_ID);
+
+ assertEquals(1, items.size());
+ assertEquals("Paracetamol 500", items.get(0).getItemName());
+ assertEquals(ITEM_ID, items.get(0).getItemID());
+ }
+
+ @Test
+ @DisplayName("getsubitemforsubStote should skip a row the query could not fill in")
+ void getSubItems_shouldSkipIncompleteRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(new Object[] { ITEM_ID, "Paracetamol 500" });
+ when(m_itemfacilitymappingRepo.getItemforSubstore(PSM_ID, FACILITY_ID)).thenReturn(rows);
+
+ assertTrue(service.getsubitemforsubStote(PSM_ID, FACILITY_ID).isEmpty());
+ }
+
+ @Test
+ @DisplayName("the mapped item lookups should each reach their own repository query")
+ void mappedItemLookups_shouldReachTheirOwnQuery() {
+ ArrayList byProvider = new ArrayList<>(List.of(new V_fetchItemFacilityMap()));
+ ArrayList byFacility = new ArrayList<>(List.of(new V_fetchItemFacilityMap()));
+ when(v_fetchItemFacilityMapRepo.getAllFacilityMappedData(PSM_ID)).thenReturn(byProvider);
+ when(v_fetchItemFacilityMapRepo.getItemMappingsByFacilityAndSubStores(FACILITY_ID)).thenReturn(byFacility);
+
+ assertSame(byProvider, service.getAllFacilityMappedData(PSM_ID));
+ assertSame(byFacility, service.getItemMappingsByFacilityID(FACILITY_ID));
+ }
+
+ @Test
+ @DisplayName("getItemMastersFromStoreID should answer what the store holds of each item mapped to it")
+ void getItemMasters_shouldAnswerWhatStoreHolds() {
+ when(m_itemfacilitymappingRepo.getItemforStore(FACILITY_ID))
+ .thenReturn(new ArrayList<>(List.of(new Object[] { ITEM_ID, "Paracetamol 500" })));
+ when(itemStockEntryRepo.getQuantity(any(Integer[].class), anyInt()))
+ .thenReturn(new ArrayList<>(List.of(
+ new Object[] { FACILITY_ID, ITEM_ID, "Paracetamol 500", 250L })));
+
+ List held = service.getItemMastersFromStoreID(FACILITY_ID);
+
+ assertEquals(1, held.size());
+ assertEquals("Paracetamol 500", held.get(0).getItemName());
+ assertEquals(250L, held.get(0).getQuantity());
+ }
+
+ @Test
+ @DisplayName("getItemMastersFromStoreID should answer nothing when the store holds none of its items")
+ void getItemMasters_shouldAnswerNothingWhenStoreEmpty() {
+ when(m_itemfacilitymappingRepo.getItemforStore(FACILITY_ID)).thenReturn(new ArrayList<>());
+ when(itemStockEntryRepo.getQuantity(any(Integer[].class), anyInt())).thenReturn(new ArrayList<>());
+
+ assertTrue(service.getItemMastersFromStoreID(FACILITY_ID).isEmpty());
+ }
+
+ @Test
+ @DisplayName("deleteItemStoreMapping should report how many mappings the retirement touched")
+ void delete_shouldReportRowsTouched() {
+ M_itemfacilitymapping request = mapping();
+ request.setDeleted(Boolean.TRUE);
+ when(m_itemfacilitymappingRepo.updateDeleteMap(MAP_ID, Boolean.TRUE)).thenReturn(1);
+
+ assertEquals(1, service.deleteItemStoreMapping(request));
+ }
+
+ @Test
+ @DisplayName("deleteItemStoreMapping should report nothing touched when the mapping is unknown")
+ void delete_shouldReportNothingTouchedForUnknownMapping() {
+ M_itemfacilitymapping request = new M_itemfacilitymapping();
+ request.setItemStoreMapID(-1);
+ when(m_itemfacilitymappingRepo.updateDeleteMap(-1, null)).thenReturn(0);
+
+ assertEquals(0, service.deleteItemStoreMapping(request));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/locationmaster/LocationMasterServiceImplTest.java b/src/test/java/com/iemr/admin/service/locationmaster/LocationMasterServiceImplTest.java
new file mode 100644
index 0000000..bdc8b14
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/locationmaster/LocationMasterServiceImplTest.java
@@ -0,0 +1,180 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.locationmaster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.locationmaster.M_District;
+import com.iemr.admin.data.locationmaster.M_ProviderServiceAddMapping;
+import com.iemr.admin.data.locationmaster.Showofficedetails;
+import com.iemr.admin.data.locationmaster.StateServiceMapping1;
+import com.iemr.admin.repo.locationmaster.LocationMasterRepo;
+import com.iemr.admin.repo.locationmaster.MdistrictRepo;
+import com.iemr.admin.repo.locationmaster.M_ProviderServiceAddMappingRepo;
+import com.iemr.admin.repo.locationmaster.ShowofficedetailsRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * The location service reads a provider's office addresses out of several
+ * differently shaped queries and reshapes them into one carrier.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("LocationMasterServiceImpl Test Suite")
+class LocationMasterServiceImplTest {
+
+ private static final Integer PROVIDER_ID = 77;
+ private static final Integer PSM_ID = 4001;
+
+ @Mock
+ private ShowofficedetailsRepo showofficedetailsRepo;
+
+ @Mock
+ private MdistrictRepo mdistricRepo;
+
+ @Mock
+ private M_ProviderServiceAddMappingRepo m_ProviderServiceAddMappingRepo;
+
+ @Mock
+ private LocationMasterRepo locationMasterRepo;
+
+ @InjectMocks
+ private LocationMasterServiceImpl service;
+
+ @Test
+ @DisplayName("getStateByServiceProviderId should skip a row the query could not fill")
+ void getStateByServiceProviderId_shouldSkipUnfillableRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(null);
+ rows.add(new Object[] { 29, "Karnataka", 1, PSM_ID });
+ when(locationMasterRepo.getStateByServiceProviderId(PROVIDER_ID)).thenReturn(rows);
+
+ assertEquals(1, service.getStateByServiceProviderId(PROVIDER_ID).size());
+ }
+
+ @Test
+ @DisplayName("getServiceByServiceProviderIdAndStateId should rebuild one mapping per row")
+ void getServiceByServiceProviderIdAndStateId_shouldRebuildEachRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(new Object[] { 3, PSM_ID, "Tele Medicine" });
+ when(locationMasterRepo.getServiceByServiceProviderIdAndStateId(PROVIDER_ID, 29)).thenReturn(rows);
+
+ assertEquals(1, service.getServiceByServiceProviderIdAndStateId(PROVIDER_ID, 29).size());
+ }
+
+ @Test
+ @DisplayName("getStatesByServiceId should rebuild one mapping per row")
+ void getStatesByServiceId_shouldRebuildEachRow() {
+ ArrayList rows = new ArrayList<>();
+ rows.add(null);
+ rows.add(new Object[] { 29, "Karnataka", PSM_ID });
+ when(locationMasterRepo.getStatesByServiceId(3, PROVIDER_ID)).thenReturn(rows);
+
+ assertEquals(1, service.getStatesByServiceId(3, PROVIDER_ID).size());
+ }
+
+ @Test
+ @DisplayName("getAllDistrictByStateId should rebuild each district into a plain carrier")
+ void getAllDistrictByStateId_shouldRebuildEachDistrict() {
+ M_District stored = new M_District();
+ stored.setDistrictID(301);
+ stored.setDistrictName("Bengaluru Urban");
+ when(mdistricRepo.getAllDistrictByStateId(29)).thenReturn(new ArrayList<>(List.of(stored)));
+
+ ArrayList districts = service.getAllDistrictByStateId(29);
+
+ assertEquals(1, districts.size());
+ assertEquals("Bengaluru Urban", districts.get(0).getDistrictName());
+ }
+
+ @Test
+ @DisplayName("getlocationByMapid1 should gather the offices of every mapping the caller lists")
+ void getlocationByMapid1_shouldGatherAcrossMappings() {
+ Showofficedetails office = new Showofficedetails();
+ when(showofficedetailsRepo.getlocationByMapid1(4001)).thenReturn(new ArrayList<>(List.of(office)));
+ when(showofficedetailsRepo.getlocationByMapid1(4002)).thenReturn(new ArrayList<>(List.of(office)));
+
+ assertEquals(2, service.getlocationByMapid1(new ArrayList<>(List.of(4001, 4002))).size());
+ }
+
+ @Test
+ @DisplayName("getOfficeName should gather the office of every mapping the caller lists")
+ void getOfficeName_shouldGatherAcrossMappings() {
+ Showofficedetails request = new Showofficedetails();
+ request.setProviderServiceMapID(PSM_ID);
+ when(showofficedetailsRepo.getOfficeName(PSM_ID))
+ .thenReturn(new ArrayList<>(List.of(new Showofficedetails())));
+
+ assertEquals(1, service.getOfficeName(new ArrayList<>(List.of(request))).size());
+ }
+
+ @Test
+ @DisplayName("the remaining calls should each reach their own repository query")
+ void remainingCalls_shouldReachTheirOwnQuery() {
+ M_ProviderServiceAddMapping address = new M_ProviderServiceAddMapping();
+ ArrayList addresses = new ArrayList<>(List.of(address));
+ ArrayList offices = new ArrayList<>(List.of(new Showofficedetails()));
+ StateServiceMapping1 mapping = new StateServiceMapping1(PSM_ID);
+ ArrayList mappings = new ArrayList<>(List.of(mapping));
+ when(m_ProviderServiceAddMappingRepo.save(address)).thenReturn(address);
+ when(m_ProviderServiceAddMappingRepo.saveAll(anyList())).thenReturn(addresses);
+ when(m_ProviderServiceAddMappingRepo.editData(51)).thenReturn(address);
+ when(m_ProviderServiceAddMappingRepo.getlocationByMapid(PSM_ID)).thenReturn(addresses);
+ when(showofficedetailsRepo.getAlldata()).thenReturn(offices);
+ when(showofficedetailsRepo.getlocationByMapid(PSM_ID)).thenReturn(offices);
+ when(showofficedetailsRepo.getlocationByMapid3(PSM_ID, 301)).thenReturn(offices);
+ when(locationMasterRepo.getProviderServiceMapID(PROVIDER_ID, 29, 3)).thenReturn(mapping);
+ when(locationMasterRepo.getAllByMapId2(PROVIDER_ID, 29, 3)).thenReturn(mappings);
+ when(locationMasterRepo.getAllByMapId3(PROVIDER_ID, 3)).thenReturn(mappings);
+ when(locationMasterRepo.getLocationByServiceID(PROVIDER_ID, 3)).thenReturn(mappings);
+ when(locationMasterRepo.getLocationByStateID(PROVIDER_ID, 29)).thenReturn(mappings);
+
+ assertSame(address, service.addlocation(address));
+ assertSame(addresses, service.addlocation(new ArrayList<>()));
+ assertSame(address, service.editData(51));
+ assertSame(address, service.saveEditData(address));
+ assertSame(addresses, service.getlocationByMapid(PSM_ID));
+ assertSame(offices, service.getAlldata());
+ assertSame(offices, service.getlocationByMapid2(PSM_ID));
+ assertSame(offices, service.getlocationByMapid4(PSM_ID, 301));
+ assertSame(mapping, service.getAllByMapId(PROVIDER_ID, 29, 3));
+ assertSame(mappings, service.getAllByMapId2(PROVIDER_ID, 29, 3));
+ assertSame(mappings, service.getAllByMapId3(PROVIDER_ID, 3));
+ assertSame(mappings, service.getLocationByServiceId(PROVIDER_ID, 3));
+ assertSame(mappings, service.getLocationBySateID(PROVIDER_ID, 29));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/manufacturer/ManufacturerServiceImplTest.java b/src/test/java/com/iemr/admin/service/manufacturer/ManufacturerServiceImplTest.java
new file mode 100644
index 0000000..a473821
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/manufacturer/ManufacturerServiceImplTest.java
@@ -0,0 +1,113 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.manufacturer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.manufacturer.M_Manufacturer;
+import com.iemr.admin.repo.manufacturer.ManufacturerRepo;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/** The manufacturer service is thin over its repository, but it answers nothing rather than an empty batch. */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ManufacturerServiceImpl Test Suite")
+class ManufacturerServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer RECORD_ID = 11;
+
+ @Mock
+ private ManufacturerRepo manufacturerRepo;
+
+ @InjectMocks
+ private ManufacturerServiceImpl service;
+
+ @Test
+ @DisplayName("createManufacturer should answer the records it stored")
+ void create_shouldAnswerStoredRecords() {
+ ArrayList stored = new ArrayList<>(List.of(new M_Manufacturer()));
+ when(manufacturerRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.createManufacturer(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createManufacturer should answer nothing when the store took nothing")
+ void create_shouldAnswerNothingWhenNothingStored() {
+ when(manufacturerRepo.saveAll(anyList())).thenReturn(new ArrayList());
+
+ assertNull(service.createManufacturer(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("the lookups should each reach their own repository query")
+ void lookups_shouldReachTheirOwnQuery() {
+ M_Manufacturer record = new M_Manufacturer();
+ ArrayList records = new ArrayList<>(List.of(record));
+ when(manufacturerRepo.getManufacturerData(PSM_ID)).thenReturn(records);
+ when(manufacturerRepo.getEditData(RECORD_ID)).thenReturn(record);
+ when(manufacturerRepo.save(record)).thenReturn(record);
+
+ assertSame(records, service.createManufacturer(PSM_ID));
+ assertSame(record, service.editManufacturer(RECORD_ID));
+ assertSame(record, service.saveEditedData(record));
+ }
+
+ @Test
+ @DisplayName("checkManufacturerCode should report a code the provider already uses")
+ void check_shouldReportUsedCode() {
+ M_Manufacturer request = new M_Manufacturer();
+ request.setManufacturerCode("C-1");
+ request.setProviderServiceMapID(PSM_ID);
+ when(manufacturerRepo.findByManufacturerCodeAndProviderServiceMapID("C-1", PSM_ID)).thenReturn(List.of(new M_Manufacturer()));
+
+ assertTrue(service.checkManufacturerCode(request));
+ }
+
+ @Test
+ @DisplayName("checkManufacturerCode should clear a code nobody uses yet")
+ void check_shouldClearFreeCode() {
+ M_Manufacturer request = new M_Manufacturer();
+ request.setManufacturerCode("C-2");
+ request.setProviderServiceMapID(PSM_ID);
+ when(manufacturerRepo.findByManufacturerCodeAndProviderServiceMapID("C-2", PSM_ID)).thenReturn(new ArrayList());
+
+ assertFalse(service.checkManufacturerCode(request));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/nodalemailconfig/NodalConfigServiceImplTest.java b/src/test/java/com/iemr/admin/service/nodalemailconfig/NodalConfigServiceImplTest.java
new file mode 100644
index 0000000..68d6667
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/nodalemailconfig/NodalConfigServiceImplTest.java
@@ -0,0 +1,190 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.nodalemailconfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.emailconfig.AuthorityEmail;
+import com.iemr.admin.mapper.emailconfig.InstituteEmailConfigMapper;
+import com.iemr.admin.model.emailconfig.NodalEmailRequest;
+import com.iemr.admin.model.emailconfig.NodalEmailResponse;
+import com.iemr.admin.model.emailconfig.CreateNodalEmailRequestModel;
+import com.iemr.admin.model.emailconfig.UpdateNodalEmailRequest;
+import com.iemr.admin.repository.emailconfig.InstituteEmailRepo;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.CriteriaQuery;
+import jakarta.persistence.criteria.Path;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The nodal config service keeps the nodal officer mailboxes a complaint is
+ * escalated to, narrowed by whichever parts of the location the caller names.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("NodalConfigServiceImpl Test Suite")
+class NodalConfigServiceImplTest {
+
+ @Mock
+ private EntityManager entityManager;
+
+ @Mock
+ private InstituteEmailRepo instituteRepo;
+
+ @Mock
+ private InstituteEmailConfigMapper instituteEmailConfigMapper;
+
+ @InjectMocks
+ private NodalConfigServiceImpl service;
+
+ private CriteriaQuery query;
+ private TypedQuery typedQuery;
+
+ @SuppressWarnings("unchecked")
+ @BeforeEach
+ @DisplayName("Stand in for the criteria query the service builds by hand")
+ void setUp() {
+ CriteriaBuilder builder = mock(CriteriaBuilder.class);
+ query = mock(CriteriaQuery.class);
+ Root root = mock(Root.class);
+ typedQuery = mock(TypedQuery.class);
+
+ when(entityManager.getCriteriaBuilder()).thenReturn(builder);
+ when(builder.createQuery(AuthorityEmail.class)).thenReturn(query);
+ when(query.from(AuthorityEmail.class)).thenReturn(root);
+ when(query.select(any())).thenReturn(query);
+ when(query.where(any(Predicate[].class))).thenReturn(query);
+ when(query.orderBy(any(jakarta.persistence.criteria.Order[].class))).thenReturn(query);
+ when(root.get(anyString())).thenReturn(mock(Path.class));
+ when(builder.equal(any(), any())).thenReturn(mock(Predicate.class));
+ when(entityManager.createQuery(query)).thenReturn(typedQuery);
+ }
+
+ private static NodalEmailRequest fullyNarrowedRequest() {
+ NodalEmailRequest request = new NodalEmailRequest();
+ request.setAuthorityEmailID(1);
+ request.setDeleted(false);
+ request.setDistrictID(301);
+ request.setDistrictBranchMappingID(30111);
+ request.setBlockID(3011);
+ request.setProviderServiceMapID(4001);
+ request.setStateID(29);
+ request.setMobileNo("9000000001");
+ return request;
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should answer the mailboxes the query found, as the screens read them")
+ void getAll_shouldAnswerFoundMailboxes() {
+ List found = List.of(new AuthorityEmail());
+ List published = List.of(new NodalEmailResponse());
+ when(typedQuery.getResultList()).thenReturn(found);
+ when(instituteEmailConfigMapper.resultToInstTypeEmailResponses(found)).thenReturn(published);
+
+ assertSame(published, service.getAllNodalEmailConfigs(fullyNarrowedRequest()));
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should narrow the query by every detail the caller named")
+ void getAll_shouldNarrowByEveryNamedDetail() {
+ when(typedQuery.getResultList()).thenReturn(new ArrayList<>());
+
+ service.getAllNodalEmailConfigs(fullyNarrowedRequest());
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(Predicate[].class);
+ verify(query).where(captor.capture());
+ assertEquals(8, captor.getValue().length, "one narrowing per detail the caller named");
+ }
+
+ @Test
+ @DisplayName("getAllEmailConfigs should narrow by nothing when the caller names nothing")
+ void getAll_shouldNarrowByNothingForEmptyRequest() {
+ when(typedQuery.getResultList()).thenReturn(new ArrayList<>());
+
+ service.getAllNodalEmailConfigs(new NodalEmailRequest());
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(Predicate[].class);
+ verify(query).where(captor.capture());
+ assertEquals(0, captor.getValue().length);
+ }
+
+ @Test
+ @DisplayName("saveEmailConfigs should store one mailbox per request and answer each as stored")
+ void save_shouldStoreEachRequestedMailbox() {
+ AuthorityEmail stored = new AuthorityEmail();
+ when(instituteEmailConfigMapper.createRequestToInstituteEmailConfig(anyList()))
+ .thenReturn(List.of(stored, stored));
+ when(instituteRepo.save(stored)).thenReturn(stored);
+ when(instituteEmailConfigMapper.resultInstType(stored))
+ .thenReturn(new NodalEmailResponse());
+
+ assertEquals(2, service.saveNodalEmailConfigs(List.of(new CreateNodalEmailRequestModel())).size());
+ }
+
+ @Test
+ @DisplayName("saveEmailConfigs should store nothing when the caller asks for nothing")
+ void save_shouldStoreNothingForEmptyRequest() {
+ when(instituteEmailConfigMapper.createRequestToInstituteEmailConfig(anyList()))
+ .thenReturn(new ArrayList<>());
+
+ assertTrue(service.saveNodalEmailConfigs(new ArrayList<>()).isEmpty());
+ }
+
+ @Test
+ @DisplayName("updateEmailConfigs should answer the mailbox as it stands after the change")
+ void update_shouldAnswerChangedMailbox() {
+ AuthorityEmail stored = new AuthorityEmail();
+ NodalEmailResponse published = new NodalEmailResponse();
+ when(instituteEmailConfigMapper.updateRequestToInstituteNodalEmailConf(any(UpdateNodalEmailRequest.class)))
+ .thenReturn(stored);
+ when(instituteRepo.save(stored)).thenReturn(stored);
+ when(instituteEmailConfigMapper.resultToInstTypeNodalEmailResponse(stored)).thenReturn(published);
+
+ assertSame(published, service.updateNodalEmailConfigs(new UpdateNodalEmailRequest()));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceServiceImplTest.java b/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceServiceImplTest.java
new file mode 100644
index 0000000..8065453
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceServiceImplTest.java
@@ -0,0 +1,184 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.parkingPlace;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.parkingPlace.M_Parkingplace;
+import com.iemr.admin.data.provideronboard.M_ProviderServiceMapping;
+import com.iemr.admin.data.zonemaster.M_Zone;
+import com.iemr.admin.repository.parkingPlace.ParkingPlaceRepository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The parking place service turns the flat rows the reporting queries answer
+ * back into parking places, and treats an omitted location filter as "any".
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ParkingPlaceServiceImpl Test Suite")
+class ParkingPlaceServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer PARKING_PLACE_ID = 31;
+
+ @Mock
+ private ParkingPlaceRepository parkingPlaceRepository;
+
+ @InjectMocks
+ private ParkingPlaceServiceImpl service;
+
+ private static Object[] reportingRow() {
+ return new Object[] { PARKING_PLACE_ID, "Hosur parking", "Near the bus stand", "Hosur Road", PSM_ID,
+ Boolean.FALSE, 1, "India", 29, "Karnataka", 301, "Bengaluru Urban", 3011, "Anekal", 30111,
+ "Attibele", new M_ProviderServiceMapping(), 5, "104 Helpline" };
+ }
+
+ @Test
+ @DisplayName("getAvailableParkingPlaces should rebuild one parking place per row the query answers")
+ void getAvailable_shouldRebuildEachRow() {
+ when(parkingPlaceRepository.getAvailableParkingPlaces("29", "301", PSM_ID))
+ .thenReturn(List.of(reportingRow()));
+
+ ArrayList places = service.getAvailableParkingPlaces(29, 301, PSM_ID);
+
+ assertEquals(1, places.size());
+ assertEquals("Hosur parking", places.get(0).getParkingPlaceName());
+ assertEquals("Karnataka", places.get(0).getStateName());
+ assertEquals("Hosur Road", places.get(0).getAreaHQAddress());
+ }
+
+ @Test
+ @DisplayName("getAvailableParkingPlaces should match any state or district the caller leaves out")
+ void getAvailable_shouldWildcardOmittedFilters() {
+ when(parkingPlaceRepository.getAvailableParkingPlaces("%%", "%%", PSM_ID)).thenReturn(new ArrayList<>());
+
+ assertTrue(service.getAvailableParkingPlaces(null, null, PSM_ID).isEmpty());
+ verify(parkingPlaceRepository).getAvailableParkingPlaces("%%", "%%", PSM_ID);
+ }
+
+ @Test
+ @DisplayName("saveParkingPlace should answer the parking places the repository stored")
+ void save_shouldAnswerStoredPlaces() {
+ ArrayList stored = new ArrayList<>(List.of(new M_Parkingplace()));
+ when(parkingPlaceRepository.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.saveParkingPlace(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("updateParkingPlaceStatus should report how many rows the retirement touched")
+ void updateStatus_shouldReportRowsTouched() {
+ M_Parkingplace request = new M_Parkingplace();
+ request.setParkingPlaceID(PARKING_PLACE_ID);
+ request.setDeleted(Boolean.TRUE);
+ request.setModifiedBy("admin");
+ when(parkingPlaceRepository.updateParkingPlaceStatus(PARKING_PLACE_ID, Boolean.TRUE, "admin")).thenReturn(1);
+
+ assertEquals(1, service.updateParkingPlaceStatus(request));
+ }
+
+ @Test
+ @DisplayName("updateParkingPlaceStatus should report nothing touched when the parking place is unknown")
+ void updateStatus_shouldReportNothingTouchedForUnknownPlace() {
+ M_Parkingplace request = new M_Parkingplace();
+ request.setParkingPlaceID(-1);
+ when(parkingPlaceRepository.updateParkingPlaceStatus(-1, null, null)).thenReturn(0);
+
+ assertEquals(0, service.updateParkingPlaceStatus(request));
+ }
+
+ @Test
+ @DisplayName("the single record lookups should each reach their own repository query")
+ void singleRecordLookups_shouldReachTheirOwnQuery() {
+ M_Parkingplace stored = new M_Parkingplace();
+ List byProvider = List.of(stored);
+ when(parkingPlaceRepository.getParkingPlaceById(PARKING_PLACE_ID)).thenReturn(stored);
+ when(parkingPlaceRepository.save(stored)).thenReturn(stored);
+ when(parkingPlaceRepository.findByProviderServiceMapID(PSM_ID)).thenReturn(byProvider);
+
+ assertSame(stored, service.getParkingPlaceByID(PARKING_PLACE_ID));
+ assertSame(stored, service.updateParkingPlaceData(stored));
+ assertSame(byProvider, service.getParkingPlaces(PSM_ID));
+ }
+
+ @Test
+ @DisplayName("getSubDistrict should answer the taluks the parking place covers")
+ void getSubDistrict_shouldAnswerCoveredTaluks() {
+ when(parkingPlaceRepository.getSubDistrict(PARKING_PLACE_ID))
+ .thenReturn(List.of(new Object[] { PARKING_PLACE_ID, 3011, "Anekal" }));
+
+ List taluks = service.getSubDistrict(PARKING_PLACE_ID);
+
+ assertEquals(1, taluks.size());
+ assertEquals("Anekal", taluks.get(0).getBlockName());
+ assertEquals(3011, taluks.get(0).getDistrictBlockID());
+ }
+
+ @Test
+ @DisplayName("getSubDistrict should answer nothing when the parking place covers no taluk")
+ void getSubDistrict_shouldAnswerNothingWhenNoneCovered() {
+ when(parkingPlaceRepository.getSubDistrict(PARKING_PLACE_ID)).thenReturn(new ArrayList<>());
+
+ assertTrue(service.getSubDistrict(PARKING_PLACE_ID).isEmpty());
+ }
+
+ @Test
+ @DisplayName("getAvailableParkingPlacesbyZoneID should name the zone on each parking place it answers")
+ void getAvailableByZone_shouldNameTheZone() {
+ M_Parkingplace place = new M_Parkingplace();
+ place.setParkingPlaceID(PARKING_PLACE_ID);
+ M_Zone zone = new M_Zone();
+ zone.setZoneName("South zone");
+ when(parkingPlaceRepository.getAvailableParkingPlacesbyzoneid(9, PSM_ID))
+ .thenReturn(List.of(new Object[] { place, zone }));
+
+ ArrayList places = service.getAvailableParkingPlacesbyZoneID(9, PSM_ID);
+
+ assertEquals(1, places.size());
+ assertEquals("South zone", places.get(0).getZoneName());
+ }
+
+ @Test
+ @DisplayName("getAvailableParkingPlacesbyZoneID should answer nothing when the zone holds no parking place")
+ void getAvailableByZone_shouldAnswerNothingForEmptyZone() {
+ when(parkingPlaceRepository.getAvailableParkingPlacesbyzoneid(9, PSM_ID)).thenReturn(new ArrayList<>());
+
+ assertTrue(service.getAvailableParkingPlacesbyZoneID(9, PSM_ID).isEmpty());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceTalukMappingServiceImplTest.java b/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceTalukMappingServiceImplTest.java
new file mode 100644
index 0000000..24df775
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/parkingPlace/ParkingPlaceTalukMappingServiceImplTest.java
@@ -0,0 +1,151 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.parkingPlace;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.locationmaster.DistrictBlock;
+import com.iemr.admin.data.parkingPlace.ParkingplaceTalukMapping;
+import com.iemr.admin.data.parkingPlace.ParkingplaceTalukMappingTO;
+import com.iemr.admin.mapper.parkingplacetalukmapping.ParkingPlaceTalukMappingMapper;
+import com.iemr.admin.repo.locationmaster.DistrictBlockRepo;
+import com.iemr.admin.repository.parkingPlace.ParkingPlaceTalukMappingRepository;
+
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The taluk mapping service records which taluks a parking place covers, and
+ * offers the remaining taluks of a district as the candidates for a new one.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("ParkingPlaceTalukMappingServiceImpl Test Suite")
+class ParkingPlaceTalukMappingServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer PARKING_PLACE_ID = 31;
+ private static final Integer DISTRICT_ID = 301;
+
+ @Mock
+ private ParkingPlaceTalukMappingRepository parkingPlaceTalukMappingRepository;
+
+ @Mock
+ private DistrictBlockRepo districtBlockRepo;
+
+ @Mock
+ private ParkingPlaceTalukMappingMapper parkingPlaceTalukMappingMapper;
+
+ @InjectMocks
+ private ParkingPlaceTalukMappingServiceImpl service;
+
+ private static ParkingplaceTalukMapping mapping() {
+ ParkingplaceTalukMapping mapping = new ParkingplaceTalukMapping();
+ mapping.setPpSubDistrictMapID(7001);
+ mapping.setParkingPlaceID(PARKING_PLACE_ID);
+ mapping.setDistrictID(DISTRICT_ID);
+ mapping.setDistrictBlockID(3011);
+ mapping.setProviderServiceMapID(PSM_ID);
+ return mapping;
+ }
+
+ @Test
+ @DisplayName("saveParkingPlaceTalukMapping should answer the mappings the repository stored")
+ void save_shouldAnswerStoredMappings() {
+ ArrayList stored = new ArrayList<>(List.of(mapping()));
+ when(parkingPlaceTalukMappingRepository.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.saveParkingPlaceTalukMapping(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("updateParkingPlaceTalukMapping and findbyID should each reach their own repository query")
+ void singleRecordOperations_shouldReachTheirOwnQuery() {
+ ParkingplaceTalukMapping stored = mapping();
+ when(parkingPlaceTalukMappingRepository.save(stored)).thenReturn(stored);
+ when(parkingPlaceTalukMappingRepository.findByPpSubDistrictMapID(7001)).thenReturn(stored);
+
+ assertSame(stored, service.updateParkingPlaceTalukMapping(stored));
+ assertSame(stored, service.findbyID(7001));
+ }
+
+ @Test
+ @DisplayName("findbyProviderservicemapid should answer the taluks the parking place covers")
+ void findbyProviderservicemapid_shouldAnswerCoveredTaluks() {
+ List rows = List.of(mapping());
+ List published = List.of(new ParkingplaceTalukMappingTO());
+ when(parkingPlaceTalukMappingRepository.findByParkingPlaceID(PARKING_PLACE_ID)).thenReturn(rows);
+ when(parkingPlaceTalukMappingMapper.getParkingplaceTalukMappingMapList(rows)).thenReturn(published);
+
+ assertSame(published, service.findbyProviderservicemapid(mapping()));
+ }
+
+ @Test
+ @DisplayName("findbyParkingplaceAndDistrictID should narrow the mappings to the district the caller names")
+ void findbyParkingplaceAndDistrictID_shouldNarrowToDistrict() {
+ List rows = List.of(mapping());
+ List published = List.of(new ParkingplaceTalukMappingTO());
+ when(parkingPlaceTalukMappingRepository
+ .findByParkingPlaceIDAndDistrictIDOrderByM_DistrictDistrictNameAsc(PARKING_PLACE_ID, DISTRICT_ID))
+ .thenReturn(rows);
+ when(parkingPlaceTalukMappingMapper.getParkingplaceTalukMappingMapList(rows)).thenReturn(published);
+
+ assertSame(published, service.findbyParkingplaceAndDistrictID(mapping()));
+ }
+
+ @Test
+ @DisplayName("getunmappedtaluk should exclude the taluks already covered when there are any")
+ void getunmappedtaluk_shouldExcludeCoveredTaluks() {
+ List covered = List.of(3011);
+ List remaining = List.of(new DistrictBlock(3012, "Hoskote"));
+ when(parkingPlaceTalukMappingRepository.finbyDistrictID(DISTRICT_ID, PSM_ID)).thenReturn(covered);
+ when(districtBlockRepo.findunmapped(covered, DISTRICT_ID)).thenReturn(remaining);
+
+ assertSame(remaining, service.getunmappedtaluk(DISTRICT_ID, PSM_ID));
+ verify(districtBlockRepo, never()).findall(anyInt());
+ }
+
+ @Test
+ @DisplayName("getunmappedtaluk should offer every taluk of the district when none is covered yet")
+ void getunmappedtaluk_shouldOfferEveryTalukWhenNoneCovered() {
+ List all = List.of(new DistrictBlock(3011, "Anekal"), new DistrictBlock(3012, "Hoskote"));
+ when(parkingPlaceTalukMappingRepository.finbyDistrictID(DISTRICT_ID, PSM_ID)).thenReturn(new ArrayList<>());
+ when(districtBlockRepo.findall(DISTRICT_ID)).thenReturn(all);
+
+ assertSame(all, service.getunmappedtaluk(DISTRICT_ID, PSM_ID));
+ verify(districtBlockRepo, never()).findunmapped(anyList(), anyInt());
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/pharmacologicalcategory/PharmacologicalcategoryServiceImplTest.java b/src/test/java/com/iemr/admin/service/pharmacologicalcategory/PharmacologicalcategoryServiceImplTest.java
new file mode 100644
index 0000000..9286283
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/pharmacologicalcategory/PharmacologicalcategoryServiceImplTest.java
@@ -0,0 +1,113 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.pharmacologicalcategory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.iemr.admin.data.pharmacologicalcategory.M_Pharmacologicalcategory;
+import com.iemr.admin.repo.pharmacologicalcategory.PharmacologicalcategoryRepo;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/** The pharmacological category service is thin over its repository, but it answers nothing rather than an empty batch. */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("PharmacologicalcategoryServiceImpl Test Suite")
+class PharmacologicalcategoryServiceImplTest {
+
+ private static final Integer PSM_ID = 4001;
+ private static final Integer RECORD_ID = 11;
+
+ @Mock
+ private PharmacologicalcategoryRepo pharmacologicalcategoryRepo;
+
+ @InjectMocks
+ private PharmacologicalcategoryServiceImpl service;
+
+ @Test
+ @DisplayName("createPharmacologicalcategory should answer the records it stored")
+ void create_shouldAnswerStoredRecords() {
+ ArrayList stored = new ArrayList<>(List.of(new M_Pharmacologicalcategory()));
+ when(pharmacologicalcategoryRepo.saveAll(anyList())).thenReturn(stored);
+
+ assertSame(stored, service.createPharmacologicalcategory(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("createPharmacologicalcategory should answer nothing when the store took nothing")
+ void create_shouldAnswerNothingWhenNothingStored() {
+ when(pharmacologicalcategoryRepo.saveAll(anyList())).thenReturn(new ArrayList());
+
+ assertNull(service.createPharmacologicalcategory(new ArrayList<>()));
+ }
+
+ @Test
+ @DisplayName("the lookups should each reach their own repository query")
+ void lookups_shouldReachTheirOwnQuery() {
+ M_Pharmacologicalcategory record = new M_Pharmacologicalcategory();
+ ArrayList records = new ArrayList<>(List.of(record));
+ when(pharmacologicalcategoryRepo.getPhormacologicalData(PSM_ID)).thenReturn(records);
+ when(pharmacologicalcategoryRepo.editPhamacologicalData(RECORD_ID)).thenReturn(record);
+ when(pharmacologicalcategoryRepo.save(record)).thenReturn(record);
+
+ assertSame(records, service.getPharmacologicalcategory(PSM_ID));
+ assertSame(record, service.editPharmacologicalcategory(RECORD_ID));
+ assertSame(record, service.saveEditedPharData(record));
+ }
+
+ @Test
+ @DisplayName("checkPharmacologicalcategoryCode should report a code the provider already uses")
+ void check_shouldReportUsedCode() {
+ M_Pharmacologicalcategory request = new M_Pharmacologicalcategory();
+ request.setPharmCategoryCode("C-1");
+ request.setProviderServiceMapID(PSM_ID);
+ when(pharmacologicalcategoryRepo.findByPharmCategoryCodeAndProviderServiceMapID("C-1", PSM_ID)).thenReturn(List.of(new M_Pharmacologicalcategory()));
+
+ assertTrue(service.checkPharmacologicalcategoryCode(request));
+ }
+
+ @Test
+ @DisplayName("checkPharmacologicalcategoryCode should clear a code nobody uses yet")
+ void check_shouldClearFreeCode() {
+ M_Pharmacologicalcategory request = new M_Pharmacologicalcategory();
+ request.setPharmCategoryCode("C-2");
+ request.setProviderServiceMapID(PSM_ID);
+ when(pharmacologicalcategoryRepo.findByPharmCategoryCodeAndProviderServiceMapID("C-2", PSM_ID)).thenReturn(new ArrayList());
+
+ assertFalse(service.checkPharmacologicalcategoryCode(request));
+ }
+}
diff --git a/src/test/java/com/iemr/admin/service/provideronboard/ProviderOnBoardServicesTest.java b/src/test/java/com/iemr/admin/service/provideronboard/ProviderOnBoardServicesTest.java
new file mode 100644
index 0000000..516cd48
--- /dev/null
+++ b/src/test/java/com/iemr/admin/service/provideronboard/ProviderOnBoardServicesTest.java
@@ -0,0 +1,801 @@
+/*
+* AMRIT - Accessible Medical Records via Integrated Technologies
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+package com.iemr.admin.service.provideronboard;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.google.gson.JsonObject;
+import com.iemr.admin.data.provideronboard.M_104druggroup;
+import com.iemr.admin.data.provideronboard.M_104drugmapping;
+import com.iemr.admin.data.provideronboard.M_104drugmaster;
+import com.iemr.admin.data.provideronboard.M_Calltype;
+import com.iemr.admin.data.provideronboard.M_Category;
+import com.iemr.admin.data.provideronboard.M_Feedbacknature;
+import com.iemr.admin.data.provideronboard.M_Feedbacktype;
+import com.iemr.admin.data.provideronboard.M_Institutedirectory;
+import com.iemr.admin.data.provideronboard.M_Institutedirectorymapping;
+import com.iemr.admin.data.provideronboard.M_Institutesubdirectory;
+import com.iemr.admin.data.provideronboard.M_Institution;
+import com.iemr.admin.data.provideronboard.M_Institutiontype;
+import com.iemr.admin.data.provideronboard.M_ProviderServiceMapping;
+import com.iemr.admin.data.provideronboard.M_ServiceMaster;
+import com.iemr.admin.data.provideronboard.M_Severity;
+import com.iemr.admin.data.provideronboard.M_Subcategory;
+import com.iemr.admin.data.provideronboard.M_Subservice;
+import com.iemr.admin.data.provideronboard.M_SubservicemasterPA;
+import com.iemr.admin.data.provideronboard.M_UserservicerolemappingForRole;
+import com.iemr.admin.data.provideronboard.ServiceProvider_Model;
+import com.iemr.admin.data.provideronboard.V_Showprovideradmin;
+import com.iemr.admin.data.provideronboard.V_Showsubcategory;
+import com.iemr.admin.exceptionhandler.DataNotFound;
+import com.iemr.admin.repository.provideronboard.CalltypeRepo;
+import com.iemr.admin.repository.provideronboard.CategoryRepo;
+import com.iemr.admin.repository.provideronboard.DrugGroupRepo;
+import com.iemr.admin.repository.provideronboard.DrugMappingRepo;
+import com.iemr.admin.repository.provideronboard.DrugMasterRepo;
+import com.iemr.admin.repository.provideronboard.IemrServiceRepository1;
+import com.iemr.admin.repository.provideronboard.InstuteDirectoryRepo;
+import com.iemr.admin.repository.provideronboard.M_FeedbacknatureRepo;
+import com.iemr.admin.repository.provideronboard.M_FeedbacktypeRepo;
+import com.iemr.admin.repository.provideronboard.M_InstitutedirectorymappingRepo;
+import com.iemr.admin.repository.provideronboard.M_InstitutesubdirectoryRepo;
+import com.iemr.admin.repository.provideronboard.M_InstitutionRepo;
+import com.iemr.admin.repository.provideronboard.M_InstitutiontypeRepo;
+import com.iemr.admin.repository.provideronboard.M_ProviderServiceMappingRepo;
+import com.iemr.admin.repository.provideronboard.M_ServiceMasterRepo;
+import com.iemr.admin.repository.provideronboard.M_SeverityRepo;
+import com.iemr.admin.repository.provideronboard.M_SubservicemasterPArepo;
+import com.iemr.admin.repository.provideronboard.M_UserservicerolemappingForRoleRepo;
+import com.iemr.admin.repository.provideronboard.SubCategoryRepo;
+import com.iemr.admin.repository.provideronboard.SubserviceMasterRepo;
+import com.iemr.admin.repository.provideronboard.V_ShowprovideradminRepo;
+import com.iemr.admin.repository.provideronboard.V_ShowsubcategoryRepo;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The onboarding services are thin over their repositories, but a few of them
+ * choose which query to run from what the caller left blank - and those choices
+ * decide what an operator sees on screen.
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+@DisplayName("Provider onboarding service Test Suite")
+class ProviderOnBoardServicesTest {
+
+ private static final Integer PSM_ID = 4001;
+
+ @Mock
+ private CalltypeRepo calltypeRepo;
+
+ @InjectMocks
+ private CalltypeServiceImpl calltypeService;
+
+ @Mock
+ private V_ShowsubcategoryRepo v_ShowsubcategoryRepo;
+
+ @Mock
+ private CategoryRepo categoryRepo;
+
+ @Mock
+ private SubCategoryRepo subCategoryRepo;
+
+ @InjectMocks
+ private CategoryMasterImpl categoryService;
+
+ @Mock
+ private DrugGroupRepo drugGroupRepo;
+
+ @Mock
+ private DrugMasterRepo drugMasterRepo;
+
+ @Mock
+ private DrugMappingRepo drugMappingRepo;
+
+ @InjectMocks
+ private DrugMasterImpl drugService;
+
+ @Mock
+ private InstuteDirectoryRepo instuteDirectoryRepo;
+
+ @InjectMocks
+ private InstuteDirectoryServiceImpl directoryService;
+
+ @Mock
+ private M_FeedbacknatureRepo m_FeedbacknatureRepo;
+
+ @InjectMocks
+ private M_FeedbacknatureImpl feedbackNatureService;
+
+ @Mock
+ private M_FeedbacktypeRepo m_FeedbacktypeRepo;
+
+ @InjectMocks
+ private M_FeedbacktypeImpl feedbackTypeService;
+
+ @Mock
+ private M_InstitutedirectorymappingRepo m_InstitutedirectorymappingRepo;
+
+ @InjectMocks
+ private M_InstitutedirectorymappingImpl directoryMappingService;
+
+ @Mock
+ private M_InstitutesubdirectoryRepo m_InstitutesubdirectoryRepo;
+
+ @InjectMocks
+ private M_InstitutesubdirectoryImpl subDirectoryService;
+
+ @Mock
+ private M_InstitutionRepo m_InstitutionRepo;
+
+ @InjectMocks
+ private M_InstitutionImpl institutionService;
+
+ @Mock
+ private M_InstitutiontypeRepo m_InstitutiontypeRepo;
+
+ @InjectMocks
+ private M_InstitutiontypeImpl instituteTypeService;
+
+ @Mock
+ private M_ServiceMasterRepo mservicemasteRepo;
+
+ @InjectMocks
+ private M_ServiceMasterImpl serviceMasterService;
+
+ @Mock
+ private M_SeverityRepo m_ServerityRepo;
+
+ @InjectMocks
+ private M_SeverityImpl severityService;
+
+ @Mock
+ private M_SubservicemasterPArepo m_SubservicemasterPArepo;
+
+ @Mock
+ private SubserviceMasterRepo subserviceMasterRepo;
+
+ @InjectMocks
+ private SubserviceImpl subServiceService;
+
+ @Mock
+ private V_ShowprovideradminRepo v_ShowprovideradminRepo;
+
+ @Mock
+ private M_UserservicerolemappingForRoleRepo m_UserservicerolemappingForRoleRepo;
+
+ @Mock
+ private IemrServiceRepository1 iemrServiceRepository1;
+
+ @Mock
+ private M_ProviderServiceMappingRepo m_ProviderServiceMappingRepo;
+
+ @InjectMocks
+ private ServiceProvider_ServiceImpl providerService;
+
+ @Nested
+ @DisplayName("CalltypeServiceImpl")
+ class CallTypeServiceTests {
+
+ @Test
+ @DisplayName("should hand each call to its own repository query")
+ void callType_shouldReachTheirOwnQuery() {
+ M_Calltype callType = new M_Calltype();
+ ArrayList stored = new ArrayList<>(List.of(callType));
+ when(calltypeRepo.saveAll(anyList())).thenReturn(stored);
+ when(calltypeRepo.updateCallType(51)).thenReturn(callType);
+ when(calltypeRepo.save(callType)).thenReturn(callType);
+ when(calltypeRepo.getCalltypeData(PSM_ID)).thenReturn(stored);
+
+ assertSame(stored, calltypeService.saveCallList(new ArrayList<>()));
+ assertSame(stored, calltypeService.createCalltype(new ArrayList<>()));
+ assertSame(callType, calltypeService.updateCallType(51));
+ assertSame(callType, calltypeService.saveupdatedData(callType));
+ assertSame(stored, calltypeService.getCalltypeData(PSM_ID));
+ }
+ }
+
+ @Nested
+ @DisplayName("CategoryMasterImpl")
+ class CategoryServiceTests {
+
+ @Test
+ @DisplayName("getCategoryId should store the category and answer the id it was given")
+ void getCategoryId_shouldStoreAndAnswerId() {
+ M_Category category = new M_Category();
+ M_Category stored = new M_Category();
+ stored.setCategoryID(81);
+ when(categoryRepo.save(category)).thenReturn(stored);
+
+ assertEquals(81, categoryService.getCategoryId(category));
+ }
+
+ @Test
+ @DisplayName("the sub-category calls should each reach their own repository query")
+ void subCategoryCalls_shouldReachTheirOwnQuery() {
+ M_Subcategory subCategory = new M_Subcategory();
+ ArrayList stored = new ArrayList<>(List.of(subCategory));
+ ArrayList views = new ArrayList<>(List.of(new V_Showsubcategory()));
+ when(subCategoryRepo.saveAll(anyList())).thenReturn(stored);
+ when(subCategoryRepo.getCategory()).thenReturn(stored);
+ when(subCategoryRepo.getCategory(81)).thenReturn(stored);
+ when(subCategoryRepo.getSubCategory(91)).thenReturn(subCategory);
+ when(subCategoryRepo.save(subCategory)).thenReturn(subCategory);
+ when(v_ShowsubcategoryRepo.getSubCategory1(91)).thenReturn(views);
+ when(v_ShowsubcategoryRepo.getCategoryByMapIDAndSubServiceID(PSM_ID, 61)).thenReturn(views);
+
+ assertSame(stored, categoryService.saveSubCatData(new ArrayList<>()));
+ assertSame(stored, categoryService.createSubCategory(new ArrayList<>()));
+ assertSame(stored, categoryService.getCategory());
+ assertSame(stored, categoryService.getCategory(81));
+ assertSame(subCategory, categoryService.getSubCategory(91));
+ assertSame(subCategory, categoryService.updateSubCatData(subCategory));
+ assertSame(views, categoryService.getSubCategory1(91));
+ assertSame(views, categoryService.getCategoryByMapIDAndSubServiceID(PSM_ID, 61));
+ }
+
+ @Test
+ @DisplayName("the category calls should each reach their own repository query")
+ void categoryCalls_shouldReachTheirOwnQuery() {
+ M_Category category = new M_Category();
+ ArrayList stored = new ArrayList<>(List.of(category));
+ when(categoryRepo.saveAll(anyList())).thenReturn(stored);
+ when(categoryRepo.getAllCategory(61, PSM_ID)).thenReturn(stored);
+ when(categoryRepo.getAllCategory1(PSM_ID)).thenReturn(stored);
+ when(categoryRepo.getCatData(81)).thenReturn(category);
+ when(categoryRepo.save(category)).thenReturn(category);
+ when(categoryRepo.updateCategory(81, 21)).thenReturn(1);
+ when(categoryRepo.findByProviderServiceMapIDAndFeedbackNatureIDOrderByCategoryNameAsc(PSM_ID, null))
+ .thenReturn(stored);
+
+ assertSame(stored, categoryService.createcat(new ArrayList<>()));
+ assertSame(stored, categoryService.getAllCategory(61, PSM_ID));
+ assertSame(stored, categoryService.getAllCategory1(PSM_ID));
+ assertSame(category, categoryService.getcatdatabycatId(81));
+ assertSame(category, categoryService.deletedata(category));
+ assertEquals(1, categoryService.updateCategory(81, 21));
+ assertSame(stored, categoryService.getUpmappedCategory(PSM_ID));
+ }
+
+ @Test
+ @DisplayName("getAllCategory should rebuild one category per row the query answers")
+ void getAllCategory_shouldRebuildEachRow() {
+ when(categoryRepo.getAllCategory(PSM_ID))
+ .thenReturn(List.of(new Object[] { 81, "Medical", 61, "Counselling", PSM_ID }));
+
+ ArrayList categories = categoryService.getAllCategory(PSM_ID);
+
+ assertEquals(1, categories.size());
+ assertEquals("Medical", categories.get(0).getCategoryName());
+ }
+
+ @Test
+ @DisplayName("getAllCategorywithFeedbackNatureID should rebuild one category per row the query answers")
+ void getAllCategoryWithFeedbackNature_shouldRebuildEachRow() {
+ when(categoryRepo.getAllCategorywithfeedbackNatureID(PSM_ID, 21))
+ .thenReturn(List.of(new Object[] { 81, "Medical", 61, "Counselling", PSM_ID }));
+
+ assertEquals(1, categoryService.getAllCategorywithFeedbackNatureID(PSM_ID, 21).size());
+ }
+ }
+
+ @Nested
+ @DisplayName("DrugMasterImpl")
+ class DrugServiceTests {
+
+ @Test
+ @DisplayName("getAllDrugData should read the live catalogue when the caller excludes retired drugs")
+ void getAllDrugData_shouldReadLiveCatalogue() {
+ when(drugMasterRepo.getValidDrugData("77"))
+ .thenReturn(List.of(new Object[] { 101, "Paracetamol", "Antipyretic", "OTC",
+ Boolean.FALSE, (short) 77 }));
+
+ ArrayList drugs = drugService.getAllDrugData(101, (short) 77, Boolean.FALSE);
+
+ assertEquals(1, drugs.size());
+ assertEquals("Paracetamol", drugs.get(0).getDrugName());
+ verify(drugMasterRepo, org.mockito.Mockito.never()).getAllDrugData(anyString(), anyString());
+ }
+
+ @Test
+ @DisplayName("getAllDrugData should read the whole catalogue when retired drugs are wanted too")
+ void getAllDrugData_shouldReadWholeCatalogue() {
+ when(drugMasterRepo.getAllDrugData("101", "77")).thenReturn(new ArrayList<>());
+
+ drugService.getAllDrugData(101, (short) 77, Boolean.TRUE);
+
+ verify(drugMasterRepo).getAllDrugData("101", "77");
+ }
+
+ @Test
+ @DisplayName("getAllDrugData should ask for the whole catalogue when the caller names nothing")
+ void getAllDrugData_shouldAskForWholeCatalogueWithoutFilters() {
+ when(drugMasterRepo.getAllDrugData("", "")).thenReturn(new ArrayList<>());
+
+ drugService.getAllDrugData(null, null, null);
+
+ verify(drugMasterRepo).getAllDrugData("", "");
+ }
+
+ @Test
+ @DisplayName("getAllDrugGroups should read the live groups when the caller excludes retired ones")
+ void getAllDrugGroups_shouldReadLiveGroups() {
+ when(drugGroupRepo.getValidDrugGroups("77"))
+ .thenReturn(List.of(new Object[] { 201, "Analgesics", "Pain relief", Boolean.FALSE,
+ (short) 77 }));
+
+ assertEquals(1, drugService.getAllDrugGroups(201, (short) 77, Boolean.FALSE).size());
+ }
+
+ @Test
+ @DisplayName("getAllDrugGroups should read every group when retired ones are wanted too")
+ void getAllDrugGroups_shouldReadEveryGroup() {
+ when(drugGroupRepo.getAllDrugGroups("201", "77")).thenReturn(new ArrayList<>());
+
+ drugService.getAllDrugGroups(201, (short) 77, Boolean.TRUE);
+
+ verify(drugGroupRepo).getAllDrugGroups("201", "77");
+ }
+
+ @Test
+ @DisplayName("getAllDrugGroupMappings should rebuild one mapping per row the query answers")
+ void getAllDrugGroupMappings_shouldRebuildEachRow() {
+ when(drugMappingRepo.getAllDrugGroupMappings("", 77, 3))
+ .thenReturn(List.of(new Object[] { 301, 101, "Paracetamol", 201, "Analgesics", "OTC",
+ Boolean.FALSE, 77, PSM_ID, "N", Boolean.FALSE }));
+
+ assertEquals(1, drugService.getAllDrugGroupMappings(null, 77, 3).size());
+ }
+
+ @Test
+ @DisplayName("the drug writes should each reach their own repository")
+ void drugWrites_shouldReachTheirOwnRepository() {
+ M_104druggroup group = new M_104druggroup();
+ group.setDrugGroupID(201);
+ M_104drugmaster drug = new M_104drugmaster();
+ M_104drugmapping mapping = new M_104drugmapping();
+ ArrayList groups = new ArrayList<>(List.of(group));
+ ArrayList