Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: 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); }### Answer: @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)))); }
### Question: 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); }### Answer: @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)))); }
### Question: 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; }### Answer: @Test public void assertOnCreateCallDatabaseExecSql() { eligibleCoupleRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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(); }### Answer: @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()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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]); }
### Question: 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; }### Answer: @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]); }
### Question: 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; }### Answer: @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]); }
### Question: 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; }### Answer: @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]); }
### Question: 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; }### Answer: @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()); }
### Question: 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(); }### Answer: @Test public void onCreateCallsDatabaseExec() { reportRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(2)).execSQL(Mockito.anyString()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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("", "", "")); }
### Question: 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(); }### Answer: @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()); }
### Question: 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; }### Answer: @Test public void assertOnCrateCallsDatabaseExec() { imageRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(2)).execSQL(Mockito.anyString()); }
### Question: 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; }### Answer: @Test public void assertAddCallsDatabaseInsert() { imageRepository.add(getProfileImage()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
### Question: 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; }### Answer: @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()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); }
### Question: 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; }### Answer: @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")); }
### Question: 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; }### Answer: @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()); }
### Question: 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; }### Answer: @Test public void constructorNotNullCallsOnCreateDatabaseExec() { Assert.assertNotNull(eventRepository); eventRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @Test public void ssertOnCreateCallsDatabaseExec() { serviceProvidedRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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")); }
### Question: 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; }### Answer: @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()); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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"}); }
### Question: UniqueIdRepository extends BaseRepository { public UniqueId getNextUniqueId() { UniqueId uniqueId = null; Cursor cursor = null; try { cursor = getReadableDatabase().query(UniqueIds_TABLE_NAME, UniqueIds_TABLE_COLUMNS, STATUS_COLUMN + " = ?", new String[]{STATUS_NOT_USED}, null, null, CREATED_AT_COLUMN + " ASC", "1"); List<UniqueId> ids = readAll(cursor); uniqueId = ids.isEmpty() ? null : ids.get(0); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } if (uniqueId != null) { reserve(uniqueId.getOpenmrsId()); } return uniqueId; } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }### Answer: @Test public void testGetNextUniqueId() { when(sqLiteDatabase.query(any(), any(), any(), any(), any(), any(), anyString(), anyString())).thenReturn(getUniqueIdCursor()); UniqueId actualUniqueId = uniqueIdRepository.getNextUniqueId(); assertEquals("12", actualUniqueId.getId()); assertEquals("openrs-id1", actualUniqueId.getOpenmrsId()); assertEquals("test-owner", actualUniqueId.getUsedBy()); assertEquals(new Date(1583830167).toString(), actualUniqueId.getCreatedAt().toString()); }
### Question: UniqueIdRepository extends BaseRepository { private ContentValues createValuesFor(UniqueId uniqueId) { ContentValues values = new ContentValues(); values.put(ID_COLUMN, uniqueId.getId()); values.put(OPENMRS_ID_COLUMN, uniqueId.getOpenmrsId()); values.put(STATUS_COLUMN, uniqueId.getStatus()); values.put(USED_BY_COLUMN, uniqueId.getUsedBy()); values.put(CREATED_AT_COLUMN, dateFormat.format(uniqueId.getCreatedAt())); return values; } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }### Answer: @Test public void testCreateValuesFor() { UniqueId expectedUniqueId = new UniqueId("12", "openrs-id1", "not_used", "test-owner", new Date()); uniqueIdRepository.add(expectedUniqueId); verify(sqLiteDatabase).insert(stringArgumentCaptor.capture(), eq(null), contentValuesArgumentCaptor.capture()); assertEquals("unique_ids", stringArgumentCaptor.getValue()); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("12", values.getAsString("_id")); assertEquals("openrs-id1", values.getAsString("openmrs_id")); assertEquals("not_used", values.getAsString("status")); assertEquals("test-owner", values.getAsString("used_by")); assertNotNull(values.getAsString("created_at")); }
### Question: UniqueIdRepository extends BaseRepository { public int releaseReservedIds() { ContentValues values = new ContentValues(); values.put(STATUS_COLUMN, STATUS_NOT_USED); values.put(USED_BY_COLUMN, ""); values.put(UPDATED_AT_COLUMN, dateFormat.format(new Date())); return getWritableDatabase().update(UniqueIds_TABLE_NAME, values, STATUS_COLUMN + " = ?", new String[]{STATUS_RESERVED}); } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }### Answer: @Test public void testReleaseReserveIds() { uniqueIdRepository.releaseReservedIds(); verify(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(),argsCaptor.capture()); Assert.assertNotNull(stringArgumentCaptor.getValue()); assertEquals("unique_ids", stringArgumentCaptor.getAllValues().get(0)); assertEquals("status = ?", stringArgumentCaptor.getAllValues().get(1)); assertEquals("reserved", argsCaptor.getValue()[0]); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("not_used", values.getAsString("status")); assertEquals("", values.getAsString("used_by")); }
### Question: UniqueIdRepository extends BaseRepository { public int open(String openmrsId) { try { String openmrsId_ = !openmrsId.contains("-") ? formatId(openmrsId) : openmrsId; ContentValues values = new ContentValues(); values.put(STATUS_COLUMN, STATUS_NOT_USED); values.put(USED_BY_COLUMN, ""); values.put(UPDATED_AT_COLUMN, dateFormat.format(new Date())); return updateOpenMRSIdentifierStatus(openmrsId_, values); } catch (Exception e) { Timber.e(e); return 0; } } static void createTable(SQLiteDatabase database); void add(UniqueId uniqueId); void bulkInsertOpenmrsIds(List<String> ids); Long countUnUsedIds(); UniqueId getNextUniqueId(); int close(String openmrsId); int reserve(String uniqueId); int releaseReservedIds(); int open(String openmrsId); }### Answer: @Test public void testOpen() { String openMrsId = "3298938-2"; uniqueIdRepository.open(openMrsId); verify(sqLiteDatabase, times(2)).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), argsCaptor.capture()); Assert.assertNotNull(stringArgumentCaptor.getValue()); assertEquals("unique_ids", stringArgumentCaptor.getAllValues().get(0)); assertEquals("openmrs_id = ?", stringArgumentCaptor.getAllValues().get(1)); assertEquals("32989382", argsCaptor.getValue()[0]); ContentValues values = contentValuesArgumentCaptor.getValue(); assertEquals("not_used", values.getAsString("status")); assertEquals("", values.getAsString("used_by")); }
### Question: P2PSenderTransferDao extends BaseP2PTransferDao implements SenderTransferDao { @Nullable @Override public TreeSet<DataType> getDataTypes() { TreeSet<DataType> dataTypeTreeSet = new TreeSet<>(); if (locationFilterEnabled()) { for (String location : getP2POptions().getLocationsFilter()) { for (DataType dataType : dataTypes) { dataTypeTreeSet.add(new DataType(dataType.getName() + SEPARATOR + location, dataType.getType(), dataTypeTreeSet.size())); } } return dataTypeTreeSet; } else { return new TreeSet<>(dataTypes); } } @Nullable @Override TreeSet<DataType> getDataTypes(); @Nullable @Override JsonData getJsonData(@NonNull DataType dataType, long lastRecordId, int batchSize); @Nullable @Override MultiMediaData getMultiMediaData(@NonNull DataType dataType, long lastRecordId); P2POptions getP2POptions(); }### Answer: @Test public void getDataTypesShouldReturnACloneOfDataType() { TreeSet<DataType> dataTypes = p2PSenderTransferDao.getDataTypes(); Assert.assertEquals(p2PSenderTransferDao.dataTypes.size(), dataTypes.size()); Assert.assertTrue(p2PSenderTransferDao.dataTypes != dataTypes); DataType[] expectedDataTypes = p2PSenderTransferDao.dataTypes.toArray(new DataType[0]); DataType[] actualDataTypes = dataTypes.toArray(new DataType[0]); for (int i = 0; i < expectedDataTypes.length; i++) { Assert.assertEquals(expectedDataTypes[i].getName(), actualDataTypes[i].getName()); Assert.assertEquals(expectedDataTypes[i].getPosition(), actualDataTypes[i].getPosition()); } }
### Question: ClientRelationshipRepository extends BaseRepository { public static void createTable(SQLiteDatabase database) { database.execSQL(CREATE_TABLE); database.execSQL(CREATE_BASE_ENTITY_ID_INDEX); } static void createTable(SQLiteDatabase database); void saveRelationship(ClientRelationship... clientRelationships); List<Client> findClientByRelationship(String relationShip, String relationalId); }### Answer: @Test public void testCreateTableShouldCreateTableAndIndex() { ClientRelationshipRepository.createTable(database); verify(database).execSQL(ClientRelationshipRepository.CREATE_TABLE); verify(database).execSQL(ClientRelationshipRepository.CREATE_BASE_ENTITY_ID_INDEX); }
### Question: ClientRelationshipRepository extends BaseRepository { public List<Client> findClientByRelationship(String relationShip, String relationalId) { List<Client> clientList = new ArrayList<>(); String query = String.format("SELECT %s FROM %s JOIN %s ON %s=%s WHERE %s=? AND %s =?", client_column.json.name(), CLIENT_RELATIONSHIP_TABLE_NAME, client.name(), BASE_ENTITY_ID, client_column.baseEntityId.name(), RELATIONSHIP, RELATIONAL_ID); try (Cursor cursor = getReadableDatabase().rawQuery(query, new String[]{relationShip, relationalId})) { while (cursor.moveToNext()) { clientList.add(JsonFormUtils.gson.fromJson(cursor.getString(0), Client.class)); } } catch (SQLException e) { Timber.e(e); } return clientList; } static void createTable(SQLiteDatabase database); void saveRelationship(ClientRelationship... clientRelationships); List<Client> findClientByRelationship(String relationShip, String relationalId); }### Answer: @Test public void findClientByRelationshipShouldReturnClients() throws JSONException { ClientRelationshipRepository repository = spy(new ClientRelationshipRepository()); when(repository.getReadableDatabase()).thenReturn(database); when(database.rawQuery(anyString(), any())).thenReturn(getClients()); List<Client> clients = repository.findClientByRelationship("family", "12323"); assertEquals(1, clients.size()); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6",clients.get(0).getBaseEntityId()); }
### Question: PlanDefinitionRepository extends BaseRepository { public static void createTable(SQLiteDatabase database) { database.execSQL(CREATE_PLAN_DEFINITION_TABLE); } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }### Answer: @Test public void testCreateTable() { PlanDefinitionRepository.createTable(sqLiteDatabase); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals("CREATE TABLE plan_definition (_id VARCHAR NOT NULL PRIMARY KEY,json VARCHAR NOT NULL,status VARCHAR NOT NULL)", stringArgumentCaptor.getValue()); }
### Question: PlanDefinitionRepository extends BaseRepository { public void addOrUpdate(PlanDefinition planDefinition) { if (DRAFT.equalsIgnoreCase(planDefinition.getStatus().value())) return; try { getWritableDatabase().beginTransaction(); ContentValues contentValues = new ContentValues(); contentValues.put(ID, planDefinition.getIdentifier()); contentValues.put(STATUS, planDefinition.getStatus().value()); for (Jurisdiction jurisdiction : planDefinition.getJurisdiction()) { searchRepository.addOrUpdate(planDefinition, jurisdiction.getCode()); } planDefinition.setJurisdiction(new ArrayList<>()); contentValues.put(JSON, gson.toJson(planDefinition)); getWritableDatabase().replace(PLAN_DEFINITION_TABLE, null, contentValues); getWritableDatabase().setTransactionSuccessful(); } finally { getWritableDatabase().endTransaction(); } } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }### Answer: @Test public void testAddOrUpdate() { PlanDefinition planDefinition = gson.fromJson(planDefinitionJSON, PlanDefinition.class); int jurisdictionCount = planDefinition.getJurisdiction().size(); planDefinitionRepository.addOrUpdate(planDefinition); verify(sqLiteDatabase, Mockito.times(jurisdictionCount + 1)).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals((jurisdictionCount + 1) * 2, stringArgumentCaptor.getAllValues().size()); assertEquals("plan_definition_search", stringArgumentCaptor.getAllValues().get(0)); assertNull(stringArgumentCaptor.getAllValues().get(1)); assertEquals(jurisdictionCount + 1, contentValuesArgumentCaptor.getAllValues().size()); assertEquals(planDefinition.getIdentifier(), contentValuesArgumentCaptor.getAllValues().get(0).get(PLAN_ID)); assertEquals(planDefinition.getName(), contentValuesArgumentCaptor.getAllValues().get(0).get(NAME)); assertEquals(planDefinition.getStatus().value(), contentValuesArgumentCaptor.getAllValues().get(0).get(STATUS)); } @Test public void testAddOrUpdateSavesSearchTable() { Whitebox.setInternalState(planDefinitionRepository, "searchRepository", searchRepository); PlanDefinition planDefinition = gson.fromJson(planDefinitionJSON, PlanDefinition.class); String jurisdictionId = UUID.randomUUID().toString(); planDefinition.setJurisdiction(Collections.singletonList(new Jurisdiction(jurisdictionId))); planDefinitionRepository.addOrUpdate(planDefinition); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); assertEquals("plan_definition", stringArgumentCaptor.getAllValues().get(0)); assertNull(stringArgumentCaptor.getAllValues().get(1)); assertEquals(3, contentValuesArgumentCaptor.getValue().size()); assertEquals(planDefinition.getIdentifier(), contentValuesArgumentCaptor.getValue().get(ID)); verify(searchRepository).addOrUpdate(planDefinition, jurisdictionId); }
### Question: PlanDefinitionRepository extends BaseRepository { public PlanDefinition findPlanDefinitionById(String identifier) { Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT " + JSON + " FROM " + PLAN_DEFINITION_TABLE + " WHERE " + ID + " =?", new String[]{identifier}); if (cursor.moveToFirst()) { return gson.fromJson(cursor.getString(0), PlanDefinition.class); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return null; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }### Answer: @Test public void testFindPlanDefinitionById() { when(sqLiteDatabase.rawQuery(anyString(), any(String[].class))) .thenReturn(getCursor()); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNotNull(planDefinition); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition.getIdentifier()); assertEquals(planDefinitionJSON, gson.toJson(planDefinition)); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); } @Test public void testFindPlanDefinitionByIdShouldReturnNull() { when(sqLiteDatabase.rawQuery(anyString(), any(String[].class))) .thenReturn(new MatrixCursor(new String[]{})); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNull(planDefinition); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); } @Test public void testFindPlanDefinitionByIdWithException() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), any(String[].class)); PlanDefinition planDefinition = planDefinitionRepository.findPlanDefinitionById("4708ca0a-d0d6-4199-bb1b-8701803c2d02"); assertNull(planDefinition); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE _id =?", new String[]{"4708ca0a-d0d6-4199-bb1b-8701803c2d02"}); }
### Question: PlanDefinitionRepository extends BaseRepository { public Set<PlanDefinition> findAllPlanDefinitions() { Cursor cursor = null; Set<PlanDefinition> planDefinitions = new TreeSet<>(); try { String query = String.format("SELECT %s FROM %s WHERE %s =?", JSON, PLAN_DEFINITION_TABLE, STATUS); cursor = getReadableDatabase().rawQuery(query, new String[]{ACTIVE.value()}); while (cursor.moveToNext()) { planDefinitions.add(gson.fromJson(cursor.getString(0), PlanDefinition.class)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return planDefinitions; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }### Answer: @Test public void testFindAllPlanDefinitions() { when(sqLiteDatabase.rawQuery(anyString(), argsCaptor.capture())) .thenReturn(getCursor()); Set<PlanDefinition> planDefinitions = planDefinitionRepository.findAllPlanDefinitions(); assertNotNull(planDefinitions); PlanDefinition planDefinition = planDefinitions.iterator().next(); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition.getIdentifier()); assertEquals(planDefinitionJSON, gson.toJson(planDefinition)); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); } @Test public void testFindAllPlanDefinitionsWithExceptions() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), argsCaptor.capture()); Set<PlanDefinition> planDefinitions = planDefinitionRepository.findAllPlanDefinitions(); assertTrue(planDefinitions.isEmpty()); verify(sqLiteDatabase).rawQuery("SELECT json FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); }
### Question: PlanDefinitionRepository extends BaseRepository { public Set<String> findAllPlanDefinitionIds() { Cursor cursor = null; Set<String> ids = new HashSet<>(); try { String query = String.format("SELECT %s FROM %s WHERE %s =?", ID, PLAN_DEFINITION_TABLE, STATUS); cursor = getReadableDatabase().rawQuery(query, new String[]{ACTIVE.value()}); while (cursor.moveToNext()) { ids.add(cursor.getString(0)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return ids; } PlanDefinitionRepository(); static void createTable(SQLiteDatabase database); void addOrUpdate(PlanDefinition planDefinition); void deletePlans(@NonNull Set<String> planIdentifiers); PlanDefinition findPlanDefinitionById(String identifier); Set<PlanDefinition> findPlanDefinitionByIds(Set<String> identifiers); Set<PlanDefinition> findAllPlanDefinitions(); Set<String> findAllPlanDefinitionIds(); static Gson gson; }### Answer: @Test public void testFindAllPlanDefinitionIds() { when(sqLiteDatabase.rawQuery(anyString(), argsCaptor.capture())) .thenReturn(getIdCursor()); Set<String> planDefinitions = planDefinitionRepository.findAllPlanDefinitionIds(); assertNotNull(planDefinitions); assertEquals(1, planDefinitions.size()); String planDefinition = planDefinitions.iterator().next(); assertEquals("4708ca0a-d0d6-4199-bb1b-8701803c2d02", planDefinition); verify(sqLiteDatabase).rawQuery("SELECT _id FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); } @Test public void testFindAllPlanDefinitionIdsWithException() { doThrow(new SQLiteException()).when(sqLiteDatabase).rawQuery(anyString(), any()); Set<String> planDefinitions = planDefinitionRepository.findAllPlanDefinitionIds(); assertTrue(planDefinitions.isEmpty()); verify(sqLiteDatabase).rawQuery("SELECT _id FROM plan_definition WHERE status =?", new String[]{ACTIVE.value()}); }
### Question: UrlUtil { public static boolean isValidUrl(String s){ return new UrlValidator(new String[]{"http", "https"}).isValid(s); } static boolean isValidUrl(String s); }### Answer: @Test public void assertValidUrlPasses() { Assert.assertTrue(UrlUtil.isValidUrl("https: Assert.assertTrue(UrlUtil.isValidUrl("http: } @Test public void assertInValidUrlFails() { Assert.assertFalse(UrlUtil.isValidUrl("invalid.org")); Assert.assertFalse(UrlUtil.isValidUrl("error.test")); }
### Question: SettingsRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(SETTINGS_SQL); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void assertOnCreate() { settingsRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(anyString()); }
### Question: SettingsRepository extends DrishtiRepository { public static void onUpgrade(SQLiteDatabase database) { database.execSQL(ADD_SETTINGS_VERSION); database.execSQL(ADD_SETTINGS_TYPE); database.execSQL(ADD_SETTINGS_SYNC_STATUS); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void testOnUpgradeExecutesCorrectSQLStatement() { settingsRepository.onUpgrade(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(3)).execSQL(anyString()); }
### Question: SettingsRepository extends DrishtiRepository { public String querySetting(String key, String defaultValue) { Cursor cursor = null; String value = defaultValue; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, new String[]{SETTINGS_VALUE_COLUMN}, SETTINGS_KEY_COLUMN + " = ?", new String[]{key}, null, null, null, "1"); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { value = cursor.getString(0); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void assertquerySetting() { MatrixCursor matrixCursor = new MatrixCursor(new String[]{SETTINGS_KEY_COLUMN, SETTINGS_VALUE_COLUMN}); matrixCursor.addRow(new String[]{"KEY", "VALUE"}); Mockito.when(sqLiteDatabase.query(anyString(), any(String[].class), anyString(), any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), anyString())).thenReturn(matrixCursor); Assert.assertEquals(settingsRepository.querySetting("", ""), "KEY"); } @Test public void testQuerySetting() { Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), anyString()); Setting s = settingsRepository.querySetting(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "key = ?", new String[]{""}, null, null, null, "1"); Assert.assertEquals(s.getKey(), "testKey"); }
### Question: SettingsRepository extends DrishtiRepository { public byte[] queryBLOB(String key) { byte[] value = null; Cursor cursor = null; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, new String[]{SETTINGS_VALUE_COLUMN}, SETTINGS_KEY_COLUMN + " = ?", new String[]{key}, null, null, null, "1"); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { value = cursor.getBlob(0); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void assertqueryBlob() { Mockito.when(sqLiteDatabase.query(anyString(), any(String[].class), anyString(), any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), anyString())).thenReturn(getCursor()); Assert.assertEquals(settingsRepository.queryBLOB(""), null); }
### Question: SettingsRepository extends DrishtiRepository { public void updateSetting(String key, String value) { ContentValues values = new ContentValues(); values.put(SETTINGS_KEY_COLUMN, key); values.put(SETTINGS_VALUE_COLUMN, value); replace(values); } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void testUpdateSetting() { Setting s = new Setting(); s.setKey("test"); s.setValue("testValue"); s.setVersion("test"); s.setType("test"); s.setSyncStatus("test"); ArgumentCaptor<ContentValues> contentValuesArgumentCaptor = ArgumentCaptor.forClass(ContentValues.class); Mockito.doReturn(1L).when(sqLiteDatabase).replace(Mockito.eq(SETTINGS_TABLE_NAME), Mockito.nullable(String.class), contentValuesArgumentCaptor.capture()); settingsRepository.updateSetting(s); Mockito.verify(sqLiteDatabase, Mockito.times(1)).replace(anyString(), Mockito.isNull(String.class), any(ContentValues.class)); Assert.assertEquals(contentValuesArgumentCaptor.getValue().get(SETTINGS_KEY_COLUMN), "test"); }
### Question: SettingsRepository extends DrishtiRepository { public List<Setting> querySettingsByType(String type) { Cursor cursor = null; List<Setting> values = new ArrayList<>(); try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, SETTINGS_PROJECTION , SETTINGS_TYPE_COLUMN + " = ?", new String[]{type}, null, null, null, null); while (cursor != null && cursor.moveToNext()) { values.add(queryCore(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return values; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void testQuerySettingsByType() { Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), nullable(String.class)); List<Setting> lst = settingsRepository.querySettingsByType(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "type = ?", new String[]{""}, null, null, null, null); Assert.assertEquals(lst.get(0).getKey(), "testKey"); }
### Question: SettingsRepository extends DrishtiRepository { public List<Setting> queryUnsyncedSettings() { Cursor cursor = null; List<Setting> values = new ArrayList<>(); try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.query(SETTINGS_TABLE_NAME, SETTINGS_PROJECTION, SETTINGS_SYNC_STATUS_COLUMN + " = ?", new String[]{SyncStatus.PENDING.name()}, null, null, null, null); while (cursor != null && cursor.moveToNext()) { values.add(queryCore(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return values; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void testQueryUnsyncedSettings(){ Mockito.doReturn(getMatrixCursor()).when(sqLiteDatabase).query(any(), any(), any(), any(), nullable(String.class), nullable(String.class), nullable(String.class), nullable(String.class)); List<Setting> lst = settingsRepository.queryUnsyncedSettings(); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query("settings", new String[]{"key", "value", "type", "version", "sync_status"}, "sync_status = ?", new String[]{"PENDING"}, null, null, null, null); Assert.assertEquals(lst.get(0).getKey(), "testKey"); }
### Question: SettingsRepository extends DrishtiRepository { protected Setting queryCore(Cursor cursor) { Setting value = new Setting(); value.setKey(cursor.getString(cursor.getColumnIndex(SETTINGS_KEY_COLUMN))); value.setValue(cursor.getString(cursor.getColumnIndex(SETTINGS_VALUE_COLUMN))); value.setType(cursor.getString(cursor.getColumnIndex(SETTINGS_TYPE_COLUMN))); value.setVersion(cursor.getString(cursor.getColumnIndex(SETTINGS_VERSION_COLUMN))); value.setSyncStatus(cursor.getString(cursor.getColumnIndex(SETTINGS_SYNC_STATUS_COLUMN))); return value; } static void onUpgrade(SQLiteDatabase database); void updateSetting(String key, String value); void updateSetting(Setting setting); void updateBLOB(String key, byte[] value); String querySetting(String key, String defaultValue); byte[] queryBLOB(String key); Setting querySetting(String key); List<Setting> querySettingsByType(String type); List<Setting> queryUnsyncedSettings(); int queryUnsyncedSettingsCount(); static final String SETTINGS_TABLE_NAME; static final String SETTINGS_KEY_COLUMN; static final String SETTINGS_VALUE_COLUMN; static final String SETTINGS_VERSION_COLUMN; static final String SETTINGS_TYPE_COLUMN; static final String SETTINGS_SYNC_STATUS_COLUMN; static final String SETTINGS_SQL; static final String ADD_SETTINGS_VERSION; static final String ADD_SETTINGS_TYPE; static final String ADD_SETTINGS_SYNC_STATUS; }### Answer: @Test public void testQueryCore() { MatrixCursor cursor = getMatrixCursor(); cursor.moveToFirst(); Setting s = settingsRepository.queryCore(cursor); Assert.assertEquals(s.getKey(), "testKey"); }
### Question: ChildRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(CHILD_SQL); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertOnCreateCallDatabaseExecSql() { childRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
### Question: ChildRepository extends DrishtiRepository { public void add(Child child) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.insert(CHILD_TABLE_NAME, null, createValuesFor(child)); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertAddChildCallsDatabaseSqlInsert() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); childRepository.add(getMockChild()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
### Question: ChildRepository extends DrishtiRepository { public void update(Child child) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.update(CHILD_TABLE_NAME, createValuesFor(child), ID_COLUMN + " = ?", new String[]{child.caseId()}); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertUpdateChildCallsDatabaseSqlUpdate() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); childRepository.update(getMockChild()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
### Question: ChildRepository extends DrishtiRepository { public List<Child> all() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, IS_CLOSED_COLUMN + " = ?", new String[]{NOT_CLOSED}, null, null, null, null); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertAllChildReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.all()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
### Question: ChildRepository extends DrishtiRepository { public Child find(String caseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, ID_COLUMN + " = ?", new String[]{caseId}, null, null, null, null); List<Child> children = readAll(cursor); if (children.isEmpty()) { return null; } return children.get(0); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertFindChildReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.find("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
### Question: ChildRepository extends DrishtiRepository { public List<Child> findByMotherCaseId(String caseId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database .query(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS, MOTHER_ID_COLUMN + " = ?", new String[]{caseId}, null, null, null, null); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertFindChildByMotherReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.findByMotherCaseId("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).query(Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString(), Mockito.any(String[].class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class), Mockito.isNull(String.class)); }
### Question: ChildRepository extends DrishtiRepository { public List<Child> findChildrenByCaseIds(String... caseIds) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( String.format("SELECT * FROM %s WHERE %s IN (%s)", CHILD_TABLE_NAME, ID_COLUMN, insertPlaceholdersForInClause(caseIds.length)), caseIds); return readAll(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertFindChildSReturnsListOfChilds() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getChildCursor()); Assert.assertNotNull(childRepository.findChildrenByCaseIds("0")); Mockito.verify(sqLiteDatabase, Mockito.times(1)).rawQuery(Mockito.anyString(), Mockito.any(String[].class)); }
### Question: ChildRepository extends DrishtiRepository { public List<Child> allChildrenWithMotherAndEC() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( "SELECT " + tableColumnsForQuery(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS) + ", " + tableColumnsForQuery(MOTHER_TABLE_NAME, MOTHER_TABLE_COLUMNS) + ", " + tableColumnsForQuery(EC_TABLE_NAME, EC_TABLE_COLUMNS) + " FROM " + CHILD_TABLE_NAME + ", " + MOTHER_TABLE_NAME + ", " + EC_TABLE_NAME + " " + "WHERE " + CHILD_TABLE_NAME + "." + IS_CLOSED_COLUMN + "= ? AND " + CHILD_TABLE_NAME + "." + MOTHER_ID_COLUMN + " = " + MOTHER_TABLE_NAME + "." + MotherRepository.ID_COLUMN + " AND " + MOTHER_TABLE_NAME + "." + MotherRepository.EC_CASEID_COLUMN + " = " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN, new String[]{NOT_CLOSED}); return readAllChildrenWithMotherAndEC(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test(expected = Exception.class) public void assertAllChildrenWithMotherAndEC() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Assert.assertNull(childRepository.allChildrenWithMotherAndEC()); } @Test public void assertAllChildrenWithMotherAndECJoinTableCursor() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getJoinCursor()); Assert.assertNotNull(childRepository.allChildrenWithMotherAndEC()); }
### Question: ChildRepository extends DrishtiRepository { public List<Child> findAllChildrenByECId(String ecId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery( "SELECT " + tableColumnsForQuery(CHILD_TABLE_NAME, CHILD_TABLE_COLUMNS) + " FROM " + CHILD_TABLE_NAME + ", " + MOTHER_TABLE_NAME + ", " + EC_TABLE_NAME + " WHERE " + CHILD_TABLE_NAME + "." + IS_CLOSED_COLUMN + "=? AND " + CHILD_TABLE_NAME + "." + MOTHER_ID_COLUMN + " = " + MOTHER_TABLE_NAME + "." + MotherRepository.ID_COLUMN + " AND " + MOTHER_TABLE_NAME + "." + MotherRepository.EC_CASEID_COLUMN + " = " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN + " AND " + EC_TABLE_NAME + "." + EligibleCoupleRepository.ID_COLUMN + "= ? ", new String[]{NOT_CLOSED, ecId}); return readAllChildren(cursor); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertFindAllChildrenWithMotherAndECJoinTableCursor() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getJoinCursor()); Assert.assertNotNull(childRepository.findAllChildrenByECId("0")); }
### Question: ChildRepository extends DrishtiRepository { public void delete(String childId) { SQLiteDatabase database = masterRepository.getWritableDatabase(); database.delete(CHILD_TABLE_NAME, ID_COLUMN + "= ?", new String[]{childId}); } void add(Child child); void update(Child child); List<Child> all(); Child find(String caseId); List<Child> findChildrenByCaseIds(String... caseIds); void updateDetails(String caseId, Map<String, String> details); List<Child> findByMotherCaseId(String caseId); long count(); void close(String caseId); List<Child> allChildrenWithMotherAndEC(); void updatePhotoPath(String caseId, String imagePath); List<Child> findAllChildrenByECId(String ecId); void delete(String childId); static final String CHILD_TABLE_NAME; static final String PHOTO_PATH_COLUMN; static final String NOT_CLOSED; static final String[] CHILD_TABLE_COLUMNS; }### Answer: @Test public void assertDeleteCallsDatabaseDelete() { childRepository.updateMasterRepository(repository); Mockito.when(repository.getReadableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(repository.getWritableDatabase()).thenReturn(sqLiteDatabase); Mockito.when(sqLiteDatabase.delete(Mockito.anyString(), Mockito.anyString(), Mockito.any(String[].class))).thenReturn(1); childRepository.delete(""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).delete(Mockito.anyString(), Mockito.anyString(), Mockito.any(String[].class)); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findClientById(String id) { Client client = fetchClientByBaseEntityId(id); return Collections.singletonList(ClientConverter.convertClientToPatientResource(client)); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindClientById() throws Exception { String query = "SELECT json FROM client WHERE baseEntityId = ? "; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(1)); List<Patient> patients = clientDao.findClientById(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(1, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyByJurisdiction(String jurisdiction) { return fetchClients(String.format("select %s from %s where %s =? and %s =?", client_column.json, clientTable.name(), client_column.locationId, client_column.clientType), new String[]{jurisdiction, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindFamilyByJurisdiction() throws Exception { String query = "select json from client where locationId =? and clientType =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor()); List<Patient> patients = clientDao.findFamilyByJurisdiction(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(16, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyByResidence(String structureId) { return fetchClients(String.format("select %s from %s where %s =? and %s =?", client_column.json, clientTable.name(), client_column.residence, client_column.clientType), new String[]{structureId, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindFamilyByResidence() throws Exception { String query = "select json from client where residence =? and clientType =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor()); List<Patient> patients = clientDao.findFamilyByResidence(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(16, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction) { return fetchClients(String.format("select %s from %s where %s =? and (%s is null or %s !=? )", client_column.json, clientTable.name(), client_column.locationId, client_column.clientType, client_column.clientType), new String[]{jurisdiction, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindFamilyMemberByJurisdiction() throws Exception { String query = "select json from client where locationId =? and (clientType is null or clientType !=? )"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(10)); List<Patient> patients = clientDao.findFamilyMemberyByJurisdiction(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(10, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findFamilyMemberByResidence(String structureId) { return fetchClients(String.format("select %s from %s where %s =? and (%s is null or %s !=? )", client_column.json, clientTable.name(), client_column.residence, client_column.clientType, client_column.clientType), new String[]{structureId, AllConstants.FAMILY}) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindFamilyMemberByResidence() throws Exception { String query = "select json from client where residence =? and (clientType is null or clientType !=? )"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(2)); List<Patient> patients = clientDao.findFamilyMemberByResidence(params[0]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(2, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: ClientDaoImpl extends EventClientRepository implements ClientDao { @Override public List<Patient> findClientByRelationship(String relationship, String id) { return CoreLibrary.getInstance().context().getClientRelationshipRepository().findClientByRelationship(relationship, id) .stream() .map(ClientConverter::convertClientToPatientResource) .collect(Collectors.toList()); } @Override List<Patient> findClientById(String id); @Override List<Patient> findFamilyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyByResidence(String structureId); @Override List<Patient> findFamilyMemberyByJurisdiction(String jurisdiction); @Override List<Patient> findFamilyMemberByResidence(String structureId); @Override List<Patient> findClientByRelationship(String relationship, String id); }### Answer: @Test public void testFindClientByRelationship() throws Exception { String query = "SELECT json FROM client_relationship JOIN client ON base_entity_id=baseEntityId WHERE relationship=? AND relational_id =?"; String[] params = new String[]{"41587456-b7c8-4c4e-b433-23a786f742fc", "Family"}; when(sqLiteDatabase.rawQuery(anyString(), any())).thenReturn(getCursor(2)); List<Patient> patients = clientDao.findClientByRelationship(params[0], params[1]); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(2, patients.size()); Patient patient = patients.iterator().next(); assertNotNull(patient); assertEquals("03b1321a-d1fb-4fd0-b1cd-a3f3509fc6a6", patient.getId()); }
### Question: EventDaoImpl extends EventClientRepository implements EventDao { @Override public List<QuestionnaireResponse> findEventsByEntityIdAndPlan(String resourceId, String planIdentifier) { return fetchEvents(String.format("select %s from %s where %s =? and (%s is null or %s =? )", event_column.json, eventTable.name(), event_column.baseEntityId, event_column.planId, event_column.planId), new String[]{resourceId, planIdentifier}) .stream() .map(this::convert) .collect(Collectors.toList()); } @Override List<QuestionnaireResponse> findEventsByEntityIdAndPlan(String resourceId, String planIdentifier); }### Answer: @Test public void testFindEventsByEntityIdAndPlan() throws Exception { String query = "select json from event where baseEntityId =? and (planId is null or planId =? )"; String[] params = new String[]{"location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"}; when(sqLiteDatabase.rawQuery(query, params)).thenReturn(EventClientRepositoryTest.getEventCursor()); List<QuestionnaireResponse> questionnaireResponses = eventDao.findEventsByEntityIdAndPlan("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(20, questionnaireResponses.size()); QuestionnaireResponse questionnaireResponse = questionnaireResponses.iterator().next(); assertEquals("Household_Registration", questionnaireResponse.getQuestionnaire().getValue()); assertEquals("2184aaaa-d1cf-4099-945a-c66bd8a93e1e", questionnaireResponse.getId()); assertEquals(11, questionnaireResponse.getItem().size()); }
### Question: TaskDaoImpl extends TaskRepository implements TaskDao { @Override public List<Task> findTasksForEntity(String id, String planIdentifier) { return getTasksByPlanAndEntity(planIdentifier, id) .stream() .map(TaskConverter::convertTasktoFihrResource) .collect(Collectors.toList()); } TaskDaoImpl(TaskNotesRepository taskNotesRepository); @Override List<Task> findTasksForEntity(String id, String planIdentifier); @Override void saveTask(org.smartregister.domain.Task task, QuestionnaireResponse questionnaireResponse); @Override boolean checkIfTaskExists(String baseEntityId, String jurisdiction, String planIdentifier, String code); @Override List<Task> findAllTasksForEntity(String entityId); @Override void updateTask(org.smartregister.domain.Task task); }### Answer: @Test public void testFindTasksForEntity() { String query = "SELECT * FROM task WHERE plan_id=? AND for =? AND status NOT IN (?,?)"; String[] params = new String[]{"IRS_2018_S1", "location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", CANCELLED.name(), ARCHIVED.name()}; when(sqLiteDatabase.rawQuery(query, params)).thenReturn(getCursor()); List<Task> allTasks = taskDao.findTasksForEntity("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", "IRS_2018_S1"); verify(sqLiteDatabase).rawQuery(query, params); assertEquals(1, allTasks.size()); Task task = allTasks.iterator().next(); assertEquals("tsk11231jh22", task.getIdentifier().get(0).getValue().getValue()); assertEquals("2018_IRS-3734", task.getGroupIdentifier().getValue().getValue()); assertEquals(READY, task.getStatus()); assertEquals("Not Visited", task.getBusinessStatus().getText().getValue()); assertEquals("IRS", task.getCode().getText().getValue()); assertEquals("Spray House", task.getDescription().getValue()); assertEquals("IRS Visit", task.getFocus().getReference().getValue()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", task.getFor().getReference().getValue()); assertEquals("2018-11-10T2200", javaTimeFormater.format(task.getExecutionPeriod().getStart().getValue())); assertNull(task.getExecutionPeriod().getEnd()); assertEquals("2018-10-31T0700", javaTimeFormater.format(task.getAuthoredOn().getValue())); assertEquals("2018-10-31T0700", javaTimeFormater.format(task.getLastModified().getValue())); assertEquals("demouser", task.getOwner().getReference().getValue()); }
### Question: FormDataRepository extends DrishtiRepository { @JavascriptInterface public String queryUniqueResult(String sql, String[] selectionArgs) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery(sql, selectionArgs); cursor.moveToFirst(); Map<String, String> result = readARow(cursor); cursor.close(); return new Gson().toJson(result); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertqueryUniqueResult() { assertNotNull(formDataRepository.queryUniqueResult("sql",new String[0])); }
### Question: FormDataRepository extends DrishtiRepository { @JavascriptInterface public String queryList(String sql, String[] selectionArgs) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.rawQuery(sql, selectionArgs); List<Map<String, String>> results = new ArrayList<Map<String, String>>(); cursor.moveToFirst(); while (!cursor.isAfterLast()) { results.add(readARow(cursor)); cursor.moveToNext(); } cursor.close(); return new Gson().toJson(results); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertqueryList() { assertNotNull(formDataRepository.queryList("sql",new String[0])); } @Test public void assertqueryListWithdetails() { Mockito.when(sqLiteDatabase.rawQuery(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(getCursor2()); assertNotNull(formDataRepository.queryList("sql", new String[0])); }
### Question: FormDataRepository extends DrishtiRepository { @JavascriptInterface public String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion) { SQLiteDatabase database = masterRepository.getWritableDatabase(); Map<String, String> params = new Gson() .fromJson(paramsJSON, new TypeToken<Map<String, String>>() { }.getType()); database.insert(FORM_SUBMISSION_TABLE_NAME, null, createValuesForFormSubmission(params, data, formDataDefinitionVersion)); return params.get(INSTANCE_ID_PARAM); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertsaveFormSubmission() { assertEquals(formDataRepository.saveFormSubmission(getJsonObject(), "data", "1.0"), "1"); } @Test public void assertsaveFormSubmissionCallsDatabaseInsert() { formDataRepository.saveFormSubmission(getFormSubmission()); Mockito.verify(sqLiteDatabase, Mockito.times(1)).insert(Mockito.anyString(), Mockito.isNull(String.class), Mockito.any(ContentValues.class)); }
### Question: FormDataRepository extends DrishtiRepository { public FormSubmission fetchFromSubmission(String instanceId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, FORM_SUBMISSION_TABLE_COLUMNS, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}, null, null, null); return readFormSubmission(cursor).get(0); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertfetchFromSubmission() { assertNotNull(formDataRepository.fetchFromSubmission("")); }
### Question: FormDataRepository extends DrishtiRepository { public List<FormSubmission> getPendingFormSubmissions() { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, FORM_SUBMISSION_TABLE_COLUMNS, SYNC_STATUS_COLUMN + " = ?", new String[]{PENDING.value()}, null, null, null); return readFormSubmission(cursor); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertgetPendingFormSubmissions() { assertNotNull(formDataRepository.getPendingFormSubmissions()); }
### Question: FormDataRepository extends DrishtiRepository { public void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions) { SQLiteDatabase database = masterRepository.getWritableDatabase(); for (FormSubmission submission : formSubmissions) { FormSubmission updatedSubmission = new FormSubmission(submission.instanceId(), submission.entityId(), submission.formName(), submission.instance(), submission.version(), SYNCED, "1"); database.update(FORM_SUBMISSION_TABLE_NAME, createValuesForFormSubmission(updatedSubmission), INSTANCE_ID_COLUMN + " = ?", new String[]{updatedSubmission.instanceId()}); } } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertmarkFormSubmissionsAsSynced() { List<FormSubmission> list = new ArrayList<FormSubmission>(); list.add(getFormSubmission()); formDataRepository.markFormSubmissionsAsSynced(list); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
### Question: FormDataRepository extends DrishtiRepository { public boolean submissionExists(String instanceId) { SQLiteDatabase database = masterRepository.getReadableDatabase(); Cursor cursor = database.query(FORM_SUBMISSION_TABLE_NAME, new String[]{INSTANCE_ID_COLUMN}, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}, null, null, null); boolean isThere = cursor.moveToFirst(); cursor.close(); return isThere; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertsubmissionExists() { assertEquals(formDataRepository.submissionExists("1"), true); }
### Question: FormDataRepository extends DrishtiRepository { @JavascriptInterface public String saveEntity(String entityType, String fields) { SQLiteDatabase database = masterRepository.getWritableDatabase(); Map<String, String> updatedFieldsMap = new Gson() .fromJson(fields, new TypeToken<Map<String, String>>() { }.getType()); String entityId = updatedFieldsMap.get(ENTITY_ID_FIELD_NAME); Map<String, String> entityMap = loadEntityMap(entityType, database, entityId); ContentValues contentValues = getContentValues(updatedFieldsMap, entityType, entityMap); database.replace(entityType, null, contentValues); return entityId; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertsaveEntity() { assertEquals(formDataRepository.saveEntity(EligibleCoupleRepository.EC_TABLE_NAME, "{\"id\":\"1\"}"), "1"); }
### Question: FormDataRepository extends DrishtiRepository { public Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs) { Map<String, String> map = new HashMap<String, String>(); Cursor cursor = null; try { SQLiteDatabase database = masterRepository.getReadableDatabase(); cursor = database.rawQuery(sql, selectionArgs); map = sqliteRowToMap(cursor); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) { cursor.close(); } } return map; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertgetMapFromSQLQuery() { assertNotNull(formDataRepository.getMapFromSQLQuery("",null)); }
### Question: FormDataRepository extends DrishtiRepository { public void updateServerVersion(String instanceId, String serverVersion) { SQLiteDatabase database = masterRepository.getWritableDatabase(); ContentValues values = new ContentValues(); values.put(SERVER_VERSION_COLUMN, serverVersion); database.update(FORM_SUBMISSION_TABLE_NAME, values, INSTANCE_ID_COLUMN + " = ?", new String[]{instanceId}); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertupdateServerVersion() { formDataRepository.updateServerVersion("", ""); Mockito.verify(sqLiteDatabase, Mockito.times(1)).update(Mockito.anyString(), Mockito.any(ContentValues.class), Mockito.anyString(), Mockito.any(String[].class)); }
### Question: FormDataRepository extends DrishtiRepository { @Override protected void onCreate(SQLiteDatabase database) { database.execSQL(FORM_SUBMISSION_SQL); } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void assertOnCreateCallsDatabaseExec() { formDataRepository.onCreate(sqLiteDatabase); Mockito.verify(sqLiteDatabase, Mockito.times(1)).execSQL(Mockito.anyString()); }
### Question: FormDataRepository extends DrishtiRepository { public Map<String, String> sqliteRowToMap(Cursor cursor) { int totalColumn = cursor.getColumnCount(); Map<String, String> rowObject = new HashMap<String, String>(); if (cursor != null && cursor.moveToFirst()) { for (int i = 0; i < totalColumn; i++) { if (cursor.getColumnName(i) != null) { try { rowObject.put(cursor.getColumnName(i), cursor.getString(i)); } catch (Exception e) { Timber.d(e.getMessage()); } } } } return rowObject; } FormDataRepository(); void addTableColumnMap(String key, String[] val); @JavascriptInterface String queryUniqueResult(String sql, String[] selectionArgs); @JavascriptInterface String queryList(String sql, String[] selectionArgs); @JavascriptInterface String saveFormSubmission(String paramsJSON, String data, String formDataDefinitionVersion); @JavascriptInterface void saveFormSubmission(FormSubmission formSubmission); FormSubmission fetchFromSubmission(String instanceId); List<FormSubmission> getPendingFormSubmissions(); long getPendingFormSubmissionsCount(); void markFormSubmissionsAsSynced(List<FormSubmission> formSubmissions); void updateServerVersion(String instanceId, String serverVersion); boolean submissionExists(String instanceId); @JavascriptInterface String saveEntity(String entityType, String fields); @JavascriptInterface String generateIdFor(String entityType); Map<String, String> getMapFromSQLQuery(String sql, String[] selectionArgs); Map<String, String> sqliteRowToMap(Cursor cursor); static final String INSTANCE_ID_COLUMN; static final String ENTITY_ID_COLUMN; static final String ID_COLUMN; static final String[] FORM_SUBMISSION_TABLE_COLUMNS; }### Answer: @Test public void testSqliteRowToMap() { Map<String, String> rowObject = formDataRepository.sqliteRowToMap(getCursor()); assertEquals("1", rowObject.get(INSTANCE_ID_COLUMN)); assertEquals("2", rowObject.get(ENTITY_ID_COLUMN)); assertEquals("FORM", rowObject.get(FORM_NAME_COLUMN)); assertEquals(getJsonObject(), rowObject.get(INSTANCE_COLUMN)); assertEquals("1.0", rowObject.get(VERSION_COLUMN)); assertEquals("1.1", rowObject.get(SERVER_VERSION_COLUMN)); assertEquals("0.1", rowObject.get(FORM_DATA_DEFINITION_VERSION_COLUMN)); assertEquals(SyncStatus.PENDING.value(), rowObject.get(SYNC_STATUS_COLUMN)); }
### Question: P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @Override public long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId) { if (multimediaDetails != null && file.exists()) { final String syncStatus = (String) multimediaDetails.get(ImageRepository.syncStatus_COLUMN); final String entityId = (String) multimediaDetails.get(ImageRepository.entityID_COLUMN); if (OpenSRPImageLoader.moveSyncedImageAndSaveProfilePic(syncStatus, entityId, file)) { return fileRecordId; } } return -1; } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }### Answer: @Test public void receiveMultimediaShouldCallImageRepositoryWhenDataTypeIsProfilePic() { long fileRecordId = 78873L; ArgumentCaptor<ProfileImage> profileImageArgumentCaptor = ArgumentCaptor.forClass(ProfileImage.class); DataType dataType = new DataType(p2PReceiverTransferDao.profilePic.getName(), DataType.Type.MEDIA, 1); DrishtiApplication drishtiApplication = Mockito.mock(DrishtiApplication.class); ReflectionHelpers.setStaticField(DrishtiApplication.class, "mInstance", drishtiApplication); Mockito.doReturn(RuntimeEnvironment.application).when(drishtiApplication).getApplicationContext(); HashMap<String, Object> multimediaDetails = new HashMap<>(); multimediaDetails.put(ImageRepository.syncStatus_COLUMN, BaseRepository.TYPE_Unsynced); String entityId = "isod-sdfsd-32432"; multimediaDetails.put(ImageRepository.entityID_COLUMN, entityId); File file = Mockito.mock(File.class); Mockito.doReturn(true).when(file).exists(); Assert.assertEquals(fileRecordId, p2PReceiverTransferDao.receiveMultimedia(dataType, file, multimediaDetails, fileRecordId)); Mockito.verify(imageRepository).add(profileImageArgumentCaptor.capture()); ProfileImage profileImage = profileImageArgumentCaptor.getValue(); Assert.assertEquals("profilepic", profileImage.getFilecategory()); Assert.assertEquals(entityId, profileImage.getEntityID()); } @Test public void receiveMultimediaShouldReturnNegative1() { long fileRecordId = 78873L; DataType dataType = new DataType(p2PReceiverTransferDao.profilePic.getName(), DataType.Type.MEDIA, 1); HashMap<String, Object> multimediaDetails = new HashMap<>(); multimediaDetails.put(ImageRepository.syncStatus_COLUMN, BaseRepository.TYPE_Unsynced); multimediaDetails.put(ImageRepository.entityID_COLUMN, "isod-sdfsd-32432"); File file = Mockito.mock(File.class); Assert.assertEquals(-1, p2PReceiverTransferDao.receiveMultimedia(dataType, file, multimediaDetails, fileRecordId)); }
### Question: P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @Override public TreeSet<DataType> getDataTypes() { return (TreeSet<DataType>) dataTypes.clone(); } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }### Answer: @Test public void getDataTypesShouldReturnAClonedMatchOfDataTypes() { TreeSet<DataType> dataTypes = p2PReceiverTransferDao.getDataTypes(); Assert.assertTrue(p2PReceiverTransferDao.dataTypes != dataTypes); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.size(), dataTypes.size()); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.first(), dataTypes.first()); Assert.assertEquals(p2PReceiverTransferDao.dataTypes.last(), dataTypes.last()); }
### Question: P2PReceiverTransferDao extends BaseP2PTransferDao implements ReceiverTransferDao { @VisibleForTesting public P2PClassifier<JSONObject> getP2PClassifier() { return DrishtiApplication.getInstance().getP2PClassifier(); } @Override TreeSet<DataType> getDataTypes(); @VisibleForTesting P2PClassifier<JSONObject> getP2PClassifier(); @Override long receiveJson(@NonNull DataType dataType, @NonNull JSONArray jsonArray); @Override long receiveMultimedia(@NonNull DataType dataType, @NonNull File file, @Nullable HashMap<String, Object> multimediaDetails, long fileRecordId); }### Answer: @Test public void getP2PClassifier() { Assert.assertEquals(DrishtiApplication.getInstance().getP2PClassifier(), p2PReceiverTransferDao.getP2PClassifier()); }
### Question: AllEligibleCouples { public void close(String entityId) { alertRepository.deleteAllAlertsForEntity(entityId); timelineEventRepository.deleteAllTimelineEventsForEntity(entityId); eligibleCoupleRepository.close(entityId); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void shouldCloseEC() throws Exception { allEligibleCouples.close("entity id 1"); Mockito.verify(alertRepository).deleteAllAlertsForEntity("entity id 1"); Mockito.verify(eligibleCoupleRepository).close("entity id 1"); Mockito.verify(timelineEventRepository).deleteAllTimelineEventsForEntity("entity id 1"); }
### Question: AllEligibleCouples { public EligibleCouple findByCaseID(String caseId) { return eligibleCoupleRepository.findByCaseID(caseId); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertFindByCaseID() { Mockito.when(eligibleCoupleRepository.findByCaseID(Mockito.anyString())).thenReturn(Mockito.mock(EligibleCouple.class)); Assert.assertNotNull(allEligibleCouples.findByCaseID("")); }
### Question: AllEligibleCouples { public List<EligibleCouple> findByCaseIDs(List<String> caseIds) { return eligibleCoupleRepository.findByCaseIDs(caseIds.toArray(new String[caseIds.size()])); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertFindByCaseIDs() { Mockito.when(eligibleCoupleRepository.findByCaseIDs(Mockito.anyString())).thenReturn(Mockito.mock(ArrayList.class)); Assert.assertNotNull(allEligibleCouples.findByCaseIDs(new ArrayList<String>())); }
### Question: AllEligibleCouples { public void updatePhotoPath(String caseId, String imagePath) { eligibleCoupleRepository.updatePhotoPath(caseId, imagePath); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertUpdatePhotoPathCallsRepositoryUpdate() { Mockito.doNothing().when(eligibleCoupleRepository).updatePhotoPath(Mockito.anyString(), Mockito.anyString()); allEligibleCouples.updatePhotoPath("", ""); Mockito.verify(eligibleCoupleRepository, Mockito.times(1)).updatePhotoPath(Mockito.anyString(), Mockito.anyString()); }
### Question: AllEligibleCouples { public void mergeDetails(String entityId, Map<String, String> details) { eligibleCoupleRepository.mergeDetails(entityId, details); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertMergeDetailsCallsRepositoryUpdate() { Mockito.doNothing().when(eligibleCoupleRepository).mergeDetails(Mockito.anyString(), Mockito.any(Map.class)); allEligibleCouples.mergeDetails("", new HashMap<String, String>()); Mockito.verify(eligibleCoupleRepository, Mockito.times(1)).mergeDetails(Mockito.anyString(), Mockito.any(Map.class)); }
### Question: AllEligibleCouples { public long count() { return eligibleCoupleRepository.count(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertCountreturnsLong() { Mockito.when(eligibleCoupleRepository.count()).thenReturn(0l); Assert.assertEquals(allEligibleCouples.count(), 0l); }
### Question: AllEligibleCouples { public long fpCount() { return eligibleCoupleRepository.fpCount(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertFPCountreturnsLong() { Mockito.when(eligibleCoupleRepository.fpCount()).thenReturn(0l); Assert.assertEquals(allEligibleCouples.fpCount(), 0l); }
### Question: AllEligibleCouples { public List<String> villages() { return eligibleCoupleRepository.villages(); } AllEligibleCouples(EligibleCoupleRepository eligibleCoupleRepository, AlertRepository alertRepository, TimelineEventRepository timelineEventRepository); List<EligibleCouple> all(); EligibleCouple findByCaseID(String caseId); long count(); long fpCount(); List<String> villages(); List<EligibleCouple> findByCaseIDs(List<String> caseIds); void updatePhotoPath(String caseId, String imagePath); void close(String entityId); void mergeDetails(String entityId, Map<String, String> details); }### Answer: @Test public void assertVillagesReturnsList() { Mockito.when(eligibleCoupleRepository.villages()).thenReturn(new ArrayList<String>()); Assert.assertNotNull(allEligibleCouples.villages()); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.