method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
HTTPAgent { public Response<String> fetch(String requestURLPath) { try { HttpURLConnection urlConnection = initializeHttp(requestURLPath, true); if (HttpStatus.SC_UNAUTHORIZED == urlConnection.getResponseCode()) { invalidateExpiredCachedAccessToken(); urlConnection = initializeHttp(requestURLPath, true); } return processResponse(urlConnection); } catch (IOException ex) { Timber.e(ex, "EXCEPTION %s", ex.toString()); return new Response<>(ResponseStatus.failure, null); } } HTTPAgent(Context context, AllSharedPreferences
allSharedPreferences, DristhiConfiguration configuration); Response<String> fetch(String requestURLPath); void invalidateExpiredCachedAccessToken(); Response<String> post(String postURLPath, String jsonPayload); Response<String> postWithJsonResponse(String postURLPath, String jsonPayload); LoginResponse urlCanBeAccessWithGivenCredentials(String requestURL, String userName, char[] password); DownloadStatus downloadFromUrl(String url, String filename); Response<String> fetchWithCredentials(String requestURL, String accessToken); String httpImagePost(String urlString, ProfileImage image); int getReadTimeout(); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); void setReadTimeout(int readTimeout); AccountResponse oauth2authenticateCore(StringBuffer requestParamBuffer, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticate(String username, char[] password, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticateRefreshToken(String refreshToken); LoginResponse fetchUserDetails(String requestURL, String oauthAccessToken); Response<DownloadStatus> downloadFromURL(String downloadURL_, String fileName); boolean verifyAuthorization(); boolean verifyAuthorizationLegacy(); AccountConfiguration fetchOAuthConfiguration(); static final int FILE_UPLOAD_CHUNK_SIZE_BYTES; }### Answer:
@Test public void testFetchFailsGivenWrongUrl() { Response<String> resp = httpAgent.fetch("wrong.url"); Assert.assertEquals(ResponseStatus.failure, resp.status()); }
@Test public void testFetchPassesGivenCorrectUrl() { PowerMockito.mockStatic(Base64.class); Response<String> resp = httpAgent.fetch("https: Assert.assertEquals(ResponseStatus.success, resp.status()); } |
### Question:
HTTPAgent { public Response<String> post(String postURLPath, String jsonPayload) { HttpURLConnection urlConnection; try { urlConnection = generatePostRequest(postURLPath, jsonPayload); if (HttpStatus.SC_UNAUTHORIZED == urlConnection.getResponseCode()) { invalidateExpiredCachedAccessToken(); urlConnection = generatePostRequest(postURLPath, jsonPayload); } return processResponse(urlConnection); } catch (IOException ex) { Timber.e(ex, "EXCEPTION: %s", ex.toString()); return new Response<>(ResponseStatus.failure, null); } } HTTPAgent(Context context, AllSharedPreferences
allSharedPreferences, DristhiConfiguration configuration); Response<String> fetch(String requestURLPath); void invalidateExpiredCachedAccessToken(); Response<String> post(String postURLPath, String jsonPayload); Response<String> postWithJsonResponse(String postURLPath, String jsonPayload); LoginResponse urlCanBeAccessWithGivenCredentials(String requestURL, String userName, char[] password); DownloadStatus downloadFromUrl(String url, String filename); Response<String> fetchWithCredentials(String requestURL, String accessToken); String httpImagePost(String urlString, ProfileImage image); int getReadTimeout(); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); void setReadTimeout(int readTimeout); AccountResponse oauth2authenticateCore(StringBuffer requestParamBuffer, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticate(String username, char[] password, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticateRefreshToken(String refreshToken); LoginResponse fetchUserDetails(String requestURL, String oauthAccessToken); Response<DownloadStatus> downloadFromURL(String downloadURL_, String fileName); boolean verifyAuthorization(); boolean verifyAuthorizationLegacy(); AccountConfiguration fetchOAuthConfiguration(); static final int FILE_UPLOAD_CHUNK_SIZE_BYTES; }### Answer:
@Test public void testPostFailsGivenWrongUrl() { HashMap<String, String> map = new HashMap<>(); map.put("title", "OpenSRP Testing Tuesdays"); JSONObject jObject = new JSONObject(map); Response<String> resp = httpAgent.post("wrong.url", jObject.toString()); Assert.assertEquals(ResponseStatus.failure, resp.status()); }
@Test public void testPostPassesGivenCorrectUrl() { PowerMockito.mockStatic(Base64.class); HashMap<String, String> map = new HashMap<>(); map.put("title", "OpenSRP Testing Tuesdays"); JSONObject jObject = new JSONObject(map); Response<String> resp = httpAgent.post("http: Assert.assertEquals(ResponseStatus.success, resp.status()); } |
### Question:
HTTPAgent { public Response<String> fetchWithCredentials(String requestURL, String accessToken) { try { HttpURLConnection urlConnection = initializeHttp(requestURL, false); urlConnection.setRequestProperty(AllConstants.HTTP_REQUEST_HEADERS.AUTHORIZATION, new StringBuilder(AllConstants.HTTP_REQUEST_AUTH_TOKEN_TYPE.BEARER + " ").append(accessToken).toString()); if (HttpStatus.SC_UNAUTHORIZED == urlConnection.getResponseCode()) { AccountAuthenticatorXml authenticatorXml = CoreLibrary.getInstance().getAccountAuthenticatorXml(); AccountHelper.invalidateAuthToken(authenticatorXml.getAccountType(), accessToken); urlConnection = initializeHttp(requestURL, true); } return processResponse(urlConnection); } catch (IOException ex) { Timber.e(ex, "EXCEPTION %s", ex.toString()); return new Response<>(ResponseStatus.failure, null); } } HTTPAgent(Context context, AllSharedPreferences
allSharedPreferences, DristhiConfiguration configuration); Response<String> fetch(String requestURLPath); void invalidateExpiredCachedAccessToken(); Response<String> post(String postURLPath, String jsonPayload); Response<String> postWithJsonResponse(String postURLPath, String jsonPayload); LoginResponse urlCanBeAccessWithGivenCredentials(String requestURL, String userName, char[] password); DownloadStatus downloadFromUrl(String url, String filename); Response<String> fetchWithCredentials(String requestURL, String accessToken); String httpImagePost(String urlString, ProfileImage image); int getReadTimeout(); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); void setReadTimeout(int readTimeout); AccountResponse oauth2authenticateCore(StringBuffer requestParamBuffer, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticate(String username, char[] password, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticateRefreshToken(String refreshToken); LoginResponse fetchUserDetails(String requestURL, String oauthAccessToken); Response<DownloadStatus> downloadFromURL(String downloadURL_, String fileName); boolean verifyAuthorization(); boolean verifyAuthorizationLegacy(); AccountConfiguration fetchOAuthConfiguration(); static final int FILE_UPLOAD_CHUNK_SIZE_BYTES; }### Answer:
@Test public void testfetchWithCredentialsFailsGivenWrongUrl() { Response<String> resp = httpAgent.fetchWithCredentials("wrong.url", SAMPLE_TEST_TOKEN); Assert.assertEquals(ResponseStatus.failure, resp.status()); }
@Test public void testfetchWithCredentialsPassesGivenCorrectUrl() { PowerMockito.mockStatic(Base64.class); Response<String> resp = httpAgent.fetchWithCredentials("https: Assert.assertEquals(ResponseStatus.success, resp.status()); } |
### Question:
HTTPAgent { public Response<String> postWithJsonResponse(String postURLPath, String jsonPayload) { logResponse(postURLPath, jsonPayload); return post(postURLPath, jsonPayload); } HTTPAgent(Context context, AllSharedPreferences
allSharedPreferences, DristhiConfiguration configuration); Response<String> fetch(String requestURLPath); void invalidateExpiredCachedAccessToken(); Response<String> post(String postURLPath, String jsonPayload); Response<String> postWithJsonResponse(String postURLPath, String jsonPayload); LoginResponse urlCanBeAccessWithGivenCredentials(String requestURL, String userName, char[] password); DownloadStatus downloadFromUrl(String url, String filename); Response<String> fetchWithCredentials(String requestURL, String accessToken); String httpImagePost(String urlString, ProfileImage image); int getReadTimeout(); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); void setReadTimeout(int readTimeout); AccountResponse oauth2authenticateCore(StringBuffer requestParamBuffer, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticate(String username, char[] password, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticateRefreshToken(String refreshToken); LoginResponse fetchUserDetails(String requestURL, String oauthAccessToken); Response<DownloadStatus> downloadFromURL(String downloadURL_, String fileName); boolean verifyAuthorization(); boolean verifyAuthorizationLegacy(); AccountConfiguration fetchOAuthConfiguration(); static final int FILE_UPLOAD_CHUNK_SIZE_BYTES; }### Answer:
@Test public void testPostWithJsonResponse() { PowerMockito.mockStatic(Base64.class); HashMap<String, String> map = new HashMap<>(); map.put("title", "OpenSRP Testing Tuesdays"); JSONObject jObject = new JSONObject(map); Response<String> resp = httpAgent.postWithJsonResponse("http: Assert.assertEquals(ResponseStatus.success, resp.status()); } |
### Question:
HTTPAgent { public DownloadStatus downloadFromUrl(String url, String filename) { Response<DownloadStatus> status = downloadFromURL(url, filename); Timber.d("downloading file name : %s and url %s", filename, url); return status.payload(); } HTTPAgent(Context context, AllSharedPreferences
allSharedPreferences, DristhiConfiguration configuration); Response<String> fetch(String requestURLPath); void invalidateExpiredCachedAccessToken(); Response<String> post(String postURLPath, String jsonPayload); Response<String> postWithJsonResponse(String postURLPath, String jsonPayload); LoginResponse urlCanBeAccessWithGivenCredentials(String requestURL, String userName, char[] password); DownloadStatus downloadFromUrl(String url, String filename); Response<String> fetchWithCredentials(String requestURL, String accessToken); String httpImagePost(String urlString, ProfileImage image); int getReadTimeout(); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); void setReadTimeout(int readTimeout); AccountResponse oauth2authenticateCore(StringBuffer requestParamBuffer, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticate(String username, char[] password, String grantType, String tokenEndpointURL); AccountResponse oauth2authenticateRefreshToken(String refreshToken); LoginResponse fetchUserDetails(String requestURL, String oauthAccessToken); Response<DownloadStatus> downloadFromURL(String downloadURL_, String fileName); boolean verifyAuthorization(); boolean verifyAuthorizationLegacy(); AccountConfiguration fetchOAuthConfiguration(); static final int FILE_UPLOAD_CHUNK_SIZE_BYTES; }### Answer:
@Test public void testDownloadFromUrl() throws Exception { HTTPAgent httpAgentSpy = Mockito.spy(httpAgent); Mockito.doReturn(dirFile).when(httpAgentSpy).getSDCardDownloadPath(); Mockito.doReturn(file).when(httpAgentSpy).getFile(TEST_FILE_NAME, dirFile); Mockito.doReturn(false).when(dirFile).exists(); Mockito.doReturn(true).when(dirFile).mkdirs(); Mockito.doReturn(httpsURLConnection).when(httpAgentSpy).getHttpURLConnection(TEST_IMAGE_DOWNLOAD_ENDPOINT); Mockito.doReturn(HttpURLConnection.HTTP_OK).when(httpsURLConnection).getResponseCode(); Mockito.doReturn(inputStream).when(httpsURLConnection).getInputStream(); Mockito.doReturn(bufferedInputStream).when(httpAgentSpy).getBufferedInputStream(inputStream); Mockito.doReturn(1985).when(bufferedInputStream).available(); Mockito.doReturn(-1).when(bufferedInputStream).read(); Mockito.doReturn(fileOutputStream).when(httpAgentSpy).getFileOutputStream(file); DownloadStatus downloadStatus = httpAgentSpy.downloadFromUrl(TEST_IMAGE_DOWNLOAD_ENDPOINT, TEST_FILE_NAME); Assert.assertNotNull(downloadStatus); Assert.assertEquals("Download successful", downloadStatus.displayValue()); Mockito.verify(fileOutputStream).write(ArgumentMatchers.any(byte[].class)); Mockito.verify(fileOutputStream).flush(); Mockito.verify(fileOutputStream).close(); } |
### Question:
DrishtiService { public Response<List<Action>> fetchNewActions(String anmIdentifier, String previouslyFetchedIndex) { String anmID = URLEncoder.encode(anmIdentifier); Response<String> response = agent .fetch(drishtiBaseURL + "/actions?anmIdentifier=" + anmID + "&timeStamp=" + previouslyFetchedIndex); Type collectionType = new TypeToken<List<Action>>() { }.getType(); List<Action> actions; try { actions = new Gson().fromJson(response.payload(), collectionType); } catch (JsonSyntaxException e) { return new Response<List<Action>>(failure, new ArrayList<Action>()); } catch (Exception e) { return new Response<List<Action>>(failure, new ArrayList<Action>()); } return new Response<List<Action>>(response.status(), actions == null ? new ArrayList<Action>() : actions); } DrishtiService(HTTPAgent agent, String drishtiBaseURL); Response<List<Action>> fetchNewActions(String anmIdentifier, String
previouslyFetchedIndex); }### Answer:
@Test public void shouldFetchAlertActions() throws Exception { Mockito.when(httpAgent.fetch(EXPECTED_URL)).thenReturn(new Response<String>(ResponseStatus.success, IOUtils.toString(getClass().getResource("/alerts.json")))); Response<List<Action>> actions = drishtiService.fetchNewActions("anm1", "0"); Mockito.verify(httpAgent).fetch(EXPECTED_URL); Assert.assertEquals(Arrays.asList(ActionBuilder.actionForCreateAlert("Case X", AlertStatus.normal.value(), BeneficiaryType.mother.value(), "Ante Natal Care - Normal", "ANC 1", "2012-01-01", "2012-01-11", "1333695798583"), ActionBuilder.actionForCloseAlert("Case Y", "ANC 1", "2012-01-01", "1333695798644")), actions.payload()); Assert.assertEquals(ResponseStatus.success, actions.status()); }
@Test public void shouldFetchNoAlertActionsWhenJsonIsForEmptyList() throws Exception { Mockito.when(httpAgent.fetch(EXPECTED_URL)).thenReturn(new Response<String>(ResponseStatus.success, "[]")); Response<List<Action>> actions = drishtiService.fetchNewActions("anm1", "0"); Assert.assertTrue(actions.payload().isEmpty()); }
@Test public void shouldFetchNoAlertActionsWhenHTTPCallFails() throws Exception { Mockito.when(httpAgent.fetch(EXPECTED_URL)).thenReturn(new Response<String>(ResponseStatus.failure, null)); Response<List<Action>> actions = drishtiService.fetchNewActions("anm1", "0"); Assert.assertTrue(actions.payload().isEmpty()); Assert.assertEquals(ResponseStatus.failure, actions.status()); }
@Test public void shouldURLEncodeTheANMIdentifierPartWhenItHasASpace() { String expectedURLWithSpaces = "http: Mockito.when(httpAgent.fetch(expectedURLWithSpaces)).thenReturn(new Response<String>(ResponseStatus.success, "[]")); drishtiService.fetchNewActions("ANM WITH SPACE", "0"); Mockito.verify(httpAgent).fetch(expectedURLWithSpaces); }
@Test public void shouldReturnFailureResponseWhenJsonIsMalformed() { String expectedURLWithSpaces = "http: Mockito.when(httpAgent.fetch(expectedURLWithSpaces)).thenReturn(new Response<String>(ResponseStatus.success, "[{\"anmIdentifier\": \"ANMX\", ")); Response<List<Action>> actions = drishtiService.fetchNewActions("ANMX", "0"); Assert.assertTrue(actions.payload().isEmpty()); Assert.assertEquals(ResponseStatus.failure, actions.status()); } |
### Question:
StringUtil { public static String replaceAndHumanize(String value, String oldCharacter, String newCharacter) { return humanize(replace(getValue(value), oldCharacter, newCharacter)); } static String humanize(String value); static String replaceAndHumanize(String value, String oldCharacter, String
newCharacter); static String replaceAndHumanizeWithInitCapText(String value, String oldCharacter,
String newCharacter); static String humanizeAndDoUPPERCASE(String value); static String humanizeAndUppercase(String value, String... skipTokens); static String getValue(String value); }### Answer:
@Test public void assertReplaceAndHumanizeCallsHumanize() throws Exception { org.junit.Assert.assertEquals("Abc def", StringUtil.replaceAndHumanize("abc def", " ", "_")); } |
### Question:
AlertService { public void deleteAll(Action action) { repository.deleteAllAlertsForEntity(action.caseID()); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void shouldDeleteAllFromRepositoryForDeleteAllActions() throws Exception { Action firstAction = ActionBuilder.actionForDeleteAllAlert("Case X"); Action secondAction = ActionBuilder.actionForDeleteAllAlert("Case Y"); service.deleteAll(firstAction); service.deleteAll(secondAction); Mockito.verify(alertRepository).deleteAllAlertsForEntity("Case X"); Mockito.verify(alertRepository).deleteAllAlertsForEntity("Case Y"); Mockito.verifyNoMoreInteractions(alertRepository); } |
### Question:
AlertService { public List<Alert> findByEntityId(String entityId) { return repository.findByEntityId(entityId); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testFindEntityById() { service.findByEntityId("entity-id"); Mockito.verify(alertRepository).findByEntityId("entity-id"); } |
### Question:
StringUtil { public static String replaceAndHumanizeWithInitCapText(String value, String oldCharacter, String newCharacter) { return humanize(WordUtils.capitalize(replace(getValue(value), oldCharacter, newCharacter))); } static String humanize(String value); static String replaceAndHumanize(String value, String oldCharacter, String
newCharacter); static String replaceAndHumanizeWithInitCapText(String value, String oldCharacter,
String newCharacter); static String humanizeAndDoUPPERCASE(String value); static String humanizeAndUppercase(String value, String... skipTokens); static String getValue(String value); }### Answer:
@Test public void assertReplaceAndHumanizeWithInitCapTextCallsHumanize() throws Exception { org.junit.Assert.assertEquals("Abc def", StringUtil.replaceAndHumanizeWithInitCapText("abc def", " ", "_")); } |
### Question:
AlertService { public List<Alert> findByEntityIdAndAlertNames(String entityId, String... names) { return repository.findByEntityIdAndAlertNames(entityId, names); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testFindByEntityIdAndAlertNames() { service.findByEntityIdAndAlertNames("Entity 1", "AncAlert"); Mockito.verify(alertRepository).findByEntityIdAndAlertNames("Entity 1", "AncAlert"); } |
### Question:
AlertService { public List<Alert> findByEntityIdAndOffline(String entityId, String... names) { return repository.findOfflineByEntityIdAndName(entityId, names); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testByEntityIdAndOffline() { service.findByEntityIdAndOffline("Entity 1", "PncAlert"); Mockito.verify(alertRepository).findOfflineByEntityIdAndName("Entity 1", "PncAlert"); } |
### Question:
AlertService { public Alert findByEntityIdAndScheduleName(String entityId, String scheduleName) { return repository.findByEntityIdAndScheduleName(entityId, scheduleName); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testFindByEntityIdAndScheduleName() { service.findByEntityIdAndScheduleName("Entity 1", "Schedule 1"); Mockito.verify(alertRepository).findByEntityIdAndScheduleName("Entity 1", "Schedule 1"); } |
### Question:
AlertService { public void changeAlertStatusToInProcess(String entityId, String alertName) { repository.changeAlertStatusToInProcess(entityId, alertName); updateFtsSearchAfterStatusChange(entityId, alertName); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testChangeAlertStatusToInProcess() { service = spy(service); service.changeAlertStatusToInProcess("Entity 1", "AncAlert"); Mockito.verify(alertRepository).changeAlertStatusToInProcess("Entity 1", "AncAlert"); Mockito.verify(service).updateFtsSearchAfterStatusChange("Entity 1", "AncAlert"); } |
### Question:
AlertService { public void changeAlertStatusToComplete(String entityId, String alertName) { repository.changeAlertStatusToComplete(entityId, alertName); updateFtsSearchAfterStatusChange(entityId, alertName); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testChangeAlertStatusToComplete() { service = spy(service); service.changeAlertStatusToComplete("Entity 1", "AncAlert"); Mockito.verify(alertRepository).changeAlertStatusToComplete("Entity 1", "AncAlert"); Mockito.verify(service).updateFtsSearchAfterStatusChange("Entity 1", "AncAlert"); } |
### Question:
AlertService { public void deleteAlert(String entityId, String visitCode) { repository.deleteVaccineAlertForEntity(entityId, visitCode); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testDeleteAlert() { service.deleteAlert("Entity 1", "Visit 1"); Mockito.verify(alertRepository).deleteVaccineAlertForEntity("Entity 1", "Visit 1"); } |
### Question:
AlertService { public void deleteOfflineAlerts(String entityId) { repository.deleteOfflineAlertsForEntity(entityId); } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testDeleteOfflineAlerts() { service.deleteOfflineAlerts("Entity 1"); Mockito.verify(alertRepository).deleteOfflineAlertsForEntity("Entity 1"); }
@Test public void testDeleteOfflineAlertsWithNames() { service.deleteOfflineAlerts("Entity 1", "AncAlert"); Mockito.verify(alertRepository).deleteOfflineAlertsForEntity("Entity 1", "AncAlert"); } |
### Question:
AlertService { public void updateFtsSearchAfterStatusChange(String entityId, String alertName) { try { if (commonFtsObject != null && allCommonsRepositoryMap != null) { List<Alert> alerts = findByEntityIdAndAlertNames(entityId, alertName); if (alerts != null && !alerts.isEmpty()) { for (Alert alert : alerts) { updateFtsSearch(alert, true); } } } } catch (Exception e) { Log.logError(android.util.Log.getStackTraceString(e)); } } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testUpdateFtsSearchAfterStatusChange() { service = spy(service); Alert alert = new Alert("Case X", "Schedule 1", "ANC 1", AlertStatus.normal, "2012-01-01", "2012-01-22"); when(service.findByEntityIdAndAlertNames("Entity 1", "AncAlert")).thenReturn(Collections.singletonList(alert)); service.updateFtsSearchAfterStatusChange("Entity 1", "AncAlert"); verify(service).updateFtsSearch(alert, true); } |
### Question:
AlertService { public boolean updateFtsSearchInACR(String bindType, String entityId, String field, String value) { AllCommonsRepository allCommonsRepository = getAllCommonRepository(bindType); if (allCommonsRepository != null) { return allCommonsRepository.updateSearch(entityId, field, value, commonFtsObject.getAlertFilterVisitCodes()); } return false; } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testUpdateFtsSearchInACR() { AllCommonsRepository allCommonsRepository = mock(AllCommonsRepository.class); when(allCommonsRepositoryMap.get("bind 1")).thenReturn(allCommonsRepository); String[] alertFilterVisitCodes = new String[] {"AncFilter"}; when(commonFtsObject.getAlertFilterVisitCodes()).thenReturn(alertFilterVisitCodes); service.updateFtsSearchInACR("bind 1", "Entity 1", "baseEntityId", "id 1"); verify(allCommonsRepository).updateSearch("Entity 1", "baseEntityId", "id 1", alertFilterVisitCodes); } |
### Question:
StringUtil { public static String humanizeAndUppercase(String value, String... skipTokens) { String res = humanizeAndDoUPPERCASE(value); for (String s : skipTokens) { res = res.replaceAll("(?i)" + s, s); } return res; } static String humanize(String value); static String replaceAndHumanize(String value, String oldCharacter, String
newCharacter); static String replaceAndHumanizeWithInitCapText(String value, String oldCharacter,
String newCharacter); static String humanizeAndDoUPPERCASE(String value); static String humanizeAndUppercase(String value, String... skipTokens); static String getValue(String value); }### Answer:
@Test public void assertHumanizeAndUppercase() throws Exception { org.junit.Assert.assertEquals("ABC DEF", StringUtil.humanizeAndUppercase("abc def", " ")); } |
### Question:
AlertService { public void updateFtsSearch(Alert alert, boolean statusChange) { try { if (commonFtsObject != null && allCommonsRepositoryMap != null) { String entityId = alert.caseId(); String scheduleName = alert.scheduleName(); String visitCode = alert.visitCode(); AlertStatus status = alert.status(); String bindType = commonFtsObject.getAlertBindType(scheduleName); if (StringUtils.isNotBlank(bindType) && status != null && StringUtils .isNotBlank(scheduleName) && StringUtils.isNotBlank(entityId)) { String field = scheduleName.replace(" ", "_"); updateFtsSearchInACR(bindType, entityId, field, status.value()); if (!statusChange && StringUtils.isNotBlank(visitCode) && commonFtsObject .alertUpdateVisitCode(scheduleName)) { updateFtsSearchInACR(bindType, entityId, CommonFtsObject.phraseColumn, visitCode); } } } } catch (Exception e) { Log.logError(android.util.Log.getStackTraceString(e)); } } AlertService(AlertRepository repository); AlertService(AlertRepository repository, CommonFtsObject commonFtsObject, Map<String,
AllCommonsRepository> allCommonsRepositoryMap); void create(Action action); void create(Alert alert); void close(Action action); void deleteAll(Action action); List<Alert> findByEntityId(String entityId); List<Alert> findByEntityIdAndAlertNames(String entityId, String... names); List<Alert> findByEntityIdAndOffline(String entityId, String... names); Alert findByEntityIdAndScheduleName(String entityId, String scheduleName); void changeAlertStatusToInProcess(String entityId, String alertName); void changeAlertStatusToComplete(String entityId, String alertName); void deleteAlert(String entityId, String visitCode); void deleteOfflineAlerts(String entityId); void deleteOfflineAlerts(String entityId, String... names); void updateFtsSearchAfterStatusChange(String entityId, String alertName); void updateFtsSearch(Alert alert, boolean statusChange); boolean updateFtsSearchInACR(String bindType, String entityId, String field, String
value); }### Answer:
@Test public void testUpdateFtsSearch() { service = spy(service); Alert alert = new Alert("Case X", "Schedule 1", "ANC 1", AlertStatus.normal, "2012-01-01", "2012-01-22"); when(commonFtsObject.getAlertBindType("Schedule 1")).thenReturn("AncBindType"); when(commonFtsObject.alertUpdateVisitCode("Schedule 1")).thenReturn(true); service.updateFtsSearch(alert, false); verify(service).updateFtsSearchInACR("AncBindType", "Case X", "Schedule_1", AlertStatus.normal.value()); verify(service).updateFtsSearchInACR("AncBindType", "Case X", CommonFtsObject.phraseColumn, "ANC 1"); } |
### Question:
FormSubmissionSyncService { public void pushToServer() { List<FormSubmission> pendingFormSubmissions = formDataRepository .getPendingFormSubmissions(); if (pendingFormSubmissions.isEmpty()) { return; } String jsonPayload = mapToFormSubmissionDTO(pendingFormSubmissions); Response<String> response = httpAgent .post(format("{0}/{1}", configuration.dristhiBaseURL(), FORM_SUBMISSIONS_PATH), jsonPayload); if (response.isFailure()) { logError(format("Form submissions sync failed. Submissions: {0}", pendingFormSubmissions)); return; } formDataRepository.markFormSubmissionsAsSynced(pendingFormSubmissions); logInfo(format("Form submissions sync successfully. Submissions: {0}", pendingFormSubmissions)); } FormSubmissionSyncService(FormSubmissionService formSubmissionService, HTTPAgent
httpAgent, FormDataRepository formDataRepository, AllSettings allSettings,
AllSharedPreferences allSharedPreferences,
DristhiConfiguration configuration); FetchStatus sync(); void pushToServer(); FetchStatus pullFromServer(); static final String FORM_SUBMISSIONS_PATH; }### Answer:
@Test public void shouldPushPendingFormSubmissionsToServerAndMarkThemAsSynced() throws Exception { Mockito.when(httpAgent.post("http: .thenReturn(new Response<String>(ResponseStatus.success, null)); service.pushToServer(); Mockito.inOrder(allSettings, httpAgent, repository); Mockito.verify(allSharedPreferences).fetchRegisteredANM(); Mockito.verify(httpAgent).post("http: Mockito.verify(repository).markFormSubmissionsAsSynced(submissions); }
@Test public void shouldNotMarkPendingSubmissionsAsSyncedIfPostFails() throws Exception { Mockito.when(httpAgent.post("http: .thenReturn(new Response<String>(ResponseStatus.failure, null)); service.pushToServer(); Mockito.verify(repository).getPendingFormSubmissions(); Mockito.verifyNoMoreInteractions(repository); }
@Test public void shouldNotPushIfThereAreNoPendingSubmissions() throws Exception { Mockito.when(repository.getPendingFormSubmissions()).thenReturn(Collections.<FormSubmission>emptyList()); service.pushToServer(); Mockito.verify(repository).getPendingFormSubmissions(); Mockito.verifyNoMoreInteractions(repository); Mockito.verifyZeroInteractions(allSettings); Mockito.verifyZeroInteractions(httpAgent); } |
### Question:
FormSubmissionSyncService { public FetchStatus pullFromServer() { FetchStatus dataStatus = nothingFetched; String anmId = allSharedPreferences.fetchRegisteredANM(); int downloadBatchSize = configuration.syncDownloadBatchSize(); String baseURL = configuration.dristhiBaseURL(); while (true) { String uri = format("{0}/{1}?anm-id={2}×tamp={3}&batch-size={4}", baseURL, FORM_SUBMISSIONS_PATH, anmId, allSettings.fetchPreviousFormSyncIndex(), downloadBatchSize); Response<String> response = httpAgent.fetch(uri); if (response.isFailure()) { logError(format("Form submissions pull failed.")); return fetchedFailed; } List<FormSubmissionDTO> formSubmissions = new Gson() .fromJson(response.payload(), new TypeToken<List<FormSubmissionDTO>>() { }.getType()); if (formSubmissions.isEmpty()) { return dataStatus; } else { formSubmissionService.processSubmissions(toDomain(formSubmissions)); dataStatus = fetched; } } } FormSubmissionSyncService(FormSubmissionService formSubmissionService, HTTPAgent
httpAgent, FormDataRepository formDataRepository, AllSettings allSettings,
AllSharedPreferences allSharedPreferences,
DristhiConfiguration configuration); FetchStatus sync(); void pushToServer(); FetchStatus pullFromServer(); static final String FORM_SUBMISSIONS_PATH; }### Answer:
@Test public void shouldPullFormSubmissionsFromServerInBatchesAndDelegateToProcessing() throws Exception { this.expectedFormSubmissionsDto = Arrays.asList(new FormSubmissionDTO( "anm id 1", "id 1", "entity id 1", "form name", formInstanceJSON, "123", "1")); List<FormSubmission> expectedFormSubmissions = Arrays.asList(new FormSubmission("id 1", "entity id 1", "form name", formInstanceJSON, "123", SyncStatus.SYNCED, "1")); Mockito.when(configuration.syncDownloadBatchSize()).thenReturn(1); Mockito.when(allSettings.fetchPreviousFormSyncIndex()).thenReturn("122"); Mockito.when(httpAgent.fetch("http: .thenReturn(new Response<String>(ResponseStatus.success, new Gson().toJson(this.expectedFormSubmissionsDto)), new Response<String>(ResponseStatus.success, new Gson().toJson(Collections.emptyList()))); FetchStatus fetchStatus = service.pullFromServer(); Assert.assertEquals(FetchStatus.fetched, fetchStatus); Mockito.verify(httpAgent, Mockito.times(2)) .fetch("http: Mockito.verify(formSubmissionService).processSubmissions(expectedFormSubmissions); }
@Test public void shouldReturnNothingFetchedStatusWhenNoFormSubmissionsAreGotFromServer() throws Exception { Mockito.when(configuration.syncDownloadBatchSize()).thenReturn(1); Mockito.when(allSettings.fetchPreviousFormSyncIndex()).thenReturn("122"); Mockito.when(httpAgent.fetch("http: .thenReturn(new Response<String>(ResponseStatus.success, new Gson().toJson(Collections.emptyList()))); FetchStatus fetchStatus = service.pullFromServer(); Assert.assertEquals(FetchStatus.nothingFetched, fetchStatus); Mockito.verify(httpAgent).fetch("http: Mockito.verifyZeroInteractions(formSubmissionService); }
@Test public void shouldNotDelegateToProcessingIfPullFails() throws Exception { Mockito.when(configuration.syncDownloadBatchSize()).thenReturn(1); Mockito.when(allSettings.fetchPreviousFormSyncIndex()).thenReturn("122"); Mockito.when(httpAgent.fetch("http: .thenReturn(new Response<String>(ResponseStatus.failure, null)); FetchStatus fetchStatus = service.pullFromServer(); Assert.assertEquals(FetchStatus.fetchedFailed, fetchStatus); Mockito.verifyZeroInteractions(formSubmissionService); } |
### Question:
UserService { public Response<String> getLocationInformation() { String requestURL = configuration.dristhiBaseURL() + OPENSRP_LOCATION_URL_PATH; return httpAgent.fetch(requestURL); } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldGetANMLocation() { when(configuration.dristhiBaseURL()).thenReturn("http: userService.getLocationInformation(); verify(httpAgent).fetch("http: } |
### Question:
UserService { public void saveUserInfo(User user) { try { if (user != null && user.getPreferredName() != null) { String preferredName = user.getPreferredName(); String userName = user.getUsername(); allSharedPreferences.updateANMPreferredName(userName, preferredName); } } catch (Exception e) { Timber.e(e); } String userInfoString = AssetHandler.javaToJsonString(user); saveUserInfoTask.save(userInfoString); } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldSaveUserInformationRemoteLoginIsSuccessful() { org.smartregister.domain.jsonmapping.User user = new org.smartregister.domain.jsonmapping.User(); user.setPreferredName("Test"); userService.saveUserInfo(user); String userInfoString = AssetHandler.javaToJsonString(user); verify(saveUserInfoTask).save(userInfoString); } |
### Question:
UserService { public void saveAnmLocation(LocationTree anmLocation) { String amnLocationString = AssetHandler.javaToJsonString(anmLocation); saveANMLocationTask.save(amnLocationString); } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldSaveANMLocation() { org.smartregister.domain.jsonmapping.util.LocationTree locationTree = new org.smartregister.domain.jsonmapping.util.LocationTree(); org.smartregister.domain.jsonmapping.Location location = new org.smartregister.domain.jsonmapping.Location(); location.setName("test location"); location.setLocationId("Test location ID"); locationTree.addLocation(location); userService.saveAnmLocation(locationTree); String locationString = AssetHandler.javaToJsonString(locationTree); verify(saveANMLocationTask).save(locationString); } |
### Question:
UserService { public boolean isValidLocalLogin(String userName, byte[] password) { return allSharedPreferences.fetchRegisteredANM().equals(userName) && DrishtiApplication.getInstance().getRepository() .canUseThisPassword(password) && !allSharedPreferences.fetchForceRemoteLogin(userName); } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldConsiderALocalLoginValid() { when(allSharedPreferences.fetchRegisteredANM()).thenReturn("ANM X"); when(repository.canUseThisPassword(password)).thenReturn(true); assertTrue(userService.isValidLocalLogin("ANM X", password)); verify(allSharedPreferences).fetchRegisteredANM(); verify(repository).canUseThisPassword(password); }
@Test public void shouldConsiderALocalLoginInvalidWhenRegisteredUserDoesNotMatch() { when(allSharedPreferences.fetchRegisteredANM()).thenReturn("ANM X"); assertFalse(userService.isValidLocalLogin("SOME OTHER ANM", "password".getBytes())); verify(allSharedPreferences).fetchRegisteredANM(); verifyZeroInteractions(repository); }
@Test public void shouldConsiderALocalLoginInvalidWhenRegisteredUserMatchesButNotThePassword() { when(allSharedPreferences.fetchRegisteredANM()).thenReturn("ANM X"); when(repository.canUseThisPassword(password)).thenReturn(false); assertFalse(userService.isValidLocalLogin("ANM X", password)); verify(allSharedPreferences).fetchRegisteredANM(); verify(repository).canUseThisPassword(password); } |
### Question:
UserService { public void logout() { logoutSession(); allSettings.registerANM(""); allSettings.savePreviousFetchIndex("0"); configuration.getDrishtiApplication().getRepository().deleteRepository(); } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldDeleteDataAndSettingsWhenLogoutHappens() throws Exception { SyncConfiguration syncConfiguration = mock(SyncConfiguration.class); Mockito.doReturn(false).when(syncConfiguration).clearDataOnNewTeamLogin(); ReflectionHelpers.setField(CoreLibrary.getInstance(), "syncConfiguration", syncConfiguration); Whitebox.setInternalState(drishtiApplication, "password", password); userService.logout(); verify(repository).deleteRepository(); verify(repository).deleteRepository(); verify(repository).deleteRepository(); verify(allSettings).savePreviousFetchIndex("0"); verify(allSettings).registerANM(""); } |
### Question:
UserService { public String switchLanguagePreference() { String preferredLocale = allSharedPreferences.fetchLanguagePreference(); if (ENGLISH_LOCALE.equals(preferredLocale)) { allSharedPreferences.saveLanguagePreference(KANNADA_LOCALE); return KANNADA_LANGUAGE; } else { allSharedPreferences.saveLanguagePreference(ENGLISH_LOCALE); return ENGLISH_LANGUAGE; } } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldSwitchLanguageToKannada() throws Exception { when(allSharedPreferences.fetchLanguagePreference()).thenReturn(ENGLISH_LOCALE); userService.switchLanguagePreference(); verify(allSharedPreferences).saveLanguagePreference(KANNADA_LOCALE); }
@Test public void shouldSwitchLanguageToEnglish() throws Exception { when(allSharedPreferences.fetchLanguagePreference()).thenReturn(KANNADA_LOCALE); userService.switchLanguagePreference(); verify(allSharedPreferences).saveLanguagePreference(ENGLISH_LOCALE); } |
### Question:
UserService { public User getUserData(LoginResponseData userInfo) { try { if (userInfo != null) { return userInfo.user; } } catch (Exception e) { Timber.e(e); } return null; } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldGetUserDataFromJSON() throws Exception { org.smartregister.domain.jsonmapping.User user = userService.getUserData(loginResponseData); assertNotNull(user); assertEquals("demotest", user.getUsername()); assertEquals("Demo test User", user.getPreferredName()); } |
### Question:
UserService { public LocationTree getUserLocation(LoginResponseData userInfo) { try { if (userInfo != null) { return userInfo.locations; } } catch (Exception e) { Timber.e(e); } return null; } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void shouldGetUserLocationFromJSON() throws Exception { org.smartregister.domain.jsonmapping.util.LocationTree locationTree = userService.getUserLocation(loginResponseData); LinkedHashMap<String, org.smartregister.domain.jsonmapping.util.TreeNode<String, org.smartregister.domain.jsonmapping.Location>> mapLocation = locationTree.getLocationsHierarchy(); assertEquals("Pakistan", mapLocation.values().iterator().next().getLabel()); } |
### Question:
UserService { public static TimeZone getServerTimeZone(LoginResponseData userInfo) { if (userInfo != null) { try { Time time = userInfo.time; if (time != null) { TimeZone timeZone = TimeZone.getTimeZone(time.getTimeZone()); return timeZone; } } catch (Exception e) { Timber.e(e); } } return null; } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void testGetServerTimeZoneForExtractsTimeZoneFromResponse() { loginResponseData = mock(LoginResponseData.class); loginResponseData.time = new Time(new Date(), TimeZone.getTimeZone("Africa/Nairobi")); TimeZone timezone = UserService.getServerTimeZone(loginResponseData); assertNotNull(timezone); long millisecondsPerHour = 3600 * 1000; assertEquals(3 * millisecondsPerHour, timezone.getRawOffset()); assertEquals("Africa/Nairobi", timezone.getID()); } |
### Question:
UserService { public boolean isUserInValidGroup(final String userName, final char[] password) { if (keyStore != null && userName != null && password != null && !allSharedPreferences.fetchForceRemoteLogin(userName)) { byte[] storedHash = null; byte[] passwordHash = null; try { storedHash = getLocalAuthenticationCredentials(userName); passwordHash = generatePasswordHash(userName, password); if (storedHash != null && Arrays.equals(storedHash, passwordHash)) { return isValidDBPassword(getDBAuthenticationCredentials(userName)); } } catch (Exception e) { Timber.e(e); } finally { SecurityHelper.clearArray(password); SecurityHelper.clearArray(passwordHash); SecurityHelper.clearArray(storedHash); } } return false; } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void testIsUserInValidGroupForNullUserAndPassword() { assertFalse(userService.isUserInValidGroup(null, null)); }
@Test public void testIsUserInValidGroupShouldReturnFalseOnError() throws Exception { Whitebox.setInternalState(userService, "keyStore", keyStore); Whitebox.setInternalState(keyStore, "initialized", true); Whitebox.setInternalState(keyStore, "keyStoreSpi", keyStoreSpi); String user = "johndoe"; when(keyStore.containsAlias(user)).thenReturn(true); KeyStore.PrivateKeyEntry privateKeyEntry = PowerMockito.mock(KeyStore.PrivateKeyEntry.class); when(keyStore.getEntry(user, null)).thenReturn(privateKeyEntry); String password = UUID.randomUUID().toString(); assertFalse(userService.isUserInValidGroup(user, password.toCharArray())); verify(allSharedPreferences, never()).fetchEncryptedGroupId(user); verifyZeroInteractions(repository); } |
### Question:
UserService { public boolean isUserInPioneerGroup(String userName) { String pioneerUser = allSharedPreferences.fetchPioneerUser(); if (userName.equals(pioneerUser)) { return true; } else { byte[] currentUserSecretKey = getDecryptedPassphraseValue(userName); byte[] pioneerUserSecretKey = getDecryptedPassphraseValue(pioneerUser); if (currentUserSecretKey != null && Arrays.equals(pioneerUserSecretKey, currentUserSecretKey)) { return isValidDBPassword(currentUserSecretKey); } } return false; } UserService(AllSettings allSettingsArg, AllSharedPreferences
allSharedPreferencesArg, HTTPAgent httpAgentArg, Session sessionArg,
DristhiConfiguration configurationArg, SaveANMLocationTask
saveANMLocationTaskArg, SaveUserInfoTask saveUserInfoTaskArg, SaveANMTeamTask saveANMTeamTaskArg); static TimeZone getServerTimeZone(LoginResponseData userInfo); void initKeyStore(); TimeStatus validateStoredServerTimeZone(); TimeStatus validateDeviceTime(LoginResponseData userInfo, long serverTimeThreshold); boolean isValidLocalLogin(String userName, byte[] password); boolean isUserInValidGroup(final String userName, final char[] password); byte[] getDecryptedAccountValue(String userName, String key); byte[] getDecryptedPassphraseValue(String userName); boolean isUserInPioneerGroup(String userName); LoginResponse fetchUserDetails(String accessToken); AllSharedPreferences getAllSharedPreferences(); Response<String> getLocationInformation(); boolean localLoginWith(String userName); void processLoginResponseDataForUser(String userName, LoginResponseData userInfo); void forceRemoteLogin(String userName); User getUserData(LoginResponseData userInfo); LocationTree getUserLocation(LoginResponseData userInfo); TeamMember getUserTeam(LoginResponseData userInfo); void saveDefaultLocationId(String userName, String locationId); String getUserDefaultTeam(LoginResponseData userInfo); void saveDefaultTeam(String userName, String team); String getUserDefaultTeamId(LoginResponseData userInfo); void saveDefaultTeamId(String userName, String teamId); String getUserDefaultLocationId(LoginResponseData userInfo); String getUserLocationId(LoginResponseData userInfo); void saveUserLocationId(String userName, String locationId); void saveAnmLocation(LocationTree anmLocation); void saveAnmTeam(TeamMember anmTeam); void saveJurisdictions(List<String> jurisdictions); void saveJurisdictionIds(Set<String> jurisdictionIds); Set<String> fetchJurisdictionIds(); void saveOrganizations(TeamMember teamMember); void saveOrganizations(List<Long> organizations); Set<Long> fetchOrganizations(); void saveUserInfo(User user); Bundle saveUserCredentials(String userName, char[] password, LoginResponseData userInfo); boolean hasARegisteredUser(); void logout(); void logoutSession(); boolean hasSessionExpired(); String switchLanguagePreference(); KeyStore getKeyStore(); @Deprecated byte[] getGroupId(String userName); @Deprecated byte[] getGroupId(String userName, KeyStore.PrivateKeyEntry privateKeyEntry); }### Answer:
@Test public void testIsUserInPioneerGroupShouldReturnTrueForPioneerUser() throws Exception { userService = spy(userService); Whitebox.setInternalState(userService, "keyStore", keyStore); Whitebox.setInternalState(keyStore, "initialized", true); Whitebox.setInternalState(keyStore, "keyStoreSpi", keyStoreSpi); String user = "johndoe"; when(keyStore.containsAlias(user)).thenReturn(true); KeyStore.PrivateKeyEntry privateKeyEntry = PowerMockito.mock(KeyStore.PrivateKeyEntry.class); when(keyStore.getEntry(user, null)).thenReturn(privateKeyEntry); when(allSharedPreferences.fetchPioneerUser()).thenReturn(user); assertTrue(userService.isUserInPioneerGroup(user)); }
@Test public void testIsUserInPioneerGroupShouldReturnFalseForOthers() throws Exception { when(allSharedPreferences.fetchPioneerUser()).thenReturn("user"); assertFalse(userService.isUserInPioneerGroup("john")); } |
### Question:
RecreateECUtil { public void saveEventAndClients(Pair<List<Event>, List<Client>> eventClients, SQLiteDatabase sqLiteDatabase) { if (eventClients == null) { return; } if (eventClients.first != null) { JSONArray events; try { events = new JSONArray(gson.toJson(eventClients.first)); Timber.d("saving %d events, %s ", eventClients.first.size(), events); eventClientRepository.batchInsertEvents(events, 0, sqLiteDatabase); } catch (JSONException e) { Timber.e(e); } } if (eventClients.second != null) { JSONArray clients; try { clients = new JSONArray(gson.toJson(eventClients.second)); Timber.d("saving %d clients, %s", eventClients.second.size(), clients); eventClientRepository.batchInsertClients(clients, sqLiteDatabase); } catch (JSONException e) { Timber.e(e); } } } Pair<List<Event>, List<Client>> createEventAndClients(SQLiteDatabase database, String tablename, String query, String[] params, String eventType, String entityType, FormTag formTag); void saveEventAndClients(Pair<List<Event>, List<Client>> eventClients, SQLiteDatabase sqLiteDatabase); }### Answer:
@Test public void testSaveEventAndClientsWithNullEC() { recreateECUtil.saveEventAndClients(null, database); verifyZeroInteractions(database); }
@Test public void testSaveEventAndClients() throws IOException { when(database.rawQuery(query, params)).thenReturn(getECCursor()); when(clientProcessor.getColumnMappings(tableName)).thenReturn(getEcConfig()); Whitebox.setInternalState(recreateECUtil, "eventClientRepository", eventClientRepository); Pair<List<Event>, List<Client>> eventsAndClients = recreateECUtil.createEventAndClients(database, tableName, query, params, "FamilyRegistration", "Family", formTag); eventsAndClients.first.get(0).addDetails("opearational_area1", "123"); eventsAndClients.first.get(0).addDetails("task_business_status", "Completed"); recreateECUtil.saveEventAndClients(eventsAndClients, database); verify(eventClientRepository).batchInsertClients(jsonArrayArgumentCaptor.capture(), eq(database)); verify(eventClientRepository).batchInsertEvents(jsonArrayArgumentCaptor.capture(), eq(0l), eq(database)); Gson gson = JsonFormUtils.gson; assertEquals(gson.toJson(eventsAndClients.second), jsonArrayArgumentCaptor.getAllValues().get(0).toString()); assertEquals(gson.toJson(eventsAndClients.first), jsonArrayArgumentCaptor.getAllValues().get(1).toString()); } |
### Question:
ChildService { public void close(FormSubmission submission) { allBeneficiaries.closeChild(submission.entityId()); } ChildService(AllBeneficiaries allBeneficiariesArg, MotherRepository
motherRepositoryArg, ChildRepository childRepositoryArg, AllTimelineEvents
allTimelineEventsArg, ServiceProvidedService serviceProvidedServiceArg, AllAlerts
allAlertsArg); void register(FormSubmission submission); void registerForEC(FormSubmission submission); void pncRegistrationOA(FormSubmission submission); void updateImmunizations(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void close(FormSubmission submission); void updatePhotoPath(String entityId, String imagePath); void updateIllnessStatus(FormSubmission submission); void updateVitaminAProvided(FormSubmission submission); void registerForOA(FormSubmission submission); }### Answer:
@Test public void shouldCloseChildRecordForDeleteChildAction() throws Exception { FormSubmission submission = Mockito.mock(FormSubmission.class); Mockito.when(submission.entityId()).thenReturn("child id 1"); service.close(submission); Mockito.verify(allBeneficiaries).closeChild("child id 1"); } |
### Question:
ChildService { public void updateIllnessStatus(FormSubmission submission) { String sickVisitDate = submission.getFieldValue(SICK_VISIT_DATE); String date = sickVisitDate != null ? sickVisitDate : submission.getFieldValue(REPORT_CHILD_DISEASE_DATE); serviceProvidedService.add(ServiceProvided.forChildIllnessVisit(submission.entityId(), date, createChildIllnessMap(submission))); } ChildService(AllBeneficiaries allBeneficiariesArg, MotherRepository
motherRepositoryArg, ChildRepository childRepositoryArg, AllTimelineEvents
allTimelineEventsArg, ServiceProvidedService serviceProvidedServiceArg, AllAlerts
allAlertsArg); void register(FormSubmission submission); void registerForEC(FormSubmission submission); void pncRegistrationOA(FormSubmission submission); void updateImmunizations(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void close(FormSubmission submission); void updatePhotoPath(String entityId, String imagePath); void updateIllnessStatus(FormSubmission submission); void updateVitaminAProvided(FormSubmission submission); void registerForOA(FormSubmission submission); }### Answer:
@Test public void shouldUpdateIllnessForUpdateIllnessAction() throws Exception { FormSubmission submission = Mockito.mock(FormSubmission.class); Mockito.when(submission.entityId()).thenReturn("child id 1"); Mockito.when(submission.getFieldValue("submissionDate")).thenReturn("2012-01-02"); Mockito.when(submission.getFieldValue("sickVisitDate")).thenReturn("2012-01-01"); Mockito.when(submission.getFieldValue("childSigns")).thenReturn("child signs"); Mockito.when(submission.getFieldValue("childSignsOther")).thenReturn("child signs other"); Mockito.when(submission.getFieldValue("reportChildDisease")).thenReturn("report child disease"); Mockito.when(submission.getFieldValue("reportChildDiseaseOther")).thenReturn("report child disease other"); Mockito.when(submission.getFieldValue("reportChildDiseaseDate")).thenReturn(null); Mockito.when(submission.getFieldValue("reportChildDiseasePlace")).thenReturn("report child disease place"); Mockito.when(submission.getFieldValue("childReferral")).thenReturn("child referral"); service.updateIllnessStatus(submission); Map<String, String> map = EasyMap.create("sickVisitDate", "2012-01-01") .put("childSignsOther", "child signs other") .put("childSigns", "child signs") .put("reportChildDisease", "report child disease") .put("reportChildDiseaseOther", "report child disease other") .put("reportChildDiseaseDate", null) .put("reportChildDiseasePlace", "report child disease place") .put("childReferral", "child referral").map(); Mockito.verify(serviceProvidedService).add(ServiceProvided.forChildIllnessVisit("child id 1", "2012-01-01", map)); } |
### Question:
ChildService { public void updateVitaminAProvided(FormSubmission submission) { serviceProvidedService.add(ServiceProvided.forVitaminAProvided(submission.entityId(), submission.getFieldValue(AllConstants.VitaminAFields.VITAMIN_A_DATE), submission.getFieldValue(AllConstants.VitaminAFields.VITAMIN_A_DOSE), submission.getFieldValue(AllConstants.VitaminAFields.VITAMIN_A_PLACE))); } ChildService(AllBeneficiaries allBeneficiariesArg, MotherRepository
motherRepositoryArg, ChildRepository childRepositoryArg, AllTimelineEvents
allTimelineEventsArg, ServiceProvidedService serviceProvidedServiceArg, AllAlerts
allAlertsArg); void register(FormSubmission submission); void registerForEC(FormSubmission submission); void pncRegistrationOA(FormSubmission submission); void updateImmunizations(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void close(FormSubmission submission); void updatePhotoPath(String entityId, String imagePath); void updateIllnessStatus(FormSubmission submission); void updateVitaminAProvided(FormSubmission submission); void registerForOA(FormSubmission submission); }### Answer:
@Test public void shouldUpdateVitaminADosagesForUpdateVitaminAProvidedAction() throws Exception { FormSubmission submission = Mockito.mock(FormSubmission.class); Mockito.when(submission.entityId()).thenReturn("child id 1"); Mockito.when(submission.getFieldValue("vitaminADate")).thenReturn("2012-01-01"); Mockito.when(submission.getFieldValue("vitaminADose")).thenReturn("1"); Mockito.when(submission.getFieldValue("vitaminAPlace")).thenReturn("PHC"); service.updateVitaminAProvided(submission); Mockito.verify(serviceProvidedService).add(ServiceProvided.forVitaminAProvided("child id 1", "2012-01-01", "1", "PHC")); } |
### Question:
ChildService { public void registerForOA(FormSubmission submission) { Child child = allBeneficiaries.findChild(submission.getFieldValue(CHILD_ID)); child.setThayiCardNumber(submission.getFieldValue(THAYI_CARD_NUMBER)); allBeneficiaries.updateChild(child); Map<String, String> immunizationDateFieldMap = createImmunizationDateFieldMap(); String immunizationsGiven = submission .getFieldValue(AllConstants.ChildRegistrationOAFields.IMMUNIZATIONS_GIVEN); immunizationsGiven = isBlank(immunizationsGiven) ? "" : immunizationsGiven; allTimelines.add(forChildBirthInChildProfile(submission.getFieldValue(CHILD_ID), submission.getFieldValue(AllConstants.ChildRegistrationOAFields.DATE_OF_BIRTH), submission.getFieldValue(AllConstants.ChildRegistrationOAFields.WEIGHT), immunizationsGiven)); for (String immunization : immunizationsGiven.split(SPACE)) { serviceProvidedService.add(ServiceProvided .forChildImmunization(submission.entityId(), immunization, submission.getFieldValue(immunizationDateFieldMap.get(immunization)))); } } ChildService(AllBeneficiaries allBeneficiariesArg, MotherRepository
motherRepositoryArg, ChildRepository childRepositoryArg, AllTimelineEvents
allTimelineEventsArg, ServiceProvidedService serviceProvidedServiceArg, AllAlerts
allAlertsArg); void register(FormSubmission submission); void registerForEC(FormSubmission submission); void pncRegistrationOA(FormSubmission submission); void updateImmunizations(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void close(FormSubmission submission); void updatePhotoPath(String entityId, String imagePath); void updateIllnessStatus(FormSubmission submission); void updateVitaminAProvided(FormSubmission submission); void registerForOA(FormSubmission submission); }### Answer:
@Test public void shouldAddTimelineEventWhenChildIsRegisteredForOA() throws Exception { FormSubmission submission = Mockito.mock(FormSubmission.class); Mockito.when(submission.entityId()).thenReturn("ec id 1"); Mockito.when(submission.getFieldValue("motherId")).thenReturn("mother id 1"); Mockito.when(submission.getFieldValue("id")).thenReturn("child id 1"); Mockito.when(submission.getFieldValue("dateOfBirth")).thenReturn("2013-01-02"); Mockito.when(submission.getFieldValue("gender")).thenReturn("female"); Mockito.when(submission.getFieldValue("weight")).thenReturn("3"); Mockito.when(submission.getFieldValue("immunizationsGiven")).thenReturn("bcg opv_0"); Mockito.when(submission.getFieldValue("bcgDate")).thenReturn("2012-01-06"); Mockito.when(submission.getFieldValue("opv0Date")).thenReturn("2012-01-07"); Mockito.when(submission.getFieldValue("thayiCardNumber")).thenReturn("1234567"); Mockito.when(allBeneficiaries.findChild("child id 1")).thenReturn(child); service.registerForOA(submission); Mockito.verify(child).setThayiCardNumber("1234567"); Mockito.verify(allBeneficiaries).updateChild(child); Mockito.verify(allTimelineEvents).add(TimelineEvent.forChildBirthInChildProfile("child id 1", "2013-01-02", "3", "bcg opv_0")); Mockito.verify(serviceProvidedService).add(ServiceProvided.forChildImmunization("ec id 1", "bcg", "2012-01-06")); Mockito.verify(serviceProvidedService).add(ServiceProvided.forChildImmunization("ec id 1", "opv_0", "2012-01-07")); } |
### Question:
ActionService { public FetchStatus fetchNewActions() { String previousFetchIndex = allSettings.fetchPreviousFetchIndex(); Response<List<Action>> response = drishtiService .fetchNewActions(allSharedPreference.fetchRegisteredANM(), previousFetchIndex); if (response.isFailure()) { return fetchedFailed; } if (response.payload().isEmpty()) { return nothingFetched; } handleActions(response); return FetchStatus.fetched; } ActionService(DrishtiService drishtiService, AllSettings allSettings,
AllSharedPreferences allSharedPreferences, AllReports allReports); ActionService(DrishtiService drishtiService, AllSettings allSettings,
AllSharedPreferences allSharedPreferences, AllReports allReports,
ActionRouter actionRouter); FetchStatus fetchNewActions(); }### Answer:
@Test public void shouldFetchAlertActionsAndNotSaveAnythingIfThereIsNothingNewToSave() throws Exception { setupActions(ResponseStatus.success, new ArrayList<Action>()); Assert.assertEquals(FetchStatus.nothingFetched, service.fetchNewActions()); Mockito.verify(drishtiService).fetchNewActions("ANM X", "1234"); Mockito.verifyNoMoreInteractions(drishtiService); Mockito.verifyNoMoreInteractions(actionRouter); }
@Test public void shouldNotSaveAnythingIfTheDrishtiResponseStatusIsFailure() throws Exception { setupActions(ResponseStatus.failure, Arrays.asList(ActionBuilder.actionForCloseAlert("Case X", "ANC 1", "2012-01-01", "0"))); Assert.assertEquals(FetchStatus.fetchedFailed, service.fetchNewActions()); Mockito.verify(drishtiService).fetchNewActions("ANM X", "1234"); Mockito.verifyNoMoreInteractions(drishtiService); Mockito.verifyNoMoreInteractions(actionRouter); }
@Test public void shouldFetchAlertActionsAndSaveThemToRepository() throws Exception { Action action = ActionBuilder.actionForCreateAlert("Case X", "normal", "mother", "Ante Natal Care - Normal", "ANC 1", "2012-01-01", null, "0"); setupActions(ResponseStatus.success, Arrays.asList(action)); Assert.assertEquals(FetchStatus.fetched, service.fetchNewActions()); Mockito.verify(drishtiService).fetchNewActions("ANM X", "1234"); Mockito.verify(actionRouter).directAlertAction(action); }
@Test public void shouldUpdatePreviousIndexWithIndexOfEachActionThatIsHandled() throws Exception { Action firstAction = ActionBuilder.actionForCreateAlert("Case X", "normal", "mother", "Ante Natal Care - Normal", "ANC 1", "2012-01-01", "2012-01-22", "11111"); Action secondAction = ActionBuilder.actionForCreateAlert("Case Y", "normal", "mother", "Ante Natal Care - Normal", "ANC 2", "2012-01-01", "2012-01-11", "12345"); setupActions(ResponseStatus.success, Arrays.asList(firstAction, secondAction)); service.fetchNewActions(); InOrder inOrder = Mockito.inOrder(actionRouter, allSettings); inOrder.verify(actionRouter).directAlertAction(firstAction); inOrder.verify(allSettings).savePreviousFetchIndex("11111"); inOrder.verify(actionRouter).directAlertAction(secondAction); inOrder.verify(allSettings).savePreviousFetchIndex("12345"); } |
### Question:
FormUtils { public String retrieveValueForLinkedRecord(String link, JSONObject entityJson) { try { String entityRelationships = readFileFromAssetsFolder( "www/form/entity_relationship" + AllConstants.JSON_FILE_EXTENSION); JSONArray json = new JSONArray(entityRelationships); Timber.i(json.toString()); JSONObject rJson; if ((rJson = retrieveRelationshipJsonForLink(link, json)) != null) { String[] path = link.split("\\."); String parentTable = path[0]; String childTable = path[1]; String joinValueKey = parentTable.equals(rJson.getString("parent")) ? rJson.getString("from") : rJson.getString("to"); joinValueKey = joinValueKey.contains(".") ? joinValueKey .substring(joinValueKey.lastIndexOf(".") + 1) : joinValueKey; String val = entityJson.getString(joinValueKey); String joinField = parentTable.equals(rJson.getString("parent")) ? rJson.getString("to") : rJson.getString("from"); String sql = "select * from " + childTable + " where " + joinField + "=?"; Timber.d(sql); String dbEntity = theAppContext.formDataRepository().queryUniqueResult(sql, new String[]{val}); JSONObject linkedEntityJson = new JSONObject(); if (dbEntity != null && !dbEntity.isEmpty()) { linkedEntityJson = new JSONObject(dbEntity); } String sourceKey = link.substring(link.lastIndexOf(".") + 1); if (linkedEntityJson.has(sourceKey)) { return linkedEntityJson.getString(sourceKey); } } } catch (Exception e) { Timber.e(e); } return null; } FormUtils(Context context); static FormUtils getInstance(Context ctx); static boolean hasChildElements(Node element); static int getIndexForFormName(String formName, String[] formNames); FormSubmission generateFormSubmisionFromXMLString(String entity_id, String formData,
String formName, JSONObject
overrides); String generateXMLInputForFormWithEntityId(String entityId, String formName, String
overrides); Object getObjectAtPath(String[] path, JSONObject jsonObject); JSONArray getPopulatedFieldsForArray(JSONObject fieldsDefinition, String entityId,
JSONObject jsonObject, JSONObject overrides); String retrieveValueForLinkedRecord(String link, JSONObject entityJson); JSONArray getFieldsArrayForSubFormDefinition(JSONObject fieldsDefinition); JSONObject getFieldValuesForSubFormDefinition(JSONObject fieldsDefinition, String
relationalId, String entityId, JSONObject jsonObject, JSONObject overrides); String getValueForPath(String[] path, JSONObject jsonObject); JSONObject getFormJson(String formIdentity); static final String TAG; static final String ecClientRelationships; }### Answer:
@Test public void assertretrieveValueForLinkedRecord() throws Exception { formUtils = new FormUtils(context_); Mockito.when(context_.getAssets()).thenReturn(assetManager); Mockito.when(assetManager.open(entityRelationShip)).thenAnswer(new Answer<InputStream>() { @Override public InputStream answer(InvocationOnMock invocation) throws Throwable { return new FileInputStream(getFileFromPath(this, entityRelationShip)); } }); JSONObject mockobject = Mockito.mock(JSONObject.class); Mockito.when(mockobject.getString(Mockito.anyString())).thenReturn("val"); formUtils.retrieveValueForLinkedRecord("household.elco", mockobject); } |
### Question:
ReplicationIntentService extends IntentService { @Override protected void onHandleIntent(Intent intent) { } ReplicationIntentService(String name); ReplicationIntentService(); }### Answer:
@Test public void assertReplicationIntentServiceInitializationTest() { ReplicationIntentService replicationIntentService = new ReplicationIntentService(); Assert.assertNotNull(replicationIntentService); replicationIntentService.onHandleIntent(null); }
@Test public void assertReplicationIntentServiceInitializationTest2() { ReplicationIntentService replicationIntentService = new ReplicationIntentService("service_name"); Assert.assertNotNull(replicationIntentService); replicationIntentService.onHandleIntent(null); } |
### Question:
MotherService { public void registerANC(FormSubmission submission) { addTimelineEventsForMotherRegistration(submission); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldRegisterANC() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("motherId")).thenReturn("mother id 1"); when(submission.getFieldValue("thayiCardNumber")).thenReturn("thayi 1"); when(submission.getFieldValue("registrationDate")).thenReturn("2012-01-02"); when(submission.getFieldValue("referenceDate")).thenReturn("2012-01-01"); service.registerANC(submission); allTimelineEvents.add(TimelineEvent.forStartOfPregnancy("mother id 1", "2012-01-02", "2012-01-01")); allTimelineEvents.add(TimelineEvent.forStartOfPregnancyForEC("entity id 1", "thayi 1", "2012-01-02", "2012-01-01")); } |
### Question:
MotherService { public void registerOutOfAreaANC(FormSubmission submission) { addTimelineEventsForMotherRegistration(submission); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldRegisterOutOfAreaANC() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("motherId")).thenReturn("mother id 1"); when(submission.getFieldValue("thayiCardNumber")).thenReturn("thayi 1"); when(submission.getFieldValue("registrationDate")).thenReturn("2012-01-02"); when(submission.getFieldValue("referenceDate")).thenReturn("2012-01-01"); service.registerOutOfAreaANC(submission); allTimelineEvents.add(TimelineEvent.forStartOfPregnancy("mother id 1", "2012-01-02", "2012-01-01")); allTimelineEvents.add(TimelineEvent.forStartOfPregnancyForEC("entity id 1", "thayi 1", "2012-01-02", "2012-01-01")); } |
### Question:
MotherService { public void ancVisit(FormSubmission submission) { allTimelines.add(forANCCareProvided(submission.entityId(), submission.getFieldValue(ANC_VISIT_NUMBER), submission.getFieldValue(ANC_VISIT_DATE), create(BP_SYSTOLIC, submission.getFieldValue(BP_SYSTOLIC)) .put(BP_DIASTOLIC, submission.getFieldValue(BP_DIASTOLIC)) .put(TEMPERATURE, submission.getFieldValue(TEMPERATURE)) .put(WEIGHT, submission.getFieldValue(WEIGHT)).map())); serviceProvidedService.add(ServiceProvided.forANCCareProvided(submission.entityId(), submission.getFieldValue(ANC_VISIT_NUMBER), submission.getFieldValue(ANC_VISIT_DATE), submission.getFieldValue(BP_SYSTOLIC), submission.getFieldValue(BP_DIASTOLIC), submission.getFieldValue(WEIGHT))); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldCreateTimelineEventsWhenANCVisitHappens() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("ancVisitDate")).thenReturn("2013-01-01"); when(submission.getFieldValue("ancVisitNumber")).thenReturn("2"); when(submission.getFieldValue("weight")).thenReturn("21"); when(submission.getFieldValue("bpDiastolic")).thenReturn("80"); when(submission.getFieldValue("bpSystolic")).thenReturn("90"); when(submission.getFieldValue("temperature")).thenReturn("98.5"); service.ancVisit(submission); verify(allTimelineEvents).add(TimelineEvent.forANCCareProvided("entity id 1", "2", "2013-01-01", create("bpDiastolic", "80").put("bpSystolic", "90").put("temperature", "98.5").put("weight", "21").map())); }
@Test public void shouldAddServiceProvidedWhenANCVisitHappens() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("ancVisitDate")).thenReturn("2013-01-01"); when(submission.getFieldValue("ancVisitNumber")).thenReturn("1"); when(submission.getFieldValue("weight")).thenReturn("21"); when(submission.getFieldValue("bpDiastolic")).thenReturn("80"); when(submission.getFieldValue("bpSystolic")).thenReturn("90"); service.ancVisit(submission); verify(serviceProvidedService).add( new ServiceProvided("entity id 1", "ANC 1", "2013-01-01", create("bpDiastolic", "80").put("bpSystolic", "90").put("weight", "21").map())); } |
### Question:
MotherService { public void ttProvided(FormSubmission submission) { allTimelines.add(forTTShotProvided(submission.entityId(), submission.getFieldValue(TT_DOSE), submission.getFieldValue(TT_DATE))); serviceProvidedService .add(forTTDose(submission.entityId(), submission.getFieldValue(TT_DOSE), submission.getFieldValue(TT_DATE))); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldHandleTTProvided() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("ttDose")).thenReturn("ttbooster"); when(submission.getFieldValue("ttDate")).thenReturn("2013-01-01"); service.ttProvided(submission); verify(allTimelineEvents).add(forTTShotProvided("entity id 1", "ttbooster", "2013-01-01")); verify(serviceProvidedService).add(new ServiceProvided("entity id 1", "TT Booster", "2013-01-01", mapOf("dose", "TT Booster"))); } |
### Question:
MotherService { public void ifaTabletsGiven(FormSubmission submission) { String numberOfIFATabletsGiven = submission.getFieldValue(NUMBER_OF_IFA_TABLETS_GIVEN); if (tryParse(numberOfIFATabletsGiven, 0) > 0) { allTimelines.add(forIFATabletsGiven(submission.entityId(), numberOfIFATabletsGiven, submission.getFieldValue(IFA_TABLETS_DATE))); serviceProvidedService.add(ServiceProvided .forIFATabletsGiven(submission.entityId(), numberOfIFATabletsGiven, submission.getFieldValue(IFA_TABLETS_DATE))); } } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldAddTimelineEventWhenIFATabletsAreGiven() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("numberOfIFATabletsGiven")).thenReturn("100"); when(submission.getFieldValue("ifaTabletsDate")).thenReturn("2013-02-01"); service.ifaTabletsGiven(submission); verify(allTimelineEvents).add(forIFATabletsGiven("entity id 1", "100", "2013-02-01")); }
@Test public void shouldAddServiceProvidedWhenIFATabletsAreGiven() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("numberOfIFATabletsGiven")).thenReturn("100"); when(submission.getFieldValue("ifaTabletsDate")).thenReturn("2013-02-01"); service.ifaTabletsGiven(submission); verify(serviceProvidedService).add(new ServiceProvided("entity id 1", "IFA", "2013-02-01", mapOf("dose", "100"))); }
@Test public void shouldDoNothingWhenIFATabletsAreNotGiven() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("numberOfIFATabletsGiven")).thenReturn("0"); when(submission.getFieldValue("ifaTabletsDate")).thenReturn("2013-02-01"); service.ifaTabletsGiven(submission); verifyZeroInteractions(allTimelineEvents); verifyZeroInteractions(serviceProvidedService); } |
### Question:
MotherService { public void hbTest(FormSubmission submission) { serviceProvidedService .add(forHBTest(submission.entityId(), submission.getFieldValue(HB_LEVEL), submission.getFieldValue(HB_TEST_DATE))); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldHandleHBTest() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("hbLevel")).thenReturn("11"); when(submission.getFieldValue("hbTestDate")).thenReturn("2013-01-01"); service.hbTest(submission); verify(serviceProvidedService).add(new ServiceProvided("entity id 1", "Hb Test", "2013-01-01", mapOf("hbLevel", "11"))); } |
### Question:
MotherService { public void deliveryOutcome(FormSubmission submission) { Mother mother = allBeneficiaries.findMotherWithOpenStatus(submission.entityId()); if (mother == null) { logWarn("Failed to handle delivery outcome for mother. Entity ID: " + submission .entityId()); return; } if (BOOLEAN_FALSE.equals(submission.getFieldValue(DID_WOMAN_SURVIVE)) || BOOLEAN_FALSE .equals(submission.getFieldValue(DID_MOTHER_SURVIVE))) { allBeneficiaries.closeMother(submission.entityId()); allEligibleCouples.close(mother.ecCaseId()); return; } allBeneficiaries.switchMotherToPNC(submission.entityId()); } MotherService(AllBeneficiaries allBeneficiaries, AllEligibleCouples
allEligibleCouples, AllTimelineEvents allTimelineEvents, ServiceProvidedService
serviceProvidedService); void registerANC(FormSubmission submission); void registerOutOfAreaANC(FormSubmission submission); void ancVisit(FormSubmission submission); void close(FormSubmission submission); void close(String entityId, String reason); void ttProvided(FormSubmission submission); void ifaTabletsGiven(FormSubmission submission); void hbTest(FormSubmission submission); void deliveryOutcome(FormSubmission submission); void pncVisitHappened(FormSubmission submission); void deliveryPlan(FormSubmission submission); static final String MOTHER_ID; static String submissionDate; }### Answer:
@Test public void shouldHandleDeliveryOutcome() throws Exception { FormSubmission submission = mock(FormSubmission.class); when(submission.entityId()).thenReturn("entity id 1"); when(submission.getFieldValue("didWomanSurvive")).thenReturn("yes"); when(allBeneficiaries.findMotherWithOpenStatus("entity id 1")).thenReturn(new Mother("entity id 1", "ec id 1", "1234567", "2014-01-01")); service.deliveryOutcome(submission); verify(allBeneficiaries).switchMotherToPNC("entity id 1"); } |
### Question:
SecurityHelper { public static char[] readValue(Editable editable) { char[] chars = new char[editable.length()]; editable.getChars(0, editable.length(), chars, 0); return chars; } static char[] readValue(Editable editable); static void clearArray(byte[] array); static void clearArray(char[] array); static byte[] toBytes(StringBuffer stringBuffer); static byte[] toBytes(char[] chars); static char[] toChars(byte[] bytes); static PasswordHash getPasswordHash(char[] password); static byte[] hashPassword(char[] password, byte[] salt); static byte[] nullSafeBase64Decode(String base64EncodedValue); static char[] generateRandomPassphrase(); static final int ITERATION_COUNT; }### Answer:
@Test public void testReadValueClearsEditableAfterReadingValue() { Mockito.doReturn(2).when(editable).length(); SecurityHelper.readValue(editable); ArgumentCaptor<Integer> lengthCaptor = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<char[]> charsCaptor = ArgumentCaptor.forClass(char[].class); ArgumentCaptor<Integer> firstArgCaptor = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<Integer> lastArgCaptor = ArgumentCaptor.forClass(Integer.class); Mockito.verify(editable).getChars(firstArgCaptor.capture(), lengthCaptor.capture(), charsCaptor.capture(), lastArgCaptor.capture()); Assert.assertEquals(2, lengthCaptor.getValue().intValue()); Assert.assertEquals(0, firstArgCaptor.getValue().intValue()); Assert.assertEquals(0, lastArgCaptor.getValue().intValue()); } |
### Question:
SecurityHelper { public static void clearArray(byte[] array) { if (array != null) { Arrays.fill(array, (byte) 0); } } static char[] readValue(Editable editable); static void clearArray(byte[] array); static void clearArray(char[] array); static byte[] toBytes(StringBuffer stringBuffer); static byte[] toBytes(char[] chars); static char[] toChars(byte[] bytes); static PasswordHash getPasswordHash(char[] password); static byte[] hashPassword(char[] password, byte[] salt); static byte[] nullSafeBase64Decode(String base64EncodedValue); static char[] generateRandomPassphrase(); static final int ITERATION_COUNT; }### Answer:
@Test public void clearArray() { byte[] sensitiveDataArray = SecurityHelper.toBytes(TEST_PASSWORD); SecurityHelper.clearArray(sensitiveDataArray); Assert.assertNotNull(sensitiveDataArray); for (byte c : sensitiveDataArray) { Assert.assertEquals((byte) 0, c); } }
@Test public void testClearArrayOverwritesCharArrayValuesWithAsterisk() { char[] sensitiveDataArray = TEST_PASSWORD; SecurityHelper.clearArray(sensitiveDataArray); Assert.assertNotNull(sensitiveDataArray); for (char c : sensitiveDataArray) { Assert.assertEquals('*', c); } } |
### Question:
SecurityHelper { public static byte[] toBytes(StringBuffer stringBuffer) throws CharacterCodingException { CharsetEncoder encoder = CHARSET.newEncoder(); CharBuffer buffer = CharBuffer.wrap(stringBuffer); ByteBuffer bytesBuffer = encoder.encode(buffer); byte[] bytes = bytesBuffer.array(); clearArray(bytesBuffer.array()); clearStringBuffer(stringBuffer); return bytes; } static char[] readValue(Editable editable); static void clearArray(byte[] array); static void clearArray(char[] array); static byte[] toBytes(StringBuffer stringBuffer); static byte[] toBytes(char[] chars); static char[] toChars(byte[] bytes); static PasswordHash getPasswordHash(char[] password); static byte[] hashPassword(char[] password, byte[] salt); static byte[] nullSafeBase64Decode(String base64EncodedValue); static char[] generateRandomPassphrase(); static final int ITERATION_COUNT; }### Answer:
@Test public void testToBytes() throws CharacterCodingException { StringBuffer stringBuffer = new StringBuffer(); stringBuffer.append(TEST_PASSWORD); byte[] testPasswordBytes = SecurityHelper.toBytes(stringBuffer); Assert.assertNotNull(testPasswordBytes); Assert.assertEquals(TEST_PASSWORD.length + 1, testPasswordBytes.length); } |
### Question:
SecurityHelper { public static byte[] nullSafeBase64Decode(String base64EncodedValue) { if (!StringUtils.isBlank(base64EncodedValue)) { return Base64.decode(base64EncodedValue, Base64.DEFAULT); } else { return null; } } static char[] readValue(Editable editable); static void clearArray(byte[] array); static void clearArray(char[] array); static byte[] toBytes(StringBuffer stringBuffer); static byte[] toBytes(char[] chars); static char[] toChars(byte[] bytes); static PasswordHash getPasswordHash(char[] password); static byte[] hashPassword(char[] password, byte[] salt); static byte[] nullSafeBase64Decode(String base64EncodedValue); static char[] generateRandomPassphrase(); static final int ITERATION_COUNT; }### Answer:
@Test public void nullSafeBase64DecodeDoesNotThrowExceptionIfParameterIsNull() { PowerMockito.mockStatic(Base64.class); PowerMockito.when(Base64.decode(ArgumentMatchers.anyString(), ArgumentMatchers.eq(Base64.DEFAULT))).thenReturn(new byte[]{0, 1}); byte[] decoded = SecurityHelper.nullSafeBase64Decode(null); Assert.assertNull(decoded); } |
### Question:
FormUtils { public JSONObject getFormJson(String formIdentity) { if (mContext != null) { try { String locale = mContext.getResources().getConfiguration().locale.getLanguage(); locale = locale.equalsIgnoreCase(Locale.ENGLISH.getLanguage()) ? "" : "-" + locale; InputStream inputStream; try { inputStream = mContext.getApplicationContext().getAssets() .open("json.form" + locale + "/" + formIdentity + AllConstants.JSON_FILE_EXTENSION); } catch (FileNotFoundException e) { inputStream = mContext.getApplicationContext().getAssets() .open("json.form/" + formIdentity + AllConstants.JSON_FILE_EXTENSION); } BufferedReader reader = new BufferedReader( new InputStreamReader(inputStream, CharEncoding.UTF_8)); String jsonString; StringBuilder stringBuilder = new StringBuilder(); while ((jsonString = reader.readLine()) != null) { stringBuilder.append(jsonString); } inputStream.close(); return new JSONObject(stringBuilder.toString()); } catch (IOException | JSONException e) { Timber.e(e); } } return null; } FormUtils(Context context); static FormUtils getInstance(Context ctx); static boolean hasChildElements(Node element); static int getIndexForFormName(String formName, String[] formNames); FormSubmission generateFormSubmisionFromXMLString(String entity_id, String formData,
String formName, JSONObject
overrides); String generateXMLInputForFormWithEntityId(String entityId, String formName, String
overrides); Object getObjectAtPath(String[] path, JSONObject jsonObject); JSONArray getPopulatedFieldsForArray(JSONObject fieldsDefinition, String entityId,
JSONObject jsonObject, JSONObject overrides); String retrieveValueForLinkedRecord(String link, JSONObject entityJson); JSONArray getFieldsArrayForSubFormDefinition(JSONObject fieldsDefinition); JSONObject getFieldValuesForSubFormDefinition(JSONObject fieldsDefinition, String
relationalId, String entityId, JSONObject jsonObject, JSONObject overrides); String getValueForPath(String[] path, JSONObject jsonObject); JSONObject getFormJson(String formIdentity); static final String TAG; static final String ecClientRelationships; }### Answer:
@Test public void getFormJsonShouldReturnCorrectFormWithSameLength() { Mockito.doReturn(RuntimeEnvironment.application.getResources()).when(context_).getResources(); Mockito.doReturn(RuntimeEnvironment.application.getApplicationContext()).when(context_).getApplicationContext(); Assert.assertEquals(10011, formUtils.getFormJson("test_basic_form").toString().length()); } |
### Question:
SecurityHelper { public static char[] generateRandomPassphrase() { return RandomStringUtils.randomAlphanumeric(PASSPHRASE_SIZE).toCharArray(); } static char[] readValue(Editable editable); static void clearArray(byte[] array); static void clearArray(char[] array); static byte[] toBytes(StringBuffer stringBuffer); static byte[] toBytes(char[] chars); static char[] toChars(byte[] bytes); static PasswordHash getPasswordHash(char[] password); static byte[] hashPassword(char[] password, byte[] salt); static byte[] nullSafeBase64Decode(String base64EncodedValue); static char[] generateRandomPassphrase(); static final int ITERATION_COUNT; }### Answer:
@Test public void testGenerateRandomPassphraseGeneratesAlphanumericArray() { char[] value = SecurityHelper.generateRandomPassphrase(); Assert.assertNotNull(value); Assert.assertTrue(StringUtils.isAlphanumeric(new StringBuilder().append(value).toString())); Assert.assertEquals(32, value.length); } |
### Question:
CoreLibrary implements OnAccountsUpdateListener { public void initP2pLibrary(@Nullable String username) { if (p2POptions != null && p2POptions.isEnableP2PLibrary()) { String p2pUsername = username; AllSharedPreferences allSharedPreferences = new AllSharedPreferences(getDefaultSharedPreferences(context.applicationContext())); if (p2pUsername == null) { p2pUsername = allSharedPreferences.fetchRegisteredANM(); } if (!TextUtils.isEmpty(p2pUsername)) { String teamId = allSharedPreferences.fetchDefaultTeamId(p2pUsername); if (p2POptions.getAuthorizationService() == null) { p2POptions.setAuthorizationService(new P2PSyncAuthorizationService(teamId)); } if (p2POptions.getReceiverTransferDao() == null) { p2POptions.setReceiverTransferDao(new P2PReceiverTransferDao()); } if (p2POptions.getSenderTransferDao() == null) { p2POptions.setSenderTransferDao(new P2PSenderTransferDao()); } if (p2POptions.getSyncFinishedCallback() == null) { p2POptions.setSyncFinishedCallback(new P2PSyncFinishCallback()); } P2PLibrary.Options options = new P2PLibrary.Options(context.applicationContext() , teamId, p2pUsername, p2POptions.getAuthorizationService(), p2POptions.getReceiverTransferDao() , p2POptions.getSenderTransferDao()); options.setBatchSize(p2POptions.getBatchSize()); options.setSyncFinishedCallback(p2POptions.getSyncFinishedCallback()); options.setRecalledIdentifier(p2POptions.getRecalledIdentifier()); P2PLibrary.init(options); } } } protected CoreLibrary(Context contextArg, SyncConfiguration syncConfiguration, @Nullable P2POptions p2POptions); static void init(Context context); static void init(Context context, SyncConfiguration syncConfiguration); static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp); static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp, @NonNull P2POptions options); static CoreLibrary getInstance(); void initP2pLibrary(@Nullable String username); Context context(); static void reset(Context context); static void reset(Context context, SyncConfiguration syncConfiguration); SyncConfiguration getSyncConfiguration(); AccountManager getAccountManager(); AccountAuthenticatorXml getAccountAuthenticatorXml(); static long getBuildTimeStamp(); String getEcClientFieldsFile(); void setEcClientFieldsFile(String ecClientFieldsFile); @Nullable P2POptions getP2POptions(); boolean isPeerToPeerProcessing(); void setPeerToPeerProcessing(boolean peerToPeerProcessing); @Override void onAccountsUpdated(Account[] accounts); }### Answer:
@Test public void initP2pLibrary() { String expectedUsername = "nurse1"; String expectedTeamIdPassword = "908980dslkjfljsdlf"; Mockito.doReturn(RuntimeEnvironment.application) .when(context) .applicationContext(); AllSharedPreferences allSharedPreferences = new AllSharedPreferences( PreferenceManager.getDefaultSharedPreferences(RuntimeEnvironment.application.getApplicationContext()) ); allSharedPreferences.updateANMUserName(expectedUsername); allSharedPreferences.saveDefaultTeamId(expectedUsername, expectedTeamIdPassword); P2PLibrary.Options p2POptions = new P2PLibrary.Options(context.applicationContext(), expectedTeamIdPassword, expectedUsername, p2PAuthorizationService, receiverTransferDao, senderTransferDao); P2PLibrary.init(p2POptions); P2PLibrary p2PLibrary = P2PLibrary.getInstance(); assertEquals(expectedUsername, p2PLibrary.getUsername()); } |
### Question:
CampaignRepository extends BaseRepository { public void addOrUpdate(Campaign campaign) { if (StringUtils.isBlank(campaign.getIdentifier())) throw new IllegalArgumentException("Identifier must be specified"); ContentValues contentValues = new ContentValues(); contentValues.put(ID, campaign.getIdentifier()); contentValues.put(TITLE, campaign.getTitle()); contentValues.put(DESCRIPTION, campaign.getDescription()); if (campaign.getStatus() != null) { contentValues.put(STATUS, campaign.getStatus().name()); } if (campaign.getExecutionPeriod() != null) { contentValues.put(START, DateUtil.getMillis(campaign.getExecutionPeriod().getStart())); contentValues.put(END, DateUtil.getMillis(campaign.getExecutionPeriod().getEnd())); } contentValues.put(AUTHORED_ON, DateUtil.getMillis(campaign.getAuthoredOn())); contentValues.put(LAST_MODIFIED, DateUtil.getMillis(campaign.getLastModified())); contentValues.put(OWNER, campaign.getOwner()); contentValues.put(SERVER_VERSION, campaign.getServerVersion()); getWritableDatabase().replace(CAMPAIGN_TABLE, null, contentValues); } static void createTable(SQLiteDatabase database); void addOrUpdate(Campaign campaign); List<Campaign> getAllCampaigns(); Campaign getCampaignByIdentifier(String identifier); }### Answer:
@Test public void testAddOrUpdateShouldAdd() { Campaign campaign = gson.fromJson(campaignJson, Campaign.class); campaignRepository.addOrUpdate(campaign); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(CAMPAIGN_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(10, contentValues.size()); assertEquals("IRS_2018_S1", contentValues.getAsString("_id")); assertEquals("2019 IRS Season 1", contentValues.getAsString("title")); assertEquals(IN_PROGRESS.name(), contentValues.getAsString("status")); }
@Test(expected = IllegalArgumentException.class) public void testAddOrUpdateShouldThrowException() { Campaign campaign = new Campaign(); campaignRepository.addOrUpdate(campaign); } |
### Question:
CampaignRepository extends BaseRepository { public List<Campaign> getAllCampaigns() { Cursor cursor = null; List<Campaign> campaigns = new ArrayList<>(); try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + CAMPAIGN_TABLE, null); while (cursor.moveToNext()) { campaigns.add(readCursor(cursor)); } cursor.close(); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return campaigns; } static void createTable(SQLiteDatabase database); void addOrUpdate(Campaign campaign); List<Campaign> getAllCampaigns(); Campaign getCampaignByIdentifier(String identifier); }### Answer:
@Test public void tesGetCampaignsAllCampaigns() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + CAMPAIGN_TABLE, null)).thenReturn(getCursor()); List<Campaign> allCampaigns = campaignRepository.getAllCampaigns(); verify(sqLiteDatabase).rawQuery("SELECT * FROM " + CAMPAIGN_TABLE, null); assertEquals(1, allCampaigns.size()); assertEquals(campaignJson, gson.toJson(allCampaigns.get(0))); } |
### Question:
CampaignRepository extends BaseRepository { public Campaign getCampaignByIdentifier(String identifier) { Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + CAMPAIGN_TABLE + " WHERE " + ID + " =?", new String[]{identifier}); if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return null; } static void createTable(SQLiteDatabase database); void addOrUpdate(Campaign campaign); List<Campaign> getAllCampaigns(); Campaign getCampaignByIdentifier(String identifier); }### Answer:
@Test public void testGetCampaignByIdentifier() { when(sqLiteDatabase.rawQuery("SELECT * FROM campaign WHERE _id =?", new String[]{"IRS_2018_S1"})).thenReturn(getCursor()); Campaign campaign = campaignRepository.getCampaignByIdentifier("IRS_2018_S1"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals(1, argsCaptor.getValue().length); assertEquals("IRS_2018_S1", argsCaptor.getValue()[0]); assertEquals("SELECT * FROM campaign WHERE _id =?", stringArgumentCaptor.getValue()); assertEquals(campaignJson, gson.toJson(campaign)); } |
### Question:
TaskNotesRepository extends BaseRepository { public void addOrUpdate(Note note, String taskId) { if (StringUtils.isBlank(taskId)) { throw new IllegalArgumentException("taskId must be specified"); } ContentValues contentValues = new ContentValues(); contentValues.put(TASK_ID, taskId); contentValues.put(AUTHOR, note.getAuthorString()); contentValues.put(TIME, note.getTime().getMillis()); contentValues.put(TEXT, note.getText()); getWritableDatabase().replace(TASK_NOTES_TABLE, null, contentValues); } static void createTable(SQLiteDatabase database); void addOrUpdate(Note note, String taskId); List<Note> getNotesByTask(String taskId); }### Answer:
@Test public void testAddOrUpdateShouldAdd() { Note note = new Note(); note.setText("Should be completed by End of November"); Long now = System.currentTimeMillis(); note.setTime(new DateTime(now)); note.setAuthorString("jdoe"); taskNotesRepository.addOrUpdate(note, "task22132"); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(TASK_NOTES_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(4, contentValues.size()); assertEquals("task22132", contentValues.getAsString("task_id")); assertEquals("Should be completed by End of November", contentValues.getAsString("text")); assertEquals("jdoe", contentValues.getAsString("author")); assertEquals(now, contentValues.getAsLong("time")); } |
### Question:
TaskNotesRepository extends BaseRepository { public List<Note> getNotesByTask(String taskId) { List<Note> notes = new ArrayList<>(); Cursor cursor = null; try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + TASK_NOTES_TABLE + " WHERE " + TASK_ID + " =?", new String[]{taskId}); while (cursor.moveToNext()) { notes.add(readCursor(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return notes; } static void createTable(SQLiteDatabase database); void addOrUpdate(Note note, String taskId); List<Note> getNotesByTask(String taskId); }### Answer:
@Test public void tesGetTasksAllTasks() { when(sqLiteDatabase.rawQuery("SELECT * FROM task_note WHERE task_id =?", new String[]{"task22132"})).thenReturn(getCursor()); List<Note> notes = taskNotesRepository.getNotesByTask("task22132"); verify(sqLiteDatabase).rawQuery("SELECT * FROM task_note WHERE task_id =?", new String[]{"task22132"}); assertEquals(1, notes.size()); assertEquals("Should be completed by End of November", notes.get(0).getText()); assertEquals("jdoe", notes.get(0).getAuthorString()); assertEquals(1543232476345l, notes.get(0).getTime().getMillis()); } |
### Question:
TaskRepository extends BaseRepository { public void addOrUpdate(Task task) { addOrUpdate(task, false); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testAddOrUpdateShouldAdd() { Task task = gson.fromJson(taskJson, Task.class); taskRepository.addOrUpdate(task); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(TASK_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(21, contentValues.size()); assertEquals("tsk11231jh22", contentValues.getAsString("_id")); assertEquals("IRS_2018_S1", contentValues.getAsString("plan_id")); assertEquals("2018_IRS-3734", contentValues.getAsString("group_id")); verify(taskNotesRepository).addOrUpdate(task.getNotes().get(0), task.getIdentifier()); }
@Test(expected = IllegalArgumentException.class) public void testAddOrUpdateShouldThrowException() { Task task = new Task(); taskRepository.addOrUpdate(task); } |
### Question:
FormUtils { public static int getIndexForFormName(String formName, String[] formNames) { for (int i = 0; i < formNames.length; i++) { if (formName.equalsIgnoreCase(formNames[i])) { return i; } } return -1; } FormUtils(Context context); static FormUtils getInstance(Context ctx); static boolean hasChildElements(Node element); static int getIndexForFormName(String formName, String[] formNames); FormSubmission generateFormSubmisionFromXMLString(String entity_id, String formData,
String formName, JSONObject
overrides); String generateXMLInputForFormWithEntityId(String entityId, String formName, String
overrides); Object getObjectAtPath(String[] path, JSONObject jsonObject); JSONArray getPopulatedFieldsForArray(JSONObject fieldsDefinition, String entityId,
JSONObject jsonObject, JSONObject overrides); String retrieveValueForLinkedRecord(String link, JSONObject entityJson); JSONArray getFieldsArrayForSubFormDefinition(JSONObject fieldsDefinition); JSONObject getFieldValuesForSubFormDefinition(JSONObject fieldsDefinition, String
relationalId, String entityId, JSONObject jsonObject, JSONObject overrides); String getValueForPath(String[] path, JSONObject jsonObject); JSONObject getFormJson(String formIdentity); static final String TAG; static final String ecClientRelationships; }### Answer:
@Test public void getIndexForFormNameShouldReturnCorrectIndex() { String[] formNames = new String[] {"Birth Reg", "Immunisation Reg", "Death Form"}; Assert.assertEquals(1, formUtils.getIndexForFormName("Immunisation Reg", formNames)); } |
### Question:
TaskRepository extends BaseRepository { public Task getTaskByIdentifier(String identifier) { try (Cursor cursor = getReadableDatabase().rawQuery("SELECT * FROM " + TASK_TABLE + " WHERE " + ID + " =?", new String[]{identifier})) { if (cursor.moveToFirst()) { return readCursor(cursor); } } catch (Exception e) { Timber.e(e); } return null; } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testGetTaskByIdentifier() { when(sqLiteDatabase.rawQuery("SELECT * FROM task WHERE _id =?", new String[]{"tsk11231jh22"})).thenReturn(getCursor()); Task task = taskRepository.getTaskByIdentifier("tsk11231jh22"); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM task WHERE _id =?", stringArgumentCaptor.getValue()); assertEquals(1, argsCaptor.getValue().length); assertEquals("tsk11231jh22", argsCaptor.getValue()[0]); assertEquals("tsk11231jh22", task.getIdentifier()); assertEquals("2018_IRS-3734", task.getGroupIdentifier()); assertEquals(READY, task.getStatus()); assertEquals("Not Visited", task.getBusinessStatus()); assertEquals(3, task.getPriority()); assertEquals("IRS", task.getCode()); assertEquals("Spray House", task.getDescription()); assertEquals("IRS Visit", task.getFocus()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", task.getForEntity()); assertEquals("2018-11-10T2200", task.getExecutionStartDate().toString(formatter)); assertNull(task.getExecutionEndDate()); assertEquals("2018-10-31T0700", task.getAuthoredOn().toString(formatter)); assertEquals("2018-10-31T0700", task.getLastModified().toString(formatter)); assertEquals("demouser", task.getOwner()); } |
### Question:
TaskRepository extends BaseRepository { public List<TaskUpdate> getUnSyncedTaskStatus() { Cursor cursor = null; List<TaskUpdate> taskUpdates = new ArrayList<>(); try { cursor = getReadableDatabase().rawQuery(String.format("SELECT " + ID + "," + STATUS + "," + BUSINESS_STATUS + "," + SERVER_VERSION + " FROM %s WHERE %s =?", TASK_TABLE, SYNC_STATUS), new String[]{BaseRepository.TYPE_Unsynced}); while (cursor.moveToNext()) { taskUpdates.add(readUpdateCursor(cursor)); } } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return taskUpdates; } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testGetUnSyncedTaskStatus() { taskRepository.getUnSyncedTaskStatus(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertNotNull(taskRepository.getUnSyncedTaskStatus()); } |
### Question:
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute) { if (clients == null || clients.isEmpty()) { return false; } SQLiteStatement updateStatement = null; try { getWritableDatabase().beginTransaction(); String updateTaskSructureIdQuery = String.format("UPDATE %s SET %s = ? WHERE %s = ? AND %s IS NULL", TASK_TABLE, STRUCTURE_ID, FOR, STRUCTURE_ID); updateStatement = getWritableDatabase().compileStatement(updateTaskSructureIdQuery); for (Client client : clients) { String taskFor = client.getBaseEntityId(); if (client.getAttribute(attribute) == null) { continue; } String structureId = client.getAttribute(attribute).toString(); updateStatement.bindString(1, structureId); updateStatement.bindString(2, taskFor); updateStatement.executeUpdateDelete(); } getWritableDatabase().setTransactionSuccessful(); getWritableDatabase().endTransaction(); return true; } catch (SQLException e) { Timber.e(e); getWritableDatabase().endTransaction(); return false; } finally { if (updateStatement != null) updateStatement.close(); } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testUpdateTaskStructureIdFromClient() throws Exception { List<Client> clients = new ArrayList<>(); Client client = gson.fromJson(clientJson, Client.class); clients.add(client); taskRepository.updateTaskStructureIdFromClient(clients, ""); assertNotNull(taskRepository.getUnSyncedTaskStatus()); } |
### Question:
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdFromStructure(List<Location> locations) { if (locations == null || locations.isEmpty()) { return false; } SQLiteStatement updateStatement = null; try { getWritableDatabase().beginTransaction(); String updateTaskSructureIdQuery = String.format("UPDATE %s SET %s = ? WHERE %s = ? AND %s IS NULL", TASK_TABLE, STRUCTURE_ID, FOR, STRUCTURE_ID); updateStatement = getWritableDatabase().compileStatement(updateTaskSructureIdQuery); for (Location location : locations) { updateStatement.bindString(1, location.getId()); updateStatement.bindString(2, location.getId()); updateStatement.executeUpdateDelete(); } getWritableDatabase().setTransactionSuccessful(); getWritableDatabase().endTransaction(); return true; } catch (SQLException e) { Timber.e(e); getWritableDatabase().endTransaction(); return false; } finally { if (updateStatement != null) updateStatement.close(); } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void updateTaskStructureIdFromStructure() throws Exception { List<Location> locations = new ArrayList<>(); Location location = gson.fromJson(structureJson, Location.class); locations.add(location); taskRepository.updateTaskStructureIdFromStructure(locations); assertTrue(taskRepository.updateTaskStructureIdFromStructure(locations)); } |
### Question:
TaskRepository extends BaseRepository { public void cancelTasksForEntity(@NonNull String entityId) { if (StringUtils.isBlank(entityId)) return; ContentValues contentValues = new ContentValues(); contentValues.put(STATUS, TaskStatus.CANCELLED.name()); contentValues.put(SYNC_STATUS, BaseRepository.TYPE_Unsynced); getWritableDatabase().update(TASK_TABLE, contentValues, String.format("%s = ? AND %s =?", FOR, STATUS), new String[]{entityId, TaskStatus.READY.name()}); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testCancelTasksForEntity() { taskRepository.cancelTasksForEntity("id1"); verify(sqLiteDatabase).update(eq(TASK_TABLE), contentValuesArgumentCaptor.capture(), eq("for = ? AND status =?"), eq(new String[]{"id1", READY.name()})); assertEquals(BaseRepository.TYPE_Unsynced, contentValuesArgumentCaptor.getValue().getAsString("sync_status")); assertEquals(CANCELLED.name(), contentValuesArgumentCaptor.getValue().getAsString("status")); assertEquals(2, contentValuesArgumentCaptor.getValue().size()); }
@Test public void testCancelTasksForEntityWithNullParams() { taskRepository.cancelTasksForEntity(null); verify(sqLiteDatabase, never()).update(any(), any(), any(), any()); verifyZeroInteractions(sqLiteDatabase); } |
### Question:
TaskRepository extends BaseRepository { public void archiveTasksForEntity(@NonNull String entityId) { if (StringUtils.isBlank(entityId)) return; ContentValues contentValues = new ContentValues(); contentValues.put(STATUS, TaskStatus.ARCHIVED.name()); contentValues.put(SYNC_STATUS, BaseRepository.TYPE_Unsynced); getWritableDatabase().update(TASK_TABLE, contentValues, String.format("%s = ? AND %s NOT IN (?,?)", FOR, STATUS), new String[]{entityId, TaskStatus.READY.name(), TaskStatus.CANCELLED.name()}); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testArchiveTasksForEntity() { taskRepository.archiveTasksForEntity("id1"); verify(sqLiteDatabase).update(eq(TASK_TABLE), contentValuesArgumentCaptor.capture(), eq("for = ? AND status NOT IN (?,?)"), eq(new String[]{"id1", READY.name(), CANCELLED.name()})); assertEquals(BaseRepository.TYPE_Unsynced, contentValuesArgumentCaptor.getValue().getAsString("sync_status")); assertEquals(ARCHIVED.name(), contentValuesArgumentCaptor.getValue().getAsString("status")); assertEquals(2, contentValuesArgumentCaptor.getValue().size()); }
@Test public void testArchiveTasksForEntityWithNullParams() { taskRepository.archiveTasksForEntity(null); verifyZeroInteractions(sqLiteDatabase); } |
### Question:
OpenSRPImageLoader extends ImageLoader { private static RequestQueue newRequestQueue(Context context) { RequestQueue requestQueue; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { HurlStack stack = new HurlStack() { @Override public HttpResponse performRequest(Request<?> request, Map<String, String> headers) throws IOException, AuthFailureError { addBearerTokenAuthorizationHeader(headers); return super.performRequest(request, headers); } }; requestQueue = Volley.newRequestQueue(context, stack); } else { HttpClientStack stack = new HttpClientStack( AndroidHttpClient.newInstance(FileUtilities.getUserAgent(context))) { @Override public HttpResponse performRequest(Request<?> request, Map<String, String> headers) throws IOException, AuthFailureError { addBearerTokenAuthorizationHeader(headers); return super.performRequest(request, headers); } }; requestQueue = Volley.newRequestQueue(context, stack); } return requestQueue; } OpenSRPImageLoader(FragmentActivity activity); OpenSRPImageLoader(Service service, int defaultPlaceHolderResId); OpenSRPImageLoader(Context context, int defaultPlaceHolderResId); OpenSRPImageLoader(FragmentActivity activity, int defaultPlaceHolderResId); OpenSRPImageLoader(FragmentActivity activity, ArrayList<Drawable> placeHolderDrawables); static File getDiskCacheDir(Context context, String uniqueName); static OpenSRPImageListener getStaticImageListener(ImageView view, int
defaultImageResId, int errorImageResId); static void saveStaticImageToDisk(String entityId, Bitmap image); static boolean moveSyncedImageAndSaveProfilePic(@NonNull String syncStatus, @NonNull String entityId, @NonNull File imageFile); static boolean copyFile(File src, File dst); OpenSRPImageLoader setFadeInImage(boolean fadeInImage); OpenSRPImageLoader setMaxImageSize(int maxImageWidth, int maxImageHeight); OpenSRPImageLoader setMaxImageSize(int maxImageSize); void getImageByClientId(String entityId, OpenSRPImageListener opensrpImageListener); void get(final ProfileImage image, final OpenSRPImageListener opensrpImageListener); ImageContainer get(String requestUrl, ImageView imageView); ImageContainer get(String requestUrl, ImageView imageView, int placeHolderIndex); ImageContainer get(String requestUrl, ImageView imageView, Drawable placeHolder); ImageContainer get(String requestUrl, ImageView imageView, Drawable placeHolder, int
maxWidth, int maxHeight); }### Answer:
@Test public void assertServiceConstructorInitializationNotNull() throws Exception { PowerMockito.mockStatic(Volley.class); PowerMockito.when(Volley.newRequestQueue(Mockito.any(android.content.Context.class), Mockito.any(HurlStack.class))).thenReturn(Mockito.mock(RequestQueue.class)); OpenSRPImageLoader openSRPImageLoader = new OpenSRPImageLoader(Mockito.mock(Service.class), -1); Assert.assertNotNull(openSRPImageLoader); } |
### Question:
TaskRepository extends BaseRepository { protected TaskUpdate readUpdateCursor(Cursor cursor) { TaskUpdate taskUpdate = new TaskUpdate(); taskUpdate.setIdentifier(cursor.getString(cursor.getColumnIndex(ID))); if (cursor.getString(cursor.getColumnIndex(STATUS)) != null) { taskUpdate.setStatus(cursor.getString(cursor.getColumnIndex(STATUS))); } if (cursor.getString(cursor.getColumnIndex(BUSINESS_STATUS)) != null) { taskUpdate.setBusinessStatus(cursor.getString(cursor.getColumnIndex(BUSINESS_STATUS))); } if (cursor.getString(cursor.getColumnIndex(SERVER_VERSION)) != null) { taskUpdate.setServerVersion(cursor.getString(cursor.getColumnIndex(SERVER_VERSION))); } return taskUpdate; } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testReadUpdateCursor() { MatrixCursor cursor = getCursor(); cursor.moveToNext(); String expectedIdentifier = cursor.getString(cursor.getColumnIndex("_id")); String expectedStatus = cursor.getString(cursor.getColumnIndex("status")); String expectedBusinessStatus = cursor.getString(cursor.getColumnIndex("business_status")); String expectedServerVersion = cursor.getString(cursor.getColumnIndex("server_version")); TaskUpdate returnedTaskUpdate = taskRepository.readUpdateCursor(cursor); assertNotNull(returnedTaskUpdate); assertEquals(expectedIdentifier, returnedTaskUpdate.getIdentifier()); assertEquals(expectedStatus, returnedTaskUpdate.getStatus()); assertEquals(expectedBusinessStatus, returnedTaskUpdate.getBusinessStatus()); assertEquals(expectedServerVersion, returnedTaskUpdate.getServerVersion()); } |
### Question:
TaskRepository extends BaseRepository { public void markTaskAsSynced(String taskID) { try { ContentValues values = new ContentValues(); values.put(TaskRepository.ID, taskID); values.put(TaskRepository.SYNC_STATUS, BaseRepository.TYPE_Synced); values.put(TaskRepository.SERVER_VERSION, 0); getWritableDatabase().update(TaskRepository.TASK_TABLE, values, TaskRepository.ID + " = ?", new String[]{taskID}); } catch (Exception e) { Timber.e(e); } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testMarkTaskAsSynced() { String expectedTaskIdentifier = "id1"; taskRepository.markTaskAsSynced(expectedTaskIdentifier); verify(sqLiteDatabase).update(stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture(), stringArgumentCaptor.capture(), stringArrayArgumentCaptor.capture()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(TaskRepository.TASK_TABLE, iterator.next()); assertEquals("_id = ?", iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(3, contentValues.size()); assertEquals(expectedTaskIdentifier, contentValues.getAsString("_id")); assertEquals(BaseRepository.TYPE_Synced, contentValues.getAsString("sync_status")); assertEquals(0, contentValues.getAsInteger("server_version").intValue()); String actualTaskIdentifier = stringArrayArgumentCaptor.getAllValues().get(0)[0]; assertEquals(expectedTaskIdentifier, actualTaskIdentifier); } |
### Question:
TaskRepository extends BaseRepository { public List<Task> getAllUnsynchedCreatedTasks() { return new ArrayList<>(getTasks(String.format("SELECT * FROM %s WHERE %s =? OR %s IS NULL", TASK_TABLE, SYNC_STATUS, SERVER_VERSION), new String[]{BaseRepository.TYPE_Created})); } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testGetAllUnSyncedCreatedTasks() { when(sqLiteDatabase.rawQuery("SELECT * FROM task WHERE sync_status =? OR server_version IS NULL", new String[]{BaseRepository.TYPE_Created})).thenReturn(getCursor()); List<Task> unsyncedCreatedTasks = taskRepository.getAllUnsynchedCreatedTasks(); assertEquals(1, unsyncedCreatedTasks.size()); Task actualTask = unsyncedCreatedTasks.get(0); assertEquals("tsk11231jh22", actualTask.getIdentifier()); assertEquals("2018_IRS-3734", actualTask.getGroupIdentifier()); assertEquals(READY, actualTask.getStatus()); assertEquals("Not Visited", actualTask.getBusinessStatus()); assertEquals(3, actualTask.getPriority()); assertEquals("IRS", actualTask.getCode()); assertEquals("Spray House", actualTask.getDescription()); assertEquals("IRS Visit", actualTask.getFocus()); assertEquals("location.properties.uid:41587456-b7c8-4c4e-b433-23a786f742fc", actualTask.getForEntity()); assertEquals("2018-11-10T2200", actualTask.getExecutionStartDate().toString(formatter)); assertNull(actualTask.getExecutionEndDate()); assertEquals("2018-10-31T0700", actualTask.getAuthoredOn().toString(formatter)); assertEquals("2018-10-31T0700", actualTask.getLastModified().toString(formatter)); assertEquals("demouser", actualTask.getOwner()); } |
### Question:
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdsFromExistingStructures() { try { getReadableDatabase().execSQL(String.format("UPDATE %s SET %s =(SELECT %s FROM structure WHERE %s = %s) WHERE %s IS NULL", TASK_TABLE, STRUCTURE_ID, ID, ID, FOR, STRUCTURE_ID)); return true; } catch (Exception e) { Timber.e(e); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testUpdateTaskStructureIdsFromExistingStructures() { String expectedSql = "UPDATE task SET structure_id =(SELECT _id FROM structure WHERE _id = for) WHERE structure_id IS NULL"; boolean updated = taskRepository.updateTaskStructureIdsFromExistingStructures(); assertTrue(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); }
@Test public void testUpdateTaskStructureIdsFromExistingStructuresFailure() { String expectedSql = "UPDATE task SET structure_id =(SELECT _id FROM structure WHERE _id = for) WHERE structure_id IS NULL"; doThrow(new SQLiteException()).when(sqLiteDatabase).execSQL(anyString()); boolean updated = taskRepository.updateTaskStructureIdsFromExistingStructures(); assertFalse(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); } |
### Question:
TaskRepository extends BaseRepository { public boolean updateTaskStructureIdsFromExistingClients(String clientTable) { try { getReadableDatabase().execSQL(String.format("UPDATE %s SET %s =(SELECT %s FROM %s WHERE base_entity_id = %s) WHERE %s IS NULL", TASK_TABLE, STRUCTURE_ID, STRUCTURE_ID, clientTable, FOR, STRUCTURE_ID)); return true; } catch (Exception e) { Timber.e(e); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testUpdateTaskStructureIdsfromExistingClients() { String expectedSql = "UPDATE task SET structure_id =(SELECT structure_id FROM ec_family_member WHERE base_entity_id = for) WHERE structure_id IS NULL"; String clientTable = "ec_family_member"; boolean updated = taskRepository.updateTaskStructureIdsFromExistingClients(clientTable); assertTrue(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); }
@Test public void testUpdateTaskStructureIdsfromExistingClientsFailure() { String expectedSql = "UPDATE task SET structure_id =(SELECT structure_id FROM ec_family_member WHERE base_entity_id = for) WHERE structure_id IS NULL"; String clientTable = "ec_family_member"; doThrow(new SQLiteException()).when(sqLiteDatabase).execSQL(anyString()); boolean updated = taskRepository.updateTaskStructureIdsFromExistingClients(clientTable); assertFalse(updated); verify(sqLiteDatabase).execSQL(stringArgumentCaptor.capture()); assertEquals(expectedSql, stringArgumentCaptor.getValue()); } |
### Question:
TaskRepository extends BaseRepository { public boolean batchInsertTasks(JSONArray array) { if (array == null || array.length() == 0) { return false; } try { getWritableDatabase().beginTransaction(); for (int i = 0; i < array.length(); i++) { JSONObject jsonObject = array.getJSONObject(i); Task task = TaskServiceHelper.taskGson.fromJson(jsonObject.toString(), Task.class); addOrUpdate(task); } getWritableDatabase().setTransactionSuccessful(); getWritableDatabase().endTransaction(); return true; } catch (Exception e) { Timber.e(e, "EXCEPTION %s", e.toString()); getWritableDatabase().endTransaction(); return false; } } TaskRepository(TaskNotesRepository taskNotesRepository); static void createTable(SQLiteDatabase database); void addOrUpdate(Task task); void addOrUpdate(Task task, boolean updateOnly); Map<String, Set<Task>> getTasksByPlanAndGroup(String planId, String groupId); Task getTaskByIdentifier(String identifier); Set<Task> getTasksByEntityAndCode(String planId, String groupId, String forEntity, String code); Set<Task> getTasksByPlanAndEntity(String planId, String forEntity); Set<Task> getTasksByEntity(String forEntity); Set<Task> getTasksByEntityAndStatus(String planId, String forEntity, TaskStatus taskStatus); Task readCursor(Cursor cursor); List<TaskUpdate> getUnSyncedTaskStatus(); void markTaskAsSynced(String taskID); List<Task> getAllUnsynchedCreatedTasks(); boolean updateTaskStructureIdFromClient(List<Client> clients, String attribute); boolean updateTaskStructureIdFromStructure(List<Location> locations); boolean updateTaskStructureIdsFromExistingStructures(); boolean updateTaskStructureIdsFromExistingClients(String clientTable); boolean batchInsertTasks(JSONArray array); @Nullable JsonData getTasks(long lastRowId, int limit, String jurisdictionId); void cancelTasksForEntity(@NonNull String entityId); void archiveTasksForEntity(@NonNull String entityId); int getUnsyncedCreatedTasksAndTaskStatusCount(); }### Answer:
@Test public void testBatchInsertTasks() throws Exception { Task expectedTask = gson.fromJson(taskJson, Task.class); JSONArray taskArray = new JSONArray().put(new JSONObject(taskJson)); taskRepository = spy(taskRepository); boolean inserted = taskRepository.batchInsertTasks(taskArray); verify(sqLiteDatabase).beginTransaction(); verify(sqLiteDatabase).setTransactionSuccessful(); verify(sqLiteDatabase).endTransaction(); assertTrue(inserted); verify(taskRepository).addOrUpdate(taskArgumentCaptor.capture()); assertEquals(expectedTask.getIdentifier(), taskArgumentCaptor.getValue().getIdentifier()); assertEquals(expectedTask.getStatus(), taskArgumentCaptor.getValue().getStatus()); assertEquals(expectedTask.getBusinessStatus(), taskArgumentCaptor.getValue().getBusinessStatus()); assertEquals(expectedTask.getCode(), taskArgumentCaptor.getValue().getCode()); assertEquals(expectedTask.getForEntity(), taskArgumentCaptor.getValue().getForEntity()); } |
### Question:
AllSettings { public void savePreviousFetchIndex(String value) { settingsRepository.updateSetting(PREVIOUS_FETCH_INDEX_SETTING_KEY, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldSavePreviousFetchIndex() throws Exception { allSettings.savePreviousFetchIndex("1234"); Mockito.verify(settingsRepository).updateSetting("previousFetchIndex", "1234"); } |
### Question:
AllSettings { public String fetchPreviousFetchIndex() { return settingsRepository.querySetting(PREVIOUS_FETCH_INDEX_SETTING_KEY, "0"); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldFetchPreviousFetchIndex() throws Exception { Mockito.when(settingsRepository.querySetting("previousFetchIndex", "0")).thenReturn("1234"); String actual = allSettings.fetchPreviousFetchIndex(); Mockito.verify(settingsRepository).querySetting("previousFetchIndex", "0"); Assert.assertEquals("1234", actual); } |
### Question:
AllSettings { public void savePreviousFormSyncIndex(String value) { settingsRepository.updateSetting(PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldSavePreviousFormSyncIndex() throws Exception { allSettings.savePreviousFormSyncIndex("1234"); Mockito.verify(settingsRepository).updateSetting("previousFormSyncIndex", "1234"); } |
### Question:
AllSettings { public String fetchPreviousFormSyncIndex() { return settingsRepository.querySetting(PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY, "0"); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldFetchPreviousFormSyncIndex() throws Exception { Mockito.when(settingsRepository.querySetting("previousFormSyncIndex", "0")).thenReturn("1234"); String actual = allSettings.fetchPreviousFormSyncIndex(); Mockito.verify(settingsRepository).querySetting("previousFormSyncIndex", "0"); Assert.assertEquals("1234", actual); } |
### Question:
AllSettings { public void saveAppliedVillageFilter(String village) { settingsRepository.updateSetting(APPLIED_VILLAGE_FILTER_SETTING_KEY, village); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldSaveAppliedVillageFilter() throws Exception { allSettings.saveAppliedVillageFilter("munjanahalli"); Mockito.verify(settingsRepository).updateSetting("appliedVillageFilter", "munjanahalli"); } |
### Question:
AllSettings { public String appliedVillageFilter(String defaultFilterValue) { return settingsRepository .querySetting(APPLIED_VILLAGE_FILTER_SETTING_KEY, defaultFilterValue); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void shouldGetAppliedVillageFilter() throws Exception { allSettings.appliedVillageFilter("All"); Mockito.verify(settingsRepository).querySetting("appliedVillageFilter", "All"); } |
### Question:
AllSettings { public void registerANM(String userName) { preferences.updateANMUserName(userName); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void assertRegisterANMCallsPreferenceAndRepositoryUpdate() throws Exception { Mockito.doNothing().when(allSharedPreferences).updateANMUserName(Mockito.anyString()); allSettings.registerANM(""); Mockito.verify(allSharedPreferences, Mockito.times(1)).updateANMUserName(Mockito.anyString()); } |
### Question:
AllSettings { public void saveANMLocation(String anmLocation) { settingsRepository.updateSetting(ANM_LOCATION, anmLocation); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void assertSaveANMLocationCallsRepositoryUpdate() { Mockito.doNothing().doNothing().when(settingsRepository).updateSetting(Mockito.anyString(), Mockito.anyString()); allSettings.saveANMLocation(""); Mockito.verify(settingsRepository, Mockito.times(1)).updateSetting(Mockito.anyString(), Mockito.anyString()); } |
### Question:
AllSettings { public String fetchANMLocation() { return settingsRepository.querySetting(ANM_LOCATION, ""); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void assertFetchANMLocationCallsRepositoryQuery() { Mockito.when(settingsRepository.querySetting(Mockito.anyString(), Mockito.anyString())).thenReturn(""); Assert.assertEquals(allSettings.fetchANMLocation(), ""); Mockito.verify(settingsRepository, Mockito.times(1)).querySetting(Mockito.anyString(), Mockito.anyString()); } |
### Question:
AllSettings { public String fetchUserInformation() { return settingsRepository.querySetting(USER_INFORMATION, ""); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void assertFetchUserInformationCallsRepositoryQuery() { Mockito.when(settingsRepository.querySetting(Mockito.anyString(), Mockito.anyString())).thenReturn(""); Assert.assertEquals(allSettings.fetchUserInformation(), ""); Mockito.verify(settingsRepository, Mockito.times(1)).querySetting(Mockito.anyString(), Mockito.anyString()); } |
### Question:
AllSettings { public void saveUserInformation(String userInformation) { settingsRepository.updateSetting(USER_INFORMATION, userInformation); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void assertSaveUserInformationCallsRepositoryUpdate() { Mockito.doNothing().doNothing().when(settingsRepository).updateSetting(Mockito.anyString(), Mockito.anyString()); allSettings.saveUserInformation(""); Mockito.verify(settingsRepository, Mockito.times(1)).updateSetting(Mockito.anyString(), Mockito.anyString()); } |
### Question:
AllSettings { public String get(String key) { return get(key, null); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testGetWithDefaultShouldReturnCorrectValue() { SettingsRepository settingsRepository = spy(new SettingsRepository()); allSettings = new AllSettings(allSharedPreferences, settingsRepository); String value = allSettings.get("non_existent_key", "default_value"); assertEquals("default_value", value); doReturn("value").when(settingsRepository).querySetting(eq("my_key"), any()); value = allSettings.get("my_key"); assertEquals("value", value); }
@Test public void testGet() { Mockito.when(settingsRepository.querySetting("testKey", null)).thenReturn("testValue"); String val = allSettings.get("testKey"); Mockito.verify(settingsRepository).querySetting("testKey", null); Assert.assertEquals("testValue", val); } |
### Question:
AllSettings { public void put(String key, String value) { settingsRepository.updateSetting(key, value); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testPut() { allSettings.put("testKey", "testValue"); Mockito.verify(settingsRepository).updateSetting("testKey", "testValue"); } |
### Question:
AllSettings { public Setting getSetting(String key) { return settingsRepository.querySetting(key); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testGetSetting() { Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); Mockito.when(settingsRepository.querySetting("testKey")).thenReturn(s); Setting setting = allSettings.getSetting("testKey"); Mockito.verify(settingsRepository).querySetting("testKey"); Assert.assertEquals("testKey", setting.getKey()); Assert.assertEquals("testValue", setting.getValue()); } |
### Question:
AllSettings { public List<Setting> getSettingsByType(String type) { return settingsRepository.querySettingsByType(type); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testGetSettingsByType() { List<Setting> ls = new ArrayList<>(); Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); ls.add(s); Setting s2 = new Setting(); s2.setKey("testKey2"); s2.setValue("testValue2"); ls.add(s2); Mockito.when(settingsRepository.querySettingsByType("testType")).thenReturn(ls); List<Setting> settings = allSettings.getSettingsByType("testType"); Mockito.verify(settingsRepository).querySettingsByType("testType"); Assert.assertEquals("testKey", settings.get(0).getKey()); Assert.assertEquals("testValue", settings.get(0).getValue()); } |
### Question:
AllSettings { public void putSetting(Setting setting) { settingsRepository.updateSetting(setting); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testPutSetting() { Setting s = new Setting(); s.setKey("testKey"); s.setValue("testValue"); allSettings.putSetting(s); Mockito.verify(settingsRepository).updateSetting(s); } |
### Question:
AllSettings { public List<Setting> getUnsyncedSettings() { return settingsRepository.queryUnsyncedSettings(); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testGetUnsyncedSettings() { List<Setting> ls = new ArrayList<>(); Setting s = new Setting(); s.setKey("testUnsyncedKey"); s.setValue("testUnsyncedValue"); ls.add(s); Mockito.when(settingsRepository.queryUnsyncedSettings()).thenReturn(ls); List<Setting> settings = allSettings.getUnsyncedSettings(); Mockito.verify(settingsRepository).queryUnsyncedSettings(); Assert.assertEquals("testUnsyncedKey", settings.get(0).getKey()); Assert.assertEquals("testUnsyncedValue", settings.get(0).getValue()); } |
### Question:
AllSettings { public AllSharedPreferences getPreferences() { return preferences; } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testGetPreferences() { assertEquals(allSharedPreferences, allSettings.getPreferences()); } |
### Question:
AllSettings { public String fetchRegisteredANM() { return preferences.fetchRegisteredANM(); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testFetchRegisteredANMShouldReturnCorrectProvider() { doReturn("provider").when(allSharedPreferences).fetchRegisteredANM(); assertEquals("provider", allSettings.fetchRegisteredANM()); } |
### Question:
AllSettings { public String fetchDefaultTeamId(String username) { return preferences.fetchDefaultTeamId(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testFetchDefaultTeamIdShouldReturnCorrectTeamId() { doReturn("team-id").when(allSharedPreferences).fetchDefaultTeamId(anyString()); assertEquals("team-id", allSettings.fetchDefaultTeamId("user-name")); } |
### Question:
AllSettings { public String fetchDefaultTeam(String username) { return preferences.fetchDefaultTeam(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testFetchDefaultTeamShouldReturnCorrectTeam() { doReturn("team").when(allSharedPreferences).fetchDefaultTeam(anyString()); assertEquals("team", allSettings.fetchDefaultTeam("user-name")); } |
### Question:
AllSettings { public String fetchDefaultLocalityId(String username) { return preferences.fetchDefaultLocalityId(username); } AllSettings(AllSharedPreferences preferences, SettingsRepository settingsRepository); void registerANM(String userName); void savePreviousFetchIndex(String value); String fetchPreviousFetchIndex(); void saveAppliedVillageFilter(String village); String appliedVillageFilter(String defaultFilterValue); String fetchPreviousFormSyncIndex(); void savePreviousFormSyncIndex(String value); void saveANMLocation(String anmLocation); void saveANMTeam(String anmTeam); String fetchANMLocation(); void saveUserInformation(String userInformation); String fetchUserInformation(); void put(String key, String value); String get(String key); String get(String key, String defaultValue); Setting getSetting(String key); List<Setting> getSettingsByType(String type); void putSetting(Setting setting); List<Setting> getUnsyncedSettings(); int getUnsyncedSettingsCount(); String fetchRegisteredANM(); String fetchDefaultTeamId(String username); String fetchDefaultTeam(String username); String fetchDefaultLocalityId(String username); AllSharedPreferences getPreferences(); static final String APPLIED_VILLAGE_FILTER_SETTING_KEY; static final String PREVIOUS_FETCH_INDEX_SETTING_KEY; static final String PREVIOUS_FORM_SYNC_INDEX_SETTING_KEY; }### Answer:
@Test public void testFetchDefaultLocalityIdShouldReturnCorrectLocalityId() { doReturn("locality").when(allSharedPreferences).fetchDefaultLocalityId(anyString()); assertEquals("locality", allSettings.fetchDefaultLocalityId("user-name")); } |
### Question:
LocationTagRepository extends BaseRepository { public void addOrUpdate(LocationTag locationTag) { if (StringUtils.isBlank(locationTag.getLocationId())) throw new IllegalArgumentException("location id not provided"); ContentValues contentValues = new ContentValues(); contentValues.put(NAME, locationTag.getName()); contentValues.put(LOCATION_ID, locationTag.getLocationId()); getWritableDatabase().replace(getLocationTagTableName(), null, contentValues); } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); }### Answer:
@Test public void testAddOrUpdateShouldAdd() { LocationTag locationTag = gson.fromJson(locationTagJson, LocationTag.class); locationTagRepository.addOrUpdate(locationTag); verify(sqLiteDatabase).replace(stringArgumentCaptor.capture(), stringArgumentCaptor.capture(), contentValuesArgumentCaptor.capture()); assertEquals(2, stringArgumentCaptor.getAllValues().size()); Iterator<String> iterator = stringArgumentCaptor.getAllValues().iterator(); assertEquals(LOCATION_TAG_TABLE, iterator.next()); assertNull(iterator.next()); ContentValues contentValues = contentValuesArgumentCaptor.getValue(); assertEquals(2, contentValues.size()); assertEquals("Facility", contentValues.getAsString("name")); assertEquals("1", contentValues.getAsString("location_id")); }
@Test(expected = IllegalArgumentException.class) public void testAddOrUpdateShouldThrowException() { LocationTag locationTag = new LocationTag(); locationTagRepository.addOrUpdate(locationTag); } |
### Question:
LocationTagRepository extends BaseRepository { public List<LocationTag> getAllLocationTags() { Cursor cursor = null; List<LocationTag> locationsTags = new ArrayList<>(); try { cursor = getReadableDatabase().rawQuery("SELECT * FROM " + getLocationTagTableName(), null); while (cursor.moveToNext()) { locationsTags.add(readCursor(cursor)); } cursor.close(); } catch (Exception e) { Timber.e(e); } finally { if (cursor != null) cursor.close(); } return locationsTags; } static void createTable(SQLiteDatabase database); void addOrUpdate(LocationTag locationTag); List<LocationTag> getAllLocationTags(); List<LocationTag> getLocationTagByLocationId(String id); List<LocationTag> getLocationTagsByTagName(String tagName); }### Answer:
@Test public void tesGetAllLocationTags() { when(sqLiteDatabase.rawQuery("SELECT * FROM " + LOCATION_TAG_TABLE, null)).thenReturn(getCursor()); List<LocationTag> allLocationsTags = locationTagRepository.getAllLocationTags(); verify(sqLiteDatabase).rawQuery(stringArgumentCaptor.capture(), argsCaptor.capture()); assertEquals("SELECT * FROM location_tag", stringArgumentCaptor.getValue()); assertEquals(1, allLocationsTags.size()); LocationTag locationTag = allLocationsTags.get(0); assertEquals(locationTagJson, stripTimezone(gson.toJson(locationTag))); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.