src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdFromStructure(List<Location> locations) { if (locations == null || locations.isEmpty()) { return false; } SQLiteStatement updateStatement = null; try { getWritableDatabase().beginTransaction(); String updateTaskSructureIdQuery = String.format("UPDATE %s SET %s = ? WHERE %s = ? AND %s IS NULL", TASK_TABLE, STRUCTURE_ID, FOR, STRUCTURE_ID); updateStatement = getWritableDatabase().compileStatement(updateTaskSructureIdQuery); for (Location location : locations) { updateStatement.bindString(1, location.getId()); updateStatement.bindString(2, location.getId()); updateStatement.executeUpdateDelete(); } getWritableDatabase().setTransactionSuccessful(); getWritableDatabase().endTransaction(); return true; } catch (SQLException e) { Timber.e(e); getWritableDatabase().endTransaction(); return false; } finally { if (updateStatement != null) updateStatement.close(); } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void updateTaskStructureIdFromStructure() throws Exception { List<Location> locations = new ArrayList<>(); Location location = gson.fromJson(structureJson, Location.class); locations.add(location); taskRepository.updateTaskStructureIdFromStructure(locations); assertTrue(taskRepository.updateTaskStructureIdFromStructure(locations)); } |
TaskRepository extends BaseRepository { public void cancelTasksForEntity(@NonNull String entityId) { if (StringUtils.isBlank(entityId)) return; ContentValues contentValues = new ContentValues(); contentValues.put(STATUS, TaskStatus.CANCELLED.name()); contentValues.put(SYNC_STATUS, BaseRepository.TYPE_Unsynced); getWritableDatabase().update(TASK_TABLE, contentValues, String.format("%s = ? AND %s =?", FOR, STATUS), new String[]{entityId, TaskStatus.READY.name()}); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testCancelTasksForEntity() { taskRepository.cancelTasksForEntity("id1"); verify(sqLiteDatabase).update(eq(TASK_TABLE), contentValuesArgumentCaptor.capture(), eq("for = ? AND status =?"), eq(new String[]{"id1", READY.name()})); assertEquals(BaseRepository.TYPE_Unsynced, contentValuesArgumentCaptor.getValue().getAsString("sync_status")); assertEquals(CANCELLED.name(), contentValuesArgumentCaptor.getValue().getAsString("status")); assertEquals(2, contentValuesArgumentCaptor.getValue().size()); }
@Test public void testCancelTasksForEntityWithNullParams() { taskRepository.cancelTasksForEntity(null); verify(sqLiteDatabase, never()).update(any(), any(), any(), any()); verifyZeroInteractions(sqLiteDatabase); } |
TaskRepository extends BaseRepository { public void archiveTasksForEntity(@NonNull String entityId) { if (StringUtils.isBlank(entityId)) return; ContentValues contentValues = new ContentValues(); contentValues.put(STATUS, TaskStatus.ARCHIVED.name()); contentValues.put(SYNC_STATUS, BaseRepository.TYPE_Unsynced); getWritableDatabase().update(TASK_TABLE, contentValues, String.format("%s = ? AND %s NOT IN (?,?)", FOR, STATUS), new String[]{entityId, TaskStatus.READY.name(), TaskStatus.CANCELLED.name()}); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testArchiveTasksForEntity() { taskRepository.archiveTasksForEntity("id1"); verify(sqLiteDatabase).update(eq(TASK_TABLE), contentValuesArgumentCaptor.capture(), eq("for = ? AND status NOT IN (?,?)"), eq(new String[]{"id1", READY.name(), CANCELLED.name()})); assertEquals(BaseRepository.TYPE_Unsynced, contentValuesArgumentCaptor.getValue().getAsString("sync_status")); assertEquals(ARCHIVED.name(), contentValuesArgumentCaptor.getValue().getAsString("status")); assertEquals(2, contentValuesArgumentCaptor.getValue().size()); }
@Test public void testArchiveTasksForEntityWithNullParams() { taskRepository.archiveTasksForEntity(null); verifyZeroInteractions(sqLiteDatabase); } |
OpenSRPImageLoader extends ImageLoader { private static RequestQueue newRequestQueue(Context context) { RequestQueue requestQueue; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { HurlStack stack = new HurlStack() { @Override public HttpResponse performRequest(Request<?> request, Map<String, String> headers) throws IOException, AuthFailureError { addBearerTokenAuthorizationHeader(headers); return super.performRequest(request, headers); } }; requestQueue = Volley.newRequestQueue(context, stack); } else { HttpClientStack stack = new HttpClientStack( AndroidHttpClient.newInstance(FileUtilities.getUserAgent(context))) { @Override public HttpResponse performRequest(Request<?> request, Map<String, String> headers) throws IOException, AuthFailureError { addBearerTokenAuthorizationHeader(headers); return super.performRequest(request, headers); } }; requestQueue = Volley.newRequestQueue(context, stack); } return requestQueue; } OpenSRPImageLoader(FragmentActivity activity); OpenSRPImageLoader(Service service, int defaultPlaceHolderResId); OpenSRPImageLoader(Context context, int defaultPlaceHolderResId); OpenSRPImageLoader(FragmentActivity activity, int defaultPlaceHolderResId); OpenSRPImageLoader(FragmentActivity activity, ArrayList<Drawable> placeHolderDrawables); static File getDiskCacheDir(Context context, String uniqueName); static OpenSRPImageListener getStaticImageListener(ImageView view, int
defaultImageResId, int errorImageResId); static void saveStaticImageToDisk(String entityId, Bitmap image); static boolean moveSyncedImageAndSaveProfilePic(@NonNull String syncStatus, @NonNull String entityId, @NonNull File imageFile); static boolean copyFile(File src, File dst); OpenSRPImageLoader setFadeInImage(boolean fadeInImage); OpenSRPImageLoader setMaxImageSize(int maxImageWidth, int maxImageHeight); OpenSRPImageLoader setMaxImageSize(int maxImageSize); void getImageByClientId(String entityId, OpenSRPImageListener opensrpImageListener); void get(final ProfileImage image, final OpenSRPImageListener opensrpImageListener); ImageContainer get(String requestUrl, ImageView imageView); ImageContainer get(String requestUrl, ImageView imageView, int placeHolderIndex); ImageContainer get(String requestUrl, ImageView imageView, Drawable placeHolder); ImageContainer get(String requestUrl, ImageView imageView, Drawable placeHolder, int
maxWidth, int maxHeight); } | @Test public void assertServiceConstructorInitializationNotNull() throws Exception { PowerMockito.mockStatic(Volley.class); PowerMockito.when(Volley.newRequestQueue(Mockito.any(android.content.Context.class), Mockito.any(HurlStack.class))).thenReturn(Mockito.mock(RequestQueue.class)); OpenSRPImageLoader openSRPImageLoader = new OpenSRPImageLoader(Mockito.mock(Service.class), -1); Assert.assertNotNull(openSRPImageLoader); } |
TaskRepository extends BaseRepository { protected TaskUpdate readUpdateCursor(Cursor cursor) { TaskUpdate taskUpdate = new TaskUpdate(); taskUpdate.setIdentifier(cursor.getString(cursor.getColumnIndex(ID))); if (cursor.getString(cursor.getColumnIndex(STATUS)) != null) { taskUpdate.setStatus(cursor.getString(cursor.getColumnIndex(STATUS))); } if (cursor.getString(cursor.getColumnIndex(BUSINESS_STATUS)) != null) { taskUpdate.setBusinessStatus(cursor.getString(cursor.getColumnIndex(BUSINESS_STATUS))); } if (cursor.getString(cursor.getColumnIndex(SERVER_VERSION)) != null) { taskUpdate.setServerVersion(cursor.getString(cursor.getColumnIndex(SERVER_VERSION))); } return taskUpdate; } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testReadUpdateCursor() { MatrixCursor cursor = getCursor(); cursor.moveToNext(); String expectedIdentifier = cursor.getString(cursor.getColumnIndex("_id")); String expectedStatus = cursor.getString(cursor.getColumnIndex("status")); String expectedBusinessStatus = cursor.getString(cursor.getColumnIndex("business_status")); String expectedServerVersion = cursor.getString(cursor.getColumnIndex("server_version")); TaskUpdate returnedTaskUpdate = taskRepository.readUpdateCursor(cursor); assertNotNull(returnedTaskUpdate); assertEquals(expectedIdentifier, returnedTaskUpdate.getIdentifier()); assertEquals(expectedStatus, returnedTaskUpdate.getStatus()); assertEquals(expectedBusinessStatus, returnedTaskUpdate.getBusinessStatus()); assertEquals(expectedServerVersion, returnedTaskUpdate.getServerVersion()); } |
TaskRepository extends BaseRepository { public void markTaskAsSynced(String taskID) { try { ContentValues values = new ContentValues(); values.put(TaskRepository.ID, taskID); values.put(TaskRepository.SYNC_STATUS, BaseRepository.TYPE_Synced); values.put(TaskRepository.SERVER_VERSION, 0); getWritableDatabase().update(TaskRepository.TASK_TABLE, values, TaskRepository.ID + " = ?", new String[]{taskID}); } catch (Exception e) { Timber.e(e); } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testMarkTaskAsSynced() { String expectedTaskIdentifier = "id1"; taskRepository.markTaskAsSynced(expectedTaskIdentifier); verify(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), stringArrayArgumentCaptor.capture()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(TaskRepository.TASK_TABLE, iterator.next()); assertEquals("_id = ?", iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(3, contentValues.size()); assertEquals(expectedTaskIdentifier, contentValues.getAsString("_id")); assertEquals(BaseRepository.TYPE_Synced, contentValues.getAsString("sync_status")); assertEquals(0, contentValues.getAsInteger("server_version").intValue()); String actualTaskIdentifier = stringArrayArgumentCaptor.getAllValues().get(0)[0]; assertEquals(expectedTaskIdentifier, actualTaskIdentifier); } |
TaskRepository extends BaseRepository { public List<Task> getAllUnsynchedCreatedTasks() { return new ArrayList<>(getTasks(String.format("SELECT * FROM %s WHERE %s =? OR %s IS NULL", TASK_TABLE, SYNC_STATUS, SERVER_VERSION), new String[]{BaseRepository.TYPE_Created})); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testGetAllUnSyncedCreatedTasks() { when(sqLiteDatabase.rawQuery("SELECT * FROM task WHERE sync_status =? OR server_version IS NULL", new String[]{BaseRepository.TYPE_Created})).thenReturn(getCursor()); List<Task> unsyncedCreatedTasks = taskRepository.getAllUnsynchedCreatedTasks(); assertEquals(1, unsyncedCreatedTasks.size()); Task actualTask = unsyncedCreatedTasks.get(0); assertEquals("tsk11231jh22", actualTask.getIdentifier()); assertEquals("2018_IRS-3734", actualTask.getGroupIdentifier()); assertEquals(READY, actualTask.getStatus()); assertEquals("Not Visited", actualTask.getBusinessStatus()); assertEquals(3, actualTask.getPriority()); assertEquals("IRS", actualTask.getCode()); assertEquals("Spray House", actualTask.getDescription()); assertEquals("IRS Visit", actualTask.getFocus()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", actualTask.getForEntity()); assertEquals("2018-11-10T2200", actualTask.getExecutionStartDate().toString(formatter)); assertNull(actualTask.getExecutionEndDate()); assertEquals("2018-10-31T0700", actualTask.getAuthoredOn().toString(formatter)); assertEquals("2018-10-31T0700", actualTask.getLastModified().toString(formatter)); assertEquals("demouser", actualTask.getOwner()); } |
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdsFromExistingStructures() { try { getReadableDatabase().execSQL(String.format("UPDATE %s SET %s =(SELECT %s FROM structure WHERE %s = %s) WHERE %s IS NULL", TASK_TABLE, STRUCTURE_ID, ID, ID, FOR, STRUCTURE_ID)); return true; } catch (Exception e) { Timber.e(e); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testUpdateTaskStructureIdsFromExistingStructures() { String expectedSql = "UPDATE task SET structure_id =(SELECT _id FROM structure WHERE _id = for) WHERE structure_id IS NULL"; boolean updated = taskRepository.updateTaskStructureIdsFromExistingStructures(); assertTrue(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); }
@Test public void testUpdateTaskStructureIdsFromExistingStructuresFailure() { String expectedSql = "UPDATE task SET structure_id =(SELECT _id FROM structure WHERE _id = for) WHERE structure_id IS NULL"; doThrow(new SQLiteException()).when(sqLiteDatabase).execSQL(anyString()); boolean updated = taskRepository.updateTaskStructureIdsFromExistingStructures(); assertFalse(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); } |
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdsFromExistingClients(String clientTable) { try { getReadableDatabase().execSQL(String.format("UPDATE %s SET %s =(SELECT %s FROM %s WHERE base_entity_id = %s) WHERE %s IS NULL", TASK_TABLE, STRUCTURE_ID, STRUCTURE_ID, clientTable, FOR, STRUCTURE_ID)); return true; } catch (Exception e) { Timber.e(e); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testUpdateTaskStructureIdsfromExistingClients() { String expectedSql = "UPDATE task SET structure_id =(SELECT structure_id FROM ec_family_member WHERE base_entity_id = for) WHERE structure_id IS NULL"; String clientTable = "ec_family_member"; boolean updated = taskRepository.updateTaskStructureIdsFromExistingClients(clientTable); assertTrue(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); }
@Test public void testUpdateTaskStructureIdsfromExistingClientsFailure() { String expectedSql = "UPDATE task SET structure_id =(SELECT structure_id FROM ec_family_member WHERE base_entity_id = for) WHERE structure_id IS NULL"; String clientTable = "ec_family_member"; doThrow(new SQLiteException()).when(sqLiteDatabase).execSQL(anyString()); boolean updated = taskRepository.updateTaskStructureIdsFromExistingClients(clientTable); assertFalse(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); } |
TaskRepository extends BaseRepository { public boolean batchInsertTasks(JSONArray array) { if (array == null || array.length() == 0) { return false; } try { getWritableDatabase().beginTransaction(); for (int i = 0; i < array.length(); i++) { JSONObject jsonObject = array.getJSONObject(i); Task task = TaskServiceHelper.taskGson.fromJson(jsonObject.toString(), Task.class); addOrUpdate(task); } getWritableDatabase().setTransactionSuccessful(); getWritableDatabase().endTransaction(); return true; } catch (Exception e) { Timber.e(e, "EXCEPTION %s", e.toString()); getWritableDatabase().endTransaction(); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testBatchInsertTasks() throws Exception { Task expectedTask = gson.fromJson(taskJson, Task.class); JSONArray taskArray = new JSONArray().put(new JSONObject(taskJson)); taskRepository = spy(taskRepository); boolean inserted = taskRepository.batchInsertTasks(taskArray); verify(sqLiteDatabase).beginTransaction(); verify(sqLiteDatabase).setTransactionSuccessful(); verify(sqLiteDatabase).endTransaction(); assertTrue(inserted); verify(taskRepository).addOrUpdate(taskArgumentCaptor.capture()); assertEquals(expectedTask.getIdentifier(), taskArgumentCaptor.getValue().getIdentifier()); assertEquals(expectedTask.getStatus(), taskArgumentCaptor.getValue().getStatus()); assertEquals(expectedTask.getBusinessStatus(), taskArgumentCaptor.getValue().getBusinessStatus()); assertEquals(expectedTask.getCode(), taskArgumentCaptor.getValue().getCode()); assertEquals(expectedTask.getForEntity(), taskArgumentCaptor.getValue().getForEntity()); } |
TaskRepository extends BaseRepository { public Set<Task> getTasksByPlanAndEntity(String planId, String forEntity) { return getTasks(String.format("SELECT * FROM %s WHERE %s=? AND %s =? AND %s NOT IN (%s)", TASK_TABLE, PLAN_ID, FOR, STATUS, TextUtils.join(",", Collections.nCopies(INACTIVE_TASK_STATUS.length, "?"))) , ArrayUtils.addAll(new String[]{planId, forEntity}, INACTIVE_TASK_STATUS)); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); } | @Test public void testGetTasksByPlanAndEntity() { String query = "SELECT * FROM task WHERE plan_id=? AND for =? AND status NOT IN (?,?)"; when(sqLiteDatabase.rawQuery(query, new String[]{"IRS_2018_S1", "location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", CANCELLED.name(), ARCHIVED.name()})).thenReturn(getCursor()); Set<Task> allTasks = taskRepository.getTasksByPlanAndEntity("IRS_2018_S1", "location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals(query, stringArgumentCaptor.getValue()); assertEquals("IRS_2018_S1", argsCaptor.getValue()[0]); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", argsCaptor.getValue()[1]); assertEquals(CANCELLED.name(), argsCaptor.getValue()[2]); assertEquals(ARCHIVED.name(), argsCaptor.getValue()[3]); assertEquals(1, allTasks.size()); Task task = allTasks.iterator().next(); assertEquals("tsk11231jh22", task.getIdentifier()); assertEquals("2018_IRS-3734", task.getGroupIdentifier()); assertEquals(READY, task.getStatus()); assertEquals("Not Visited", task.getBusinessStatus()); assertEquals(3, task.getPriority()); assertEquals("IRS", task.getCode()); assertEquals("Spray House", task.getDescription()); assertEquals("IRS Visit", task.getFocus()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", task.getForEntity()); assertEquals("2018-11-10T2200", task.getExecutionStartDate().toString(formatter)); assertNull(task.getExecutionEndDate()); assertEquals("2018-10-31T0700", task.getAuthoredOn().toString(formatter)); assertEquals("2018-10-31T0700", task.getLastModified().toString(formatter)); assertEquals("demouser", task.getOwner()); } |
AllSettings { public void savePreviousFetchIndex(String value) { settingsRepository.updateSetting(PREVIOUS_FETCH_INDEX_SETTING_KEY, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldSavePreviousFetchIndex() throws Exception { allSettings.savePreviousFetchIndex("1234"); Mockito.verify(settingsRepository).updateSetting("previousFetchIndex", "1234"); } |
JsonFormUtils { public static Date formatDate(String dateString, boolean startOfToday) { try { if (StringUtils.isBlank(dateString)) { return null; } if (dateString.matches("\\d{2}-\\d{2}-\\d{4}")) { return dd_MM_yyyy.parse(dateString); } else if (dateString.matches("\\d{4}-\\d{2}-\\d{2}") || dateString.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) { return DateUtil.parseDate(dateString); } } catch (ParseException e) { Timber.e(e); } return null; } 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 formatDateReturnsinRequiredFormat() throws Exception { Date date = new Date(); String dateInFormat = dd_MM_yyyy.format(date); SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.sss'Z'"); String dateinFMT = fmt.format(dd_MM_yyyy.parse(dateInFormat)); String returnedDateinString = (JsonFormUtils.formatDate(dateInFormat)); Assert.assertEquals(dateinFMT, returnedDateinString); }
@Test public void formatDateReturnsDate() throws Exception { SimpleDateFormat yyyy_MM_dd = new SimpleDateFormat("yyyy-MM-dd"); Date date = dd_MM_yyyy.parse("22-05-1988"); String dateInFormat = dd_MM_yyyy.format(date); String dateInFormat2 = yyyy_MM_dd.format(date); Date datereturned = (JsonFormUtils.formatDate(dateInFormat, true)); Date datereturned2 = (JsonFormUtils.formatDate(dateInFormat2, true)); long diff = date.getTime() - datereturned.getTime(); long diff2 = date.getTime() - datereturned2.getTime(); Assert.assertEquals(diff, 0l); Assert.assertEquals(diff2, 0l); }
@Test public void testFormatDateShouldCorrectlyFormatDateStr() throws ParseException { String formattedDate = JsonFormUtils.formatDate("02-44-2970"); assertEquals("2973-08-02T00:00:00.000Z", formattedDate); }
@Test public void testFormatDateShouldCorrectlyFormatDate() throws ParseException { Date formattedDate = JsonFormUtils.formatDate("02-12-2970", false); assertEquals(dd_MM_yyyy.parse("02-12-2970"), formattedDate); formattedDate = JsonFormUtils.formatDate("02-12-2970", false); assertEquals(yyyyMMdd.parse("2970-12-02").toString(), formattedDate.toString()); formattedDate = JsonFormUtils.formatDate("2970-12-02 01:12:34", false); assertEquals(yyyyMMddHHmmss.parse("2970-12-02 01:12:34").toString(), formattedDate.toString()); } |
AllSettings { public String fetchPreviousFetchIndex() { return settingsRepository.querySetting(PREVIOUS_FETCH_INDEX_SETTING_KEY, "0"); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldFetchPreviousFetchIndex() throws Exception { Mockito.when(settingsRepository.querySetting("previousFetchIndex", "0")).thenReturn("1234"); String actual = allSettings.fetchPreviousFetchIndex(); Mockito.verify(settingsRepository).querySetting("previousFetchIndex", "0"); Assert.assertEquals("1234", actual); } |
AllSettings { public void savePreviousFormSyncIndex(String value) { settingsRepository.updateSetting(PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldSavePreviousFormSyncIndex() throws Exception { allSettings.savePreviousFormSyncIndex("1234"); Mockito.verify(settingsRepository).updateSetting("previousFormSyncIndex", "1234"); } |
AllSettings { public String fetchPreviousFormSyncIndex() { return settingsRepository.querySetting(PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY, "0"); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldFetchPreviousFormSyncIndex() throws Exception { Mockito.when(settingsRepository.querySetting("previousFormSyncIndex", "0")).thenReturn("1234"); String actual = allSettings.fetchPreviousFormSyncIndex(); Mockito.verify(settingsRepository).querySetting("previousFormSyncIndex", "0"); Assert.assertEquals("1234", actual); } |
AllSettings { public void saveAppliedVillageFilter(String village) { settingsRepository.updateSetting(APPLIED_VILLAGE_FILTER_SETTING_KEY, village); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldSaveAppliedVillageFilter() throws Exception { allSettings.saveAppliedVillageFilter("munjanahalli"); Mockito.verify(settingsRepository).updateSetting("appliedVillageFilter", "munjanahalli"); } |
AllSettings { public String appliedVillageFilter(String defaultFilterValue) { return settingsRepository .querySetting(APPLIED_VILLAGE_FILTER_SETTING_KEY, defaultFilterValue); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void shouldGetAppliedVillageFilter() throws Exception { allSettings.appliedVillageFilter("All"); Mockito.verify(settingsRepository).querySetting("appliedVillageFilter", "All"); } |
AllSettings { public void registerANM(String userName) { preferences.updateANMUserName(userName); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void assertRegisterANMCallsPreferenceAndRepositoryUpdate() throws Exception { Mockito.doNothing().when(allSharedPreferences).updateANMUserName(Mockito.anyString()); allSettings.registerANM(""); Mockito.verify(allSharedPreferences, Mockito.times(1)).updateANMUserName(Mockito.anyString()); } |
AllSettings { public void saveANMLocation(String anmLocation) { settingsRepository.updateSetting(ANM_LOCATION, anmLocation); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void assertSaveANMLocationCallsRepositoryUpdate() { Mockito.doNothing().doNothing().when(settingsRepository).updateSetting(Mockito.anyString(), Mockito.anyString()); allSettings.saveANMLocation(""); Mockito.verify(settingsRepository, Mockito.times(1)).updateSetting(Mockito.anyString(), Mockito.anyString()); } |
AllSettings { public String fetchANMLocation() { return settingsRepository.querySetting(ANM_LOCATION, ""); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void assertFetchANMLocationCallsRepositoryQuery() { Mockito.when(settingsRepository.querySetting(Mockito.anyString(), Mockito.anyString())).thenReturn(""); Assert.assertEquals(allSettings.fetchANMLocation(), ""); Mockito.verify(settingsRepository, Mockito.times(1)).querySetting(Mockito.anyString(), Mockito.anyString()); } |
AllSettings { public String fetchUserInformation() { return settingsRepository.querySetting(USER_INFORMATION, ""); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void assertFetchUserInformationCallsRepositoryQuery() { Mockito.when(settingsRepository.querySetting(Mockito.anyString(), Mockito.anyString())).thenReturn(""); Assert.assertEquals(allSettings.fetchUserInformation(), ""); Mockito.verify(settingsRepository, Mockito.times(1)).querySetting(Mockito.anyString(), Mockito.anyString()); } |
AllSettings { public void saveUserInformation(String userInformation) { settingsRepository.updateSetting(USER_INFORMATION, userInformation); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void assertSaveUserInformationCallsRepositoryUpdate() { Mockito.doNothing().doNothing().when(settingsRepository).updateSetting(Mockito.anyString(), Mockito.anyString()); allSettings.saveUserInformation(""); Mockito.verify(settingsRepository, Mockito.times(1)).updateSetting(Mockito.anyString(), Mockito.anyString()); } |
AllSettings { public String get(String key) { return get(key, null); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testGetWithDefaultShouldReturnCorrectValue() { SettingsRepository settingsRepository = spy(new SettingsRepository()); allSettings = new AllSettings(allSharedPreferences, settingsRepository); String value = allSettings.get("non_existent_key", "default_value"); assertEquals("default_value", value); doReturn("value").when(settingsRepository).querySetting(eq("my_key"), any()); value = allSettings.get("my_key"); assertEquals("value", value); }
@Test public void testGet() { Mockito.when(settingsRepository.querySetting("testKey", null)).thenReturn("testValue"); String val = allSettings.get("testKey"); Mockito.verify(settingsRepository).querySetting("testKey", null); Assert.assertEquals("testValue", val); } |
AllSettings { public void put(String key, String value) { settingsRepository.updateSetting(key, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testPut() { allSettings.put("testKey", "testValue"); Mockito.verify(settingsRepository).updateSetting("testKey", "testValue"); } |
AllSettings { public Setting getSetting(String key) { return settingsRepository.querySetting(key); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testGetSetting() { Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); Mockito.when(settingsRepository.querySetting("testKey")).thenReturn(s); Setting setting = allSettings.getSetting("testKey"); Mockito.verify(settingsRepository).querySetting("testKey"); Assert.assertEquals("testKey", setting.getKey()); Assert.assertEquals("testValue", setting.getValue()); } |
AllSettings { public List<Setting> getSettingsByType(String type) { return settingsRepository.querySettingsByType(type); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testGetSettingsByType() { List<Setting> ls = new ArrayList<>(); Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); ls.add(s); Setting s2 = new Setting(); s2.setKey("testKey2"); s2.setValue("testValue2"); ls.add(s2); Mockito.when(settingsRepository.querySettingsByType("testType")).thenReturn(ls); List<Setting> settings = allSettings.getSettingsByType("testType"); Mockito.verify(settingsRepository).querySettingsByType("testType"); Assert.assertEquals("testKey", settings.get(0).getKey()); Assert.assertEquals("testValue", settings.get(0).getValue()); } |
AllSettings { public void putSetting(Setting setting) { settingsRepository.updateSetting(setting); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testPutSetting() { Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); allSettings.putSetting(s); Mockito.verify(settingsRepository).updateSetting(s); } |
AllSettings { public List<Setting> getUnsyncedSettings() { return settingsRepository.queryUnsyncedSettings(); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testGetUnsyncedSettings() { List<Setting> ls = new ArrayList<>(); Setting s = new Setting(); s.setKey("testUnsyncedKey"); s.setValue("testUnsyncedValue"); ls.add(s); Mockito.when(settingsRepository.queryUnsyncedSettings()).thenReturn(ls); List<Setting> settings = allSettings.getUnsyncedSettings(); Mockito.verify(settingsRepository).queryUnsyncedSettings(); Assert.assertEquals("testUnsyncedKey", settings.get(0).getKey()); Assert.assertEquals("testUnsyncedValue", settings.get(0).getValue()); } |
AllSettings { public AllSharedPreferences getPreferences() { return preferences; } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testGetPreferences() { assertEquals(allSharedPreferences, allSettings.getPreferences()); } |
AllSettings { public String fetchRegisteredANM() { return preferences.fetchRegisteredANM(); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testFetchRegisteredANMShouldReturnCorrectProvider() { doReturn("provider").when(allSharedPreferences).fetchRegisteredANM(); assertEquals("provider", allSettings.fetchRegisteredANM()); } |
AllSettings { public String fetchDefaultTeamId(String username) { return preferences.fetchDefaultTeamId(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testFetchDefaultTeamIdShouldReturnCorrectTeamId() { doReturn("team-id").when(allSharedPreferences).fetchDefaultTeamId(anyString()); assertEquals("team-id", allSettings.fetchDefaultTeamId("user-name")); } |
JsonFormUtils { public static void addObservation(Event e, JSONObject jsonObject) { String value = getString(jsonObject, VALUE); if (StringUtils.isBlank(value)) { return; } String type = getString(jsonObject, AllConstants.TYPE); if (AllConstants.CHECK_BOX.equals(type)) { try { List<Object> optionValues = new ArrayList<>(); List<Object> optionEntityIds = new ArrayList<>(); Map<String, Object> optionKeyVals = new HashMap<>(); if (jsonObject.has(AllConstants.OPTIONS)) { JSONArray options = jsonObject.getJSONArray(AllConstants.OPTIONS); String fieldsOpenmrsEntityId = jsonObject.optString(OPENMRS_ENTITY_ID); String fieldOpenmrsEntityParent = jsonObject.optString(OPENMRS_ENTITY_PARENT); String fieldKey = jsonObject.optString(KEY); boolean shouldBeCombined = jsonObject.optBoolean(AllConstants.COMBINE_CHECKBOX_OPTION_VALUES); String entity = getString(jsonObject, OPENMRS_ENTITY); for (int i = 0; i < options.length(); i++) { JSONObject option = options.getJSONObject(i); boolean optionValue = option.optBoolean(VALUE); if (!optionValue) { continue; } if (CONCEPT.equals(entity)) { if (shouldBeCombined) { String optionKey = option.optString(KEY); String optionsOpenmrsEntityId = option.optString(OPENMRS_ENTITY_ID); optionValues.add(optionKey); optionEntityIds.add(optionsOpenmrsEntityId); continue; } option.put(AllConstants.TYPE, type); option.put(AllConstants.PARENT_ENTITY_ID, fieldsOpenmrsEntityId); option.put(KEY, fieldKey); createObservation(e, option, String.valueOf(option.getBoolean(VALUE))); } else { String optionText = option.optString(AllConstants.TEXT); optionValues.add(optionText); optionKeyVals.put(option.optString(KEY), optionText); } } if (!optionValues.isEmpty()) { if (CONCEPT.equals(entity) && shouldBeCombined) { e.addObs(new Obs(CONCEPT, AllConstants.CHECK_BOX, fieldsOpenmrsEntityId, fieldOpenmrsEntityParent, optionEntityIds, optionValues, null, fieldKey)); } else { createObservation(e, jsonObject, optionKeyVals, optionValues); } } } } catch (JSONException e1) { Timber.e(e1); } } else { createObservation(e, jsonObject, value); } } 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 addObservationAddsObservationToEvent() throws Exception { String observationJsonObjectString = "{\"v_required\":{\"value\":\"false\",\"err\":\"Enter the child's birth weight\"},\"v_min\":{\"value\":\"0" + ".1\",\"err\":\"Weight must be greater than 0\"},\"value\":\"5\",\"openmrs_entity\":\"concept\"," + "\"openmrs_entity_id\":\"5916AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\",\"hint\":\"জন্মের সময় ওজন (kg) " + "*\",\"openmrs_entity_parent\":\"\",\"openmrs_data_type\":\"text\",\"type\":\"edit_text\"," + "\"key\":\"Birth_Weight\",\"v_numeric\":{\"value\":\"true\",\"err\":\"Enter a valid weight\"}}"; JSONObject observationJsonObject = new JSONObject(observationJsonObjectString); org.smartregister.clientandeventmodel.Event event = Mockito.mock(org.smartregister.clientandeventmodel.Event.class); JsonFormUtils.addObservation(event, observationJsonObject); Mockito.verify(event, Mockito.atLeastOnce()).addObs(any(Obs.class)); }
@Test public void addObservationAddsObservationFormSubmissionFieldToEvent() throws Exception { String observationJsonObjectString = "{\"v_required\":{\"value\":\"false\",\"err\":\"Enter the child's birth weight\"},\"v_min\":{\"value\":\"0" + ".1\",\"err\":\"Weight must be greater than 0\"},\"value\":\"5\",\"openmrs_entity\":\"\"," + "\"openmrs_entity_id\":\"\",\"hint\":\"জন্মের সময় ওজন (kg) *\",\"openmrs_entity_parent\":\"\"," + "\"openmrs_data_type\":\"text\",\"type\":\"edit_text\",\"key\":\"Birth_Weight\"," + "\"v_numeric\":{\"value\":\"true\",\"err\":\"Enter a valid weight\"}}"; JSONObject observationJsonObject = new JSONObject(observationJsonObjectString); org.smartregister.clientandeventmodel.Event event = Mockito.mock(org.smartregister.clientandeventmodel.Event.class); JsonFormUtils.addObservation(event, observationJsonObject); Mockito.verify(event, Mockito.atLeastOnce()).addObs(any(Obs.class)); }
@Test public void addObservationAddsCombinedObservationFormSubmissionFieldForCheckboxesToEvent() throws Exception { String observationJsonObjectString = " {\n" + " \"key\": \"testMicrosResult\",\n" + " \"openmrs_entity_parent\": \"\",\n" + " \"openmrs_entity\": \"\",\n" + " \"openmrs_entity_id\": \"\",\n" + " \"type\": \"check_box\",\n" + " \"label\": \"Microscopy Result\",\n" + " \"value\": \"true\",\n" + " \"options\": [\n" + " {\n" + " \"key\": \"Negative\",\n" + " \"text\": \"Negative\",\n" + " \"value\": \"false\"\n" + " },\n" + " {\n" + " \"key\": \"PositiveFalciparum\",\n" + " \"text\": \"Positive - Falciparum\",\n" + " \"value\": \"false\"\n" + " },\n" + " {\n" + " \"key\": \"PositiveVivax\",\n" + " \"text\": \"Positive - Vivax\",\n" + " \"value\": \"true\"\n" + " },\n" + " {\n" + " \"key\": \"Fg\",\n" + " \"text\": \"Fg\",\n" + " \"value\": \"true\"\n" + " }\n" + " ]\n" + " }"; JSONObject observationJsonObject = new JSONObject(observationJsonObjectString); org.smartregister.clientandeventmodel.Event event = Mockito.mock(org.smartregister.clientandeventmodel.Event.class); JsonFormUtils.addObservation(event, observationJsonObject); Mockito.verify(event, Mockito.atLeastOnce()).addObs(obsArgumentCaptor.capture()); List<Object> values = obsArgumentCaptor.getValue().getValues(); assertEquals(2, values.size()); assertTrue(values.contains("Fg")); assertTrue(values.contains("Positive - Vivax")); assertFalse(values.contains("Positive - Falciparum")); } |
AllSettings { public String fetchDefaultTeam(String username) { return preferences.fetchDefaultTeam(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testFetchDefaultTeamShouldReturnCorrectTeam() { doReturn("team").when(allSharedPreferences).fetchDefaultTeam(anyString()); assertEquals("team", allSettings.fetchDefaultTeam("user-name")); } |
AllSettings { public String fetchDefaultLocalityId(String username) { return preferences.fetchDefaultLocalityId(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; } | @Test public void testFetchDefaultLocalityIdShouldReturnCorrectLocalityId() { doReturn("locality").when(allSharedPreferences).fetchDefaultLocalityId(anyString()); assertEquals("locality", allSettings.fetchDefaultLocalityId("user-name")); } |
LocationTagRepository extends BaseRepository { public void addOrUpdate(LocationTag locationTag) { if (StringUtils.isBlank(locationTag.getLocationId())) throw new IllegalArgumentException("location id not provided"); ContentValues contentValues = new ContentValues(); contentValues.put(NAME, locationTag.getName()); contentValues.put(LOCATION_ID, locationTag.getLocationId()); getWritableDatabase().replace(getLocationTagTableName(), null, contentValues); } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); } | @Test public void testAddOrUpdateShouldAdd() { LocationTag locationTag = gson.fromJson(locationTagJson, LocationTag.class); locationTagRepository.addOrUpdate(locationTag); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(LOCATION_TAG_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(2, contentValues.size()); assertEquals("Facility", contentValues.getAsString("name")); assertEquals("1", contentValues.getAsString("location_id")); }
@Test(expected = IllegalArgumentException.class) public void testAddOrUpdateShouldThrowException() { LocationTag locationTag = new LocationTag(); locationTagRepository.addOrUpdate(locationTag); } |
LocationTagRepository extends BaseRepository { public List<LocationTag> getAllLocationTags() { Cursor cursor = null; List<LocationTag> locationsTags = new ArrayList<>(); try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTagTableName(), null); while (cursor.moveToNext()) { locationsTags.add(readCursor(cursor)); } cursor.close(); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return locationsTags; } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); } | @Test public void tesGetAllLocationTags() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + LOCATION_TAG_TABLE, null)).thenReturn(getCursor()); List<LocationTag> allLocationsTags = locationTagRepository.getAllLocationTags(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location_tag", stringArgumentCaptor.getValue()); assertEquals(1, allLocationsTags.size()); LocationTag locationTag = allLocationsTags.get(0); assertEquals(locationTagJson, stripTimezone(gson.toJson(locationTag))); } |
LocationTagRepository extends BaseRepository { public List<LocationTag> getLocationTagByLocationId(String id) { List<LocationTag> locationsTags = new ArrayList<>(); try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTagTableName() + " WHERE " + LOCATION_ID + " =?", new String[]{id})) { while (cursor.moveToNext()) { locationsTags.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } return locationsTags; } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); } | @Test public void testGetLocationTagsById() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + LOCATION_TAG_TABLE + " WHERE " + LOCATION_ID + " =?", new String[]{"1"})).thenReturn(getCursor()); List<LocationTag> locationTags = locationTagRepository.getLocationTagByLocationId("1"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + LOCATION_TAG_TABLE + " WHERE " + LOCATION_ID + " =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("1", argsCaptor.getValue()[0]); assertEquals(locationTagJson, stripTimezone(gson.toJson(locationTags.get(0)))); } |
LocationTagRepository extends BaseRepository { public List<LocationTag> getLocationTagsByTagName(String tagName) { List<LocationTag> locationTags = new ArrayList<>(); try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTagTableName() + " WHERE " + NAME + " =?", new String[]{tagName})) { while (cursor.moveToNext()) { locationTags.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } return locationTags; } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); } | @Test public void testGetLocationTagsByTagName() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + LOCATION_TAG_TABLE + " WHERE " + NAME + " =?", new String[]{"Facility"})).thenReturn(getCursor()); List<LocationTag> locationTags = locationTagRepository.getLocationTagsByTagName("Facility"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + LOCATION_TAG_TABLE + " WHERE " + NAME + " =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("Facility", argsCaptor.getValue()[0]); assertEquals(locationTagJson, stripTimezone(gson.toJson(locationTags.get(0)))); } |
EligibleCoupleRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(EC_SQL); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertOnCreateCallDatabaseExecSql() { eligibleCoupleRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); } |
EligibleCoupleRepository extends DrishtiRepository { public void updatePhotoPath(String caseId, String imagePath) { SQLiteDatabase database = masterRepository.getWritableDatabase(); ContentValues values = new ContentValues(); values.put(PHOTO_PATH_COLUMN, imagePath); database.update(EC_TABLE_NAME, values, ID_COLUMN + " = ?", new String[]{caseId}); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertUpdatePhotoPathCallsUpdate() { eligibleCoupleRepository.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); eligibleCoupleRepository.updatePhotoPath("caseId", "photoPath"); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); } |
EligibleCoupleRepository extends DrishtiRepository { public void close(String caseId) { ContentValues values = new ContentValues(); values.put(IS_CLOSED_COLUMN, TRUE.toString()); masterRepository.getWritableDatabase() .update(EC_TABLE_NAME, values, ID_COLUMN + " = ?", new String[]{caseId}); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertCloseCallsUpdate() { eligibleCoupleRepository.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); eligibleCoupleRepository.close("0"); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); } |
SyncUtils { public boolean isAppVersionAllowed() throws PackageManager.NameNotFoundException { boolean isAppVersionAllowed = true; AllSettings settingsRepository = opensrpContent.allSettings(); Setting rawMinAllowedAppVersionSetting=null; try { rawMinAllowedAppVersionSetting = settingsRepository.getSetting(MIN_ALLOWED_APP_VERSION_SETTING); }catch ( NullPointerException e ){ Timber.e(e); return true; } if (rawMinAllowedAppVersionSetting == null) { return true; } Setting extractedMinAllowedAppVersionSetting = settingsRepository.getSetting(MIN_ALLOWED_APP_VERSION); if (extractedMinAllowedAppVersionSetting != null && isNewerSetting(extractedMinAllowedAppVersionSetting, rawMinAllowedAppVersionSetting)) { return !isOutdatedVersion(Long.parseLong(extractedMinAllowedAppVersionSetting.getValue())); } int minAllowedAppVersion = extractMinAllowedAppVersion(rawMinAllowedAppVersionSetting.getValue()); if (isOutdatedVersion(minAllowedAppVersion)) { isAppVersionAllowed = false; } extractedMinAllowedAppVersionSetting = new Setting(); extractedMinAllowedAppVersionSetting.setValue(String.valueOf(minAllowedAppVersion)); extractedMinAllowedAppVersionSetting.setKey(MIN_ALLOWED_APP_VERSION); extractedMinAllowedAppVersionSetting.setSyncStatus(BaseRepository.TYPE_Synced); extractedMinAllowedAppVersionSetting.setIdentifier(MIN_ALLOWED_APP_VERSION); extractedMinAllowedAppVersionSetting.setVersion(getIncrementedServerVersion(rawMinAllowedAppVersionSetting)); settingsRepository.putSetting(extractedMinAllowedAppVersionSetting); return isAppVersionAllowed; } SyncUtils(Context context); boolean verifyAuthorization(); void logoutUser(); void logoutUser(@StringRes int logoutMessage); boolean isAppVersionAllowed(); } | @Test public void testIsAppVersionAllowedShouldReturnCorrectStatus() throws PackageManager.NameNotFoundException { mockStatic(Utils.class); assertTrue(syncUtils.isAppVersionAllowed()); Setting setting = new Setting(); setting.setIdentifier(MIN_ALLOWED_APP_VERSION_SETTING); setting.setValue(getMinAppVersionSetting(2)); doReturn(setting).when(settingsRepository).getSetting(eq(MIN_ALLOWED_APP_VERSION_SETTING)); when(Utils.getVersionCode(any(Context.class))).thenReturn(1l); assertFalse(syncUtils.isAppVersionAllowed()); when(Utils.getVersionCode(any())).thenReturn(2l); doReturn(setting).when(settingsRepository).getSetting(eq(MIN_ALLOWED_APP_VERSION_SETTING)); assertTrue(syncUtils.isAppVersionAllowed()); when(Utils.getVersionCode(any())).thenReturn(3l); doReturn(setting).when(settingsRepository).getSetting(eq(MIN_ALLOWED_APP_VERSION_SETTING)); assertTrue(syncUtils.isAppVersionAllowed()); doReturn("2").when(settingsRepository).get(eq(MIN_ALLOWED_APP_VERSION)); when(Utils.getVersionCode(any())).thenReturn(1l); assertFalse(syncUtils.isAppVersionAllowed()); when(Utils.getVersionCode(any())).thenReturn(2l); assertTrue(syncUtils.isAppVersionAllowed()); when(Utils.getVersionCode(any())).thenReturn(3l); assertTrue(syncUtils.isAppVersionAllowed()); } |
EligibleCoupleRepository extends DrishtiRepository { public void add(EligibleCouple eligibleCouple) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(EC_TABLE_NAME, null, createValuesFor(eligibleCouple)); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertAddECCallsDatabaseSqlInsert() { eligibleCoupleRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); eligibleCoupleRepository.add(getMockEligibleCouple()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); } |
EligibleCoupleRepository extends DrishtiRepository { public void updateDetails(String caseId, Map<String, String> details) { SQLiteDatabase database = masterRepository.getWritableDatabase(); EligibleCouple couple = findByCaseID(caseId); if (couple == null) { return; } ContentValues valuesToUpdate = new ContentValues(); valuesToUpdate.put(DETAILS_COLUMN, new Gson().toJson(details)); database.update(EC_TABLE_NAME, valuesToUpdate, ID_COLUMN + " = ?", new String[]{caseId}); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertUpdateDetails() { eligibleCoupleRepository.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(getECCursor()); HashMap<String, String> details = new HashMap<String, String>(); details.put("details", "1"); eligibleCoupleRepository.updateDetails("0", details); 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)); } |
EligibleCoupleRepository extends DrishtiRepository { public List<EligibleCouple> allEligibleCouples() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(EC_TABLE_NAME, EC_TABLE_COLUMNS, IS_OUT_OF_AREA_COLUMN + "" + " = ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{IN_AREA, NOT_CLOSED}, null, null, null, null); return readAllEligibleCouples(cursor); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertAllEligibleCouples() { eligibleCoupleRepository.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(getECCursor()); HashMap<String, String> details = new HashMap<String, String>(); details.put("details", "1"); eligibleCoupleRepository.allEligibleCouples(); 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)); } |
EligibleCoupleRepository extends DrishtiRepository { public List<String> villages() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(true, EC_TABLE_NAME, new String[]{VILLAGE_NAME_COLUMN}, IS_OUT_OF_AREA_COLUMN + " = ? AND " + IS_CLOSED_COLUMN + " = ?", new String[]{IN_AREA, NOT_CLOSED}, null, null, null, null); cursor.moveToFirst(); List<String> villages = new ArrayList<String>(); while (!cursor.isAfterLast()) { villages.add(cursor.getString(0)); cursor.moveToNext(); } cursor.close(); return villages; } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertAllVillagesReturnsVillageList() { eligibleCoupleRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyBoolean(), 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(getECCursor()); HashMap<String, String> details = new HashMap<String, String>(); details.put("details", "1"); Assert.assertNotNull(eligibleCoupleRepository.villages()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyBoolean(), 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)); } |
EligibleCoupleRepository extends DrishtiRepository { public List<EligibleCouple> findByCaseIDs(String... caseIds) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( String.format("SELECT * FROM %s WHERE %s IN (%s)", EC_TABLE_NAME, ID_COLUMN, insertPlaceholdersForInClause(caseIds.length)), caseIds); return readAllEligibleCouples(cursor); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertFindCaseByIdsReturnsECList() { eligibleCoupleRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getECCursor()); Assert.assertNotNull(eligibleCoupleRepository.findByCaseIDs("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).rawQuery(Mockito.anyString(), Mockito.any(String[].class)); } |
EligibleCoupleRepository extends DrishtiRepository { public void mergeDetails(String caseId, Map<String, String> details) { SQLiteDatabase database = masterRepository.getWritableDatabase(); EligibleCouple couple = findByCaseID(caseId); if (couple == null) { return; } Map<String, String> mergedDetails = new HashMap<String, String>(couple.details()); mergedDetails.putAll(details); ContentValues valuesToUpdate = new ContentValues(); valuesToUpdate.put(DETAILS_COLUMN, new Gson().toJson(mergedDetails)); database.update(EC_TABLE_NAME, valuesToUpdate, ID_COLUMN + " = ?", new String[]{caseId}); } void add(EligibleCouple eligibleCouple); void updateDetails(String caseId, Map<String, String> details); void mergeDetails(String caseId, Map<String, String> details); List<EligibleCouple> allEligibleCouples(); List<EligibleCouple> findByCaseIDs(String... caseIds); EligibleCouple findByCaseID(String caseId); long count(); List<String> villages(); void updatePhotoPath(String caseId, String imagePath); void close(String caseId); long fpCount(); static final String ID_COLUMN; static final String EC_NUMBER_COLUMN; static final String WIFE_NAME_COLUMN; static final String HUSBAND_NAME_COLUMN; static final String VILLAGE_NAME_COLUMN; static final String SUBCENTER_NAME_COLUMN; static final String IS_OUT_OF_AREA_COLUMN; static final String DETAILS_COLUMN; static final String PHOTO_PATH_COLUMN; static final String EC_TABLE_NAME; static final String NOT_CLOSED; static final String[] EC_TABLE_COLUMNS; } | @Test public void assertMergeDetails() { eligibleCoupleRepository.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(getECCursor()); HashMap<String, String> details = new HashMap<String, String>(); details.put("details", "1"); eligibleCoupleRepository.mergeDetails("0", details); 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)); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { @Override public void addOrUpdate(ClientFormContract.Model clientForm) { ContentValues contentValues = new ContentValues(); contentValues.put(ID, clientForm.getId()); contentValues.put(VERSION, clientForm.getVersion()); contentValues.put(IDENTIFIER, clientForm.getIdentifier()); contentValues.put(MODULE, clientForm.getModule()); contentValues.put(JSON, clientForm.getJson()); contentValues.put(JURISDICTION, clientForm.getJurisdiction()); contentValues.put(LABEL, clientForm.getLabel()); contentValues.put(IS_NEW, clientForm.isNew()); contentValues.put(ACTIVE, clientForm.isActive()); contentValues.put(CREATED_AT, DATE_FORMAT.format(clientForm.getCreatedAt())); getWritableDatabase().replace(getClientFormTableName(), null, contentValues); } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testAddOrUpdateShouldAdd() { ClientForm clientForm = gson.fromJson(clientFormJson, ClientForm.class); clientFormRepository.addOrUpdate(clientForm); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(CLIENT_FORM_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(10, contentValues.size()); assertEquals("1", contentValues.getAsString(ClientFormRepository.ID)); assertEquals("1.1.0", contentValues.getAsString(VERSION)); assertEquals("en/child/enrollment.json", contentValues.getAsString(IDENTIFIER)); assertEquals(true, contentValues.getAsBoolean(ACTIVE)); assertEquals(true, contentValues.getAsBoolean(ClientFormRepository.IS_NEW)); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { public ClientForm getActiveClientFormByIdentifier(String identifier) { try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getClientFormTableName() + " WHERE " + IDENTIFIER + " =? AND " + ACTIVE + " = 1", new String[]{identifier})) { if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } return null; } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testGetActiveClientFormByIdentifier() { String identifier = "en/child/enrollment.json"; clientFormRepository.getActiveClientFormByIdentifier(identifier); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + CLIENT_FORM_TABLE + " WHERE " + IDENTIFIER + " =? AND " + ACTIVE + " = 1", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals(identifier, argsCaptor.getValue()[0]); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { @Override public List<ClientFormContract.Model> getClientFormByIdentifier(String identifier) { List<ClientFormContract.Model> clientForms = new ArrayList<>(); try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getClientFormTableName() + " WHERE " + IDENTIFIER + " =? ORDER BY " + CREATED_AT + " DESC", new String[]{identifier})) { while (cursor.moveToNext()) { clientForms.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } return clientForms; } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testGetClientFormByIdentifier() { String identifier = "en/child/enrollment.json"; clientFormRepository.getClientFormByIdentifier(identifier); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + CLIENT_FORM_TABLE + " WHERE " + IDENTIFIER + " =? ORDER BY " + CREATED_AT + " DESC", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals(identifier, argsCaptor.getValue()[0]); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { @Override public ClientForm getLatestFormByIdentifier(String identifier) { try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getClientFormTableName() + " WHERE " + IDENTIFIER + " = ? ORDER BY " + CREATED_AT + " DESC LIMIT 1", new String[]{identifier})) { if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } return null; } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testGetLatestFormByIdentifier() { String identifier = "en/child/enrollment.json"; clientFormRepository.getLatestFormByIdentifier(identifier); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM " + CLIENT_FORM_TABLE + " WHERE " + IDENTIFIER + " = ? ORDER BY " + CREATED_AT + " DESC LIMIT 1", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals(identifier, argsCaptor.getValue()[0]); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { @Override public void setIsNew(boolean isNew, int formId) { ContentValues contentValues = new ContentValues(); contentValues.put(ID, formId); contentValues.put(IS_NEW, isNew); getWritableDatabase().update(getClientFormTableName(),contentValues, ID + " = ?", new String[]{String.valueOf(formId)}); } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testSetIsNewShouldCallDatabaseUpdateWithCorrectValues() { ArgumentCaptor<ContentValues> argumentCaptor = ArgumentCaptor.forClass(ContentValues.class); ArgumentCaptor<String[]> stringArgumentCaptor = ArgumentCaptor.forClass(String[].class); clientFormRepository.setIsNew(false, 56); verify(sqLiteDatabase).update(eq("client_form"), argumentCaptor.capture(), eq("id = ?"), stringArgumentCaptor.capture()); ContentValues contentValues = argumentCaptor.getValue(); assertEquals(false, contentValues.getAsBoolean(ClientFormRepository.IS_NEW)); assertEquals(56, (int) contentValues.getAsInteger(ClientFormRepository.ID)); String[] whereArgs = stringArgumentCaptor.getValue(); assertEquals("56", whereArgs[0]); } |
ClientFormRepository extends BaseRepository implements ClientFormContract.Dao { protected ClientForm readCursor(Cursor cursor) { ClientForm clientForm = new ClientForm(); clientForm.setId(cursor.getInt(cursor.getColumnIndex(ID))); clientForm.setVersion(cursor.getString(cursor.getColumnIndex(VERSION))); clientForm.setIdentifier(cursor.getString(cursor.getColumnIndex(IDENTIFIER))); clientForm.setModule(cursor.getString(cursor.getColumnIndex(MODULE))); clientForm.setJson(cursor.getString(cursor.getColumnIndex(JSON))); clientForm.setJurisdiction(cursor.getString(cursor.getColumnIndex(JURISDICTION))); clientForm.setLabel(cursor.getString(cursor.getColumnIndex(LABEL))); clientForm.setNew(cursor.getInt(cursor.getColumnIndex(IS_NEW)) == 1); clientForm.setActive(cursor.getInt(cursor.getColumnIndex(ACTIVE)) == 1); try { clientForm.setCreatedAt(DATE_FORMAT.parse(cursor.getString(cursor.getColumnIndex(CREATED_AT)))); } catch (ParseException e) { Timber.e(e); } return clientForm; } static void createTable(SQLiteDatabase database); @Override void addOrUpdate(ClientFormContract.Model clientForm); @Override void setIsNew(boolean isNew, int formId); @Override List<ClientFormContract.Model> getClientFormByIdentifier(String identifier); ClientForm getActiveClientFormByIdentifier(String identifier); @Override ClientForm getLatestFormByIdentifier(String identifier); @Override void delete(int clientFormId); @Override ClientFormContract.Model createNewClientFormModel(); static final String CREATE_CLIENT_FORM_TABLE; } | @Test public void testReadCursorShouldReturnValidObject() { int formId = 78; String version = "0.0.4"; String identifier = "child_registration.json"; String module = null; String json = "{}"; String jurisdiction = null; String label = "Child Registration"; boolean isNew = true; boolean isActive = true; MatrixCursor matrixCursor = new MatrixCursor(new String[]{ClientFormRepository.ID, VERSION , IDENTIFIER, ClientFormRepository.MODULE, ClientFormRepository.JSON , ClientFormRepository.JURISDICTION, ClientFormRepository.LABEL , ClientFormRepository.IS_NEW, ACTIVE, CREATED_AT}); matrixCursor.addRow(new Object[]{formId, version, identifier, module, json, jurisdiction, label, isNew ? 1 : 0, isActive ? 1 : 0, ""}); matrixCursor.moveToFirst(); ClientForm clientForm = clientFormRepository.readCursor(matrixCursor); assertEquals(formId, clientForm.getId()); assertEquals(version, clientForm.getVersion()); assertEquals(identifier, clientForm.getIdentifier()); assertEquals(module, clientForm.getModule()); assertEquals(json, clientForm.getJson()); assertEquals(jurisdiction, clientForm.getJurisdiction()); assertEquals(label, clientForm.getLabel()); assertEquals(isActive, clientForm.isActive()); assertEquals(isNew, clientForm.isNew()); } |
ReportRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(REPORT_SQL); database.execSQL(REPORT_INDICATOR_INDEX_SQL); } void update(Report report); List<Report> allFor(String... indicators); List<Report> all(); } | @Test public void onCreateCallsDatabaseExec() { reportRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(2)).execSQL(Mockito.anyString()); } |
ReportRepository extends DrishtiRepository { public void update(Report report) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.replace(REPORT_TABLE_NAME, null, createValuesFor(report)); } void update(Report report); List<Report> allFor(String... indicators); List<Report> all(); } | @Test public void assertUpdateCallsDatabaseUpdate() { Report report = new Report("", "", ""); reportRepository.update(report); Mockito.verify(sqLiteDatabase, Mockito.times(1)).replace(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); } |
ReportRepository extends DrishtiRepository { public List<Report> allFor(String... indicators) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( String.format("SELECT * FROM %s WHERE %s IN (%s)", REPORT_TABLE_NAME, INDICATOR_COLUMN, insertPlaceholdersForInClause(indicators.length)), indicators); return readAll(cursor); } void update(Report report); List<Report> allFor(String... indicators); List<Report> all(); } | @Test public void assertAllForReturnsReportList() { String[] columns = {"a", "b", "c"}; MatrixCursor cursor = new MatrixCursor(columns); cursor.addRow(new Object[]{"", "", ""}); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(cursor); Assert.assertNotNull(reportRepository.allFor("", "", "")); } |
ReportRepository extends DrishtiRepository { public List<Report> all() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(REPORT_TABLE_NAME, REPORT_TABLE_COLUMNS, null, null, null, null, null); return readAll(cursor); } void update(Report report); List<Report> allFor(String... indicators); List<Report> all(); } | @Test public void assertAllReturnsAllReports() { String[] columns = {"a", "b", "c"}; MatrixCursor cursor = new MatrixCursor(columns); cursor.addRow(new Object[]{"", "", ""}); Mockito.when(sqLiteDatabase.query(REPORT_TABLE_NAME, REPORT_TABLE_COLUMNS, null, null, null, null, null)).thenReturn(cursor); Assert.assertNotNull(reportRepository.all()); } |
EventClientRepository extends BaseRepository { public boolean batchInsertClients(JSONArray array) { return batchInsertClients(array, getWritableDatabase()); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void batchInsertClientsReturnsNotNull() throws Exception { Assert.assertTrue(eventClientRepository.batchInsertClients(new JSONArray(ClientData.clientJsonArray))); } |
EventClientRepository extends BaseRepository { public boolean batchInsertEvents(JSONArray array, long serverVersion) { return batchInsertEvents(array, serverVersion, getWritableDatabase()); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void batchInsertEventsReturnsNotNull() throws Exception { Assert.assertTrue(eventClientRepository.batchInsertEvents(new JSONArray(ClientData.eventJsonArray), 0l)); } |
EventClientRepository extends BaseRepository { public List<JSONObject> getEvents(long startServerVersion, long lastServerVersion) { List<JSONObject> list = new ArrayList<>(); Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.serverVersion.name() + " > " + startServerVersion + " AND " + event_column.serverVersion.name() + " <= " + lastServerVersion + " ORDER BY " + event_column.serverVersion.name(), null); while (cursor.moveToNext()) { String jsonEventStr = cursor.getString(0); jsonEventStr = jsonEventStr.replaceAll("'", ""); JSONObject ev = new JSONObject(jsonEventStr); if (ev.has(event_column.baseEntityId.name())) { String baseEntityId = ev.getString(event_column.baseEntityId.name()); JSONObject cl = getClient(getWritableDatabase(), baseEntityId); ev.put("client", cl); } list.add(ev); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return list; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getEventsByServerVersionsReturnsNotNull() throws Exception { String query = "SELECT json FROM event WHERE serverVersion > 0 AND serverVersion <= 0 ORDER BY serverVersion"; Mockito.when(sqliteDatabase.rawQuery(query, null)).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getEvents(0l, 0l)); }
@Test public void getEventsBySyncDateAndSyncStatusReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getEvents(new Date(), "unsynced")); }
@Test public void getEventsBySyncDateReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getEvents(new Date())); }
@Test public void getEventsShouldReturnGenerateMaxRowIdAndIncludeRowIdAndSyncStatusInJson() throws JSONException { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"json", EventClientRepository.event_column.syncStatus.name(), AllConstants.ROWID}, 0); for (int i = 0; i < 30; i++) { matrixCursor.addRow(new Object[]{"{\"eventId\": \"d89sd\"}", BaseRepository.TYPE_Synced, (i + 1L)}); } Mockito.doReturn(matrixCursor).when(sqliteDatabase).rawQuery(Mockito.eq("SELECT json,syncStatus,rowid FROM event WHERE rowid > ? ORDER BY rowid ASC LIMIT ?"), Mockito.any(Object[].class)); JsonData jsonData = eventClientRepository.getEvents(0, 20, null); Assert.assertEquals(30L, jsonData.getHighestRecordId()); JSONObject jsonObject = jsonData.getJsonArray().getJSONObject(0); Assert.assertTrue(jsonObject.has(EventClientRepository.event_column.syncStatus.name())); Assert.assertTrue(jsonObject.has(AllConstants.ROWID)); } |
JsonFormUtils { public static void fillAddressFields(JSONObject jsonObject, Map<String, Address> addresses) { if (jsonObject == null) { return; } try { String value = getString(jsonObject, VALUE); if (StringUtils.isBlank(value)) { return; } if (StringUtils.isNotBlank(getString(jsonObject, ENTITY_ID))) { 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 assertfilladdressStartDateAddsStartDate() throws Exception { String addressJsonWithStartDateString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithStartDateString), addressHashMap); 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 assertfilladdressEndDateAddsEndDate() throws Exception { String addressJsonWithEndDateString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithEndDateString), addressHashMap); 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 assertfilladdressLongitudeAddsLongitude() throws Exception { String addressJsonWithLongitudeString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithLongitudeString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getLongitude(), "34.044494"); }
@Test public void assertfilladdresslatitudeAddslatitude() throws Exception { String addressJsonWithStartlatitudeString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithStartlatitudeString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getLatitude(), "34.044494"); }
@Test public void assertfilladdressGeopointAddsGeopoint() throws Exception { String addressJsonWithGeopointString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithGeopointString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getGeopoint(), "34.044494 -84.695704 4 76 = lat lon alt prec"); }
@Test public void assertfilladdressPostal_codeAddsPostal_code() throws Exception { String addressJsonWithStartPostal_code = "{\"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.fillAddressFields(new JSONObject(addressJsonWithStartPostal_code), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getPostalCode(), "4021"); }
@Test public void assertfilladdressSub_townAddsSub_town() throws Exception { String addressJsonWithSub_townString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithSub_townString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getSubTown(), "Kotwali"); }
@Test public void assertfilladdressTownAddsTown() throws Exception { String addressJsonWithTownString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithTownString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getTown(), "Chittagong"); }
@Test public void assertfilladdressSub_districtAddsSub_district() throws Exception { String addressJsonWithsub_districtString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithsub_districtString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getSubDistrict(), "Chittagong"); }
@Test public void assertfilladdressDistrictAddsDistrict() throws Exception { String addressJsonWithDistrictString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithDistrictString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCountyDistrict(), "Chittagong"); }
@Test public void assertfilladdressCityVillageAddsCityVillage() throws Exception { String addressJsonWithCityVillageString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithCityVillageString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCityVillage(), "Chittagong"); }
@Test public void assertfilladdressStateAddsState() throws Exception { String addressJsonWithStateString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithStateString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getStateProvince(), "Chittagong"); }
@Test public void assertfilladdressCountryAddsCountry() throws Exception { String addressJsonWithCountryString = "{\"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.fillAddressFields(new JSONObject(addressJsonWithCountryString), addressHashMap); assertTrue(addressHashMap.size() > 0); Assert.assertEquals(addressHashMap.get("usual_residence").getCountry(), "Bangladesh"); } |
EventClientRepository extends BaseRepository { public List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes) { if (eventTypes == null) return null; String eventTypeString = TextUtils.join(",", Collections.nCopies(eventTypes.size(), "?")); return fetchEventClientsCore(String.format("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.eventType.name() + " IN (%s) " + " ORDER BY " + event_column.serverVersion.name(), eventTypeString), eventTypes.toArray(new String[]{})); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void fetchEventClientsByEventVersion() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.fetchEventClientsByEventTypes(Collections.singletonList("Registration"))); } |
EventClientRepository extends BaseRepository { public List<EventClient> fetchEventClients(List<String> formSubmissionIds) { return fetchEventClientsCore("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.formSubmissionId.name() + " IN (" + (getPlaceHolders(formSubmissionIds.size())) + ")" + " ORDER BY " + event_column.serverVersion.name(), formSubmissionIds.toArray(new String[formSubmissionIds.size()])); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void testFetchEventClients() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.fetchEventClients(Collections.singletonList("123"))); }
@Test public void testFetchEventClientsByMinMaxTimestamp() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.fetchEventClients(10000l, 20000l)); } |
EventClientRepository extends BaseRepository { public Map<String, Object> getUnSyncedEvents(int limit) { Map<String, Object> result = new HashMap<>(); List<JSONObject> clients = new ArrayList<>(); List<JSONObject> events = new ArrayList<>(); String query = "select " + event_column.json + "," + event_column.syncStatus + " from " + eventTable.name() + " where " + event_column.syncStatus + " in (? , ?) and length(" + event_column.json + ")>2 order by " + event_column.updatedAt + " asc limit " + limit; Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery(query, new String[]{BaseRepository.TYPE_Unsynced, BaseRepository.TYPE_Unprocessed}); while (cursor.moveToNext()) { String jsonEventStr = (cursor.getString(0)); if (StringUtils.isBlank(jsonEventStr) || jsonEventStr.equals("{}")) { continue; } jsonEventStr = jsonEventStr.replaceAll("'", ""); JSONObject jsonObectEvent = new JSONObject(jsonEventStr); events.add(jsonObectEvent); if (jsonObectEvent.has(event_column.baseEntityId.name())) { String baseEntityId = jsonObectEvent.getString(event_column.baseEntityId.name ()); JSONObject cl = getUnSyncedClientByBaseEntityId(baseEntityId); if (cl != null) { clients.add(cl); } } } if (!clients.isEmpty()) { result.put(AllConstants.KEY.CLIENTS, clients); } if (!events.isEmpty()) { result.put(AllConstants.KEY.EVENTS, events); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return result; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getUnsyncedEventsReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getUnSyncedEvents(100)); } |
EventClientRepository extends BaseRepository { public JSONObject getEventsByBaseEntityId(String baseEntityId) { JSONObject events = new JSONObject(); JSONArray list = new JSONArray(); if (StringUtils.isBlank(baseEntityId)) { return events; } Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.baseEntityId.name() + "= ? ", new String[]{baseEntityId}); while (cursor.moveToNext()) { String jsonEventStr = cursor.getString(0); jsonEventStr = jsonEventStr.replaceAll("'", ""); JSONObject ev = new JSONObject(jsonEventStr); list.put(ev); } JSONObject cl = getClient(getWritableDatabase(), baseEntityId); events.put("client", cl); events.put("events", list); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return events; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getEventsByBaseEntityIdReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); JSONObject events = eventClientRepository.getEventsByBaseEntityId(baseEntityId); Assert.assertNotNull(events); Assert.assertTrue(events.has("events")); }
@Test public void getEventsByBaseEntityIdReturnsNotNullIfIdIsNull() { Assert.assertNotNull(eventClientRepository.getEventsByBaseEntityId(null)); Mockito.verifyNoMoreInteractions(sqliteDatabase); }
@Test public void getEventsByBaseEntityIdReturnsNotNullOnError() { Mockito.doThrow(new RuntimeException()).when(sqliteDatabase).rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); Assert.assertNotNull(eventClientRepository.getEventsByBaseEntityId(null)); } |
EventClientRepository extends BaseRepository { public JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType) { if (StringUtils.isBlank(baseEntityId)) { return null; } Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.baseEntityId.name() + "= ? AND " + event_column.eventType.name() + "= ? ", new String[]{baseEntityId, eventType}); if (cursor.moveToNext()) { String jsonEventStr = cursor.getString(0); jsonEventStr = jsonEventStr.replaceAll("'", ""); return new JSONObject(jsonEventStr); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return null; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void testGetEventsByBaseEntityIdAndEventTypeReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getEventsByBaseEntityIdAndEventType(baseEntityId, eventType)); } |
EventClientRepository extends BaseRepository { public List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds) { List<EventClient> list = new ArrayList<>(); if (Utils.isEmptyCollection(baseEntityIds)) return list; Cursor cursor = null; try { int len = baseEntityIds.size(); String query = String.format("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.baseEntityId.name() + " IN (%s) " + " AND " + event_column.syncStatus.name() + "= ? " + " ORDER BY " + event_column.serverVersion.name(), TextUtils.join(",", Collections.nCopies(len, "?"))); String[] params = baseEntityIds.toArray(new String[len + 1]); params[len] = syncStatus; cursor = getReadableDatabase().rawQuery(query, params); while (cursor.moveToNext()) { String jsonEventStr = cursor.getString(0); jsonEventStr = jsonEventStr.replaceAll("'", ""); Event event = convert(jsonEventStr, Event.class); list.add(new EventClient(event)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return list; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void testGetEventsByBaseEntityIdsAndSyncStatusReturnsNotNull() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getEventCursor()); Assert.assertNotNull(eventClientRepository.getEventsByBaseEntityIdsAndSyncStatus(syncStatus, Arrays.asList(baseEntityId))); } |
EventClientRepository extends BaseRepository { public JSONObject getEventsByFormSubmissionId(String formSubmissionId) { if (StringUtils.isBlank(formSubmissionId)) { return null; } Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT json FROM " + eventTable.name() + " WHERE " + event_column.formSubmissionId.name() + "= ? ", new String[]{formSubmissionId}); if (cursor.moveToNext()) { String jsonEventStr = cursor.getString(0); jsonEventStr = jsonEventStr.replaceAll("'", ""); return new JSONObject(jsonEventStr); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return null; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getEventsByFormSubmissionIdReturnsNotNull() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"json"}); JSONArray eventArray = new JSONArray(ClientData.eventJsonArray); for (int i = 0; i < eventArray.length(); i++) { matrixCursor.addRow(new String[]{eventArray.getJSONObject(i).toString()}); } Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(matrixCursor); Assert.assertNotNull(eventClientRepository.getEventsByFormSubmissionId("FormSubmissionID")); } |
EventClientRepository extends BaseRepository { @SuppressWarnings("unchecked") public void markEventsAsSynced(Map<String, Object> syncedEvents) { try { List<JSONObject> clients = syncedEvents.containsKey(AllConstants.KEY.CLIENTS) ? (List<JSONObject>) syncedEvents.get( AllConstants.KEY.CLIENTS) : null; List<JSONObject> events = syncedEvents.containsKey(AllConstants.KEY.EVENTS) ? (List<JSONObject>) syncedEvents.get( AllConstants.KEY.EVENTS) : null; if (clients != null && !clients.isEmpty()) { for (JSONObject client : clients) { String baseEntityId = client.getString(client_column.baseEntityId.name()); markClientAsSynced(baseEntityId); } } if (events != null && !events.isEmpty()) { for (JSONObject event : events) { String formSubmissionId = event.getString(event_column.formSubmissionId.name()); markEventAsSynced(formSubmissionId); } } } catch (Exception e) { Timber.e(e); } } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void markEventsAsSyncedCallsUpdateAsMAnyTimesAsEventsAndClientsPassedIntoMethod() throws Exception { HashMap<String, Object> syncedObjects = new HashMap<String, Object>(); syncedObjects.put("clients", getClientList()); syncedObjects.put("events", getEventList()); eventClientRepository.markEventsAsSynced(syncedObjects); Mockito.verify(sqliteDatabase, Mockito.times(getEventList().size() + getClientList().size())).update(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(ContentValues.class), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); } |
EventClientRepository extends BaseRepository { public void markAllAsUnSynced() { String events = "select " + event_column.baseEntityId + "," + event_column.syncStatus + " from " + eventTable.name(); String clients = "select " + client_column.baseEntityId + "," + client_column.syncStatus + " from " + clientTable.name(); Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery(clients, null); int maxRowId = getMaxRowId(clientTable); while (cursor.moveToNext()) { String beid = (cursor.getString(0)); if (StringUtils.isBlank(beid) || "{}".equals(beid)) { continue; } ContentValues values = new ContentValues(); values.put(client_column.baseEntityId.name(), beid); values.put(client_column.syncStatus.name(), BaseRepository.TYPE_Unsynced); values.put(ROWID, maxRowId++); getWritableDatabase().update(clientTable.name(), values, client_column.baseEntityId.name() + " = ?", new String[]{beid}); } cursor.close(); cursor = getWritableDatabase().rawQuery(events, null); maxRowId = getMaxRowId(eventTable); while (cursor.moveToNext()) { String beid = (cursor.getString(0)); if (StringUtils.isBlank(beid) || "{}".equals(beid)) { continue; } ContentValues values = new ContentValues(); values.put(event_column.baseEntityId.name(), beid); values.put(event_column.syncStatus.name(), BaseRepository.TYPE_Unsynced); values.put(ROWID, maxRowId++); getWritableDatabase().update(eventTable.name(), values, event_column.baseEntityId.name() + " = ?", new String[]{beid}); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void markAllAsUnSyncedCallsUpdate2timesFor2Objects() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{baseEntityId, syncStatus}); matrixCursor.addRow(new String[]{baseEntityId, syncStatus}); matrixCursor.addRow(new String[]{baseEntityId, syncStatus}); Mockito.when(sqliteDatabase.rawQuery("select baseEntityId,syncStatus from client", null)).thenReturn(matrixCursor); Mockito.when(sqliteDatabase.rawQuery("select baseEntityId,syncStatus from event", null)).thenReturn(matrixCursor); eventClientRepository.markAllAsUnSynced(); Mockito.verify(sqliteDatabase, Mockito.times(2)).update(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(ContentValues.class), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); } |
EventClientRepository extends BaseRepository { public void addorUpdateClient(String baseEntityId, JSONObject jsonObject) { addorUpdateClient(baseEntityId, jsonObject, BaseRepository.TYPE_Unsynced); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void addorUpdateClientCallsInsert1timeForNewClients() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{baseEntityId, syncStatus}); Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(matrixCursor); eventClientRepository.addorUpdateClient(baseEntityId, getClientList().get(0)); Mockito.verify(sqliteDatabase, Mockito.times(1)).insert(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.isNull(String.class), org.mockito.ArgumentMatchers.any(ContentValues.class)); }
@Test public void addorUpdateClientCallsUpdate1timeForOldClients() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{baseEntityId, syncStatus}); matrixCursor.addRow(new String[]{baseEntityId, syncStatus}); Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(matrixCursor); eventClientRepository.addorUpdateClient(baseEntityId, getClientList().get(0)); Mockito.verify(sqliteDatabase, Mockito.times(1)).update(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(ContentValues.class), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); } |
EventClientRepository extends BaseRepository { public void addEvent(String baseEntityId, JSONObject jsonObject) { addEvent(baseEntityId, jsonObject, BaseRepository.TYPE_Unprocessed); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void addorUpdateEventCallsInsert1timeForNewEvents() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{baseEntityId, syncStatus}); Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.isNull(String[].class))).thenReturn(matrixCursor); eventClientRepository.addEvent(baseEntityId, getEventList().get(0)); Mockito.verify(sqliteDatabase, Mockito.times(1)).insert(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.isNull(String.class), org.mockito.ArgumentMatchers.any(ContentValues.class)); }
@Test public void addorUpdateEventCallsUpdate1timeForOldEvents() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{baseEntityId, syncStatus}); matrixCursor.addRow(new String[]{baseEntityId, syncStatus}); Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(matrixCursor); eventClientRepository.addEvent(baseEntityId, getEventList().get(0)); Mockito.verify(sqliteDatabase, Mockito.times(1)).update(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(ContentValues.class), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); }
@Test public void testAddEventDefaultStatus() { EventClientRepository eventClientRepository = Mockito.spy(new EventClientRepository()); String baseEntityId = "12345"; JSONObject jsonObject = Mockito.mock(JSONObject.class); eventClientRepository.addEvent(baseEntityId, jsonObject); Mockito.verify(eventClientRepository).addEvent(baseEntityId, jsonObject, BaseRepository.TYPE_Unprocessed); } |
EventClientRepository extends BaseRepository { public boolean deleteClient(String baseEntityId) { try { int rowsAffected = getWritableDatabase().delete(clientTable.name(), client_column.baseEntityId.name() + " = ?", new String[]{baseEntityId}); if (rowsAffected > 0) { return true; } } catch (Exception e) { Timber.e(e); } return false; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void deleteClientCallsDelete1time() { eventClientRepository.deleteClient(baseEntityId); Mockito.verify(sqliteDatabase, Mockito.times(1)).delete(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); } |
EventClientRepository extends BaseRepository { public boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType) { try { int rowsAffected = getWritableDatabase().delete(eventTable.name(), event_column.baseEntityId.name() + " = ? AND " + event_column.eventType.name() + " != ?", new String[]{baseEntityId, eventType}); if (rowsAffected > 0) { return true; } } catch (Exception e) { Timber.e(e); } return false; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void deleteEventCallsDelete1time() { eventClientRepository.deleteEventsByBaseEntityId(baseEntityId, "eventType"); Mockito.verify(sqliteDatabase, Mockito.times(1)).delete(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class)); } |
EventClientRepository extends BaseRepository { public P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId) { List<EventClient> list = new ArrayList<>(); Cursor cursor = null; int maxRowId = 0; try { cursor = getWritableDatabase().rawQuery("SELECT " + ROWID + ",json FROM " + eventTable.name() + " WHERE " + ROWID + " > ?" + "ORDER BY " + ROWID + " ASC LIMIT 100", new Object[]{lastProcessedRowId}); while (cursor.moveToNext()) { String jsonEventStr = cursor.getString(cursor.getColumnIndex("json")); int rowId = cursor.getInt(cursor.getColumnIndex(ROWID)); if (rowId > maxRowId) { maxRowId = rowId; } if (StringUtils.isBlank(jsonEventStr) || "{}".equals(jsonEventStr)) { continue; } jsonEventStr = jsonEventStr.replaceAll("'", ""); Event event = convert(jsonEventStr, Event.class); String baseEntityId = event.getBaseEntityId(); Client client = fetchClientByBaseEntityId(baseEntityId); EventClient eventClient = new EventClient(event, client); list.add(eventClient); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return new P2pProcessRecordsService.EventClientQueryResult(maxRowId, list); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void fetchEventClientsByRowId() throws Exception { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"rowid", "json"}); JSONArray eventArray = new JSONArray(ClientData.eventJsonArray); for (int i = 0; i < eventArray.length(); i++) { matrixCursor.addRow(new String[]{(i + 1) + "", eventArray.getJSONObject(i).toString()}); } Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(Object[].class))).thenReturn(matrixCursor); P2pProcessRecordsService.EventClientQueryResult eventClientQueryResult = eventClientRepository.fetchEventClientsByRowId(0); Assert.assertEquals(eventArray.length(), eventClientQueryResult.getMaxRowId()); } |
EventClientRepository extends BaseRepository { public JSONObject convertToJson(Object object) { if (object == null) { return null; } try { return new JSONObject(JsonFormUtils.gson.toJson(object)); } catch (Exception e) { Timber.e(e, "Unable to convert to json %s ", object); return null; } } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void assertConvertToJson() { Assert.assertNull(eventClientRepository.convertToJson(null)); } |
EventClientRepository extends BaseRepository { public List<String> getUnValidatedEventFormSubmissionIds(int limit) { List<String> ids = new ArrayList<>(); final String validateFilter = " where " + event_column.syncStatus + " = ? " + " AND ( " + event_column.validationStatus + " is NULL or " + event_column.validationStatus + " != ? ) "; String query = "select " + event_column.formSubmissionId + " from " + eventTable.name() + validateFilter + ORDER_BY + event_column.updatedAt + " asc limit " + limit; Cursor cursor = null; try { cursor = getReadableDatabase().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; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void assertGetUnValidatedEventFormSubmissionIdsReturnsList() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getCursorSyncStatus()); org.junit.Assert.assertNotNull(eventClientRepository.getUnValidatedEventFormSubmissionIds(1)); } |
EventClientRepository extends BaseRepository { public List<String> getUnValidatedClientBaseEntityIds(int limit) { List<String> ids = new ArrayList<>(); final String validateFilter = " where " + client_column.syncStatus + " = ? " + " AND ( " + client_column.validationStatus + " is NULL or " + client_column.validationStatus + " != ? ) "; String query = "select " + client_column.baseEntityId + " from " + clientTable.name() + validateFilter + ORDER_BY + client_column.updatedAt + " asc limit " + limit; Cursor cursor = null; try { cursor = getReadableDatabase().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; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void assertGetUnValidatedClientBaseEntityIdsReturnsList() throws Exception { Mockito.when(sqliteDatabase.rawQuery(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any(String[].class))).thenReturn(getCursorSyncStatus()); org.junit.Assert.assertNotNull(eventClientRepository.getUnValidatedClientBaseEntityIds(1)); } |
EventClientRepository extends BaseRepository { public static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns) { try { String cl = ""; for (Column cc : columns) { cl += getCreateTableColumn(cc) + ","; } cl = removeEndingComma(cl); String create_tb = "CREATE TABLE " + table.name() + " ( " + cl + " )"; db.execSQL(create_tb); createIndex(db, table, columns); } catch (Exception e) { Timber.e(e); } } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void assertcreateTableCallsExecSql() { int count = 1; for (Column cc : EventClientRepository.client_column.values()) { if (cc.column().index()) { count++; } } EventClientRepository.createTable(sqliteDatabase, EventClientRepository.Table.client, EventClientRepository.client_column.values()); Mockito.verify(sqliteDatabase, Mockito.times(count)).execSQL(Mockito.anyString()); } |
EventClientRepository extends BaseRepository { public Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject) { final String EVENTS = AllConstants.KEY.EVENTS; try { if (jsonObject != null && jsonObject.has(EVENTS)) { JSONArray events = jsonObject.getJSONArray(EVENTS); Type listType = new TypeToken<List<Event>>() { }.getType(); List<Event> eventList = JsonFormUtils.gson.fromJson(events.toString(), listType); long maxServerVersion = Long.MIN_VALUE; long minServerVersion = Long.MAX_VALUE; for (Event event : eventList) { long serverVersion = event.getServerVersion(); if (serverVersion > maxServerVersion) { maxServerVersion = serverVersion; } if (serverVersion < minServerVersion) { minServerVersion = serverVersion; } } return Pair.create(minServerVersion, maxServerVersion); } } catch (Exception e) { Timber.e(e); } return Pair.create(0L, 0L); } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getMinMaxServerVersionsShouldReturnMaxAndMinServerVersionFromEvents() throws JSONException { JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); jsonObject.put("events", jsonArray); for (int i = 0; i < 5; i++) { JSONObject jsonObject1 = new JSONObject(); jsonObject1.put("serverVersion", (i +1) * 1000L); jsonArray.put(jsonObject1); } Pair<Long, Long> minMaxServerVersions = eventClientRepository.getMinMaxServerVersions(jsonObject); Assert.assertEquals(5000L, minMaxServerVersions.second, 0L); Assert.assertEquals(1000L, minMaxServerVersions.first, 0L); }
@Test public void getMinMaxServerVersionsShouldReturnDefaultMinMaxWhenEventsArrayIsEmpty() throws JSONException { JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); jsonObject.put("events", jsonArray); Pair<Long, Long> minMaxServerVersions = eventClientRepository.getMinMaxServerVersions(jsonObject); Assert.assertEquals(Long.MIN_VALUE, minMaxServerVersions.second, 0L); Assert.assertEquals(Long.MAX_VALUE, minMaxServerVersions.first, 0L); } |
EventClientRepository extends BaseRepository { @Nullable public JsonData getClients(long lastRowId, int limit, @Nullable String locationId) { JsonData jsonData = null; JSONArray jsonArray = new JSONArray(); long maxRowId = 0; String locationFilter = locationId != null ? String.format(" %s =? AND ", client_column.locationId.name()) : ""; String query = "SELECT " + client_column.json + "," + client_column.syncStatus + "," + ROWID + " FROM " + clientTable.name() + " WHERE " + locationFilter + ROWID + " > ? " + " ORDER BY " + ROWID + " ASC LIMIT ?"; Cursor cursor = null; try { Object[] params; if (locationId == null) { params = new Object[]{lastRowId, limit}; } else { params = new Object[]{locationId, lastRowId, limit}; } cursor = getWritableDatabase().rawQuery(query, params); while (cursor.moveToNext()) { long rowId = cursor.getLong(2); JSONObject eventObject = getEventObject(cursor, rowId); if (eventObject == null) continue; jsonArray.put(eventObject); if (rowId > maxRowId) { maxRowId = rowId; } } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } if (jsonArray.length() > 0) { jsonData = new JsonData(jsonArray, maxRowId); } } return jsonData; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getClientShouldReturnGenerateMaxRowIdAndIncludeRowIdAndSyncStatusInJson() throws JSONException { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"json", EventClientRepository.event_column.syncStatus.name(), AllConstants.ROWID}, 0); for (int i = 0; i < 30; i++) { matrixCursor.addRow(new Object[]{"{\"gender\": \"male\"}", BaseRepository.TYPE_Synced, (i + 1L)}); } Mockito.doReturn(matrixCursor).when(sqliteDatabase).rawQuery(Mockito.eq("SELECT json,syncStatus,rowid FROM client WHERE rowid > ? ORDER BY rowid ASC LIMIT ?"), Mockito.any(Object[].class)); JsonData jsonData = eventClientRepository.getClients(0, 20,null); Assert.assertEquals(30L, jsonData.getHighestRecordId()); JSONObject jsonObject = jsonData.getJsonArray().getJSONObject(0); Assert.assertTrue(jsonObject.has(EventClientRepository.event_column.syncStatus.name())); Assert.assertTrue(jsonObject.has(AllConstants.ROWID)); } |
EventClientRepository extends BaseRepository { @Nullable public JsonData getClientsWithLastLocationID(long lastRowId, int limit) { JsonData jsonData = null; JSONArray jsonArray = new JSONArray(); long maxRowId = 0; String eventJson = "(select event.json from event where event.baseEntityId = client.baseEntityId \n" + " ORDER by event.eventDate desc , event.updatedAt desc , event.dateEdited desc , event.serverVersion desc limit 1) eventJson"; String query = "SELECT " + event_column.json + "," + event_column.syncStatus + "," + ROWID + "," + eventJson + " FROM " + clientTable.name() + " WHERE " + ROWID + " > ? " + " ORDER BY " + ROWID + " ASC LIMIT ?"; Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery(query, new Object[]{lastRowId, limit}); while (cursor.moveToNext()) { long rowId = cursor.getLong(2); String jsonEventStr = (cursor.getString(3)); if (StringUtils.isBlank(jsonEventStr) || jsonEventStr.equals("{}")) { return null; } jsonEventStr = jsonEventStr.replaceAll("'", ""); JSONObject eventJsonObject = new JSONObject(jsonEventStr); String locationId = eventJsonObject.getString("locationId"); JSONObject eventObject = getEventObject(cursor, rowId); if (eventObject == null) continue; eventObject.put("locationId", locationId); jsonArray.put(eventObject); if (rowId > maxRowId) { maxRowId = rowId; } } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } if (jsonArray.length() > 0) { jsonData = new JsonData(jsonArray, maxRowId); } } return jsonData; } EventClientRepository(); EventClientRepository(Table clientTable, Table eventTable); static String getCreateTableColumn(Column col); static String removeEndingComma(String str); static void createTable(SQLiteDatabase db, BaseTable table, Column[] columns); static void createIndex(SQLiteDatabase db, BaseTable table, Column[] columns); static void createAdditionalColumns(SQLiteDatabase db, String eventTable, String clientTable); static void createAdditionalColumns(SQLiteDatabase db); static void addEventLocationId(SQLiteDatabase db); static void dropIndexes(SQLiteDatabase db, BaseTable table); static String getSqliteType(ColumnAttribute.Type type); Table getClientTable(); Table getEventTable(); Boolean checkIfExists(Table table, String baseEntityId); Boolean checkIfExists(Table table, String baseEntityId, SQLiteDatabase sqLiteDatabase); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId); Boolean checkIfExistsByFormSubmissionId(Table table, String formSubmissionId, SQLiteDatabase sqLiteDatabase); boolean batchInsertClients(JSONArray array); boolean batchInsertClients(JSONArray array, SQLiteDatabase sqLiteDatabase); int getMaxRowId(@NonNull Table table); int getMaxRowId(@NonNull Table table, SQLiteDatabase sqLiteDatabase); boolean batchInsertEvents(JSONArray array, long serverVersion); boolean batchInsertEvents(JSONArray array, long serverVersion, SQLiteDatabase sqLiteDatabase); T convert(JSONObject jo, Class<T> t); T convert(String jsonString, Class<T> t); JSONObject convertToJson(Object object); Pair<Long, Long> getMinMaxServerVersions(JSONObject jsonObject); List<JSONObject> getEvents(long startServerVersion, long lastServerVersion); List<EventClient> fetchEventClientsCore(String query, String[] params); List<EventClient> fetchEventClients(List<String> formSubmissionIds); List<EventClient> fetchEventClients(long startServerVersion, long lastServerVersion); P2pProcessRecordsService.EventClientQueryResult fetchEventClientsByRowId(long lastProcessedRowId); List<EventClient> fetchEventClientsByEventTypes(List<String> eventTypes); List<JSONObject> getEvents(Date lastSyncDate); List<JSONObject> getEvents(Date lastSyncDate, String syncStatus); List<EventClient> fetchEventClients(Date lastSyncDate, String syncStatus); Map<String, Object> getUnSyncedEvents(int limit); int getUnSyncedEventsCount(); List<String> getUnValidatedEventFormSubmissionIds(int limit); List<String> getUnValidatedClientBaseEntityIds(int limit); void markAllAsUnSynced(); JSONObject getClient(SQLiteDatabase db, String baseEntityId); JSONObject getEventsByBaseEntityId(String baseEntityId); JSONObject getEventsByEventId(String eventId); JSONObject getEventsByFormSubmissionId(String formSubmissionId); JSONObject getClientByBaseEntityId(String baseEntityId); Client fetchClientByBaseEntityId(String baseEntityId); JSONObject getUnSyncedClientByBaseEntityId(String baseEntityId); JSONObject getEventsByBaseEntityIdAndEventType(String baseEntityId, String eventType); List<EventClient> getEventsByBaseEntityIdsAndSyncStatus(String syncStatus, List<String> baseEntityIds); @Nullable JsonData getEvents(long lastRowId, int limit, @Nullable String locationId); @Nullable JsonData getClientsWithLastLocationID(long lastRowId, int limit); @Nullable JsonData getClients(long lastRowId, int limit, @Nullable String locationId); void addorUpdateClient(String baseEntityId, JSONObject jsonObject); void addorUpdateClient(String baseEntityId, JSONObject jsonObject, String syncStatus); void addEvent(String baseEntityId, JSONObject jsonObject); void addEvent(String baseEntityId, JSONObject jsonObject, String syncStatus); void markEventAsProcessed(String formSubmissionId); void markEventAsSynced(String formSubmissionId); void markClientAsSynced(String baseEntityId); void markEventValidationStatus(String formSubmissionId, boolean valid); void markClientValidationStatus(String baseEntityId, boolean valid); void markEventAsTaskUnprocessed(String formSubmissionId); @SuppressWarnings("unchecked") void markEventsAsSynced(Map<String, Object> syncedEvents); boolean deleteClient(String baseEntityId); boolean deleteEventsByBaseEntityId(String baseEntityId, String eventType); } | @Test public void getClientsWithLastLocationIDShouldReturnGenerateMaxRowIdAndIncludeRowIdAndSyncStatusInJson() throws JSONException { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"json", EventClientRepository.event_column.syncStatus.name(), AllConstants.ROWID, "eventJson"}, 0); for (int i = 0; i < 30; i++) { matrixCursor.addRow(new Object[]{"{\"gender\": \"male\"}", BaseRepository.TYPE_Synced, (i + 1L), "{\"baseEntityId\":\"a423f801-8f6e-421d-ac9b-a3e4a24a0d61\",\"locationId\":\"d5ff0ea1-bbc5-424d-84c2-5b084e10ef90\"}"}); } Mockito.doReturn(matrixCursor).when(sqliteDatabase).rawQuery(Mockito.eq("SELECT json,syncStatus,rowid,(select event.json from event where event.baseEntityId = client.baseEntityId \n" + " ORDER by event.eventDate desc , event.updatedAt desc , event.dateEdited desc , event.serverVersion desc limit 1) eventJson FROM client WHERE rowid > ? ORDER BY rowid ASC LIMIT ?"), Mockito.any(Object[].class)); JsonData jsonData = eventClientRepository.getClientsWithLastLocationID(0, 20); Assert.assertEquals(30L, jsonData.getHighestRecordId()); JSONObject jsonObject = jsonData.getJsonArray().getJSONObject(0); Assert.assertTrue(jsonObject.has(EventClientRepository.event_column.syncStatus.name())); Assert.assertTrue(jsonObject.has(AllConstants.ROWID)); } |
ImageRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(Image_SQL); database.execSQL(ENTITY_ID_INDEX); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertOnCrateCallsDatabaseExec() { imageRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(2)).execSQL(Mockito.anyString()); } |
ImageRepository extends DrishtiRepository { public void add(ProfileImage Image) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(Image_TABLE_NAME, null, createValuesFor(Image, TYPE_ANC)); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertAddCallsDatabaseInsert() { imageRepository.add(getProfileImage()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); } |
ImageRepository extends DrishtiRepository { public List<ProfileImage> allProfileImages() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(Image_TABLE_NAME, Image_TABLE_COLUMNS, syncStatus_COLUMN + " = ?", new String[]{TYPE_Unsynced}, null, null, null, null); return readAll(cursor); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertallProfileImages() { 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(getCursor()); Assert.assertNotNull(imageRepository.allProfileImages()); } |
ImageRepository extends DrishtiRepository { public void close(String caseId) { ContentValues values = new ContentValues(); values.put(syncStatus_COLUMN, TYPE_Synced); masterRepository.getWritableDatabase() .update(Image_TABLE_NAME, values, ID_COLUMN + " = ?", new String[]{caseId}); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertclose() { imageRepository.close("1"); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); } |
ImageRepository extends DrishtiRepository { public List<ProfileImage> findAllUnSynced() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(Image_TABLE_NAME, Image_TABLE_COLUMNS, syncStatus_COLUMN + " = ?", new String[]{TYPE_Unsynced}, null, null, null, null); return readAll(cursor); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertfindAllUnSynced() { 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(getCursor()); Assert.assertNotNull(imageRepository.findAllUnSynced()); } |
ImageRepository extends DrishtiRepository { public ProfileImage findByEntityId(String entityId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(Image_TABLE_NAME, Image_TABLE_COLUMNS, entityID_COLUMN + " = ? COLLATE NOCASE ", new String[]{entityId}, null, null, null, null); List<ProfileImage> profileImages = readAll(cursor); return profileImages.isEmpty() ? null : profileImages.get(0); } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void assertfindByEntityId() { 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(getCursor()); Assert.assertNotNull(imageRepository.findByEntityId("1")); } |
ImageRepository extends DrishtiRepository { @Nullable public HashMap<String, Object> getImage(long lastRowId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(Image_TABLE_NAME, new String[]{"rowid", filepath_COLUMN, syncStatus_COLUMN, entityID_COLUMN, anm_ID_COLUMN , filecategory_COLUMN} , AllConstants.ROWID + " > ?", new String[]{String.valueOf(lastRowId)} , null, null, AllConstants.ROWID + " ASC", "1"); try { if (cursor != null && cursor.moveToFirst()) { long rowId = cursor.getLong(0); String filePath = cursor.getString(1); HashMap<String, Object> details = new HashMap<>(); details.put(AllConstants.ROWID, rowId); details.put(syncStatus_COLUMN, cursor.getString(2)); details.put(filepath_COLUMN, filePath); details.put(entityID_COLUMN, cursor.getString(3)); details.put(anm_ID_COLUMN, cursor.getString(4)); details.put(filecategory_COLUMN, cursor.getString(5)); return details; } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return null; } void add(ProfileImage Image); List<ProfileImage> allProfileImages(); @Nullable HashMap<String, Object> getImage(long lastRowId); ProfileImage findByEntityId(String entityId); List<ProfileImage> findAllUnSynced(); void close(String caseId); static final String Image_TABLE_NAME; static final String ID_COLUMN; static final String anm_ID_COLUMN; static final String entityID_COLUMN; static final String filepath_COLUMN; static final String syncStatus_COLUMN; static final String filecategory_COLUMN; static final String TYPE_ANC; static final String TYPE_PNC; static final String[] Image_TABLE_COLUMNS; static String TYPE_Unsynced; static String TYPE_Synced; } | @Test public void getImageShouldReturnValidHashMap() { MatrixCursor matrixCursor = new MatrixCursor(new String[]{"rowid", filepath_COLUMN, syncStatus_COLUMN , entityID_COLUMN, anm_ID_COLUMN , filecategory_COLUMN}); matrixCursor.addRow(new String[]{"1", "sample_file_path", SyncStatus.SYNCED.toString(), "992jdwmkkk", "sample_anm_id", "profile_image"}); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString() , Mockito.any(String[].class), (String) Mockito.isNull(), (String) Mockito.isNull() , Mockito.anyString(), Mockito.anyString())) .thenReturn(matrixCursor); HashMap<String, Object> actualDetails = imageRepository.getImage(9); Assert.assertEquals(1l, actualDetails.get(AllConstants.ROWID)); Assert.assertEquals(6, actualDetails.size()); } |
EventRepository extends SQLiteOpenHelper { @Override public void onCreate(SQLiteDatabase database) { database.execSQL(common_SQL); } EventRepository(Context context, String[] columns); EventRepository(Context context, String tableName, String[] columns); @Override void onOpen(SQLiteDatabase db); @Override void onCreate(SQLiteDatabase database); @Override void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1); ContentValues createValuesFor(Event common); void insertValues(ContentValues values); static final String ID_COLUMN; static final String Relational_ID; static final String obsDETAILS_COLUMN; static final String attributeDETAILS_COLUMN; public String TABLE_NAME; public String[] additionalcolumns; } | @Test public void constructorNotNullCallsOnCreateDatabaseExec() { Assert.assertNotNull(eventRepository); eventRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); } |
EventRepository extends SQLiteOpenHelper { public ContentValues createValuesFor(Event common) { ContentValues values = new ContentValues(); values.put(Relational_ID, common.getBaseEntityID()); values.put(obsDETAILS_COLUMN, new Gson().toJson(common.getObsDetailsMap())); values.put(attributeDETAILS_COLUMN, new Gson().toJson(common.getAttributesDetailsMap())); for (Map.Entry<String, String> entry : common.getAttributesColumnsMap().entrySet()) { String key = entry.getKey(); String value = entry.getValue(); values.put(key, value); } for (Map.Entry<String, String> entry : common.getObsColumnsMap().entrySet()) { String key = entry.getKey(); String value = entry.getValue(); values.put(key, value); } return values; } EventRepository(Context context, String[] columns); EventRepository(Context context, String tableName, String[] columns); @Override void onOpen(SQLiteDatabase db); @Override void onCreate(SQLiteDatabase database); @Override void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1); ContentValues createValuesFor(Event common); void insertValues(ContentValues values); static final String ID_COLUMN; static final String Relational_ID; static final String obsDETAILS_COLUMN; static final String attributeDETAILS_COLUMN; public String TABLE_NAME; public String[] additionalcolumns; } | @Test public void assertcreateValuesForReturnsContentValues() { HashMap<String, String> mockmap = new HashMap<>(); mockmap.put("key", "value"); Event common = new Event(Relational_ID, mockmap, mockmap, mockmap, mockmap); Assert.assertNotNull(eventRepository.createValuesFor(common)); } |
ServiceProvidedRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(SERVICE_PROVIDED_SQL); } void add(ServiceProvided serviceProvided); List<ServiceProvided> findByEntityIdAndServiceNames(String entityId, String... names); List<ServiceProvided> all(); static final String SERVICE_PROVIDED_TABLE_NAME; static final String ENTITY_ID_COLUMN; static final String NAME_ID_COLUMN; static final String DATE_ID_COLUMN; static final String DATA_ID_COLUMN; static final String[] SERVICE_PROVIDED_TABLE_COLUMNS; } | @Test public void ssertOnCreateCallsDatabaseExec() { serviceProvidedRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); } |
ServiceProvidedRepository extends DrishtiRepository { public void add(ServiceProvided serviceProvided) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(SERVICE_PROVIDED_TABLE_NAME, null, createValuesFor(serviceProvided)); } void add(ServiceProvided serviceProvided); List<ServiceProvided> findByEntityIdAndServiceNames(String entityId, String... names); List<ServiceProvided> all(); static final String SERVICE_PROVIDED_TABLE_NAME; static final String ENTITY_ID_COLUMN; static final String NAME_ID_COLUMN; static final String DATE_ID_COLUMN; static final String DATA_ID_COLUMN; static final String[] SERVICE_PROVIDED_TABLE_COLUMNS; } | @Test public void assertadCallsDatabaseInsert() { ServiceProvided serviceProvided = new ServiceProvided("", "", "", new HashMap<String, String>()); serviceProvidedRepository.add(serviceProvided); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); } |
ServiceProvidedRepository extends DrishtiRepository { public List<ServiceProvided> findByEntityIdAndServiceNames(String entityId, String... names) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( format("SELECT * FROM %s WHERE %s = ? AND %s IN (%s) " + "ORDER BY " + "DATE" + "(%s)", SERVICE_PROVIDED_TABLE_NAME, ENTITY_ID_COLUMN, NAME_ID_COLUMN, insertPlaceholdersForInClause(names.length), DATE_ID_COLUMN), addAll(new String[]{entityId}, names)); return readAllServicesProvided(cursor); } void add(ServiceProvided serviceProvided); List<ServiceProvided> findByEntityIdAndServiceNames(String entityId, String... names); List<ServiceProvided> all(); static final String SERVICE_PROVIDED_TABLE_NAME; static final String ENTITY_ID_COLUMN; static final String NAME_ID_COLUMN; static final String DATE_ID_COLUMN; static final String DATA_ID_COLUMN; static final String[] SERVICE_PROVIDED_TABLE_COLUMNS; } | @Test public void assertAllfindByEntityIdAndServiceNames() { Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getCursor()); Assert.assertNotNull(serviceProvidedRepository.findByEntityIdAndServiceNames(ENTITY_ID_COLUMN, "a", "b")); } |
ServiceProvidedRepository extends DrishtiRepository { public List<ServiceProvided> all() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(SERVICE_PROVIDED_TABLE_NAME, SERVICE_PROVIDED_TABLE_COLUMNS, null, null, null, null, DATE_ID_COLUMN); return readAllServicesProvided(cursor); } void add(ServiceProvided serviceProvided); List<ServiceProvided> findByEntityIdAndServiceNames(String entityId, String... names); List<ServiceProvided> all(); static final String SERVICE_PROVIDED_TABLE_NAME; static final String ENTITY_ID_COLUMN; static final String NAME_ID_COLUMN; static final String DATE_ID_COLUMN; static final String DATA_ID_COLUMN; static final String[] SERVICE_PROVIDED_TABLE_COLUMNS; } | @Test public void assertAllReturnsList() { Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.anyString())).thenReturn(getCursor()); Assert.assertNotNull(serviceProvidedRepository.all()); } |
UniqueIdRepository extends BaseRepository { public int close(String openmrsId) { return reserveOrClose(openmrsId, STATUS_USED); } 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 testUpdateOpenMRSIdentifierStatusInvokesDatabaseUpdateMethodCorrectlyWithNoHyphen() { String openMrsId = "329893823"; uniqueIdRepository.close(openMrsId); verify(sqLiteDatabase, times(2)).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); }
@Test public void testUpdateOpenMRSIdentifierStatusInvokesDatabaseUpdateMethodCorrectlyWithHyphen() { String openMrsId = "32989382-3"; uniqueIdRepository.close(openMrsId); verify(sqLiteDatabase, times(2)).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); }
@Test public void testUpdateOpenMRSIdentifierStatusInvokesDatabaseUpdateMethodOnceIfRowUpdated() { CoreLibrary.getInstance().context().allSharedPreferences().updateANMUserName(testUsername); String openMrsId = "3298938-2"; doReturn(1).when(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); uniqueIdRepository.close(openMrsId); verify(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); Assert.assertNotNull(stringArgumentCaptor.getValue()); assertEquals("unique_ids", stringArgumentCaptor.getAllValues().get(2)); assertEquals(openMrsId, argsCaptor.getValue()[0]); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals(testUsername, values.getAsString("used_by")); } |
UniqueIdRepository extends BaseRepository { public void bulkInsertOpenmrsIds(List<String> ids) { if (ids == null || ids.isEmpty()){ return; } SQLiteDatabase database = getWritableDatabase(); try { String userName = CoreLibrary.getInstance().context().allSharedPreferences().fetchRegisteredANM(); database.beginTransaction(); for (String id : ids) { ContentValues values = new ContentValues(); values.put(OPENMRS_ID_COLUMN, id); values.put(STATUS_COLUMN, STATUS_NOT_USED); values.put(SYNCED_BY_COLUMN, userName); values.put(CREATED_AT_COLUMN, dateFormat.format(new Date())); database.insert(UniqueIds_TABLE_NAME, null, values); } database.setTransactionSuccessful(); } catch (SQLException e) { Timber.e(e); } finally { database.endTransaction(); } } 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 testBulkInsertOpenMrsIds() { CoreLibrary.getInstance().context().allSharedPreferences().updateANMUserName(testUsername); String openMrsId = "3298938-2"; List<String> openMrsIds = Collections.singletonList(openMrsId); uniqueIdRepository.bulkInsertOpenmrsIds(openMrsIds); verify(sqLiteDatabase).beginTransaction(); verify(sqLiteDatabase).setTransactionSuccessful(); verify(sqLiteDatabase).endTransaction(); verify(sqLiteDatabase).insert(stringArgumentCaptor.capture(), eq(null), contentValuesArgumentCaptor.capture()); assertEquals("unique_ids", stringArgumentCaptor.getValue()); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals(openMrsId, values.getAsString("openmrs_id")); assertEquals("not_used", values.getAsString("status")); assertEquals(testUsername, values.getAsString("synced_by")); assertNotNull(values.getAsString("created_at")); }
@Test public void testBulkInsertOpenMrsIdsWithEmptyParamList() { CoreLibrary.getInstance().context().allSharedPreferences().updateANMUserName(testUsername); uniqueIdRepository.bulkInsertOpenmrsIds(null); verifyNoMoreInteractions(sqLiteDatabase); }
@Test public void testBulkInsertOpenMrsIdsWithExceptionThrown() { CoreLibrary.getInstance().context().allSharedPreferences().updateANMUserName(testUsername); String openMrsId = "3298938-2"; List<String> openMrsIds = Collections.singletonList(openMrsId); uniqueIdRepository = spy(uniqueIdRepository); doThrow(new SQLException()).when(sqLiteDatabase).insert(any(), any(), any()); uniqueIdRepository.bulkInsertOpenmrsIds(openMrsIds); verify(sqLiteDatabase).beginTransaction(); verify(sqLiteDatabase, never()).setTransactionSuccessful(); verify(sqLiteDatabase).endTransaction(); verify(sqLiteDatabase).insert(stringArgumentCaptor.capture(), eq(null), contentValuesArgumentCaptor.capture()); assertEquals("unique_ids", stringArgumentCaptor.getValue()); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals(openMrsId, values.getAsString("openmrs_id")); assertEquals("not_used", values.getAsString("status")); assertEquals(testUsername, values.getAsString("synced_by")); assertNotNull(values.getAsString("created_at")); } |
UniqueIdRepository extends BaseRepository { public Long countUnUsedIds() { long count = 0; Cursor cursor = null; try { cursor = getWritableDatabase().rawQuery("SELECT COUNT (*) FROM " + UniqueIds_TABLE_NAME + " WHERE " + STATUS_COLUMN + "=?", new String[]{STATUS_NOT_USED}); if (null != cursor && cursor.getCount() > 0) { cursor.moveToFirst(); count = cursor.getInt(0); } } catch (SQLException e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return count; } 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 testCountUnusedIds() { when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCountCursor()); long actualCount = uniqueIdRepository.countUnUsedIds(); assertEquals(12, actualCount); verify(sqLiteDatabase).rawQuery("SELECT COUNT (*) FROM unique_ids WHERE status=?", new String[]{"not_used"}); } |
Subsets and Splits