Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
UniqueIdRepository extends BaseRepository { public UniqueId getNextUniqueId() { UniqueId uniqueId = null; Cursor cursor = null; try { cursor = getReadableDatabase().query(UniqueIds_TABLE_NAME, UniqueIds_TABLE_COLUMNS, STATUS_COLUMN + " = ?", new String[]{STATUS_NOT_USED}, null, null, CREATED_AT_COLUMN + " ASC", "1"); List<UniqueId> ids = readAll(cursor); uniqueId = ids.isEmpty() ? null : ids.get(0); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } if (uniqueId != null) { reserve(uniqueId.getOpenmrsId()); } return uniqueId; } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }
@Test public void testGetNextUniqueId() { when(sqLiteDatabase.query(any(), any(), any(), any(), any(), any(), anyString(), anyString())).thenReturn(getUniqueIdCursor()); UniqueId actualUniqueId = uniqueIdRepository.getNextUniqueId(); assertEquals("12", actualUniqueId.getId()); assertEquals("openrs-id1", actualUniqueId.getOpenmrsId()); assertEquals("test-owner", actualUniqueId.getUsedBy()); assertEquals(new Date(1583830167).toString(), actualUniqueId.getCreatedAt().toString()); }
UniqueIdRepository extends BaseRepository { private ContentValues createValuesFor(UniqueId uniqueId) { ContentValues values = new ContentValues(); values.put(ID_COLUMN, uniqueId.getId()); values.put(OPENMRS_ID_COLUMN, uniqueId.getOpenmrsId()); values.put(STATUS_COLUMN, uniqueId.getStatus()); values.put(USED_BY_COLUMN, uniqueId.getUsedBy()); values.put(CREATED_AT_COLUMN, dateFormat.format(uniqueId.getCreatedAt())); return values; } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }
@Test public void testCreateValuesFor() { UniqueId expectedUniqueId = new UniqueId("12", "openrs-id1", "not_used", "test-owner", new Date()); uniqueIdRepository.add(expectedUniqueId); verify(sqLiteDatabase).insert(stringArgumentCaptor.capture(), eq(null), contentValuesArgumentCaptor.capture()); assertEquals("unique_ids", stringArgumentCaptor.getValue()); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("12", values.getAsString("_id")); assertEquals("openrs-id1", values.getAsString("openmrs_id")); assertEquals("not_used", values.getAsString("status")); assertEquals("test-owner", values.getAsString("used_by")); assertNotNull(values.getAsString("created_at")); }
UniqueIdRepository extends BaseRepository { public int releaseReservedIds() { ContentValues values = new ContentValues(); values.put(STATUS_COLUMN, STATUS_NOT_USED); values.put(USED_BY_COLUMN, ""); values.put(UPDATED_AT_COLUMN, dateFormat.format(new Date())); return getWritableDatabase().update(UniqueIds_TABLE_NAME, values, STATUS_COLUMN + " = ?", new String[]{STATUS_RESERVED}); } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }
@Test public void testReleaseReserveIds() { uniqueIdRepository.releaseReservedIds(); verify(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(),argsCaptor.capture()); Assert.assertNotNull(stringArgumentCaptor.getValue()); assertEquals("unique_ids", stringArgumentCaptor.getAllValues().get(0)); assertEquals("status = ?", stringArgumentCaptor.getAllValues().get(1)); assertEquals("reserved", argsCaptor.getValue()[0]); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("not_used", values.getAsString("status")); assertEquals("", values.getAsString("used_by")); }
UniqueIdRepository extends BaseRepository { public int open(String openmrsId) { try { String openmrsId_ = !openmrsId.contains("-") ? formatId(openmrsId) : openmrsId; ContentValues values = new ContentValues(); values.put(STATUS_COLUMN, STATUS_NOT_USED); values.put(USED_BY_COLUMN, ""); values.put(UPDATED_AT_COLUMN, dateFormat.format(new Date())); return updateOpenMRSIdentifierStatus(openmrsId_, values); } catch (Exception e) { Timber.e(e); return 0; } } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }
@Test public void testOpen() { String openMrsId = "3298938-2"; uniqueIdRepository.open(openMrsId); verify(sqLiteDatabase, times(2)).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); Assert.assertNotNull(stringArgumentCaptor.getValue()); assertEquals("unique_ids", stringArgumentCaptor.getAllValues().get(0)); assertEquals("openmrs_id = ?", stringArgumentCaptor.getAllValues().get(1)); assertEquals("32989382", argsCaptor.getValue()[0]); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("not_used", values.getAsString("status")); assertEquals("", values.getAsString("used_by")); }
P2PSenderTransferDao extends BaseP2PTransferDao implements SenderTransferDao { @Nullable @Override public TreeSet<DataType> getDataTypes() { TreeSet<DataType> dataTypeTreeSet = new TreeSet<>(); if (locationFilterEnabled()) { for (String location : getP2POptions().getLocationsFilter()) { for (DataType dataType : dataTypes) { dataTypeTreeSet.add(new DataType(dataType.getName() + SEPARATOR + location, dataType.getType(), dataTypeTreeSet.size())); } } return dataTypeTreeSet; } else { return new TreeSet<>(dataTypes); } } @Nullable @Override TreeSet<DataType> getDataTypes(); @Nullable @Override JsonData getJsonData(@NonNull DataType dataType, long lastRecordId, int batchSize); @Nullable @Override MultiMediaData getMultiMediaData(@NonNull DataType dataType, long lastRecordId); P2POptions getP2POptions(); }
@Test public void getDataTypesShouldReturnACloneOfDataType() { TreeSet<DataType> dataTypes = p2PSenderTransferDao.getDataTypes(); Assert.assertEquals(p2PSenderTransferDao.dataTypes.size(), dataTypes.size()); Assert.assertTrue(p2PSenderTransferDao.dataTypes != dataTypes); DataType[] expectedDataTypes = p2PSenderTransferDao.dataTypes.toArray(new DataType[0]); DataType[] actualDataTypes = dataTypes.toArray(new DataType[0]); for (int i = 0; i < expectedDataTypes.length; i++) { Assert.assertEquals(expectedDataTypes[i].getName(), actualDataTypes[i].getName()); Assert.assertEquals(expectedDataTypes[i].getPosition(), actualDataTypes[i].getPosition()); } }
P2PSenderTransferDao extends BaseP2PTransferDao implements SenderTransferDao { @Nullable @Override public JsonData getJsonData(@NonNull DataType dataType, long lastRecordId, int batchSize) { String locationId = null; if (locationFilterEnabled()) { String[] dataTypeParams = dataType.getName().split(SEPARATOR); locationId = dataTypeParams.length == 1 ? null : dataTypeParams[1]; } if (dataType.getName().startsWith(event.getName())) { return CoreLibrary.getInstance().context() .getEventClientRepository().getEvents(lastRecordId, batchSize, locationId); } else if (dataType.getName().startsWith(client.getName())) { if (DrishtiApplication.getInstance().getP2PClassifier() == null) { return CoreLibrary.getInstance().context() .getEventClientRepository().getClients(lastRecordId, batchSize, locationId); } else { return CoreLibrary.getInstance().context() .getEventClientRepository().getClientsWithLastLocationID(lastRecordId, batchSize); } } else if (dataType.getName().startsWith(structure.getName())) { return CoreLibrary.getInstance().context() .getStructureRepository().getStructures(lastRecordId, batchSize, locationId); } else if (dataType.getName().startsWith(task.getName())) { return CoreLibrary.getInstance().context() .getTaskRepository().getTasks(lastRecordId, batchSize, locationId); } else if (CoreLibrary.getInstance().context().hasForeignEvents() && dataType.getName().startsWith(foreignClient.getName())) { return CoreLibrary.getInstance().context() .getForeignEventClientRepository().getClients(lastRecordId, batchSize, locationId); } else if (CoreLibrary.getInstance().context().hasForeignEvents() && dataType.getName().startsWith(foreignEvent.getName())) { return CoreLibrary.getInstance().context() .getForeignEventClientRepository().getEvents(lastRecordId, batchSize, locationId); } else { Timber.e(P2PLibrary.getInstance().getContext().getString(R.string.log_data_type_provided_does_not_exist_in_the_sender) , dataType.getName()); return null; } } @Nullable @Override TreeSet<DataType> getDataTypes(); @Nullable @Override JsonData getJsonData(@NonNull DataType dataType, long lastRecordId, int batchSize); @Nullable @Override MultiMediaData getMultiMediaData(@NonNull DataType dataType, long lastRecordId); P2POptions getP2POptions(); }
@Test public void getJsonDataShouldCallEventRepositoryGetEventsWhenDataTypeIsEvent() { EventClientRepository eventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "eventClientRepository", eventClientRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(eventClientRepository).getEvents(lastRecordId, batchSize, null); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.event, lastRecordId, batchSize); Mockito.verify(eventClientRepository).getEvents(lastRecordId, batchSize, null); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallEventRepositoryGetClientsWhenDataTypeIsClient() { EventClientRepository eventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "eventClientRepository", eventClientRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(eventClientRepository).getClients(lastRecordId, batchSize, null); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.client, lastRecordId, batchSize); Mockito.verify(eventClientRepository).getClients(lastRecordId, batchSize, null); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallEventRepositoryGetClientsWithLocationIdWhenDataTypeIsClientAndP2pClassifierIsConfigured() { EventClientRepository eventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "eventClientRepository", eventClientRepository); ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(eventClientRepository).getClientsWithLastLocationID(lastRecordId, batchSize); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.client, lastRecordId, batchSize); Mockito.verify(eventClientRepository).getClientsWithLastLocationID(lastRecordId, batchSize); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallStructureRepositoryGetStructuresWhenDataTypeIsStructure() { StructureRepository structureRepository = Mockito.spy(CoreLibrary.getInstance().context().getStructureRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "structureRepository", structureRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(structureRepository).getStructures(lastRecordId, batchSize, locationId); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.structure, lastRecordId, batchSize); Mockito.verify(structureRepository).getStructures(lastRecordId, batchSize, locationId); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallTaskRepositoryGetTasksWhenDataTypeIsTask() { TaskRepository taskRepository = Mockito.spy(CoreLibrary.getInstance().context().getTaskRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "taskRepository", taskRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(taskRepository).getTasks(lastRecordId, batchSize, locationId); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.task, lastRecordId, batchSize); Mockito.verify(taskRepository).getTasks(lastRecordId, batchSize, locationId); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallEventRepositoryGetClientsWhenContextHasForeignEventsAndDataTypeIsForeignClient() { ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); EventClientRepository foreignEventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getForeignEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "foreignEventClientRepository", foreignEventClientRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(foreignEventClientRepository).getClients(lastRecordId, batchSize, null); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.foreignClient, lastRecordId, batchSize); Mockito.verify(foreignEventClientRepository).getClients(lastRecordId, batchSize, null); Assert.assertEquals(jsonData, actualJsonData); } @Test public void getJsonDataShouldCallEventRepositoryGetEventsWhenContextHasForeignEventsAndDataTypeIsForeignEvent() { ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); EventClientRepository foreignEventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getForeignEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "foreignEventClientRepository", foreignEventClientRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(foreignEventClientRepository).getEvents(lastRecordId, batchSize, null); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(p2PSenderTransferDao.foreignEvent, lastRecordId, batchSize); Mockito.verify(foreignEventClientRepository).getEvents(lastRecordId, batchSize, null); Assert.assertEquals(jsonData, actualJsonData); } @Config(application = TestP2pApplication.class) @Test public void getJsonDataShouldReturnNullAndMakeNoCallsWhenContextHasForeignEventsAndDataTypeIsCoach() { EventClientRepository foreignEventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getForeignEventClientRepository()); EventClientRepository eventClientRepository = Mockito.spy(CoreLibrary.getInstance().context().getEventClientRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "foreignEventClientRepository", foreignEventClientRepository); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "eventClientRepository", eventClientRepository); int lastRecordId = 789; int batchSize = 100; JsonData jsonData = Mockito.mock(JsonData.class); Mockito.doReturn(jsonData).when(foreignEventClientRepository).getEvents(lastRecordId, batchSize, null); DataType coachDataType = new DataType("coach", DataType.Type.NON_MEDIA, 99); JsonData actualJsonData = p2PSenderTransferDao.getJsonData(coachDataType, lastRecordId, batchSize); Assert.assertNull(actualJsonData); Mockito.verify(foreignEventClientRepository, Mockito.never()).getEvents(lastRecordId, batchSize, null); Mockito.verify(foreignEventClientRepository, Mockito.never()).getClients(lastRecordId, batchSize, null); Mockito.verify(eventClientRepository, Mockito.never()).getEvents(lastRecordId, batchSize, null); Mockito.verify(eventClientRepository, Mockito.never()).getClients(lastRecordId, batchSize, null); }
P2PSenderTransferDao extends BaseP2PTransferDao implements SenderTransferDao { @Nullable @Override public MultiMediaData getMultiMediaData(@NonNull DataType dataType, long lastRecordId) { if (dataType.getName().equalsIgnoreCase(profilePic.getName())) { HashMap<String, Object> imageDetails = CoreLibrary.getInstance().context() .imageRepository().getImage(lastRecordId); if (imageDetails != null) { File inputFile = new File((String) imageDetails.get(ImageRepository.filepath_COLUMN)); if (inputFile.exists()) { MultiMediaData multiMediaData = new MultiMediaData( inputFile, (long) imageDetails.get(AllConstants.ROWID) ); imageDetails.remove(ImageRepository.filepath_COLUMN); HashMap<String, String> multimediaDataDetails = new HashMap<>(); multimediaDataDetails.put(ImageRepository.syncStatus_COLUMN, (String) imageDetails.get(ImageRepository.syncStatus_COLUMN)); multimediaDataDetails.put(AllConstants.ROWID, String.valueOf((long) imageDetails.get(AllConstants.ROWID))); multimediaDataDetails.put(ImageRepository.filecategory_COLUMN, (String) imageDetails.get(ImageRepository.filecategory_COLUMN)); multimediaDataDetails.put(ImageRepository.anm_ID_COLUMN, (String) imageDetails.get(ImageRepository.anm_ID_COLUMN)); multimediaDataDetails.put(ImageRepository.entityID_COLUMN, (String) imageDetails.get(ImageRepository.entityID_COLUMN)); multiMediaData.setMediaDetails(multimediaDataDetails); return multiMediaData; } else { return null; } } return null; } else { Timber.e(P2PLibrary.getInstance().getContext().getString(R.string.log_data_type_provided_does_not_exist_in_the_sender) , dataType.getName()); return null; } } @Nullable @Override TreeSet<DataType> getDataTypes(); @Nullable @Override JsonData getJsonData(@NonNull DataType dataType, long lastRecordId, int batchSize); @Nullable @Override MultiMediaData getMultiMediaData(@NonNull DataType dataType, long lastRecordId); P2POptions getP2POptions(); }
@Test public void getMultiMediaDataShouldCallImageRepositoryAndReturnMultiMediaDataWhenDataTypeIsProfielPic() throws IOException { ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); ImageRepository imageRepository = Mockito.spy(CoreLibrary.getInstance().context().imageRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "imageRepository", imageRepository); int lastRecordId = 789; String anmId = "90293-fsdawecSD"; String imagePath = "profile-pig.png"; new File(imagePath).createNewFile(); HashMap<String, Object> imageDetails = new HashMap<>(); imageDetails.put(ImageRepository.filepath_COLUMN, imagePath); imageDetails.put(ImageRepository.syncStatus_COLUMN, SyncStatus.SYNCED.value()); imageDetails.put(AllConstants.ROWID, 87L); imageDetails.put(ImageRepository.filecategory_COLUMN, "profile-pic-male"); imageDetails.put(ImageRepository.anm_ID_COLUMN, anmId); imageDetails.put(ImageRepository.entityID_COLUMN, "entity-id"); Mockito.doReturn(imageDetails).when(imageRepository).getImage(lastRecordId); MultiMediaData actualJsonData = p2PSenderTransferDao.getMultiMediaData(p2PSenderTransferDao.profilePic, lastRecordId); Mockito.verify(imageRepository).getImage(lastRecordId); Assert.assertEquals("entity-id", actualJsonData.getMediaDetails().get(ImageRepository.entityID_COLUMN)); Assert.assertEquals(anmId, actualJsonData.getMediaDetails().get(ImageRepository.anm_ID_COLUMN)); Assert.assertEquals("profile-pic-male", actualJsonData.getMediaDetails().get(ImageRepository.filecategory_COLUMN)); Assert.assertEquals(SyncStatus.SYNCED.value(), actualJsonData.getMediaDetails().get(ImageRepository.syncStatus_COLUMN)); Assert.assertEquals(String.valueOf(87L), actualJsonData.getMediaDetails().get(AllConstants.ROWID)); Assert.assertEquals(87L, actualJsonData.getRecordId()); Assert.assertNotNull(actualJsonData.getFile()); } @Test public void getMultiMediaDataShouldReturnNullWhenDataTypeIsNotProfielPic() throws IOException { ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); ImageRepository imageRepository = Mockito.spy(CoreLibrary.getInstance().context().imageRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "imageRepository", imageRepository); int lastRecordId = 789; String anmId = "90293-fsdawecSD"; String imagePath = "profile-pig.png"; new File(imagePath).createNewFile(); HashMap<String, Object> imageDetails = new HashMap<>(); imageDetails.put(ImageRepository.filepath_COLUMN, imagePath); imageDetails.put(ImageRepository.syncStatus_COLUMN, SyncStatus.SYNCED.value()); imageDetails.put(AllConstants.ROWID, 87L); imageDetails.put(ImageRepository.filecategory_COLUMN, "profile-pic-male"); imageDetails.put(ImageRepository.anm_ID_COLUMN, anmId); imageDetails.put(ImageRepository.entityID_COLUMN, "entity-id"); Mockito.doReturn(imageDetails).when(imageRepository).getImage(lastRecordId); DataType dataType = new DataType("some data type", DataType.Type.MEDIA, 9); MultiMediaData actualJsonData = p2PSenderTransferDao.getMultiMediaData(dataType, lastRecordId); Mockito.verify(imageRepository, Mockito.times(0)).getImage(lastRecordId); Assert.assertNull(actualJsonData); } @Test public void getMultiMediaDataShouldCallImageRepositoryAndReturnNullWhenDataTypeIsProfielPicAndImageRecordIsNotFound() throws IOException { ((TestApplication) TestApplication.getInstance()).setP2PClassifier(Mockito.mock(P2PClassifier.class)); ImageRepository imageRepository = Mockito.spy(CoreLibrary.getInstance().context().imageRepository()); ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "imageRepository", imageRepository); int lastRecordId = 789; Mockito.doReturn(null).when(imageRepository).getImage(lastRecordId); MultiMediaData actualJsonData = p2PSenderTransferDao.getMultiMediaData(p2PSenderTransferDao.profilePic, lastRecordId); Mockito.verify(imageRepository, Mockito.times(1)).getImage(lastRecordId); Assert.assertNull(actualJsonData); }
ClientRelationshipRepository extends BaseRepository { public static void createTable(SQLiteDatabase database) { database.execSQL(CREATE_TABLE); database.execSQL(CREATE_BASE_ENTITY_ID_INDEX); } static void createTable(SQLiteDatabase database); void saveRelationship(ClientRelationship... clientRelationships); List<Client> findClientByRelationship(String relationShip, String relationalId); }
@Test public void testCreateTableShouldCreateTableAndIndex() { ClientRelationshipRepository.createTable(database); verify(database).execSQL(ClientRelationshipRepository.CREATE_TABLE); verify(database).execSQL(ClientRelationshipRepository.CREATE_BASE_ENTITY_ID_INDEX); }
ClientRelationshipRepository extends BaseRepository { public List<Client> findClientByRelationship(String relationShip, String relationalId) { List<Client> clientList = new ArrayList<>(); String query = String.format("SELECT %s FROM %s JOIN %s ON %s=%s WHERE %s=? AND %s =?", client_column.json.name(), CLIENT_RELATIONSHIP_TABLE_NAME, client.name(), BASE_ENTITY_ID, client_column.baseEntityId.name(), RELATIONSHIP, RELATIONAL_ID); try (Cursor cursor = getReadableDatabase().rawQuery(query, new String[]{relationShip, relationalId})) { while (cursor.moveToNext()) { clientList.add(JsonFormUtils.gson.fromJson(cursor.getString(0), Client.class)); } } catch (SQLException e) { Timber.e(e); } return clientList; } static void createTable(SQLiteDatabase database); void saveRelationship(ClientRelationship... clientRelationships); List<Client> findClientByRelationship(String relationShip, String relationalId); }
@Test public void findClientByRelationshipShouldReturnClients() throws JSONException { ClientRelationshipRepository repository = spy(new ClientRelationshipRepository()); when(repository.getReadableDatabase()).thenReturn(database); when(database.rawQuery(anyString(), any())).thenReturn(getClients()); List<Client> clients = repository.findClientByRelationship("family", "12323"); assertEquals(1, clients.size()); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6",clients.get(0).getBaseEntityId()); }
PlanDefinitionRepository extends BaseRepository { public static void createTable(SQLiteDatabase database) { database.execSQL(CREATE_PLAN_DEFINITION_TABLE); } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testCreateTable() { PlanDefinitionRepository.createTable(sqLiteDatabase); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals("CREATE TABLE plan_definition (_id VARCHAR NOT NULL PRIMARY KEY,json VARCHAR NOT NULL,status VARCHAR NOT NULL)", stringArgumentCaptor.getValue()); }
PlanDefinitionRepository extends BaseRepository { public void addOrUpdate(PlanDefinition planDefinition) { if (DRAFT.equalsIgnoreCase(planDefinition.getStatus().value())) return; try { getWritableDatabase().beginTransaction(); ContentValues contentValues = new ContentValues(); contentValues.put(ID, planDefinition.getIdentifier()); contentValues.put(STATUS, planDefinition.getStatus().value()); for (Jurisdiction jurisdiction : planDefinition.getJurisdiction()) { searchRepository.addOrUpdate(planDefinition, jurisdiction.getCode()); } planDefinition.setJurisdiction(new ArrayList<>()); contentValues.put(JSON, gson.toJson(planDefinition)); getWritableDatabase().replace(PLAN_DEFINITION_TABLE, null, contentValues); getWritableDatabase().setTransactionSuccessful(); } finally { getWritableDatabase().endTransaction(); } } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testAddOrUpdate() { PlanDefinition planDefinition = gson.fromJson(planDefinitionJSON, PlanDefinition.class); int jurisdictionCount = planDefinition.getJurisdiction().size(); planDefinitionRepository.addOrUpdate(planDefinition); verify(sqLiteDatabase, Mockito.times(jurisdictionCount + 1)).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals((jurisdictionCount + 1) * 2, stringArgumentCaptor.getAllValues().size()); assertEquals("plan_definition_search", stringArgumentCaptor.getAllValues().get(0)); assertNull(stringArgumentCaptor.getAllValues().get(1)); assertEquals(jurisdictionCount + 1, contentValuesArgumentCaptor.getAllValues().size()); assertEquals(planDefinition.getIdentifier(), contentValuesArgumentCaptor.getAllValues().get(0).get(PLAN_ID)); assertEquals(planDefinition.getName(), contentValuesArgumentCaptor.getAllValues().get(0).get(NAME)); assertEquals(planDefinition.getStatus().value(), contentValuesArgumentCaptor.getAllValues().get(0).get(STATUS)); } @Test public void testAddOrUpdateSavesSearchTable() { Whitebox.setInternalState(planDefinitionRepository, "searchRepository", searchRepository); PlanDefinition planDefinition = gson.fromJson(planDefinitionJSON, PlanDefinition.class); String jurisdictionId = UUID.randomUUID().toString(); planDefinition.setJurisdiction(Collections.singletonList(new Jurisdiction(jurisdictionId))); planDefinitionRepository.addOrUpdate(planDefinition); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); assertEquals("plan_definition", stringArgumentCaptor.getAllValues().get(0)); assertNull(stringArgumentCaptor.getAllValues().get(1)); assertEquals(3, contentValuesArgumentCaptor.getValue().size()); assertEquals(planDefinition.getIdentifier(), contentValuesArgumentCaptor.getValue().get(ID)); verify(searchRepository).addOrUpdate(planDefinition, jurisdictionId); }
PlanDefinitionRepository extends BaseRepository { public PlanDefinition findPlanDefinitionById(String identifier) { Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT " + JSON + " FROM " + PLAN_DEFINITION_TABLE + " WHERE " + ID + " =?", new String[]{identifier}); if (cursor.moveToFirst()) { return gson.fromJson(cursor.getString(0), PlanDefinition.class); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return null; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testFindPlanDefinitionById() { when(sqLiteDatabase.rawQuery(anyString(), any(String[].class))) .thenReturn(getCursor()); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNotNull(planDefinition); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition.getIdentifier()); assertEquals(planDefinitionJSON, gson.toJson(planDefinition)); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); } @Test public void testFindPlanDefinitionByIdShouldReturnNull() { when(sqLiteDatabase.rawQuery(anyString(), any(String[].class))) .thenReturn(new MatrixCursor(new String[]{})); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNull(planDefinition); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); } @Test public void testFindPlanDefinitionByIdWithException() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), any(String[].class)); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNull(planDefinition); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); }
PlanDefinitionRepository extends BaseRepository { public Set<PlanDefinition> findAllPlanDefinitions() { Cursor cursor = null; Set<PlanDefinition> planDefinitions = new TreeSet<>(); try { String query = String.format("SELECT %s FROM %s WHERE %s =?", JSON, PLAN_DEFINITION_TABLE, STATUS); cursor = getReadableDatabase().rawQuery(query, new String[]{ACTIVE.value()}); while (cursor.moveToNext()) { planDefinitions.add(gson.fromJson(cursor.getString(0), PlanDefinition.class)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return planDefinitions; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testFindAllPlanDefinitions() { when(sqLiteDatabase.rawQuery(anyString(), argsCaptor.capture())) .thenReturn(getCursor()); Set<PlanDefinition> planDefinitions = planDefinitionRepository.findAllPlanDefinitions(); assertNotNull(planDefinitions); PlanDefinition planDefinition = planDefinitions.iterator().next(); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition.getIdentifier()); assertEquals(planDefinitionJSON, gson.toJson(planDefinition)); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); } @Test public void testFindAllPlanDefinitionsWithExceptions() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), argsCaptor.capture()); Set<PlanDefinition> planDefinitions = planDefinitionRepository.findAllPlanDefinitions(); assertTrue(planDefinitions.isEmpty()); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); }
PlanDefinitionRepository extends BaseRepository { public Set<String> findAllPlanDefinitionIds() { Cursor cursor = null; Set<String> ids = new HashSet<>(); try { String query = String.format("SELECT %s FROM %s WHERE %s =?", ID, PLAN_DEFINITION_TABLE, STATUS); cursor = getReadableDatabase().rawQuery(query, new String[]{ACTIVE.value()}); while (cursor.moveToNext()) { ids.add(cursor.getString(0)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return ids; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testFindAllPlanDefinitionIds() { when(sqLiteDatabase.rawQuery(anyString(), argsCaptor.capture())) .thenReturn(getIdCursor()); Set<String> planDefinitions = planDefinitionRepository.findAllPlanDefinitionIds(); assertNotNull(planDefinitions); assertEquals(1, planDefinitions.size()); String planDefinition = planDefinitions.iterator().next(); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition); verify(sqLiteDatabase).rawQuery("SELECT _id FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); } @Test public void testFindAllPlanDefinitionIdsWithException() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), any()); Set<String> planDefinitions = planDefinitionRepository.findAllPlanDefinitionIds(); assertTrue(planDefinitions.isEmpty()); verify(sqLiteDatabase).rawQuery("SELECT _id FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); }
PlanDefinitionRepository extends BaseRepository { public Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers) { Cursor cursor = null; Set<PlanDefinition> planDefinitions = new HashSet<>(); try { String query = String.format("SELECT %s FROM %s WHERE %s IN (%s)", JSON, PLAN_DEFINITION_TABLE, ID, TextUtils.join(",", Collections.nCopies(identifiers.size(), "?"))); cursor = getReadableDatabase().rawQuery(query, identifiers.toArray(new String[0])); while (cursor.moveToNext()) { planDefinitions.add(gson.fromJson(cursor.getString(0), PlanDefinition.class)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return planDefinitions; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }
@Test public void testFindPlanDefinitionByIds() { when(sqLiteDatabase.rawQuery(anyString(), any(String[].class))) .thenReturn(getMultiplePlanCursor()); Set<String> expectedIdentifiers = new HashSet<>(); expectedIdentifiers.add("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); expectedIdentifiers.add("10f9e9fa-ce34-4b27-a961-72fab5206ab6"); Set<PlanDefinition> expectedPlanDefinitions = new HashSet<>(); expectedPlanDefinitions.add(gson.fromJson(planDefinitionJSON, PlanDefinition.class)); expectedPlanDefinitions.add(gson.fromJson(fiPlanDefinitionJSON, PlanDefinition.class)); Set<PlanDefinition> planDefinitionsSet = planDefinitionRepository.findPlanDefinitionByIds(expectedIdentifiers); assertNotNull(planDefinitionsSet); assertFalse(planDefinitionsSet.isEmpty()); assertEquals(2, planDefinitionsSet.size()); Iterator<PlanDefinition> iterator = planDefinitionsSet.iterator(); while (iterator.hasNext()){ PlanDefinition planDefinition = iterator.next(); expectedIdentifiers.contains(planDefinition.getIdentifier()); expectedPlanDefinitions.contains(planDefinition); } verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); List<String> planIds = Arrays.asList(argsCaptor.getAllValues().get(0)); assertTrue(planIds.contains("4708ca0a-d0d6-4199-bb1b-8701803c2d02")); assertTrue(planIds.contains("10f9e9fa-ce34-4b27-a961-72fab5206ab6")); assertEquals("SELECT json FROM plan_definition WHERE _id IN (?,?)", stringArgumentCaptor.getValue()); } @Test public void testFindPlanDefinitionByIdsWithExceptionThrown() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), any(String[].class)); Set<String> expectedIdentifiers = new HashSet<>(); expectedIdentifiers.add("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); expectedIdentifiers.add("10f9e9fa-ce34-4b27-a961-72fab5206ab6"); Set<PlanDefinition> planDefinitionsSet = planDefinitionRepository.findPlanDefinitionByIds(expectedIdentifiers); assertTrue(planDefinitionsSet.isEmpty()); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); List<String> planIds = Arrays.asList(argsCaptor.getAllValues().get(0)); assertTrue(planIds.contains("4708ca0a-d0d6-4199-bb1b-8701803c2d02")); assertTrue(planIds.contains("10f9e9fa-ce34-4b27-a961-72fab5206ab6")); assertEquals("SELECT json FROM plan_definition WHERE _id IN (?,?)", stringArgumentCaptor.getValue()); }
UrlUtil { public static boolean isValidUrl(String s){ return new UrlValidator(new String[]{"http", "https"}).isValid(s); } static boolean isValidUrl(String s); }
@Test public void assertValidUrlPasses() { Assert.assertTrue(UrlUtil.isValidUrl("https: Assert.assertTrue(UrlUtil.isValidUrl("http: } @Test public void assertInValidUrlFails() { Assert.assertFalse(UrlUtil.isValidUrl("invalid.org")); Assert.assertFalse(UrlUtil.isValidUrl("error.test")); }
SettingsRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(SETTINGS_SQL); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void assertOnCreate() { settingsRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(anyString()); }
SettingsRepository extends DrishtiRepository { public static void onUpgrade(SQLiteDatabase database) { database.execSQL(ADD_SETTINGS_VERSION); database.execSQL(ADD_SETTINGS_TYPE); database.execSQL(ADD_SETTINGS_SYNC_STATUS); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void testOnUpgradeExecutesCorrectSQLStatement() { settingsRepository.onUpgrade(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(3)).execSQL(anyString()); }
SettingsRepository extends DrishtiRepository { public String querySetting(String key, String defaultValue) { Cursor cursor = null; String value = defaultValue; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, new String[]{SETTINGS_VALUE_COLUMN}, SETTINGS_KEY_COLUMN + " = ?", new String[]{key}, null, null, null, "1"); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { value = cursor.getString(0); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void assertquerySetting() { MatrixCursor matrixCursor = new MatrixCursor(new String[]{SETTINGS_KEY_COLUMN, SETTINGS_VALUE_COLUMN}); matrixCursor.addRow(new String[]{"KEY", "VALUE"}); Mockito.when(sqLiteDatabase.query(anyString(), any(String[].class), anyString(), any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), anyString())).thenReturn(matrixCursor); Assert.assertEquals(settingsRepository.querySetting("", ""), "KEY"); } @Test public void testQuerySetting() { Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), anyString()); Setting s = settingsRepository.querySetting(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "key = ?", new String[]{""}, null, null, null, "1"); Assert.assertEquals(s.getKey(), "testKey"); }
SettingsRepository extends DrishtiRepository { public byte[] queryBLOB(String key) { byte[] value = null; Cursor cursor = null; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, new String[]{SETTINGS_VALUE_COLUMN}, SETTINGS_KEY_COLUMN + " = ?", new String[]{key}, null, null, null, "1"); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { value = cursor.getBlob(0); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void assertqueryBlob() { Mockito.when(sqLiteDatabase.query(anyString(), any(String[].class), anyString(), any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), anyString())).thenReturn(getCursor()); Assert.assertEquals(settingsRepository.queryBLOB(""), null); }
SettingsRepository extends DrishtiRepository { public void updateSetting(String key, String value) { ContentValues values = new ContentValues(); values.put(SETTINGS_KEY_COLUMN, key); values.put(SETTINGS_VALUE_COLUMN, value); replace(values); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void testUpdateSetting() { Setting s = new Setting(); s.setKey("test"); s.setValue("testValue"); s.setVersion("test"); s.setType("test"); s.setSyncStatus("test"); ArgumentCaptor<ContentValues> contentValuesArgumentCaptor = ArgumentCaptor.forClass(ContentValues.class); Mockito.doReturn(1L).when(sqLiteDatabase).replace(Mockito.eq(SETTINGS_TABLE_NAME), Mockito.nullable(String.class), contentValuesArgumentCaptor.capture()); settingsRepository.updateSetting(s); Mockito.verify(sqLiteDatabase, Mockito.times(1)).replace(anyString(), Mockito.isNull(String.class), any(ContentValues.class)); Assert.assertEquals(contentValuesArgumentCaptor.getValue().get(SETTINGS_KEY_COLUMN), "test"); }
SettingsRepository extends DrishtiRepository { public List<Setting> querySettingsByType(String type) { Cursor cursor = null; List<Setting> values = new ArrayList<>(); try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, SETTINGS_PROJECTION , SETTINGS_TYPE_COLUMN + " = ?", new String[]{type}, null, null, null, null); while (cursor != null && cursor.moveToNext()) { values.add(queryCore(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return values; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void testQuerySettingsByType() { Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), nullable(String.class)); List<Setting> lst = settingsRepository.querySettingsByType(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "type = ?", new String[]{""}, null, null, null, null); Assert.assertEquals(lst.get(0).getKey(), "testKey"); }
SettingsRepository extends DrishtiRepository { public List<Setting> queryUnsyncedSettings() { Cursor cursor = null; List<Setting> values = new ArrayList<>(); try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, SETTINGS_PROJECTION, SETTINGS_SYNC_STATUS_COLUMN + " = ?", new String[]{SyncStatus.PENDING.name()}, null, null, null, null); while (cursor != null && cursor.moveToNext()) { values.add(queryCore(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return values; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void testQueryUnsyncedSettings(){ Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), nullable(String.class)); List<Setting> lst = settingsRepository.queryUnsyncedSettings(); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "sync_status = ?", new String[]{"PENDING"}, null, null, null, null); Assert.assertEquals(lst.get(0).getKey(), "testKey"); }
SettingsRepository extends DrishtiRepository { protected Setting queryCore(Cursor cursor) { Setting value = new Setting(); value.setKey(cursor.getString(cursor.getColumnIndex(SETTINGS_KEY_COLUMN))); value.setValue(cursor.getString(cursor.getColumnIndex(SETTINGS_VALUE_COLUMN))); value.setType(cursor.getString(cursor.getColumnIndex(SETTINGS_TYPE_COLUMN))); value.setVersion(cursor.getString(cursor.getColumnIndex(SETTINGS_VERSION_COLUMN))); value.setSyncStatus(cursor.getString(cursor.getColumnIndex(SETTINGS_SYNC_STATUS_COLUMN))); return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }
@Test public void testQueryCore() { MatrixCursor cursor = getMatrixCursor(); cursor.moveToFirst(); Setting s = settingsRepository.queryCore(cursor); Assert.assertEquals(s.getKey(), "testKey"); }
ChildRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(CHILD_SQL); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertOnCreateCallDatabaseExecSql() { childRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
ChildRepository extends DrishtiRepository { public void add(Child child) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(CHILD_TABLE_NAME, null, createValuesFor(child)); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertAddChildCallsDatabaseSqlInsert() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); childRepository.add(getMockChild()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
ChildRepository extends DrishtiRepository { public void update(Child child) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.update(CHILD_TABLE_NAME, createValuesFor(child), ID_COLUMN + " = ?", new String[]{child.caseId()}); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertUpdateChildCallsDatabaseSqlUpdate() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); childRepository.update(getMockChild()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
ChildRepository extends DrishtiRepository { public List<Child> all() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, IS_CLOSED_COLUMN + " = ?", new String[]{NOT_CLOSED}, null, null, null, null); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertAllChildReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.all()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
ChildRepository extends DrishtiRepository { public Child find(String caseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, ID_COLUMN + " = ?", new String[]{caseId}, null, null, null, null); List<Child> children = readAll(cursor); if (children.isEmpty()) { return null; } return children.get(0); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertFindChildReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.find("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
ChildRepository extends DrishtiRepository { public List<Child> findByMotherCaseId(String caseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, MOTHER_ID_COLUMN + " = ?", new String[]{caseId}, null, null, null, null); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertFindChildByMotherReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.findByMotherCaseId("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
ChildRepository extends DrishtiRepository { public List<Child> findChildrenByCaseIds(String... caseIds) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( String.format("SELECT * FROM %s WHERE %s IN (%s)", CHILD_TABLE_NAME, ID_COLUMN, insertPlaceholdersForInClause(caseIds.length)), caseIds); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertFindChildSReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.findChildrenByCaseIds("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).rawQuery(Mockito.anyString(), Mockito.any(String[].class)); }
ChildRepository extends DrishtiRepository { public List<Child> allChildrenWithMotherAndEC() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( "SELECT " + tableColumnsForQuery(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS) + ", " + tableColumnsForQuery(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS) + ", " + tableColumnsForQuery(EC_TABLE_NAME, EC_TABLE_COLUMNS) + " FROM " + CHILD_TABLE_NAME + ", " + MOTHER_TABLE_NAME + ", " + EC_TABLE_NAME + " " + "WHERE " + CHILD_TABLE_NAME + "." + IS_CLOSED_COLUMN + "= ? AND " + CHILD_TABLE_NAME + "." + MOTHER_ID_COLUMN + " = " + MOTHER_TABLE_NAME + "." + MotherRepository.ID_COLUMN + " AND " + MOTHER_TABLE_NAME + "." + MotherRepository.EC_CASEID_COLUMN + " = " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN, new String[]{NOT_CLOSED}); return readAllChildrenWithMotherAndEC(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test(expected = Exception.class) public void assertAllChildrenWithMotherAndEC() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Assert.assertNull(childRepository.allChildrenWithMotherAndEC()); } @Test public void assertAllChildrenWithMotherAndECJoinTableCursor() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getJoinCursor()); Assert.assertNotNull(childRepository.allChildrenWithMotherAndEC()); }
ChildRepository extends DrishtiRepository { public List<Child> findAllChildrenByECId(String ecId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( "SELECT " + tableColumnsForQuery(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS) + " FROM " + CHILD_TABLE_NAME + ", " + MOTHER_TABLE_NAME + ", " + EC_TABLE_NAME + " WHERE " + CHILD_TABLE_NAME + "." + IS_CLOSED_COLUMN + "=? AND " + CHILD_TABLE_NAME + "." + MOTHER_ID_COLUMN + " = " + MOTHER_TABLE_NAME + "." + MotherRepository.ID_COLUMN + " AND " + MOTHER_TABLE_NAME + "." + MotherRepository.EC_CASEID_COLUMN + " = " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN + " AND " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN + "= ? ", new String[]{NOT_CLOSED, ecId}); return readAllChildren(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertFindAllChildrenWithMotherAndECJoinTableCursor() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getJoinCursor()); Assert.assertNotNull(childRepository.findAllChildrenByECId("0")); }
ChildRepository extends DrishtiRepository { public void delete(String childId) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.delete(CHILD_TABLE_NAME, ID_COLUMN + "= ?", new String[]{childId}); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }
@Test public void assertDeleteCallsDatabaseDelete() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.delete(Mockito.anyString(), Mockito.anyString(), Mockito.any(String[].class))).thenReturn(1); childRepository.delete(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).delete(Mockito.anyString(), Mockito.anyString(), Mockito.any(String[].class)); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findClientById(String id) { Client client = fetchClientByBaseEntityId(id); return Collections.singletonList(ClientConverter.convertClientToPatientResource(client)); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindClientById() throws Exception { String query = "SELECT json FROM client WHERE baseEntityId = ? "; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(1)); List<Patient> patients = clientDao.findClientById(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(1, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyByJurisdiction(String jurisdiction) { return fetchClients(String.format("select %s from %s where %s =? and %s =?", client_column.json, clientTable.name(), client_column.locationId, client_column.clientType), new String[]{jurisdiction, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindFamilyByJurisdiction() throws Exception { String query = "select json from client where locationId =? and clientType =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor()); List<Patient> patients = clientDao.findFamilyByJurisdiction(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(16, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyByResidence(String structureId) { return fetchClients(String.format("select %s from %s where %s =? and %s =?", client_column.json, clientTable.name(), client_column.residence, client_column.clientType), new String[]{structureId, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindFamilyByResidence() throws Exception { String query = "select json from client where residence =? and clientType =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor()); List<Patient> patients = clientDao.findFamilyByResidence(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(16, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction) { return fetchClients(String.format("select %s from %s where %s =? and (%s is null or %s !=? )", client_column.json, clientTable.name(), client_column.locationId, client_column.clientType, client_column.clientType), new String[]{jurisdiction, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindFamilyMemberByJurisdiction() throws Exception { String query = "select json from client where locationId =? and (clientType is null or clientType !=? )"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(10)); List<Patient> patients = clientDao.findFamilyMemberyByJurisdiction(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(10, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyMemberByResidence(String structureId) { return fetchClients(String.format("select %s from %s where %s =? and (%s is null or %s !=? )", client_column.json, clientTable.name(), client_column.residence, client_column.clientType, client_column.clientType), new String[]{structureId, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindFamilyMemberByResidence() throws Exception { String query = "select json from client where residence =? and (clientType is null or clientType !=? )"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(2)); List<Patient> patients = clientDao.findFamilyMemberByResidence(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(2, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findClientByRelationship(String relationship, String id) { return CoreLibrary.getInstance().context().getClientRelationshipRepository().findClientByRelationship(relationship, id) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }
@Test public void testFindClientByRelationship() throws Exception { String query = "SELECT json FROM client_relationship JOIN client ON base_entity_id=baseEntityId WHERE relationship=? AND relational_id =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(2)); List<Patient> patients = clientDao.findClientByRelationship(params[0], params[1]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(2, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
EventDaoImpl extends EventClientRepository implements EventDao { @Override public List<QuestionnaireResponse> findEventsByEntityIdAndPlan(String resourceId, String planIdentifier) { return fetchEvents(String.format("select %s from %s where %s =? and (%s is null or %s =? )", event_column.json, eventTable.name(), event_column.baseEntityId, event_column.planId, event_column.planId), new String[]{resourceId, planIdentifier}) .stream() .map(this::convert) .collect(Collectors.toList()); } @Override List<QuestionnaireResponse> findEventsByEntityIdAndPlan(String resourceId, String planIdentifier); }
@Test public void testFindEventsByEntityIdAndPlan() throws Exception { String query = "select json from event where baseEntityId =? and (planId is null or planId =? )"; String[] params = new String[]{"location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"}; when(sqLiteDatabase.rawQuery(query, params)).thenReturn(EventClientRepositoryTest.getEventCursor()); List<QuestionnaireResponse> questionnaireResponses = eventDao.findEventsByEntityIdAndPlan("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(20, questionnaireResponses.size()); QuestionnaireResponse questionnaireResponse = questionnaireResponses.iterator().next(); assertEquals("Household_Registration", questionnaireResponse.getQuestionnaire().getValue()); assertEquals("2184aaaa-d1cf-4099-945a-c66bd8a93e1e", questionnaireResponse.getId()); assertEquals(11, questionnaireResponse.getItem().size()); }
TaskDaoImpl extends TaskRepository implements TaskDao { @Override public List<Task> findTasksForEntity(String id, String planIdentifier) { return getTasksByPlanAndEntity(planIdentifier, id) .stream() .map(TaskConverter::convertTasktoFihrResource) .collect(Collectors.toList()); } TaskDaoImpl(TaskNotesRepository taskNotesRepository); @Override List<Task> findTasksForEntity(String id, String planIdentifier); @Override void saveTask(org.smartregister.domain.Task task, QuestionnaireResponse questionnaireResponse); @Override boolean checkIfTaskExists(String baseEntityId, String jurisdiction, String planIdentifier, String code); @Override List<Task> findAllTasksForEntity(String entityId); @Override void updateTask(org.smartregister.domain.Task task); }
@Test public void testFindTasksForEntity() { String query = "SELECT * FROM task WHERE plan_id=? AND for =? AND status NOT IN (?,?)"; String[] params = new String[]{"IRS_2018_S1", "location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", CANCELLED.name(), ARCHIVED.name()}; when(sqLiteDatabase.rawQuery(query, params)).thenReturn(getCursor()); List<Task> allTasks = taskDao.findTasksForEntity("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(1, allTasks.size()); Task task = allTasks.iterator().next(); assertEquals("tsk11231jh22", task.getIdentifier().get(0).getValue().getValue()); assertEquals("2018_IRS-3734", task.getGroupIdentifier().getValue().getValue()); assertEquals(READY, task.getStatus()); assertEquals("Not Visited", task.getBusinessStatus().getText().getValue()); assertEquals("IRS", task.getCode().getText().getValue()); assertEquals("Spray House", task.getDescription().getValue()); assertEquals("IRS Visit", task.getFocus().getReference().getValue()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", task.getFor().getReference().getValue()); assertEquals("2018-11-10T2200", javaTimeFormater.format(task.getExecutionPeriod().getStart().getValue())); assertNull(task.getExecutionPeriod().getEnd()); assertEquals("2018-10-31T0700", javaTimeFormater.format(task.getAuthoredOn().getValue())); assertEquals("2018-10-31T0700", javaTimeFormater.format(task.getLastModified().getValue())); assertEquals("demouser", task.getOwner().getReference().getValue()); }
FormDataRepository extends DrishtiRepository { @JavascriptInterface public String queryUniqueResult(String sql, String[] selectionArgs) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery(sql, selectionArgs); cursor.moveToFirst(); Map<String, String> result = readARow(cursor); cursor.close(); return new Gson().toJson(result); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertqueryUniqueResult() { assertNotNull(formDataRepository.queryUniqueResult("sql",new String[0])); }
FormDataRepository extends DrishtiRepository { @JavascriptInterface public String queryList(String sql, String[] selectionArgs) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery(sql, selectionArgs); List<Map<String, String>> results = new ArrayList<Map<String, String>>(); cursor.moveToFirst(); while (!cursor.isAfterLast()) { results.add(readARow(cursor)); cursor.moveToNext(); } cursor.close(); return new Gson().toJson(results); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertqueryList() { assertNotNull(formDataRepository.queryList("sql",new String[0])); } @Test public void assertqueryListWithdetails() { Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getCursor2()); assertNotNull(formDataRepository.queryList("sql", new String[0])); }
FormDataRepository extends DrishtiRepository { @JavascriptInterface public String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion) { SQLiteDatabase database = masterRepository.getWritableDatabase(); Map<String, String> params = new Gson() .fromJson(paramsJSON, new TypeToken<Map<String, String>>() { }.getType()); database.insert(FORM_SUBMISSION_TABLE_NAME, null, createValuesForFormSubmission(params, data, formDataDefinitionVersion)); return params.get(INSTANCE_ID_PARAM); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertsaveFormSubmission() { assertEquals(formDataRepository.saveFormSubmission(getJsonObject(), "data", "1.0"), "1"); } @Test public void assertsaveFormSubmissionCallsDatabaseInsert() { formDataRepository.saveFormSubmission(getFormSubmission()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
FormDataRepository extends DrishtiRepository { public FormSubmission fetchFromSubmission(String instanceId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, FORM_SUBMISSION_TABLE_COLUMNS, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}, null, null, null); return readFormSubmission(cursor).get(0); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertfetchFromSubmission() { assertNotNull(formDataRepository.fetchFromSubmission("")); }
FormDataRepository extends DrishtiRepository { public List<FormSubmission> getPendingFormSubmissions() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, FORM_SUBMISSION_TABLE_COLUMNS, SYNC_STATUS_COLUMN + " = ?", new String[]{PENDING.value()}, null, null, null); return readFormSubmission(cursor); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertgetPendingFormSubmissions() { assertNotNull(formDataRepository.getPendingFormSubmissions()); }
FormDataRepository extends DrishtiRepository { public void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions) { SQLiteDatabase database = masterRepository.getWritableDatabase(); for (FormSubmission submission : formSubmissions) { FormSubmission updatedSubmission = new FormSubmission(submission.instanceId(), submission.entityId(), submission.formName(), submission.instance(), submission.version(), SYNCED, "1"); database.update(FORM_SUBMISSION_TABLE_NAME, createValuesForFormSubmission(updatedSubmission), INSTANCE_ID_COLUMN + " = ?", new String[]{updatedSubmission.instanceId()}); } } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertmarkFormSubmissionsAsSynced() { List<FormSubmission> list = new ArrayList<FormSubmission>(); list.add(getFormSubmission()); formDataRepository.markFormSubmissionsAsSynced(list); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
FormDataRepository extends DrishtiRepository { public boolean submissionExists(String instanceId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, new String[]{INSTANCE_ID_COLUMN}, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}, null, null, null); boolean isThere = cursor.moveToFirst(); cursor.close(); return isThere; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertsubmissionExists() { assertEquals(formDataRepository.submissionExists("1"), true); }
FormDataRepository extends DrishtiRepository { @JavascriptInterface public String saveEntity(String entityType, String fields) { SQLiteDatabase database = masterRepository.getWritableDatabase(); Map<String, String> updatedFieldsMap = new Gson() .fromJson(fields, new TypeToken<Map<String, String>>() { }.getType()); String entityId = updatedFieldsMap.get(ENTITY_ID_FIELD_NAME); Map<String, String> entityMap = loadEntityMap(entityType, database, entityId); ContentValues contentValues = getContentValues(updatedFieldsMap, entityType, entityMap); database.replace(entityType, null, contentValues); return entityId; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertsaveEntity() { assertEquals(formDataRepository.saveEntity(EligibleCoupleRepository.EC_TABLE_NAME, "{\"id\":\"1\"}"), "1"); }
FormDataRepository extends DrishtiRepository { public Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs) { Map<String, String> map = new HashMap<String, String>(); Cursor cursor = null; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.rawQuery(sql, selectionArgs); map = sqliteRowToMap(cursor); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return map; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertgetMapFromSQLQuery() { assertNotNull(formDataRepository.getMapFromSQLQuery("",null)); }
FormDataRepository extends DrishtiRepository { public void updateServerVersion(String instanceId, String serverVersion) { SQLiteDatabase database = masterRepository.getWritableDatabase(); ContentValues values = new ContentValues(); values.put(SERVER_VERSION_COLUMN, serverVersion); database.update(FORM_SUBMISSION_TABLE_NAME, values, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertupdateServerVersion() { formDataRepository.updateServerVersion("", ""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
FormDataRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(FORM_SUBMISSION_SQL); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void assertOnCreateCallsDatabaseExec() { formDataRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
FormDataRepository extends DrishtiRepository { public Map<String, String> sqliteRowToMap(Cursor cursor) { int totalColumn = cursor.getColumnCount(); Map<String, String> rowObject = new HashMap<String, String>(); if (cursor != null && cursor.moveToFirst()) { for (int i = 0; i < totalColumn; i++) { if (cursor.getColumnName(i) != null) { try { rowObject.put(cursor.getColumnName(i), cursor.getString(i)); } catch (Exception e) { Timber.d(e.getMessage()); } } } } return rowObject; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }
@Test public void testSqliteRowToMap() { Map<String, String> rowObject = formDataRepository.sqliteRowToMap(getCursor()); assertEquals("1", rowObject.get(INSTANCE_ID_COLUMN)); assertEquals("2", rowObject.get(ENTITY_ID_COLUMN)); assertEquals("FORM", rowObject.get(FORM_NAME_COLUMN)); assertEquals(getJsonObject(), rowObject.get(INSTANCE_COLUMN)); assertEquals("1.0", rowObject.get(VERSION_COLUMN)); assertEquals("1.1", rowObject.get(SERVER_VERSION_COLUMN)); assertEquals("0.1", rowObject.get(FORM_DATA_DEFINITION_VERSION_COLUMN)); assertEquals(SyncStatus.PENDING.value(), rowObject.get(SYNC_STATUS_COLUMN)); }
P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @Override public long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray) { EventClientRepository eventClientRepository = CoreLibrary.getInstance().context().getEventClientRepository(); StructureRepository structureRepository = CoreLibrary.getInstance().context().getStructureRepository(); TaskRepository taskRepository = CoreLibrary.getInstance().context().getTaskRepository(); EventClientRepository foreignEventClientRepository = CoreLibrary.getInstance().context().getForeignEventClientRepository(); int eventsMaxRowId = eventClientRepository.getMaxRowId(eventClientRepository.getEventTable()); int foreignEventsMaxRowId = !CoreLibrary.getInstance().context().hasForeignEvents() ? 0 : foreignEventClientRepository.getMaxRowId(foreignEventClientRepository.getEventTable()); long maxTableRowId = 0; P2PClassifier<JSONObject> classifier = getP2PClassifier(); JSONArray homeData = new JSONArray(); JSONArray foreignData = new JSONArray(); try { for (int i = 0; i < jsonArray.length(); i++) { JSONObject jsonObject = jsonArray.getJSONObject(i); if (classifier != null && classifiables.contains(dataType.getName()) && classifier.isForeign(jsonObject, dataType)) { foreignData.put(jsonObject); } else { homeData.put(jsonObject); } long rowId = jsonObject.getLong(AllConstants.ROWID); jsonObject.remove(AllConstants.ROWID); if (rowId > maxTableRowId) { maxTableRowId = rowId; } } } catch (JSONException e) { Timber.e(e); return 0; } if (dataType.getName().startsWith(event.getName())) { Timber.e("Received %s total events", String.valueOf(jsonArray.length())); Timber.e(" %s resident events", String.valueOf(homeData.length())); if (homeData.length() > 0) eventClientRepository.batchInsertEvents(homeData, 0); Timber.e(" %s foreign events", String.valueOf(foreignData.length())); if (foreignData.length() > 0) foreignEventClientRepository.batchInsertEvents(foreignData, 0); } else if (dataType.getName().startsWith(client.getName())) { Timber.e("Received %s clients", String.valueOf(jsonArray.length())); Timber.e(" %s resident clients", String.valueOf(homeData.length())); if (homeData.length() > 0) eventClientRepository.batchInsertClients(homeData); Timber.e(" %s foreign clients", String.valueOf(foreignData.length())); if (foreignData.length() > 0) foreignEventClientRepository.batchInsertClients(foreignData); } else if (dataType.getName().startsWith(structure.getName())) { Timber.e("Received %s structures", String.valueOf(jsonArray.length())); structureRepository.batchInsertStructures(jsonArray); } else if (dataType.getName().startsWith(task.getName())) { Timber.e("Received %s tasks", String.valueOf(jsonArray.length())); taskRepository.batchInsertTasks(jsonArray); } else if (dataType.getName().startsWith(foreignClient.getName())) { Timber.e("Received %s foreign clients", String.valueOf(jsonArray.length())); Timber.e(" %s resident clients", String.valueOf(homeData.length())); if (homeData.length() > 0) eventClientRepository.batchInsertClients(homeData); Timber.e(" %s foreign clients", String.valueOf(foreignData.length())); if (foreignData.length() > 0) foreignEventClientRepository.batchInsertClients(foreignData); } else if (dataType.getName().startsWith(foreignEvent.getName())) { Timber.e("Received %s foreign events", String.valueOf(jsonArray.length())); Timber.e(" %s resident events", String.valueOf(homeData.length())); if (homeData.length() > 0) eventClientRepository.batchInsertEvents(homeData, 0); Timber.e(" %s foreign events", String.valueOf(foreignData.length())); if (foreignData.length() > 0) foreignEventClientRepository.batchInsertEvents(foreignData, 0); } else { Timber.e("The data type provided does not exist"); return maxTableRowId; } AllSharedPreferences allSharedPreferences = CoreLibrary.getInstance().context().allSharedPreferences(); if (!allSharedPreferences.isPeerToPeerUnprocessedEvents()) { allSharedPreferences.setLastPeerToPeerSyncProcessedEvent(eventsMaxRowId); allSharedPreferences.setLastPeerToPeerSyncForeignProcessedEvent(foreignEventsMaxRowId); } return maxTableRowId; } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }
@Test public void receiveJsonShouldReturnRecordsMaxRowId() throws JSONException { int count = 12; DataType dataType = new DataType("misc", DataType.Type.NON_MEDIA, 1); JSONArray jsonArray = new JSONArray(); for (int i = 0; i < count; i++) { JSONObject jsonObject = new JSONObject(); jsonObject.put(AllConstants.ROWID, (i * 2L)); jsonArray.put(jsonObject); } long actualMaxRowId = p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Assert.assertEquals((count - 1) * 2, actualMaxRowId); } @Test public void receiveJsonShouldCallEventClientRepositoryBatchInsertEventsWhenDataTypeIsEvent() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.event.getName(), DataType.Type.NON_MEDIA, 1); JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); jsonObject.put(AllConstants.ROWID, 0); jsonArray.put(jsonObject); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(eventClientRepository).batchInsertEvents(Mockito.eq(jsonArray), Mockito.eq(0L)); } @Test public void receiveJsonShouldCallEventClientRepositoryBatchInsertClientsWhenDataTypeIsClient() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.client.getName(), DataType.Type.NON_MEDIA, 1); JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); jsonObject.put(AllConstants.ROWID, 0); jsonArray.put(jsonObject); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(eventClientRepository).batchInsertClients(Mockito.eq(jsonArray)); } @Test public void receiveJsonShouldCallStructuresRepositoryBatchInsertStructuresWhenDataTypeIsStructure() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.structure.getName(), DataType.Type.NON_MEDIA, 1); JSONArray jsonArray = new JSONArray(); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(structureRepository).batchInsertStructures(Mockito.eq(jsonArray)); } @Test public void receiveJsonShouldCallTaskRepositoryBatchInsertTasksWhenDataTypeIsTask() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.task.getName(), DataType.Type.NON_MEDIA, 1); JSONArray jsonArray = new JSONArray(); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(taskRepository).batchInsertTasks(Mockito.eq(jsonArray)); } @Test public void receiveJsonShouldRemoveRowIdFromJsonObjectBeforeBatchInserting() throws JSONException { int count = 12; DataType dataType = new DataType(p2PReceiverTransferDao.event.getName(), DataType.Type.NON_MEDIA, 1); JSONArray jsonArray = new JSONArray(); for (int i = 0; i < count; i++) { JSONObject jsonObject = new JSONObject(); jsonObject.put(AllConstants.ROWID, (i * 2L)); jsonArray.put(jsonObject); } ArgumentCaptor<JSONArray> jsonArrayArgumentCaptor = ArgumentCaptor.forClass(JSONArray.class); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.doReturn(true).when(eventClientRepository).batchInsertEvents(jsonArrayArgumentCaptor.capture(), Mockito.eq(0L)); for (int i = 0; i < jsonArray.length(); i++) { Assert.assertFalse(jsonArray.getJSONObject(i).has(AllConstants.ROWID)); } } @Test public void receiveJsonShouldCallForeignEventClientRepositoryBatchInsertEventsWhenDataTypeIsForeignEvent() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.foreignEvent.getName(), DataType.Type.NON_MEDIA, 1); JSONObject jsonObject = new JSONObject(); String foreignLocationId = "foreign-loco-loco"; jsonObject.put("locationId", foreignLocationId); JSONArray jsonArray = new JSONArray(); jsonObject.put(AllConstants.ROWID, 0); jsonArray.put(jsonObject); Mockito.doAnswer(new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { JSONObject jsonObject1 = invocation.getArgument(0); String locationId = jsonObject1.optString("locationId"); return locationId != null && locationId.equals(foreignLocationId); } }).when(classifier).isForeign(Mockito.any(JSONObject.class), Mockito.any(DataType.class)); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(foreignEventClientRepository).batchInsertEvents(Mockito.eq(jsonArray), Mockito.eq(0L)); } @Test public void receiveJsonShouldCallForeignEventClientRepositoryBatchInsertClientsWhenDataTypeIsForeignClient() throws JSONException { DataType dataType = new DataType(p2PReceiverTransferDao.foreignClient.getName(), DataType.Type.NON_MEDIA, 1); JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); jsonObject.put(AllConstants.ROWID, 0); jsonArray.put(jsonObject); p2PReceiverTransferDao.receiveJson(dataType, jsonArray); Mockito.verify(eventClientRepository).batchInsertClients(Mockito.eq(jsonArray)); }
JsonFormUtils { public static void fillSubFormAddressFields(JSONObject jsonObject, Map<String, Address> addresses, String bindType) { if (jsonObject == null) { return; } try { String value = getString(jsonObject, VALUE); if (StringUtils.isBlank(value)) { return; } String bind = getString(jsonObject, ENTITY_ID); if (bind == null || !bind.equals(bindType)) { return; } String entity = PERSON_ADDRESS; String entityVal = getString(jsonObject, OPENMRS_ENTITY); if (entityVal != null && entityVal.equalsIgnoreCase(entity)) { String addressType = getString(jsonObject, OPENMRS_ENTITY_PARENT); String addressField = getString(jsonObject, OPENMRS_ENTITY_ID); Address ad = addresses.get(addressType); if (ad == null) { ad = new Address(addressType, null, null, null, null, null, null, null, null); } if (addressField.equalsIgnoreCase("startDate") || addressField.equalsIgnoreCase("start_date")) { ad.setStartDate(DateUtil.parseDate(value)); } else if (addressField.equalsIgnoreCase("endDate") || addressField.equalsIgnoreCase("end_date")) { ad.setEndDate(DateUtil.parseDate(value)); } else if (addressField.equalsIgnoreCase("latitude")) { ad.setLatitude(value); } else if (addressField.equalsIgnoreCase("longitude")) { ad.setLongitude(value); } else if (addressField.equalsIgnoreCase("geopoint")) { String geopoint = value; if (!StringUtils.isEmpty(geopoint)) { String[] g = geopoint.split(" "); ad.setLatitude(g[0]); ad.setLongitude(g[1]); ad.setGeopoint(geopoint); } } else if (addressField.equalsIgnoreCase("postal_code") || addressField.equalsIgnoreCase("postalCode")) { ad.setPostalCode(value); } else if (addressField.equalsIgnoreCase("sub_town") || addressField.equalsIgnoreCase("subTown")) { ad.setSubTown(value); } else if (addressField.equalsIgnoreCase("town")) { ad.setTown(value); } else if (addressField.equalsIgnoreCase("sub_district") || addressField.equalsIgnoreCase("subDistrict")) { ad.setSubDistrict(value); } else if (addressField.equalsIgnoreCase("district") || addressField.equalsIgnoreCase("county") || addressField.equalsIgnoreCase("county_district") || addressField.equalsIgnoreCase("countyDistrict")) { ad.setCountyDistrict(value); } else if (addressField.equalsIgnoreCase("city") || addressField.equalsIgnoreCase("village") || addressField.equalsIgnoreCase("cityVillage") || addressField.equalsIgnoreCase("city_village")) { ad.setCityVillage(value); } else if (addressField.equalsIgnoreCase("state") || addressField.equalsIgnoreCase("state_province") || addressField.equalsIgnoreCase("stateProvince")) { ad.setStateProvince(value); } else if (addressField.equalsIgnoreCase("country")) { ad.setCountry(value); } else { ad.addAddressField(addressField, value); } addresses.put(addressType, ad); } } catch (ParseException e) { Timber.e(e); } } static Client createBaseClient(JSONArray fields, FormTag formTag, String entityId); static Event createEvent(JSONArray fields, JSONObject metadata, FormTag formTag, String entityId, String encounterType, String bindType); static void addObservation(Event e, JSONObject jsonObject); static Map<String, String> extractIdentifiers(JSONArray fields); static Map<String, Object> extractAttributes(JSONArray fields); static Map<String, Address> extractAddresses(JSONArray fields); static void fillIdentifiers(Map<String, String> pids, JSONObject jsonObject); static void fillAttributes(Map<String, Object> pattributes, JSONObject jsonObject); static void fillAddressFields(JSONObject jsonObject, Map<String, Address> addresses); static Map<String, String> extractIdentifiers(JSONArray fields, String bindType); static Map<String, Object> extractAttributes(JSONArray fields, String bindType); static Map<String, Address> extractAddresses(JSONArray fields, String bindType); static String getSubFormFieldValue(JSONArray jsonArray, FormEntityConstants.Person person, String bindType); static void fillSubFormIdentifiers(Map<String, String> pids, JSONObject jsonObject, String bindType); static void fillSubFormAttributes(Map<String, Object> pattributes, JSONObject jsonObject, String bindType); static void fillSubFormAddressFields(JSONObject jsonObject, Map<String, Address> addresses, String bindType); static JSONArray getSingleStepFormfields(JSONObject jsonForm); static JSONArray fields(JSONObject jsonForm); static JSONArray getMultiStepFormFields(JSONObject jsonForm); static Map<String, String> sectionFields(JSONObject jsonForm); static JSONObject toJSONObject(String jsonString); static String getFieldValue(JSONArray jsonArray, FormEntityConstants.Person person); static String getFieldValue(JSONArray jsonArray, FormEntityConstants.Encounter encounter); static String getFieldValue(String jsonString, String key); @Nullable static JSONObject getFieldJSONObject(JSONArray jsonArray, String key); @Nullable static String value(JSONArray jsonArray, String entity, String entityId); @Nullable static String getFieldValue(JSONArray jsonArray, String key); @Nullable static JSONObject getJSONObject(JSONArray jsonArray, int index); @Nullable static JSONArray getJSONArray(JSONObject jsonObject, String field); static JSONObject getJSONObject(JSONObject jsonObject, String field); static String getString(JSONObject jsonObject, String field); static String getString(String jsonString, String field); static Long getLong(JSONObject jsonObject, String field); static Date formatDate(String dateString, boolean startOfToday); static String generateRandomUUIDString(); static void addToJSONObject(JSONObject jsonObject, String key, String value); static String formatDate(String date); static JSONObject merge(JSONObject original, JSONObject updated); static String[] getNames(JSONObject jo); static String convertToOpenMRSDate(String value); static boolean isBlankJsonArray(JSONArray jsonArray); static boolean isBlankJsonObject(JSONObject jsonObject); static final String TAG; static final String OPENMRS_ENTITY; static final String OPENMRS_ENTITY_ID; static final String OPENMRS_ENTITY_PARENT; static final String OPENMRS_CHOICE_IDS; static final String OPENMRS_DATA_TYPE; static final String PERSON_ATTRIBUTE; static final String PERSON_INDENTIFIER; static final String PERSON_ADDRESS; static final String SIMPRINTS_GUID; static final String FINGERPRINT_KEY; static final String FINGERPRINT_OPTION; static final String FINGERPRINT_OPTION_REGISTER; static final String CONCEPT; static final String VALUE; static final String VALUES; static final String FIELDS; static final String KEY; static final String ENTITY_ID; static final String STEP1; static final String SECTIONS; static final String attributes; static final String ENCOUNTER; static final String ENCOUNTER_LOCATION; static final String SAVE_OBS_AS_ARRAY; static final String SAVE_ALL_CHECKBOX_OBS_AS_ARRAY; static final SimpleDateFormat dd_MM_yyyy; static Gson gson; }
@Test public void assertfillSubformaddressStartDateAddsStartDate() throws Exception { String addressJsonWithStartDateString = "{\"entity_id\":\"mother\",\"value\":\"2017-05-22\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"startDate\",\"hint\":\"address of household start date\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"date\"," + "\"type\":\"edit_text\",\"key\":\"address_start_date\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithStartDateString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getStartDate().getTime() - org.smartregister.clientandeventmodel.DateUtil.parseDate("2017-05-22").getTime(), 0); } @Test public void assertfillSubFormaddressEndDateAddsEndDate() throws Exception { String addressJsonWithEndDateString = "{\"entity_id\":\"mother\",\"value\":\"2017-05-22\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"end_date\",\"hint\":\"address of household end date\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"date\"," + "\"type\":\"edit_text\",\"key\":\"address_end_date\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithEndDateString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getEndDate().getTime() - org.smartregister.clientandeventmodel.DateUtil.parseDate("2017-05-22").getTime(), 0); } @Test public void assertfillSubFormaddressLongitudeAddsLongitude() throws Exception { String addressJsonWithLongitudeString = "{\"entity_id\":\"mother\",\"value\":\"34.044494\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"longitude\",\"hint\":\"address of household longitude\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"address_longitude\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithLongitudeString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getLongitude(), "34.044494"); } @Test public void assertfillSubFormaddresslatitudeAddslatitude() throws Exception { String addressJsonWithStartlatitudeString = "{\"entity_id\":\"mother\",\"value\":\"34.044494\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"latitude\",\"hint\":\"address of household latitude\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"address_latitude\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithStartlatitudeString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getLatitude(), "34.044494"); } @Test public void assertfillSubFormaddressGeopointAddsGeopoint() throws Exception { String addressJsonWithGeopointString = "{\"entity_id\":\"mother\",\"value\":\"34.044494 -84.695704 4 76 = lat lon alt prec\"," + "\"openmrs_entity\":\"person_address\",\"openmrs_entity_id\":\"geopoint\",\"hint\":\"address of " + "household geopoint\",\"openmrs_entity_parent\":\"usual_residence\"," + "\"openmrs_data_type\":\"text\",\"type\":\"edit_text\",\"key\":\"address_geopoint\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithGeopointString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getGeopoint(), "34.044494 -84.695704 4 76 = lat lon alt prec"); } @Test public void assertfillSubFormaddressPostal_codeAddsPostal_code() throws Exception { String addressJsonWithStartPostal_code = "{\"entity_id\":\"mother\",\"value\":\"4021\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"postal_code\",\"hint\":\"address of household postal_code\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"postal_code\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithStartPostal_code), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getPostalCode(), "4021"); } @Test public void assertfillSubFormaddressSub_townAddsSub_town() throws Exception { String addressJsonWithSub_townString = "{\"entity_id\":\"mother\",\"value\":\"Kotwali\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"sub_town\",\"hint\":\"address of household sub_town\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"sub_town\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithSub_townString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getSubTown(), "Kotwali"); } @Test public void assertfillSubFormaddressTownAddsTown() throws Exception { String addressJsonWithTownString = "{\"entity_id\":\"mother\",\"value\":\"Chittagong\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"town\",\"hint\":\"address of household town\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"town\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithTownString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getTown(), "Chittagong"); } @Test public void assertfillSubformaddressSub_districtAddsSub_district() throws Exception { String addressJsonWithsub_districtString = "{\"entity_id\":\"mother\",\"value\":\"Chittagong\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"sub_district\",\"hint\":\"address of household sub_district\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"sub_district\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithsub_districtString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getSubDistrict(), "Chittagong"); } @Test public void assertfillSubformaddressDistrictAddsDistrict() throws Exception { String addressJsonWithDistrictString = "{\"entity_id\":\"mother\",\"value\":\"Chittagong\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"district\",\"hint\":\"address of household district\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"district\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithDistrictString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCountyDistrict(), "Chittagong"); } @Test public void assertfillSubformaddressCityVillageAddsCityVillage() throws Exception { String addressJsonWithCityVillageString = "{\"entity_id\":\"mother\",\"value\":\"Chittagong\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"cityVillage\",\"hint\":\"address of household cityVillage\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"cityVillage\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithCityVillageString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCityVillage(), "Chittagong"); } @Test public void assertfillSubformaddressStateAddsState() throws Exception { String addressJsonWithStateString = "{\"entity_id\":\"mother\",\"value\":\"Chittagong\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"state\",\"hint\":\"address of household state\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"state\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithStateString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getStateProvince(), "Chittagong"); } @Test public void assertfillSubformaddressCountryAddsCountry() throws Exception { String addressJsonWithCountryString = "{\"entity_id\":\"mother\",\"value\":\"Bangladesh\",\"openmrs_entity\":\"person_address\"," + "\"openmrs_entity_id\":\"country\",\"hint\":\"address of household country\"," + "\"openmrs_entity_parent\":\"usual_residence\",\"openmrs_data_type\":\"text\"," + "\"type\":\"edit_text\",\"key\":\"country\"}"; HashMap<String, Address> addressHashMap = new HashMap<String, Address>(); JsonFormUtils.fillSubFormAddressFields(new JSONObject(addressJsonWithCountryString), addressHashMap, "mother"); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCountry(), "Bangladesh"); }
P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @Override public long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId) { if (multimediaDetails != null && file.exists()) { final String syncStatus = (String) multimediaDetails.get(ImageRepository.syncStatus_COLUMN); final String entityId = (String) multimediaDetails.get(ImageRepository.entityID_COLUMN); if (OpenSRPImageLoader.moveSyncedImageAndSaveProfilePic(syncStatus, entityId, file)) { return fileRecordId; } } return -1; } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }
@Test public void receiveMultimediaShouldCallImageRepositoryWhenDataTypeIsProfilePic() { long fileRecordId = 78873L; ArgumentCaptor<ProfileImage> profileImageArgumentCaptor = ArgumentCaptor.forClass(ProfileImage.class); DataType dataType = new DataType(p2PReceiverTransferDao.profilePic.getName(), DataType.Type.MEDIA, 1); DrishtiApplication drishtiApplication = Mockito.mock(DrishtiApplication.class); ReflectionHelpers.setStaticField(DrishtiApplication.class, "mInstance", drishtiApplication); Mockito.doReturn(RuntimeEnvironment.application).when(drishtiApplication).getApplicationContext(); HashMap<String, Object> multimediaDetails = new HashMap<>(); multimediaDetails.put(ImageRepository.syncStatus_COLUMN, BaseRepository.TYPE_Unsynced); String entityId = "isod-sdfsd-32432"; multimediaDetails.put(ImageRepository.entityID_COLUMN, entityId); File file = Mockito.mock(File.class); Mockito.doReturn(true).when(file).exists(); Assert.assertEquals(fileRecordId, p2PReceiverTransferDao.receiveMultimedia(dataType, file, multimediaDetails, fileRecordId)); Mockito.verify(imageRepository).add(profileImageArgumentCaptor.capture()); ProfileImage profileImage = profileImageArgumentCaptor.getValue(); Assert.assertEquals("profilepic", profileImage.getFilecategory()); Assert.assertEquals(entityId, profileImage.getEntityID()); } @Test public void receiveMultimediaShouldReturnNegative1() { long fileRecordId = 78873L; DataType dataType = new DataType(p2PReceiverTransferDao.profilePic.getName(), DataType.Type.MEDIA, 1); HashMap<String, Object> multimediaDetails = new HashMap<>(); multimediaDetails.put(ImageRepository.syncStatus_COLUMN, BaseRepository.TYPE_Unsynced); multimediaDetails.put(ImageRepository.entityID_COLUMN, "isod-sdfsd-32432"); File file = Mockito.mock(File.class); Assert.assertEquals(-1, p2PReceiverTransferDao.receiveMultimedia(dataType, file, multimediaDetails, fileRecordId)); }
P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @Override public TreeSet<DataType> getDataTypes() { return (TreeSet<DataType>) dataTypes.clone(); } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }
@Test public void getDataTypesShouldReturnAClonedMatchOfDataTypes() { TreeSet<DataType> dataTypes = p2PReceiverTransferDao.getDataTypes(); Assert.assertTrue(p2PReceiverTransferDao.dataTypes != dataTypes); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.size(), dataTypes.size()); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.first(), dataTypes.first()); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.last(), dataTypes.last()); }
P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @VisibleForTesting public P2PClassifier<JSONObject> getP2PClassifier() { return DrishtiApplication.getInstance().getP2PClassifier(); } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }
@Test public void getP2PClassifier() { Assert.assertEquals(DrishtiApplication.getInstance().getP2PClassifier(), p2PReceiverTransferDao.getP2PClassifier()); }
AllEligibleCouples { public void close(String entityId) { alertRepository.deleteAllAlertsForEntity(entityId); timelineEventRepository.deleteAllTimelineEventsForEntity(entityId); eligibleCoupleRepository.close(entityId); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void shouldCloseEC() throws Exception { allEligibleCouples.close("entity id 1"); Mockito.verify(alertRepository).deleteAllAlertsForEntity("entity id 1"); Mockito.verify(eligibleCoupleRepository).close("entity id 1"); Mockito.verify(timelineEventRepository).deleteAllTimelineEventsForEntity("entity id 1"); }
AllEligibleCouples { public EligibleCouple findByCaseID(String caseId) { return eligibleCoupleRepository.findByCaseID(caseId); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertFindByCaseID() { Mockito.when(eligibleCoupleRepository.findByCaseID(Mockito.anyString())).thenReturn(Mockito.mock(EligibleCouple.class)); Assert.assertNotNull(allEligibleCouples.findByCaseID("")); }
AllEligibleCouples { public List<EligibleCouple> findByCaseIDs(List<String> caseIds) { return eligibleCoupleRepository.findByCaseIDs(caseIds.toArray(new String[caseIds.size()])); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertFindByCaseIDs() { Mockito.when(eligibleCoupleRepository.findByCaseIDs(Mockito.anyString())).thenReturn(Mockito.mock(ArrayList.class)); Assert.assertNotNull(allEligibleCouples.findByCaseIDs(new ArrayList<String>())); }
AllEligibleCouples { public void updatePhotoPath(String caseId, String imagePath) { eligibleCoupleRepository.updatePhotoPath(caseId, imagePath); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertUpdatePhotoPathCallsRepositoryUpdate() { Mockito.doNothing().when(eligibleCoupleRepository).updatePhotoPath(Mockito.anyString(), Mockito.anyString()); allEligibleCouples.updatePhotoPath("", ""); Mockito.verify(eligibleCoupleRepository, Mockito.times(1)).updatePhotoPath(Mockito.anyString(), Mockito.anyString()); }
AllEligibleCouples { public void mergeDetails(String entityId, Map<String, String> details) { eligibleCoupleRepository.mergeDetails(entityId, details); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertMergeDetailsCallsRepositoryUpdate() { Mockito.doNothing().when(eligibleCoupleRepository).mergeDetails(Mockito.anyString(), Mockito.any(Map.class)); allEligibleCouples.mergeDetails("", new HashMap<String, String>()); Mockito.verify(eligibleCoupleRepository, Mockito.times(1)).mergeDetails(Mockito.anyString(), Mockito.any(Map.class)); }
AllEligibleCouples { public long count() { return eligibleCoupleRepository.count(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertCountreturnsLong() { Mockito.when(eligibleCoupleRepository.count()).thenReturn(0l); Assert.assertEquals(allEligibleCouples.count(), 0l); }
AllEligibleCouples { public long fpCount() { return eligibleCoupleRepository.fpCount(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertFPCountreturnsLong() { Mockito.when(eligibleCoupleRepository.fpCount()).thenReturn(0l); Assert.assertEquals(allEligibleCouples.fpCount(), 0l); }
AllEligibleCouples { public List<String> villages() { return eligibleCoupleRepository.villages(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }
@Test public void assertVillagesReturnsList() { Mockito.when(eligibleCoupleRepository.villages()).thenReturn(new ArrayList<String>()); Assert.assertNotNull(allEligibleCouples.villages()); }
MotherRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(MOTHER_SQL); database.execSQL(MOTHER_TYPE_INDEX_SQL); database.execSQL(MOTHER_REFERENCE_DATE_INDEX_SQL); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertOnCreateCallDatabaseExecSql() { motherRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(3)).execSQL(Mockito.anyString()); }
MotherRepository extends DrishtiRepository { public void add(Mother mother) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(MOTHER_TABLE_NAME, null, createValuesFor(mother, TYPE_ANC)); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertAddMotherCallsDatabaseSqlInsert() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); motherRepository.add(getMockMother()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
MotherRepository extends DrishtiRepository { public void update(Mother mother) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.update(MOTHER_TABLE_NAME, createValuesFor(mother, TYPE_ANC), ID_COLUMN + " = ?", new String[]{mother.caseId()}); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertUpdateMotherCallsDatabaseUpdate() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class))).thenReturn(1); motherRepository.update(getMockMother()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
MotherRepository extends DrishtiRepository { public List<Mother> allANCs() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, TYPE_COLUMN + " = ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{TYPE_ANC, NOT_CLOSED}, null, null, null, null); return readAll(cursor); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertAllANCsCallsDatabaseQueryAndReturnsListOfANCs() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); org.junit.Assert.assertNotNull(motherRepository.allANCs()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public List<Mother> allPNCs() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, TYPE_COLUMN + " =" + " ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{TYPE_PNC, NOT_CLOSED}, null, null, null, null); return readAll(cursor); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertAllPNCsCallsDatabaseQueryAndReturnsListOfANCs() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); org.junit.Assert.assertNotNull(motherRepository.allPNCs()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public List<Mother> findAllCasesForEC(String ecCaseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, EC_CASEID_COLUMN + " = ?", new String[]{ecCaseId}, null, null, null, null); return readAll(cursor); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertAllECCallsDatabaseQueryAndReturnsListOfANCs() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); org.junit.Assert.assertNotNull(motherRepository.findAllCasesForEC("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public Mother findById(String entityId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, ID_COLUMN + " = ?", new String[]{entityId}, null, null, null, null); return readAll(cursor).get(0); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertFindMotherByIdReturnsMother() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); Assert.assertNotNull(motherRepository.findById("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public Mother findMotherWithOpenStatusByECId(String ecId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, EC_CASEID_COLUMN + " = ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{ecId, NOT_CLOSED}, null, null, null, null); List<Mother> mothers = readAll(cursor); return mothers.isEmpty() ? null : mothers.get(0); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertFindMotherWithOpenStatusByECIdReturnsMother() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); Assert.assertNotNull(motherRepository.findMotherWithOpenStatusByECId("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public Mother findOpenCaseByCaseID(String caseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS, ID_COLUMN + " = ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{caseId, NOT_CLOSED}, null, null, null, null); List<Mother> mothers = readAll(cursor); if (mothers.isEmpty()) { return null; } return mothers.get(0); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertFindCaseByIdReturnsMother() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); Assert.assertNotNull(motherRepository.findOpenCaseByCaseID("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
MotherRepository extends DrishtiRepository { public List<Mother> findByCaseIds(String... caseIds) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( String.format("SELECT * FROM %s WHERE %s IN (%s)", MOTHER_TABLE_NAME, ID_COLUMN, insertPlaceholdersForInClause(caseIds.length)), caseIds); return readAll(cursor); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertFindCaseByIdsReturnsMotherList() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getMotherCursor()); Assert.assertNotNull(motherRepository.findByCaseIds("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).rawQuery(Mockito.anyString(), Mockito.any(String[].class)); }
MotherRepository extends DrishtiRepository { public List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( "SELECT " + tableColumnsForQuery(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS) + ", " + tableColumnsForQuery(EC_TABLE_NAME, EC_TABLE_COLUMNS) + " FROM " + MOTHER_TABLE_NAME + ", " + EC_TABLE_NAME + " WHERE" + " " + TYPE_COLUMN + "=? AND " + MOTHER_TABLE_NAME + "." + IS_CLOSED_COLUMN + "= ? AND " + MOTHER_TABLE_NAME + "." + EC_CASEID_COLUMN + " = " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN, new String[]{type,NOT_CLOSED}); return readAllMothersWithEC(cursor); } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test(expected = Exception.class) public void assertAllMothersOfATypeWithECReturnsNull() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Assert.assertNull(motherRepository.allMothersOfATypeWithEC("type")); } @Test public void assertAllMothersOfATypeWithECReturnsAllMother() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getJoinCursor()); Assert.assertNotNull(motherRepository.allMothersOfATypeWithEC("type")); }
MotherRepository extends DrishtiRepository { public void closeAllCasesForEC(String ecCaseId) { List<Mother> mothers = findAllCasesForEC(ecCaseId); for (Mother mother : mothers) { close(mother.caseId()); } } void add(Mother mother); void switchToPNC(String caseId); List<Mother> allANCs(); Mother findById(String entityId); List<Mother> allPNCs(); long ancCount(); long pncCount(); Mother findOpenCaseByCaseID(String caseId); List<Mother> findAllCasesForEC(String ecCaseId); List<Mother> findByCaseIds(String... caseIds); List<Pair<Mother, EligibleCouple>> allMothersOfATypeWithEC(String type); void closeAllCasesForEC(String ecCaseId); void close(String caseId); Mother findMotherWithOpenStatusByECId(String ecId); boolean isPregnant(String ecId); void update(Mother mother); static final String MOTHER_TABLE_NAME; static final String ID_COLUMN; static final String EC_CASEID_COLUMN; static final String THAYI_CARD_NUMBER_COLUMN; static final String REF_DATE_COLUMN; static final String DETAILS_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] MOTHER_TABLE_COLUMNS; }
@Test public void assertCloseAllCasesForECCallsDatabaseUpdate() { motherRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getMotherCursor()); motherRepository.closeAllCasesForEC("0"); }
LocationRepository extends BaseRepository { public void addOrUpdate(Location location) { if (StringUtils.isBlank(location.getId())) throw new IllegalArgumentException("id not provided"); ContentValues contentValues = new ContentValues(); contentValues.put(ID, location.getId()); contentValues.put(UUID, location.getProperties().getUid()); contentValues.put(PARENT_ID, location.getProperties().getParentId()); contentValues.put(NAME, location.getProperties().getName()); contentValues.put(GEOJSON, gson.toJson(location)); contentValues.put(SYNC_STATUS, location.getSyncStatus()); getWritableDatabase().replace(getLocationTableName(), null, contentValues); } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void testAddOrUpdateShouldAdd() { Location location = gson.fromJson(locationJson, Location.class); locationRepository.addOrUpdate(location); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(LOCATION_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(6, contentValues.size()); assertEquals("3734", contentValues.getAsString("_id")); assertEquals("41587456-b7c8-4c4e-b433-23a786f742fc", contentValues.getAsString("uuid")); assertEquals("21", contentValues.getAsString("parent_id")); assertEquals(locationJson, stripTimezone(contentValues.getAsString("geojson"))); assertTrue(contentValues.containsKey("sync_status")); } @Test public void testAddOrUpdateWithSyncStatus() { Location location = gson.fromJson(locationJson, Location.class); location.setSyncStatus(TYPE_Unsynced); locationRepository.addOrUpdate(location); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(6, contentValues.size()); assertEquals(TYPE_Unsynced, contentValues.getAsString("sync_status")); } @Test(expected = IllegalArgumentException.class) public void testAddOrUpdateShouldThrowException() { Location location = new Location(); locationRepository.addOrUpdate(location); }
LocationRepository extends BaseRepository { public List<Location> getAllLocations() { Cursor cursor = null; List<Location> locations = new ArrayList<>(); try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTableName(), null); while (cursor.moveToNext()) { locations.add(readCursor(cursor)); } cursor.close(); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return locations; } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetAllLocations() { when(sqLiteDatabase.rawQuery("SELECT * FROM location", null)).thenReturn(getCursor()); List<Location> allLocations = locationRepository.getAllLocations(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location", stringArgumentCaptor.getValue()); assertEquals(1, allLocations.size()); Location location = allLocations.get(0); assertEquals(locationJson, stripTimezone(gson.toJson(location))); }
LocationRepository extends BaseRepository { public List<Location> getLocationsByParentId(String parentId) { return getLocationsByParentId(parentId, getLocationTableName()); } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetLocationsByParentId() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE parent_id =?", new String[]{"21"})).thenReturn(getCursor()); List<Location> allLocations = locationRepository.getLocationsByParentId("21"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE parent_id =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("21", argsCaptor.getValue()[0]); assertEquals(1, allLocations.size()); Location location = allLocations.get(0); assertEquals(locationJson, stripTimezone(gson.toJson(location))); }
LocationRepository extends BaseRepository { public Location getLocationById(String id) { return getLocationById(id, getLocationTableName()); } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetLocationById() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE _id =?", new String[]{"3734"})).thenReturn(getCursor()); Location location = locationRepository.getLocationById("3734"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE _id =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("3734", argsCaptor.getValue()[0]); assertEquals(locationJson, stripTimezone(gson.toJson(location))); }
LocationRepository extends BaseRepository { public Location getLocationByUUId(String uuid) { Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTableName() + " WHERE " + UUID + " =?", new String[]{uuid}); if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return null; } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetLocationByUUID() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE uuid =?", new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc"})).thenReturn(getCursor()); Location location = locationRepository.getLocationByUUId("41587456-b7c8-4c4e-b433-23a786f742fc"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE uuid =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("41587456-b7c8-4c4e-b433-23a786f742fc", argsCaptor.getValue()[0]); assertEquals(locationJson, stripTimezone(gson.toJson(location))); }
LocationRepository extends BaseRepository { public Location getLocationByName(String name) { Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTableName() + " WHERE " + NAME + " =?", new String[]{name}); if (cursor.moveToFirst()) { return readCursor(cursor); } cursor.close(); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return null; } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetLocationByName() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE name =?", new String[]{"01_5"})).thenReturn(getCursor()); Location location = locationRepository.getLocationByName("01_5"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE name =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("01_5", argsCaptor.getValue()[0]); assertEquals(locationJson, stripTimezone(gson.toJson(location))); }
LocationRepository extends BaseRepository { public List<Location> getLocationsByIds(List<String> ids) { return getLocationsByIds(ids, true); } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void tesGetLocationsByIds() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE _id IN (?)", new String[]{"3734"})).thenReturn(getCursor()); List<Location> locations = locationRepository.getLocationsByIds(Collections.singletonList("3734")); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE _id IN (?)", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("3734", argsCaptor.getValue()[0]); assertNotNull(locations); assertEquals(locationJson, stripTimezone(gson.toJson(locations.get(0)))); } @Test public void tesGetLocationsByIdsExclusive() { when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE _id NOT IN (?)", new Object[]{"3734"})).thenReturn(getCursor()); List<Location> locations = locationRepository.getLocationsByIds(Collections.singletonList("3734"), false); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location WHERE _id NOT IN (?)", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("3734", argsCaptor.getValue()[0]); assertEquals(0, locations.size()); }
LocationRepository extends BaseRepository { public List<Location> getLocationsByTagName(String tagName) { LocationTagRepository locationTagRepository = new LocationTagRepository(); List<LocationTag> locationTags = locationTagRepository.getLocationTagsByTagName(tagName); List<String> locationIds = locationTags.stream() .map(LocationTag::getLocationId) .collect(Collectors.toList()); return getLocationsByIds(locationIds); } static void createTable(SQLiteDatabase database); void addOrUpdate(Location location); void deleteLocations(@NonNull Set<String> locationIdentifiers); List<Location> getAllLocations(); List<String> getAllLocationIds(); Location getLocationById(String id); Location getLocationById(String id, String tableName); Location getLocationByUUId(String uuid); List<Location> getLocationsByParentId(String parentId); List<Location> getLocationsByParentId(String parentId, String tableName); Location getLocationByName(String name); List<Location> getLocationsByIds(List<String> ids); List<Location> getLocationsByIds(List<String> ids, Boolean inclusive); List<Location> getAllUnsynchedLocation(); void markLocationsAsSynced(String locationId); List<Location> getLocationsByTagName(String tagName); }
@Test public void testGetLocationsByTagName() { when(sqLiteDatabase.rawQuery("SELECT * FROM location_tag WHERE name =?", new String[]{"Facility"})).thenReturn(getLocationTagsCursor()); when(sqLiteDatabase.rawQuery("SELECT * FROM location WHERE _id IN (?)", new String[]{"1"})).thenReturn(getCursor()); List<Location> tags = locationRepository.getLocationsByTagName("Facility"); assertNotNull(tags); assertEquals(1, tags.size()); }
ManifestRepository extends BaseRepository { public void addOrUpdate(Manifest manifest) { ContentValues contentValues = new ContentValues(); if (manifest.getId() != null) contentValues.put(ID, manifest.getId()); contentValues.put(VERSION, manifest.getVersion()); contentValues.put(APP_VERSION, manifest.getAppVersion()); contentValues.put(FORM_VERSION, manifest.getFormVersion()); contentValues.put(IDENTIFIERS, new Gson().toJson(manifest.getIdentifiers())); contentValues.put(IS_NEW, manifest.isNew()); contentValues.put(ACTIVE, manifest.isActive()); contentValues.put(CREATED_AT, DATE_FORMAT.format(manifest.getCreatedAt())); getWritableDatabase().replace(getManifestTableName(), null, contentValues); } static void createTable(SQLiteDatabase database); static void addVersionColumn(@NonNull SQLiteDatabase database); static boolean isVersionColumnExist(@NonNull SQLiteDatabase database); void addOrUpdate(Manifest manifest); List<Manifest> getAllManifests(); List<Manifest> getManifestByAppVersion(String appVersion); Manifest getActiveManifest(); void delete(String manifestId); }
@Test public void testAddOrUpdateShouldAdd() { Manifest manifest = gson.fromJson(manifestJson, Manifest.class); manifestRepository.addOrUpdate(manifest); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(MANIFEST_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(8, contentValues.size()); assertEquals("1", contentValues.getAsString(ManifestRepository.ID)); assertEquals("1.1.0", contentValues.getAsString(APP_VERSION)); assertEquals("1.0.0", contentValues.getAsString(ManifestRepository.FORM_VERSION)); assertEquals("[\"en/child/enrollment.json\"]", contentValues.getAsString(ManifestRepository.IDENTIFIERS)); assertEquals(true, contentValues.getAsBoolean(ACTIVE)); assertEquals(true, contentValues.getAsBoolean(ManifestRepository.IS_NEW)); }
ManifestRepository extends BaseRepository { public List<Manifest> getAllManifests() { List<Manifest> manifests = new ArrayList<>(); try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getManifestTableName() + " ORDER BY " + CREATED_AT + " DESC ", null)) { while (cursor.moveToNext()) { manifests.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } return manifests; } static void createTable(SQLiteDatabase database); static void addVersionColumn(@NonNull SQLiteDatabase database); static boolean isVersionColumnExist(@NonNull SQLiteDatabase database); void addOrUpdate(Manifest manifest); List<Manifest> getAllManifests(); List<Manifest> getManifestByAppVersion(String appVersion); Manifest getActiveManifest(); void delete(String manifestId); }
@Test public void testGetAllManifests() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + MANIFEST_TABLE + " ORDER BY " + CREATED_AT + " DESC ", null)).thenReturn(getCursor()); List<Manifest> manifests = manifestRepository.getAllManifests(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM manifest ORDER BY created_at DESC ", stringArgumentCaptor.getValue()); assertEquals(1, manifests.size()); Manifest manifest = manifests.get(0); assertEquals("1", manifest.getId()); }
ManifestRepository extends BaseRepository { public List<Manifest> getManifestByAppVersion(String appVersion) { List<Manifest> manifests = new ArrayList<>(); try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getManifestTableName() + " WHERE " + APP_VERSION + " =?", new String[]{appVersion})) { while (cursor.moveToNext()) { manifests.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } return manifests; } static void createTable(SQLiteDatabase database); static void addVersionColumn(@NonNull SQLiteDatabase database); static boolean isVersionColumnExist(@NonNull SQLiteDatabase database); void addOrUpdate(Manifest manifest); List<Manifest> getAllManifests(); List<Manifest> getManifestByAppVersion(String appVersion); Manifest getActiveManifest(); void delete(String manifestId); }
@Test public void testGetManifestByAppVersion() { String appVersion = "1.1.0"; when(sqLiteDatabase.rawQuery("SELECT * FROM " + MANIFEST_TABLE + " WHERE " + APP_VERSION + " =?", new String[]{appVersion})).thenReturn(getCursor()); List<Manifest> manifests = manifestRepository.getManifestByAppVersion(appVersion); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + MANIFEST_TABLE + " WHERE " + APP_VERSION + " =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals(appVersion, argsCaptor.getValue()[0]); Manifest manifest = manifests.get(0); assertEquals("1", manifest.getId()); }
ManifestRepository extends BaseRepository { public Manifest getActiveManifest() { try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getManifestTableName() + " WHERE " + ACTIVE + " =?", new String[]{"1"})) { if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } return null; } static void createTable(SQLiteDatabase database); static void addVersionColumn(@NonNull SQLiteDatabase database); static boolean isVersionColumnExist(@NonNull SQLiteDatabase database); void addOrUpdate(Manifest manifest); List<Manifest> getAllManifests(); List<Manifest> getManifestByAppVersion(String appVersion); Manifest getActiveManifest(); void delete(String manifestId); }
@Test public void testGetActiveManifest() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + MANIFEST_TABLE + " WHERE " + ACTIVE + " =?", new String[]{"1"})).thenReturn(getCursor()); Manifest manifest = manifestRepository.getActiveManifest(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + MANIFEST_TABLE + " WHERE " + ACTIVE + " =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("1", argsCaptor.getValue()[0]); assertEquals(true, manifest.isActive()); }
Hia2ReportRepository extends BaseRepository { public List<JSONObject> getUnSyncedReports(int limit) { List<JSONObject> reports = new ArrayList<JSONObject>(); String query = "select " + report_column.json + "," + report_column.syncStatus + " from " + Table.hia2_report.name() + " where " + report_column.syncStatus + " = ? and length(" + report_column.json + ")>2 order by " + report_column.updatedAt + " asc limit " + limit; Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery(query, new String[]{BaseRepository.TYPE_Unsynced}); while (cursor.moveToNext()) { String jsonEventStr = (cursor.getString(0)); if (StringUtils.isBlank(jsonEventStr) || "{}".equals(jsonEventStr)) { continue; } jsonEventStr = jsonEventStr.replaceAll("'", ""); JSONObject jsonObectEvent = new JSONObject(jsonEventStr); reports.add(jsonObectEvent); } } catch (Exception e) { Timber.e(e.getMessage()); } finally { if (cursor != null) { cursor.close(); } } return reports; } List<JSONObject> getUnSyncedReports(int limit); List<String> getUnValidatedReportFormSubmissionIds(int limit); void addReport(JSONObject jsonObject); void markReportAsSynced(String formSubmissionId); void markReportValidationStatus(String formSubmissionId, boolean valid); void markReportsAsSynced(List<JSONObject> syncedReports); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); }
@Test public void assertGetUnSyncedReportsReturnsList() { when(sqliteDatabase.rawQuery(anyString(), any(String[].class))).thenReturn(getCursorSyncStatus()); assertNotNull(hia2ReportRepository.getUnSyncedReports(1)); }
Hia2ReportRepository extends BaseRepository { public List<String> getUnValidatedReportFormSubmissionIds(int limit) { List<String> ids = new ArrayList<String>(); final String validateFilter = " where " + report_column.syncStatus + " = ? " + " AND ( " + report_column.validationStatus + " is NULL or " + report_column.validationStatus + " != ? ) "; String query = "select " + report_column.formSubmissionId + " from " + Table.hia2_report.name() + validateFilter + ORDER_BY + report_column.updatedAt + " asc limit " + limit; Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery(query, new String[]{BaseRepository.TYPE_Synced, BaseRepository.TYPE_Valid}); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { while (!cursor.isAfterLast()) { String id = cursor.getString(0); ids.add(id); cursor.moveToNext(); } } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return ids; } List<JSONObject> getUnSyncedReports(int limit); List<String> getUnValidatedReportFormSubmissionIds(int limit); void addReport(JSONObject jsonObject); void markReportAsSynced(String formSubmissionId); void markReportValidationStatus(String formSubmissionId, boolean valid); void markReportsAsSynced(List<JSONObject> syncedReports); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); }
@Test public void assertGetUnValidatedReportFormSubmissionIdsReturnsList() { when(sqliteDatabase.rawQuery(anyString(), any(String[].class))).thenReturn(getCursorSyncStatus()); assertNotNull(hia2ReportRepository.getUnValidatedReportFormSubmissionIds(1)); }
Hia2ReportRepository extends BaseRepository { public void addReport(JSONObject jsonObject) { try { ContentValues values = new ContentValues(); values.put(report_column.json.name(), jsonObject.toString()); values.put(report_column.reportType.name(), jsonObject.has(report_column.reportType.name()) ? jsonObject.getString( report_column.reportType.name()) : ""); values.put(report_column.updatedAt.name(), dateFormat.format(new Date())); values.put(report_column.syncStatus.name(), BaseRepository.TYPE_Unsynced); if (jsonObject.has(report_column.formSubmissionId.name()) && jsonObject.getString(report_column.formSubmissionId.name()) != null) { if (checkIfExistsByFormSubmissionId(Table.hia2_report, jsonObject.getString(report_column .formSubmissionId .name()))) { getWritableDatabase().update(Table.hia2_report.name(), values, report_column.formSubmissionId.name() + "=?", new String[]{jsonObject.getString( report_column.formSubmissionId.name())}); } else { values.put(report_column.formSubmissionId.name(), jsonObject.getString(report_column.formSubmissionId.name())); getWritableDatabase().insert(Table.hia2_report.name(), null, values); } } else { getWritableDatabase().insert(Table.hia2_report.name(), null, values); } } catch (Exception e) { Timber.e(e); } } List<JSONObject> getUnSyncedReports(int limit); List<String> getUnValidatedReportFormSubmissionIds(int limit); void addReport(JSONObject jsonObject); void markReportAsSynced(String formSubmissionId); void markReportValidationStatus(String formSubmissionId, boolean valid); void markReportsAsSynced(List<JSONObject> syncedReports); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); }
@Test public void assertAddReportCallsDatabaseInsertAndUpdate() throws Exception { String jsonReport = "{\"reportType\":\"reportType\", \"formSubmissionId\":\"formSubmissionId\"}"; when(sqliteDatabase.rawQuery(anyString(), any(String[].class))).thenReturn(getCursorSyncStatus()); hia2ReportRepository.addReport(new JSONObject(jsonReport)); verify(sqliteDatabase, Mockito.times(1)).update(anyString(), any(ContentValues.class), anyString(), any(String[].class)); when(sqliteDatabase.rawQuery(anyString(), any(String[].class))).thenReturn(null); hia2ReportRepository.addReport(new JSONObject(jsonReport)); verify(sqliteDatabase, Mockito.times(1)).insert(anyString(), isNull(String.class), any(ContentValues.class)); }
Hia2ReportRepository extends BaseRepository { public void markReportsAsSynced(List<JSONObject> syncedReports) { try { if (syncedReports != null && !syncedReports.isEmpty()) { for (JSONObject report : syncedReports) { String formSubmissionId = report.getString(report_column.formSubmissionId .name()); markReportAsSynced(formSubmissionId); } } } catch (Exception e) { Timber.e(e); } } List<JSONObject> getUnSyncedReports(int limit); List<String> getUnValidatedReportFormSubmissionIds(int limit); void addReport(JSONObject jsonObject); void markReportAsSynced(String formSubmissionId); void markReportValidationStatus(String formSubmissionId, boolean valid); void markReportsAsSynced(List<JSONObject> syncedReports); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); }
@Test public void assertmarkReportsAsSyncedCallsDatabaseUpdate() throws Exception { String jsonReport = "{\"reportType\":\"reportType\", \"formSubmissionId\":\"formSubmissionId\"}"; List<JSONObject> reports = new ArrayList<>(); reports.add(new JSONObject(jsonReport)); hia2ReportRepository.markReportsAsSynced(reports); verify(sqliteDatabase, Mockito.times(1)).update(anyString(), any(ContentValues.class), anyString(), any(String[].class)); }
DetailsRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(SQL); } void add(String baseEntityId, String key, String value, Long timestamp); Map<String, String> getAllDetailsForClient(String baseEntityId); Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient); Map<String, String> updateDetails(CommonPersonObject commonPersonObject); boolean deleteDetails(String baseEntityId); }
@Test public void assertOnCreateCallsDatabaseExec() { detailsRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
DetailsRepository extends DrishtiRepository { public void add(String baseEntityId, String key, String value, Long timestamp) { SQLiteDatabase database = masterRepository.getWritableDatabase(); Boolean exists = getIdForDetailsIfExists(baseEntityId, key, value); if (exists == null) { return; } ContentValues values = new ContentValues(); values.put(BASE_ENTITY_ID_COLUMN, baseEntityId); values.put(KEY_COLUMN, key); values.put(VALUE_COLUMN, value); values.put(EVENT_DATE_COLUMN, timestamp); if (exists) { int updated = database.update(TABLE_NAME, values, BASE_ENTITY_ID_COLUMN + " = ? AND " + KEY_COLUMN + " MATCH ? ", new String[]{baseEntityId, key}); } else { long rowId = database.insert(TABLE_NAME, null, values); } } void add(String baseEntityId, String key, String value, Long timestamp); Map<String, String> getAllDetailsForClient(String baseEntityId); Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient); Map<String, String> updateDetails(CommonPersonObject commonPersonObject); boolean deleteDetails(String baseEntityId); }
@Test public void assertAddCallsRawQueryAndInsertUpdate() { detailsRepository.add("1", "key", "value", new Long(0)); Mockito.verify(sqLiteDatabase, Mockito.times(1)).rawQuery(Mockito.anyString(), Mockito.any(String[].class)); detailsRepository.add("1", "key", "xyz", new Long(0)); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(null); detailsRepository.add("1", "key", "xyz", new Long(0)); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
DetailsRepository extends DrishtiRepository { public Map<String, String> getAllDetailsForClient(String baseEntityId) { Cursor cursor = null; Map<String, String> clientDetails = new HashMap<String, String>(); try { SQLiteDatabase db = masterRepository.getReadableDatabase(); String query = "SELECT * FROM " + TABLE_NAME + " WHERE " + BASE_ENTITY_ID_COLUMN + " =?"; cursor = db.rawQuery(query, new String[]{baseEntityId}); if (cursor != null && cursor.moveToFirst()) { do { String key = cursor.getString(cursor.getColumnIndex(KEY_COLUMN)); String value = cursor.getString(cursor.getColumnIndex(VALUE_COLUMN)); clientDetails.put(key, value); } while (cursor.moveToNext()); } return clientDetails; } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return clientDetails; } void add(String baseEntityId, String key, String value, Long timestamp); Map<String, String> getAllDetailsForClient(String baseEntityId); Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient); Map<String, String> updateDetails(CommonPersonObject commonPersonObject); boolean deleteDetails(String baseEntityId); }
@Test public void assertgetAllDetailsForClient() { Map<String, String> detail = detailsRepository.getAllDetailsForClient("1"); Assert.assertNotNull(detail); Assert.assertEquals(detail.get("key"), "value"); }
DetailsRepository extends DrishtiRepository { public Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient) { Map<String, String> details = getAllDetailsForClient(commonPersonObjectClient.entityId()); details.putAll(commonPersonObjectClient.getColumnmaps()); if (commonPersonObjectClient.getDetails() != null) { commonPersonObjectClient.getDetails().putAll(details); } else { commonPersonObjectClient.setDetails(details); } return details; } void add(String baseEntityId, String key, String value, Long timestamp); Map<String, String> getAllDetailsForClient(String baseEntityId); Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient); Map<String, String> updateDetails(CommonPersonObject commonPersonObject); boolean deleteDetails(String baseEntityId); }
@Test public void assertupdateDetails() { Assert.assertNotNull(detailsRepository.updateDetails(Mockito.mock(CommonPersonObject.class))); } @Test public void assertupdateDetails2() { Assert.assertNotNull(detailsRepository.updateDetails(Mockito.mock(CommonPersonObjectClient.class))); }
DetailsRepository extends DrishtiRepository { public boolean deleteDetails(String baseEntityId) { try { SQLiteDatabase db = masterRepository.getWritableDatabase(); int afftectedRows = db .delete(TABLE_NAME, BASE_ENTITY_ID_COLUMN + " = ?", new String[]{baseEntityId}); if (afftectedRows > 0) { return true; } } catch (Exception e) { Timber.e(e); } return false; } void add(String baseEntityId, String key, String value, Long timestamp); Map<String, String> getAllDetailsForClient(String baseEntityId); Map<String, String> updateDetails(CommonPersonObjectClient commonPersonObjectClient); Map<String, String> updateDetails(CommonPersonObject commonPersonObject); boolean deleteDetails(String baseEntityId); }
@Test public void assertdeleteDetails() { Assert.assertEquals(detailsRepository.deleteDetails("1"), false); Mockito.when(sqLiteDatabase.delete(Mockito.anyString(), Mockito.anyString(), Mockito.any(String[].class))).thenReturn(1); Assert.assertEquals(detailsRepository.deleteDetails("1"), true); }