Java tutorial
/* * Copyright 2012 Shared Learning Collaborative, LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.slc.sli.dashboard.unit.client; import static junit.framework.Assert.assertNotNull; import static junit.framework.Assert.assertNull; import static junit.framework.Assert.assertTrue; import static org.junit.Assert.assertEquals; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.net.URISyntaxException; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.ListIterator; import java.util.Map; import javax.ws.rs.MessageProcessingException; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mockito; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.security.core.Authentication; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.slc.sli.api.client.Entity; import org.slc.sli.api.client.SLIClient; import org.slc.sli.api.client.SLIClientException; import org.slc.sli.api.client.SLIClientFactory; import org.slc.sli.api.client.impl.BasicClient; import org.slc.sli.dashboard.client.SDKAPIClient; import org.slc.sli.dashboard.entity.Config; import org.slc.sli.dashboard.entity.ConfigMap; import org.slc.sli.dashboard.entity.GenericEntity; /** * Unit test for the Live API client. * * @author iivanisevic */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "/application-context-test.xml" }) public class SDKAPIClientTest { private static Logger log = LoggerFactory.getLogger(SDKAPIClientTest.class); private static final String CUSTOM_CONFIG_JSON = "{config:{" + "\"component_1\": " + "{" + "\"id\" : \"component_1\", " + "\"name\" : \"Component 1\", " + "\"type\" : \"LAYOUT\", " + "\"items\": [" + "{\"id\" : \"component_1_1\", \"name\": \"First Child Component\", \"type\": \"PANEL\"}, " + "{\"id\" : \"component_1_2\", \"name\": \"Second Child Component\", \"type\": \"PANEL\"}" + "]" + "}" + "}}"; // Mock Data Files private static final String MOCK_DATA_DIRECTORY = "mock_data/"; private static final String MOCK_SCHOOL_FILE = "school.json"; private static final String MOCK_STAFF_FILE = "staffInfo.json"; private static final String MOCK_SESSIONS_FILE = "session.json"; private static final String MOCK_SECTIONS_FILE = "sections.json"; private static final String MOCK_ENROLLMENT_FILE = "school.json"; private static final String MOCK_STUDENTS_FILE = "student.json"; private static final String MOCK_PROGRAMS_FILE = "student_program_association.json"; private static final String MOCK_ASSESSMENT_METADATA_FILE = "assessment_meta_data.json"; private static final String MOCK_ASSESSMENTS_FILE = "assessment.json"; private static final String MOCK_ATTENDANCE_FILE = "attendance.json"; private static final String MOCK_ED_ORG_FILE = "educational_organization.json"; private static final String MOCK_ED_ORG_ASSOC_FILE = "educational_organization_association.json"; private static final String MOCK_SCHOOL_ED_ORG_ASSOC_FILE = "school_educational_organization_association.json"; private SDKAPIClient client; private SLIClient mockSdk; private ClassLoader classLoader; @Value("${api.server.url}") private String apiUrl; @Before public void setUp() throws Exception { client = new SDKAPIClient(); mockSdk = mock(BasicClient.class); SLIClientFactory factory = mock(SLIClientFactory.class); when(factory.getClientWithSessionToken(anyString())).thenReturn(mockSdk); client.setClientFactory(factory); this.classLoader = Thread.currentThread().getContextClassLoader(); } @After public void tearDown() throws Exception { client = null; mockSdk = null; } /* * @Test * public void testGetEdOrgCustomData() throws Exception { * * String token = "token"; * String id = "id"; * String componentId = "component_1"; * String componentName = "Component 1"; * String componentType = "LAYOUT"; * * SdkClientReadAnswer sdkClientReadAnswer = new SdkClientReadAnswer(CUSTOM_CONFIG_JSON); * Mockito.doAnswer(sdkClientReadAnswer).when(mockSdk) * .read(Mockito.anyString(), Mockito.any(List.class), Mockito.anyString(), * Mockito.any(Class.class)); * * ConfigMap configMap = client.getEdOrgCustomData(token, id); * * assertNotNull(configMap); * assertEquals(1, configMap.size()); * assertEquals(componentId, configMap.getComponentConfig(componentId).getId()); * assertEquals(componentName, configMap.getComponentConfig(componentId).getName()); * assertEquals(componentType, configMap.getComponentConfig(componentId).getType().name()); * * } */ /* * @Test * public void testPutEdOrgCustomData() throws Exception { * * String token = "token"; * String id = "id"; * String componentId = "component_1"; * String componentName = "Component 1"; * String componentType = "LAYOUT"; * * Gson gson = new GsonBuilder().create(); * ConfigMap configMap = gson.fromJson(CUSTOM_CONFIG_JSON, ConfigMap.class); * * SdkClientCreateAnswer sdkClientCreateAnswer = new SdkClientCreateAnswer(); * Mockito.doAnswer(sdkClientCreateAnswer).when(mockSdk) * .create(Mockito.anyString(), Mockito.anyString(), Mockito.any(Entity.class)); * * client.putEdOrgCustomData(token, id, configMap); * * ConfigMap verifyConfigMap = sdkClientCreateAnswer.getConfigMap(); * * assertNotNull(verifyConfigMap); * assertEquals(1, verifyConfigMap.size()); * assertEquals(componentId, verifyConfigMap.getComponentConfig(componentId).getId()); * assertEquals(componentName, verifyConfigMap.getComponentConfig(componentId).getName()); * assertEquals(componentType, * verifyConfigMap.getComponentConfig(componentId).getType().name()); * * } */ @Test public void testGetStudent() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "uid"; String studentId = "541397175"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_STUDENTS_FILE); Mockito.when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, studentId, key)); GenericEntity studentEntity = client.getStudent(token, studentId); assertNotNull(studentEntity); assertEquals(12, studentEntity.size()); assertEquals(studentEntity.getString(key), studentId); } public void testGetStudentsWithIdsAndParams() { // this test is not implemented because the underlying method is not called by anything at // this time } public void testGetStudents() { // this test is not implemented because the underlying method is only used by // getStudentsWithSearch and that method has its own associated test } @Test public void testGetStudentsForSection() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "sectionId"; // lookup of valid section String value = "1"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); when(mockSdk.read(anyString())).thenReturn(fromFileWithValue(filename, value, key)); List<GenericEntity> students = client.getStudentsForSection(token, value); assertNotNull(students); // one section returned assertEquals(1, students.size()); // containing 12 students GenericEntity ge = students.get(0); Object o = ge.get("studentUIDs"); assertNotNull(o); assertEquals(12, ((List) o).size()); // lookup of invalid section value = "3124"; when(mockSdk.read(anyString())).thenReturn(fromFileWithValue(filename, value, key)); students = client.getStudentsForSection(token, value); assertEquals(0, students.size()); } @Test public void testGetStudentsWithSearch() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_STUDENTS_FILE); // search by first name only String firstName = "Isaiah"; String lastName = ""; String[] searchStr = { firstName, lastName }; when(mockSdk.read(anyString())).thenReturn(fromFileWithSearch(filename, searchStr)); List<GenericEntity> students = client.getStudentsWithSearch(token, firstName, lastName, null); assertNotNull(students); assertEquals(2, students.size()); assertEquals(students.get(0).getString("firstName"), firstName); // search by last name only firstName = ""; lastName = "Glass"; searchStr[0] = firstName; searchStr[1] = lastName; when(mockSdk.read(anyString())).thenReturn(fromFileWithSearch(filename, searchStr)); students = client.getStudentsWithSearch(token, firstName, lastName, null); assertNotNull(students); assertEquals(2, students.size()); assertEquals(students.get(0).getString("lastName"), lastName); // search by first and last name firstName = "Isaiah"; lastName = "Glass"; searchStr[0] = firstName; searchStr[1] = lastName; when(mockSdk.read(anyString())).thenReturn(fromFileWithSearch(filename, searchStr)); students = client.getStudentsWithSearch(token, firstName, lastName, null); assertNotNull(students); assertEquals(1, students.size()); assertEquals(students.get(0).getString("firstName"), firstName); assertEquals(students.get(0).getString("lastName"), lastName); } @Test public void testGetAssessmentsForStudent() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "studentId"; String studentId = "288598192"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_ASSESSMENTS_FILE); when(mockSdk.read(anyString())).thenReturn(fromFileWithValue(filename, studentId, key)); List<GenericEntity> assessments = client.getAssessmentsForStudent(token, studentId); assertNotNull(assessments); assertEquals(18, assessments.size()); ListIterator<GenericEntity> li = assessments.listIterator(); int count = 0; while (li.hasNext()) { GenericEntity ge = li.next(); assertEquals(ge.getString(key), studentId); if (ge.getString("assessmentName").equals("StateTest_READING")) { count++; } } assertEquals(count, 6); } public void testGetAssessment() throws URISyntaxException, IOException { // this test is not implemented because the underlying method is not called by anything at // this time } public void testGetAssessments() throws URISyntaxException, IOException { // this test is not implemented because the underlying method is not called by anything at // this time } @Test public void testGetSchool() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "schoolId"; String schoolId = "Illinois PS145"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SCHOOL_FILE); Mockito.when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, schoolId, key)); GenericEntity schoolEntity = client.getSchool(token, schoolId); assertNotNull(schoolEntity); assertEquals(3, schoolEntity.size()); assertEquals(schoolEntity.getString(key), schoolId); } public void testGetSchoolsWithParams() throws URISyntaxException, IOException { // this test is not implemented because the underlying method is not called by anything at // this time } @Test public void testGetSchools() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { SDKAPIClient client = new SDKAPIClient() { @Override public String getId(String token) { return null; } @Override public List<GenericEntity> getSectionsForTeacher(String teacherId, String token, Map<String, String> params) { return null; } @Override public List<GenericEntity> getSectionsForNonEducator(String token, Map<String, String> params) { return null; } }; SLIClientFactory factory = mock(SLIClientFactory.class); when(factory.getClientWithSessionToken(anyString())).thenReturn(mockSdk); client.setClientFactory(factory); SecurityContextHolder.getContext().setAuthentication(new Authentication() { @Override public String getName() { return null; } @Override public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException { } @Override public boolean isAuthenticated() { return false; } @Override public Object getPrincipal() { return null; } @Override public Object getDetails() { return null; } @Override public Object getCredentials() { return null; } @Override public Collection<GrantedAuthority> getAuthorities() { return Collections.emptyList(); } }); String token = "token"; String key = "schoolId"; String[] idArr = { "Illinois PS145", "Illinois PS200" }; List<String> schoolIds = Arrays.asList(idArr); String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SCHOOL_FILE); when(mockSdk.read(anyString())).thenReturn(fromFileWithIDList(filename, schoolIds, key)); List<GenericEntity> schoolList = client.getSchools(token, schoolIds); assertNotNull(schoolList); assertEquals(2, schoolList.size()); ListIterator<GenericEntity> li = schoolList.listIterator(); while (li.hasNext()) { assertTrue(schoolIds.contains(li.next().getString(key))); } } @Test public void testGetSession() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "sessionId"; // lookup of valid session String value = "123456789"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SESSIONS_FILE); SdkClientReadAnswerFromFile sdkClientReadAnswerFromFile = new SdkClientReadAnswerFromFile(filename, value, key); Mockito.when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); GenericEntity entity = client.getSession(token, value); assertNotNull(entity); assertEquals(3, entity.size()); assertEquals(entity.getString(key), value); // lookup of invalid session value = "3124"; sdkClientReadAnswerFromFile = new SdkClientReadAnswerFromFile(filename, value, key); Mockito.doAnswer(sdkClientReadAnswerFromFile).when(mockSdk).read(Mockito.anyString()); entity = client.getSession(token, value); assertNull(entity); } @Test public void testGetSessions() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SESSIONS_FILE); // note that this test currently does not test for optional parameters because they are // never used by any call at this time when(mockSdk.read(anyString())).thenReturn(fromFile(filename)); List<GenericEntity> sessions = client.getSessions(token, (String) null, null); assertNotNull(sessions); assertEquals(5, sessions.size()); } public void testGetSessionsWithIdsAndParams() { // this test is not implemented because the underlying method is not called by anything at // this time } @Test public void testGetSessionsForYear() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "schoolYear"; String value = "2011"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SESSIONS_FILE); // 2 sessions expected when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); List<GenericEntity> sessions = client.getSessionsForYear(token, value); assertNotNull(sessions); assertEquals(2, sessions.size()); for (GenericEntity ge : sessions) { assertEquals(ge.getString(key), value); } // no sessions expected value = "2005"; when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); sessions = client.getSessionsForYear(token, value); assertNotNull(sessions); assertEquals(0, sessions.size()); } @Test public void testGetSections() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); // note that this test currently does not test for optional parameters because they are // never used by any call at this time when(mockSdk.read(Mockito.anyString())).thenReturn(fromFile(filename)); List<GenericEntity> sections = client.getSections(token, null); assertNotNull(sections); assertEquals(3, sections.size()); } @Test public void testGetSectionsForStudent() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "studentUIDs"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); // note that this test currently does not test for optional parameters because they are // never used by any call at this time // testing with a student id present in two sections String value = "288598192"; when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); List<GenericEntity> sections = client.getSectionsForStudent(token, value, new HashMap<String, String>()); assertNotNull(sections); assertEquals(2, sections.size()); // testing with a student id not present in any sections value = "288598193"; when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); sections = client.getSectionsForStudent(token, value, new HashMap<String, String>()); assertNotNull(sections); assertEquals(0, sections.size()); } @Test public void testGetSectionsForTeacher() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "teacherId"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); // note that this test currently does not test for optional parameters because they are // never used by any call at this time // testing with a teacher id present in a single section String value = "12399"; when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); List<GenericEntity> sections = client.getSectionsForTeacher(token, value, null); assertNotNull(sections); assertEquals(1, sections.size()); // testing with a teacher id not present in any sections value = "28859"; when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); sections = client.getSectionsForTeacher(token, value, null); assertNotNull(sections); assertEquals(0, sections.size()); } public void testGetSectionsNonEducator() throws URISyntaxException, IOException { // this test is not implemented because the underlying method does not appear to be used // even though it is potentially called in getSchools } public void testGetSectionsWithIdsAndParams() { // this test is not implemented because the underlying method is not called by anything at // this time } public void testGetSectionHomeForStudent() throws URISyntaxException, IOException { // this test is not implemented because the mock json data does not conform to the proper // format // once it is updated, this test can be implemented /* * String token = "token"; * String key = "studentUIDs"; * String mapKey = "studentSectionAssociation"; * String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); * String value = "288598192"; * * SdkClientReadAnswerFromFile sdkClientReadAnswerFromFile = new * SdkClientReadAnswerFromFile(filename, value, key); * Mockito.doAnswer(sdkClientReadAnswerFromFile).when(mockSdk) * .read(Mockito.anyString(), Mockito.any(List.class), Mockito.anyString(), * Mockito.any(Class.class)); * GenericEntity section = client.getSectionHomeForStudent(token, value); * * assertNotNull(section); * assertEquals("True", section.getString("homeroomIndicator")); */ } @Test public void testGetSection() throws URISyntaxException, IOException, MessageProcessingException, SLIClientException { String token = "token"; String key = "sectionId"; // lookup of valid section String value = "1"; String filename = getFilename(MOCK_DATA_DIRECTORY + "common/" + MOCK_SECTIONS_FILE); SdkClientReadAnswerFromFile sdkClientReadAnswerFromFile = new SdkClientReadAnswerFromFile(filename, value, key); Mockito.when(mockSdk.read(Mockito.anyString())).thenReturn(fromFileWithValue(filename, value, key)); GenericEntity entity = client.getSection(token, value); assertNotNull(entity); assertEquals(5, entity.size()); assertEquals(entity.getString(key), value); // lookup of invalid section value = "3124"; sdkClientReadAnswerFromFile = new SdkClientReadAnswerFromFile(filename, value, key); Mockito.doAnswer(sdkClientReadAnswerFromFile).when(mockSdk).read(Mockito.anyString()); entity = client.getSection(token, value); assertNull(entity); } public String getFilename(String filename) { URL url = classLoader.getResource(filename); return url == null ? null : url.getFile(); } private static class SdkClientReadAnswer implements Answer { private String json; private ConfigMap configMap; private List entityList; public SdkClientReadAnswer(String json) { this.json = json; Gson gson = new GsonBuilder().create(); this.configMap = gson.fromJson(getJson(), ConfigMap.class); } @Override public Object answer(InvocationOnMock invocation) throws Throwable { entityList = (List) invocation.getArguments()[1]; entityList.add(getConfigMap()); return null; } public String getJson() { return json; } public ConfigMap getConfigMap() { return configMap; } public List getEntityList() { return entityList; } } private static class SdkClientCreateAnswer implements Answer { private ConfigMap configMap; @Override public Object answer(InvocationOnMock invocation) throws Throwable { Entity configMapEntity = (Entity) invocation.getArguments()[2]; Map<String, Config> config = (Map<String, Config>) configMapEntity.getData().get("config"); this.configMap = new ConfigMap(); this.configMap.setConfig(config); return null; } public ConfigMap getConfigMap() { return configMap; } } private static class SdkClientReadAnswerFromFile implements Answer { private String json; private List<Entity> genericEntities; private List entityList; private String url; private String id; private String key; private String[] searchStr; private List<String> idList; /** get the json from a specified filename */ public SdkClientReadAnswerFromFile(String filename) { genericEntities = fromFile(filename); } /** get the json from a specified filename, with the selected argument */ public SdkClientReadAnswerFromFile(String filename, String entityid, String entityKey) { this(filename); this.id = entityid; this.key = entityKey; } /** get the json from a specified filename, with the selected search parameters */ public SdkClientReadAnswerFromFile(String filename, String[] searchStr) { this(filename); this.searchStr = searchStr; } /** get the json from a specified filename, with the List of arguments */ public SdkClientReadAnswerFromFile(String filename, List<String> entityIds, String entityKey) { this(filename); this.idList = entityIds; this.key = entityKey; } @Override public Object answer(InvocationOnMock invocation) throws Throwable { return getMatchingEntities(invocation); } private Object getMatchingEntities(InvocationOnMock invocation) { entityList = (List) invocation.getArguments()[1]; if (key != null && id != null) { url = (String) invocation.getArguments()[2]; List<Entity> genericEntities = getGenericEntities(); for (Entity ge : genericEntities) { Object entity = ((GenericEntity) ge).get(key); // entity can be a single value or an ArrayList of values if (entity instanceof ArrayList) { if (((ArrayList) entity).contains(id)) { entityList.add(ge); } } else if (entity.equals(id)) { entityList.add(ge); } } } else if (searchStr != null) { url = (String) invocation.getArguments()[2]; List<Entity> genericEntities = getGenericEntities(); for (Entity ge : genericEntities) { if ((searchStr[0].equals("") || ((GenericEntity) ge).getString("firstName").equals(searchStr[0])) && (searchStr[1].equals("") || ((GenericEntity) ge).getString("lastName").equals(searchStr[1]))) { entityList.add(ge); } } } else if (idList != null && key != null) { url = (String) invocation.getArguments()[2]; List<Entity> genericEntities = getGenericEntities(); for (Entity ge : genericEntities) { if (idList.contains(((GenericEntity) ge).getString(key))) { entityList.add(ge); } } } else { entityList.addAll(getGenericEntities()); } return null; } public String getJson() { return json; } public List getEntityList() { return entityList; } public List<Entity> getGenericEntities() { return genericEntities; } } /** * Retrieves an entity list from the specified file * and instantiates from its JSON representation * * @param filePath * - the file path to persist the view component XML string representation * @return entityList * - the generic entity list */ private static List<Entity> fromFile(String filePath) { List<Entity> entityList = new ArrayList<Entity>(); BufferedReader reader = null; try { // Read JSON file reader = new BufferedReader(new FileReader(filePath)); StringBuffer jsonBuffer = new StringBuffer(); String line; while ((line = reader.readLine()) != null) { jsonBuffer.append(line); } // Parse JSON Gson gson = new Gson(); List<Map> maps = gson.fromJson(jsonBuffer.toString(), new ArrayList<Map>().getClass()); for (Map<String, Object> map : maps) { entityList.add(new GenericEntity(map)); } } catch (IOException e) { log.error(e.getMessage()); } catch (NullPointerException e) { log.error(e.getMessage()); } catch (Exception e) { log.error(e.getMessage()); } finally { try { if (reader != null) { reader.close(); } } catch (Exception e) { log.error(e.getMessage()); } } return entityList; } private static List<Entity> fromFileWithValue(String filename, String value, String key) { List<Entity> allEntities = fromFile(filename); List<Entity> matchingEntities = new ArrayList<Entity>(); for (Entity e : allEntities) { Object entity = ((GenericEntity) e).get(key); // entity can be a single value or an ArrayList of values if (entity instanceof ArrayList) { if (((ArrayList<?>) entity).contains(value)) { matchingEntities.add(e); } } else if (entity.equals(value)) { matchingEntities.add(e); } } return matchingEntities; } private static List<Entity> fromFileWithSearch(String filename, String[] searchStr) { List<Entity> allEntities = fromFile(filename); List<Entity> matchingEntities = new ArrayList<Entity>(); for (Entity ge : allEntities) { if ((searchStr[0].equals("") || ((GenericEntity) ge).getString("firstName").equals(searchStr[0])) && (searchStr[1].equals("") || ((GenericEntity) ge).getString("lastName").equals(searchStr[1]))) { matchingEntities.add(ge); } } return matchingEntities; } private static List<Entity> fromFileWithIDList(String filename, List<String> idList, String key) { List<Entity> allEntities = fromFile(filename); List<Entity> matchingEntities = new ArrayList<Entity>(); for (Entity ge : allEntities) { if (idList.contains(((GenericEntity) ge).getString(key))) { matchingEntities.add(ge); } } return matchingEntities; } }