src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
XmiFeature { @Override public String toString() { return String.format("{name : %s, exists : %s, className : %s, classExists : %s}", name, exists, className, classExists); } XmiFeature(final String name, final boolean exists, final String className, final boolean classExists); String getName(); String getOwnerName(); boolean ownerExists(); boolean exists(); @Override String toString(); }
|
@Test public void testToString() { assertNotNull(XMI_FEATURE.toString()); }
|
XmiDefinition { public String getName() { return name; } XmiDefinition(final String name, final String version, final String file); String getName(); String getVersion(); String getFile(); }
|
@Test public void testGetName() { Assert.assertEquals(NAME, xmiDefinition.getName()); }
|
XmiDefinition { public String getVersion() { return version; } XmiDefinition(final String name, final String version, final String file); String getName(); String getVersion(); String getFile(); }
|
@Test public void testGetVersion() { Assert.assertEquals(VERSION, xmiDefinition.getVersion()); }
|
XmiDefinition { public String getFile() { return file; } XmiDefinition(final String name, final String version, final String file); String getName(); String getVersion(); String getFile(); }
|
@Test public void testGetFile() { Assert.assertEquals(FILE, xmiDefinition.getFile()); }
|
XmiReader { protected static final <T> T assertNotNull(final T obj) { if (obj != null) { return obj; } else { throw new AssertionError(); } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testAssertNotNullHappyPath() { Object o = new Object(); assertTrue(XmiReader.assertNotNull(o) == o); }
@Test(expected = AssertionError.class) public void testAssertNotNullSadPath() { XmiReader.assertNotNull(null); }
@Test public void testAllPublicMethods() throws XMLStreamException, IOException { String filename = "src/test/resources/SLI.xmi"; Model model1 = this.readModelByFile(filename); Model model2 = this.readModelByStream(filename); Model model4 = this.readModelByName(filename); assertNotNull(model1); assertNotNull(model2); assertNotNull(model4); assertEquals(model1, model2); assertEquals(model1, model4); }
|
XmiReader { protected static final Occurs getOccurs(final XMLStreamReader reader, final XmiAttributeName name) { final int value = Integer.valueOf(reader.getAttributeValue(GLOBAL_NAMESPACE, name.getLocalName())); switch (value) { case 0: { return Occurs.ZERO; } case 1: { return Occurs.ONE; } case -1: { return Occurs.UNBOUNDED; } default: { throw new AssertionError(value); } } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testGetOccursHappyPath() { when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("1"); assertTrue(XmiReader.getOccurs(mockReader, sampleAttribute) == Occurs.ONE); when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("0"); assertTrue(XmiReader.getOccurs(mockReader, sampleAttribute) == Occurs.ZERO); when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("-1"); assertTrue(XmiReader.getOccurs(mockReader, sampleAttribute) == Occurs.UNBOUNDED); }
@Test(expected = AssertionError.class) public void testGetOccursSadPath() { when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("123"); XmiReader.getOccurs(mockReader, sampleAttribute); }
|
DocumentManipulator { protected Document parseDocument(File file) throws DocumentManipulatorException { Document doc = null; try { DocumentBuilder builder = docFactory.newDocumentBuilder(); doc = builder.parse(file); } catch (SAXException e) { throw new DocumentManipulatorException(e); } catch (IOException e) { throw new DocumentManipulatorException(e); } catch (ParserConfigurationException e) { throw new DocumentManipulatorException(e); } return doc; } DocumentManipulator(); NodeList getNodeList(Document doc, String expression); void serializeDocumentToHtml(Document document, File outputFile, File xslFile); void serializeDocumentToXml(Document document, File outputFile); String serializeDocumentToString(Document document); }
|
@Test(expected = DocumentManipulatorException.class) public void testParseDocumentEmptyFile() throws DocumentManipulatorException { handler.parseDocument(new File("")); }
@Test public void testParseDocument() throws DocumentManipulatorException, URISyntaxException { URL url = this.getClass().getResource("/sample.xml"); Document doc = handler.parseDocument(new File(url.toURI())); assertNotNull("Document should not be null", doc); }
|
XmiReader { protected static final Identifier getIdRef(final XMLStreamReader reader) throws XmiMissingAttributeException { final String value = reader.getAttributeValue(GLOBAL_NAMESPACE, XmiAttributeName.IDREF.getLocalName()); if (value != null) { return Identifier.fromString(value); } else { throw new XmiMissingAttributeException(XmiAttributeName.IDREF.getLocalName()); } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testGetIdRefHappyPath() { String id = "ID1234567890"; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(id); assertTrue(XmiReader.getIdRef(mockReader).toString().equals(id)); }
@Test(expected = XmiMissingAttributeException.class) public void testGetIdRefSadPath() { when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(null); XmiReader.getIdRef(mockReader); }
|
XmiReader { protected static final Identifier getId(final XMLStreamReader reader) { return Identifier.fromString(reader.getAttributeValue(GLOBAL_NAMESPACE, XmiAttributeName.ID.getLocalName())); } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testGetIdHappyPath() { String id = "ID1234567890"; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(id); assertTrue(XmiReader.getId(mockReader).toString().equals(id)); }
|
XmiReader { protected static final boolean getBoolean(final XmiAttributeName name, final boolean defaultValue, final XMLStreamReader reader) { final String value = reader.getAttributeValue(GLOBAL_NAMESPACE, name.getLocalName()); if (value != null) { return Boolean.valueOf(value); } else { return defaultValue; } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testGetBoolean() { boolean defaultBoolean; defaultBoolean = false; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("true"); assertTrue(XmiReader.getBoolean(sampleAttribute, defaultBoolean, mockReader)); defaultBoolean = true; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("false"); assertFalse(XmiReader.getBoolean(sampleAttribute, defaultBoolean, mockReader)); defaultBoolean = false; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(null); assertFalse(XmiReader.getBoolean(sampleAttribute, defaultBoolean, mockReader)); defaultBoolean = true; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(null); assertTrue(XmiReader.getBoolean(sampleAttribute, defaultBoolean, mockReader)); }
|
XmiReader { protected static final void closeQuiet(final Closeable closeable) { IOUtils.closeQuietly(closeable); } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testCloseQuiet() throws IOException { Closeable mockCloseable = mock(Closeable.class); final StringBuffer stringBuffer = new StringBuffer(); PrintStream stdErr = System.err; PrintStream myErr = new PrintStream(new OutputStream() { @Override public void write(int b) throws IOException { stringBuffer.append((char) b); } }); System.setErr(myErr); XmiReader.closeQuiet(mockCloseable); assertTrue(stringBuffer.toString().equals("")); System.setErr(stdErr); }
|
XmiReader { protected static final void assertName(final QName name, final XMLStreamReader reader) { if (!match(name, reader)) { throw new AssertionError(reader.getLocalName()); } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testAssertElementNameEqualsStreamReadNameHappyPath() { XmiElementName xmiElementName = XmiElementName.ASSOCIATION; String elementName = xmiElementName.getLocalName(); when(mockReader.getLocalName()).thenReturn(elementName); XmiReader.assertName(xmiElementName, mockReader); }
@Test(expected = AssertionError.class) public void testAssertElementNameEqualsStreamReadNameSadPath() { XmiElementName xmiElementName = XmiElementName.ASSOCIATION; String elementName = XmiElementName.ASSOCIATION_END.getLocalName(); when(mockReader.getLocalName()).thenReturn(elementName); XmiReader.assertName(xmiElementName, mockReader); }
|
XmiReader { protected static final void skipElement(final XMLStreamReader reader, final boolean check) throws XMLStreamException { if (check) { throw new AssertionError(reader.getName()); } final String localName = reader.getLocalName(); while (reader.hasNext()) { reader.next(); switch (reader.getEventType()) { case XMLStreamConstants.START_ELEMENT: { skipElement(reader, check); break; } case XMLStreamConstants.END_ELEMENT: { if (localName.equals(reader.getLocalName())) { return; } else { throw new AssertionError(reader.getLocalName()); } } case XMLStreamConstants.CHARACTERS: { break; } default: { throw new AssertionError(reader.getEventType()); } } } throw new AssertionError(); } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testSkipElement() throws XMLStreamException { final List<String> localNames = new ArrayList<String>(); localNames.add("myLocalName1"); localNames.add("myLocalName2"); localNames.add("myLocalName2"); localNames.add("myLocalName1"); final List<Integer> eventTypes = new ArrayList<Integer>(); eventTypes.add(XMLStreamConstants.START_ELEMENT); eventTypes.add(XMLStreamConstants.CHARACTERS); eventTypes.add(XMLStreamConstants.END_ELEMENT); eventTypes.add(XMLStreamConstants.END_ELEMENT); when(mockReader.hasNext()).thenReturn(true); when(mockReader.getEventType()).thenAnswer(new Answer<Integer>() { @Override public Integer answer(InvocationOnMock invocation) throws Throwable { return eventTypes.remove(0); } }); when(mockReader.getLocalName()).thenAnswer(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return localNames.remove(0); } }); XmiReader.skipElement(mockReader, false); }
@Test(expected = AssertionError.class) public void testSkipElementSadPath2NoNext() throws XMLStreamException { when(mockReader.hasNext()).thenReturn(false); XmiReader.skipElement(mockReader, false); }
@Test(expected = AssertionError.class) public void testSkipElementSadPath3UnknownEventType() throws XMLStreamException { when(mockReader.hasNext()).thenReturn(true); when(mockReader.getEventType()).thenReturn(123456789); XmiReader.skipElement(mockReader, false); }
@Test(expected = AssertionError.class) public void testSkipElementSadPath4LocalNamesDoNotMatch() throws XMLStreamException { final List<String> localNames = new ArrayList<String>(); localNames.add("myLocalName1"); localNames.add("myLocalName2"); localNames.add("myLocalName2"); when(mockReader.hasNext()).thenReturn(true); when(mockReader.getEventType()).thenReturn(XMLStreamConstants.END_ELEMENT); when(mockReader.getLocalName()).thenAnswer(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return localNames.remove(0); } }); XmiReader.skipElement(mockReader, false); }
|
ValueMapper extends Mapper<TenantAndIdEmittableKey, BSONWritable, TenantAndIdEmittableKey, Writable> { @Override public void map(TenantAndIdEmittableKey key, BSONWritable entity, Context context) throws InterruptedException, IOException { context.write(key, getValue(entity)); } @Override void map(TenantAndIdEmittableKey key, BSONWritable entity, Context context); abstract Writable getValue(BSONWritable entity); }
|
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testMap() throws Exception { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey(); ValueMapper m = new MockValueMapper(); BSONObject entry = new BasicBSONObject("found", "data"); BSONWritable entity = new BSONWritable(entry); Context context = Mockito.mock(Context.class); PowerMockito.when(context, "write", Matchers.any(EmittableKey.class), Matchers.any(BSONObject.class)).thenAnswer(new Answer<BSONObject>() { @Override public BSONObject answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); assertNotNull(args); assertEquals(args.length, 2); assertTrue(args[0] instanceof TenantAndIdEmittableKey); assertTrue(args[1] instanceof ContentSummary); TenantAndIdEmittableKey id = (TenantAndIdEmittableKey) args[0]; assertNotNull(id); ContentSummary e = (ContentSummary) args[1]; assertEquals(e.getLength(), 1); assertEquals(e.getFileCount(), 2); assertEquals(e.getDirectoryCount(), 3); return null; } }); m.map(key, entity, context); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testMapValueNotFound() throws Exception { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey(); ValueMapper m = new MockValueMapper(); BSONObject entry = new BasicBSONObject("not_found", "data"); BSONWritable entity = new BSONWritable(entry); Context context = Mockito.mock(Context.class); PowerMockito.when(context, "write", Matchers.any(TenantAndIdEmittableKey.class), Matchers.any(BSONObject.class)).thenAnswer(new Answer<BSONObject>() { @Override public BSONObject answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); assertNotNull(args); assertEquals(args.length, 2); assertTrue(args[0] instanceof TenantAndIdEmittableKey); assertTrue(args[1] instanceof NullWritable); return null; } }); m.map(key, entity, context); }
|
XmiReader { protected static final String getName(final XMLStreamReader reader, final String defaultName, final XmiAttributeName attr) { final String name = reader.getAttributeValue(GLOBAL_NAMESPACE, attr.getLocalName()); if (name != null) { return name; } else { return defaultName; } } static final Model readModel(final File file); static final Model readModel(final InputStream stream); static final Model readModel(final String fileName); }
|
@Test public void testGetName() { String defaultString; defaultString = "defString"; when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn("specifiedString"); assertEquals("specifiedString", XmiReader.getName(mockReader, defaultString, sampleAttribute)); when(mockReader.getAttributeValue(any(String.class), any(String.class))).thenReturn(null); assertEquals(defaultString, XmiReader.getName(mockReader, defaultString, sampleAttribute)); }
|
XmiWriter { public static final void writeDocument(final Model model, final ModelIndex mapper, final OutputStream outstream) { final XMLOutputFactory xof = XMLOutputFactory.newInstance(); try { final XMLStreamWriter xsw = new IndentingXMLStreamWriter(xof.createXMLStreamWriter(outstream, "UTF-8")); xsw.writeStartDocument("UTF-8", "1.0"); try { XmiWriter.writeXMI(model, mapper, xsw); } finally { xsw.writeEndDocument(); } xsw.flush(); } catch (final XMLStreamException e) { throw new XmiRuntimeException(e); } } static final void writeDocument(final Model model, final ModelIndex mapper, final OutputStream outstream); static final void writeDocument(final Model model, final ModelIndex mapper, final String fileName); static final void writeDocument(final Model model, final ModelIndex mapper, final File file); }
|
@Test public void testWriteDocumentOutputStream() throws Exception { OutputStream os = new ByteArrayOutputStream(); OutputStream mockOutputStream = spy(os); XmiWriter.writeDocument(model, modelIndex, mockOutputStream); String output = mockOutputStream.toString(); assertTrue(output.contains(MODEL_ID.toString())); assertTrue(output.contains(MODEL_NAME)); assertTrue(output.contains(PACKAGE_ID.toString())); assertTrue(output.contains(PACKAGE_NAME)); assertTrue(output.contains(TAGGEDVALUE_VALUE)); assertTrue(output.contains(TAGDEFINITION_ID.toString())); assertTrue(output.contains(TAGDEFINITION_NAME)); assertTrue(output.contains("lower=\"0\"")); assertTrue(output.contains("upper=\"1\"")); assertFalse(output.contains("upper=\"-1\"")); assertTrue(output.contains(DATATYPE_ID.toString())); assertTrue(output.contains(DATATYPE_NAME)); assertTrue(output.contains(ATTRIBUTE_ID.toString())); assertTrue(output.contains(ATTRIBUTE_NAME)); assertTrue(output.contains(CLASSTYPE_ID.toString())); assertTrue(output.contains(CLASSTYPE_NAME)); assertTrue(output.contains(ENUMLITERALA_ID.toString())); assertTrue(output.contains(ENUMLITERALA_NAME)); assertTrue(output.contains(ENUMTYPE_ID.toString())); assertTrue(output.contains(ENUMTYPE_NAME)); assertTrue(output.contains(ASSOCIATIONEND_PARENT_ID.toString())); assertTrue(output.contains(ASSOCIATIONEND_PARENT_NAME)); assertTrue(output.contains(GENERALIZATION_ID.toString())); assertTrue(output.contains(GENERALIZATION_NAME)); }
@Test public void testWriteDocumentFile() { File file = new File("unittest-writedocumentfile.xmi"); assertFalse(file.exists()); XmiWriter.writeDocument(model, modelIndex, file); assertTrue(file.exists()); file.deleteOnExit(); }
@Test public void testWriteDocumentString() { String filename = "unittest-writedocumentstring.xmi"; File file = new File(filename); assertFalse(file.exists()); XmiWriter.writeDocument(model, modelIndex, filename); assertTrue(file.exists()); file.deleteOnExit(); }
|
WadlWalker { public void walk(final Application application) { if (application == null) { throw new IllegalArgumentException("application"); } handler.beginApplication(application); try { final Resources resources = application.getResources(); final Stack<Resource> ancestors = new Stack<Resource>(); for (final Resource resource : resources.getResources()) { walkResource(resource, resources, application, ancestors); } } finally { handler.endApplication(application); } } WadlWalker(final WadlHandler handler); void walk(final Application application); }
|
@Test(expected = IllegalArgumentException.class) public void testWalkNullApplication() { WadlHandler mockHandler = mock(WadlHandler.class); WadlWalker ww = new WadlWalker(mockHandler); ww.walk(null); }
@Test public void testWalk() { WadlHandler wadlHandler = mock(WadlHandler.class); WadlWalker ww = new WadlWalker(wadlHandler); List<Resource> emptyResourcesList = new ArrayList<Resource>(0); Resources mockResources = mock(Resources.class); when(mockResources.getResources()).thenReturn(emptyResourcesList); Application mockApplication = mock(Application.class); when(mockApplication.getResources()).thenReturn(mockResources); ww.walk(mockApplication); verify(wadlHandler).beginApplication(mockApplication); verify(wadlHandler).endApplication(mockApplication); }
|
WadlHelper { public static List<Param> getRequestParams(final Method method) { if (method == null) { throw new IllegalArgumentException(); } final Request request = method.getRequest(); if (request != null) { return request.getParams(); } else { return Collections.emptyList(); } } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testGetRequestParams() throws Exception { Param mockParam = mock(Param.class); Request mockRequest = mock(Request.class); List<Param> mockParamList = new ArrayList<Param>(1); mockParamList.add(mockParam); when(mockRequest.getParams()).thenReturn(mockParamList); Method mockMethod = mock(Method.class); when(mockMethod.getRequest()).thenReturn(mockRequest); List<Param> paramList = WadlHelper.getRequestParams(mockMethod); assertEquals(1, paramList.size()); }
|
DocumentManipulator { public NodeList getNodeList(Document doc, String expression) throws XPathException { XPath xpath = xPathFactory.newXPath(); xpath.setNamespaceContext(new DocumentNamespaceResolver(doc)); XPathExpression exp = xpath.compile(expression); Object result = exp.evaluate(doc, XPathConstants.NODESET); return (NodeList) result; } DocumentManipulator(); NodeList getNodeList(Document doc, String expression); void serializeDocumentToHtml(Document document, File outputFile, File xslFile); void serializeDocumentToXml(Document document, File outputFile); String serializeDocumentToString(Document document); }
|
@Test public void testGetNodeList() throws DocumentManipulatorException, URISyntaxException, XPathException { URL url = this.getClass().getResource("/sample.xml"); String expression = " Document doc = handler.parseDocument(new File(url.toURI())); NodeList list = handler.getNodeList(doc, expression); assertNotNull("list shoud not be null", list); }
|
WadlHelper { public static final String computeId(final Method method, final Resource resource, final Resources resources, final Application app, final Stack<Resource> ancestors) { final List<String> steps = reverse(toSteps(resource, ancestors)); final StringBuilder sb = new StringBuilder(); sb.append(method.getVerb().toLowerCase()); boolean first = true; boolean seenParam = false; String paramName = null; for (final String step : steps) { if (isTemplateParam(step)) { seenParam = true; paramName = parseTemplateParam(step); } else if (!isVersion(step)) { if (first) { first = false; } else { sb.append("For"); } sb.append(titleCase(step)); if (seenParam) { sb.append("By" + titleCase(paramName)); seenParam = false; } } } return sb.toString(); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testComputeId() throws Exception { String id = "getStudentsByIdForApi"; Method mockMethod = mock(Method.class); when(mockMethod.getVerb()).thenReturn(Method.NAME_HTTP_GET); Resource mockResource = mock(Resource.class); when(mockResource.getPath()).thenReturn("students/{id}"); Resource mockAncestorResource = mock(Resource.class); when(mockAncestorResource.getPath()).thenReturn("api/v1"); Stack<Resource> resources = new Stack<Resource>(); resources.push(mockAncestorResource); String computedId = WadlHelper.computeId(mockMethod, mockResource, null, null, resources); assertEquals(id, computedId); }
|
WadlHelper { public static final String titleCase(final String text) { return text.substring(0, 1).toUpperCase().concat(text.substring(1)); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testTitleCase() throws Exception { String camelCase = "randomName"; String titleCase = "RandomName"; assertEquals(titleCase, WadlHelper.titleCase(camelCase)); }
|
WadlHelper { public static final <T> List<T> reverse(final List<T> strings) { final LinkedList<T> result = new LinkedList<T>(); for (final T s : strings) { result.addFirst(s); } return Collections.unmodifiableList(result); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testReverse() throws Exception { @SuppressWarnings({ "serial" }) List<Integer> strList = new ArrayList<Integer>(3) { { add(1); add(2); add(3); } }; List<Integer> revList = WadlHelper.reverse(strList); assertEquals(3, revList.size()); assertEquals(3, (int) revList.get(0)); assertEquals(2, (int) revList.get(1)); assertEquals(1, (int) revList.get(2)); }
|
WadlHelper { public static final boolean isVersion(final String step) { return step.toLowerCase().equals("v1"); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testIsVersion() throws Exception { String versionString = "v1"; String versionStringUpperCase = "V1"; String nonVersionString = "blah"; assertTrue(WadlHelper.isVersion(versionString)); assertTrue(WadlHelper.isVersion(versionStringUpperCase)); assertFalse(WadlHelper.isVersion(nonVersionString)); }
|
WadlHelper { public static final String parseTemplateParam(final String step) { if (isTemplateParam(step)) { return step.substring(1, step.length() - 1); } else { throw new AssertionError(step); } } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testParseTemplateParam() throws Exception { String templateParam = "{paramName}"; assertEquals("paramName", WadlHelper.parseTemplateParam(templateParam)); }
|
WadlHelper { public static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors) { final List<String> result = new LinkedList<String>(); for (final Resource ancestor : ancestors) { result.addAll(splitBasedOnFwdSlash(ancestor.getPath())); } result.addAll(splitBasedOnFwdSlash(resource.getPath())); return Collections.unmodifiableList(result); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testToSteps() throws Exception { Resource mockResource = mock(Resource.class); when(mockResource.getPath()).thenReturn("students/{id}"); Resource mockAncestorResource = mock(Resource.class); when(mockAncestorResource.getPath()).thenReturn("api/v1"); Stack<Resource> resources = new Stack<Resource>(); resources.push(mockAncestorResource); List<String> steps = WadlHelper.toSteps(mockResource, resources); assertEquals(4, steps.size()); assertEquals("api", steps.get(0)); assertEquals("v1", steps.get(1)); assertEquals("students", steps.get(2)); assertEquals("{id}", steps.get(3)); }
|
WadlHelper { public static final boolean isTemplateParam(final String step) { return step.trim().startsWith("{") && step.endsWith("}"); } private WadlHelper(); static List<Param> getRequestParams(final Method method); static final String computeId(final Method method, final Resource resource, final Resources resources,
final Application app, final Stack<Resource> ancestors); static final String titleCase(final String text); static final List<T> reverse(final List<T> strings); static final boolean isVersion(final String step); static final String parseTemplateParam(final String step); static final List<String> toSteps(final Resource resource, final Stack<Resource> ancestors); static final boolean isTemplateParam(final String step); }
|
@Test public void testIsTemplateParam() throws Exception { String templateParam = "{paramName}"; String nonTemplateParam = "blah"; assertTrue(WadlHelper.isTemplateParam(templateParam)); assertFalse(WadlHelper.isTemplateParam(nonTemplateParam)); }
|
XsdReader { public static final XmlSchema readSchema(final String fileName, final URIResolver schemaResolver) throws FileNotFoundException { final InputStream istream = new BufferedInputStream(new FileInputStream(fileName)); try { return readSchema(istream, schemaResolver); } finally { closeQuiet(istream); } } static final XmlSchema readSchema(final String fileName, final URIResolver schemaResolver); static final XmlSchema readSchema(final File file, final URIResolver schemaResolver); }
|
@Test public void testReadSchemaUsingFile() throws FileNotFoundException, URISyntaxException { final URIResolver mockResolver = mock(URIResolver.class); final File testXSD = new File(getClass().getResource("/test.xsd").toURI()); final XmlSchema schema = XsdReader.readSchema(testXSD, mockResolver); testReadSchema(schema); }
@Test public void testReadSchemaUsingString() throws URISyntaxException, FileNotFoundException { final URIResolver mockResolver = mock(URIResolver.class); final String testXSD = new File(getClass().getResource("/test.xsd").toURI()).getAbsolutePath(); final XmlSchema schema = XsdReader.readSchema(testXSD, mockResolver); testReadSchema(schema); }
|
SeaCustomDataProvider { public Map<String, List<SliEntityLocator>> getIdMap(String seaGuid) { LOG.info("Attempting to pull id map from SEA custom data, will cause exception if doesn't exist"); List<Entity> list = slcInterface.read("/educationOrganizations/" + seaGuid + "/custom"); if (list.size() > 0) { Map<String, Object> rawMap = list.get(0).getData(); return toSpecificMap(rawMap); } return new HashMap<String, List<SliEntityLocator>>(); } Map<String, List<SliEntityLocator>> getIdMap(String seaGuid); void storeIdMap(String seaGuid, Map<String, List<SliEntityLocator>> idMap); }
|
@Test public void testGetMap() { String seaGuid = "asladfalsd"; String url = "/educationOrganizations/" + seaGuid + "/custom"; Mockito.when(mockSlcInterface.read(url)).thenReturn(buildCustomDataList()); Map<String, List<SliEntityLocator>> result = dataProvider.getIdMap(seaGuid); Assert.assertNotNull(result); Assert.assertEquals(1, result.keySet().size()); List<SliEntityLocator> list = result.get(SIF_ID); Assert.assertNotNull(list); Assert.assertEquals(1, list.size()); SliEntityLocator locator = list.get(0); Assert.assertEquals(TYPE, locator.getType()); Assert.assertEquals(VALUE, locator.getValue()); Assert.assertEquals(FIELD, locator.getField()); }
|
ResourceDocumentation { public void addDocumentation() throws IOException, XPathException { final NodeList topLevelResources = manipulator.getNodeList(this.doc, " for (int i = 0; i < topLevelResources.getLength(); i++) { final Node node = topLevelResources.item(i); final ResourceEndPointTemplate resourceTemplate = getResourceTemplate(node); if (resourceTemplate != null) { addTag(node, "doc", resourceTemplate.getDoc()); addTag(node, "deprecatedVersion", resourceTemplate.getDeprecatedVersion()); addTag(node, "deprecatedReason", resourceTemplate.getDeprecatedReason()); addTag(node, "availableSince", resourceTemplate.getAvailableSince()); } } } ResourceDocumentation(final Document doc); ResourceDocumentation(final Document doc, final String resourceLoc); void addDocumentation(); }
|
@Test public void testAddDocumentation() throws Exception { NodeList section = documentManipulator.getNodeList(testWadl, " assertEquals(1, section.getLength()); Node sectionNodeDoc = documentManipulator.getNodeList(testWadl, " assertNotNull(sectionNodeDoc); assertEquals("test /sections doc", sectionNodeDoc.getFirstChild().getNodeValue()); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public Entity getSliEntity(String sifId, String zoneId) { synchronized (lock) { List<Entity> entities = getSliEntityList(sifId, zoneId); if (entities == null || entities.size() == 0) { LOG.warn("No entity found for sifId: " + sifId); return null; } return entities.get(0); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliEntityShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); Entity expected = new GenericEntity(SLI_TYPE1, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE1), any(Query.class))).thenReturn(queryResult); Entity result = resolver.getSliEntity(SIF_REF_ID1, ZONE_ID1); assertEquals(expected, result); }
@Test public void getSliEntityShouldHandleEmptyQueryList() throws Exception { setupCustomDataMocking(); List<Entity> queryResult = Arrays.asList(new Entity[] {}); when(mockSlcInterface.read(eq(SLI_TYPE1), any(Query.class))).thenReturn(queryResult); Entity result = resolver.getSliEntity(SIF_REF_ID1, ZONE_ID1); Assert.assertNull("Result should be null", result); }
@Test public void getSliEntityShouldUseCorrectType() throws Exception { setupCustomDataMocking(); Entity expected = new GenericEntity(SLI_TYPE2, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE2), any(Query.class))).thenReturn(queryResult); Entity result = resolver.getSliEntity(SIF_REF_ID2, ZONE_ID1); Mockito.verify(mockSlcInterface).read(eq(SLI_TYPE2), any(Query.class)); assertEquals(expected, result); }
@Test public void getSliEntityShouldUseQueryFilter() throws Exception { setupCustomDataMocking(); Entity expected = new GenericEntity(SLI_TYPE2, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE2), queryCaptor.capture())).thenReturn(queryResult); resolver.getSliEntity(SIF_REF_ID2, ZONE_ID1); Assert.assertEquals(SLI_VALUE2, queryCaptor.getAllValues().get(0).getParameters().get(SLI_FIELD2)); Assert.assertEquals(1, queryCaptor.getAllValues().get(0).getParameters().get("limit")); }
@Test public void getSliEntityShouldHandleEmptyLocatorList() throws Exception { setupCustomDataMocking(); Entity result = resolver.getSliEntity(SIF_REF_ID_EMPTY_LIST, ZONE_ID1); Assert.assertNull("Entity should be null", result); }
@Test public void getSliEntityShouldHandleNullLocatorList() throws Exception { setupCustomDataMocking(); Entity result = resolver.getSliEntity(SIF_REF_ID_NULL_LIST, ZONE_ID1); Assert.assertNull("Entity should be null", result); }
@Test public void getSliEntityShouldLookupSeaGuid() throws Exception { when(mockZoneMapProvider.getZoneToSliIdMap()).thenReturn(getDummySeaIdMap()); Entity seaEntity = Mockito.mock(Entity.class); when(seaEntity.getId()).thenReturn(SEA_ID2); List<Entity> queryResult = Arrays.asList(new Entity[] { seaEntity }); when(mockSlcInterface.read(eq(SLI_TYPE_SEA2), queryCaptor.capture())).thenReturn(queryResult); when(mockSeaCustomDataProvider.getIdMap(SEA_ID2)).thenReturn(getDummyIdMap()); resolver.getSliEntity(SIF_REF_ID_NULL_LIST, ZONE_ID2); Assert.assertEquals(SLI_VALUE_SEA2, queryCaptor.getAllValues().get(0).getParameters().get(SLI_FIELD_SEA2)); verify(mockZoneMapProvider, times(1)).getZoneToSliIdMap(); verify(mockSeaCustomDataProvider, times(1)).getIdMap(Mockito.anyString()); verify(mockSeaCustomDataProvider, times(1)).getIdMap(SEA_ID2); }
@Test public void getSliEntityShouldHandleNullSeaEntityList() throws Exception { when(mockZoneMapProvider.getZoneToSliIdMap()).thenReturn(getDummySeaIdMap()); when(mockSlcInterface.read(eq(SLI_TYPE_SEA2), queryCaptor.capture())).thenReturn(null); Entity result = resolver.getSliEntity(SIF_REF_ID_NULL_LIST, ZONE_ID2); Assert.assertNull(result); }
@Test public void getSliEntityShouldHandleEmptySeaEntityList() throws Exception { when(mockZoneMapProvider.getZoneToSliIdMap()).thenReturn(getDummySeaIdMap()); when(mockSlcInterface.read(eq(SLI_TYPE_SEA2), queryCaptor.capture())).thenReturn(new ArrayList<Entity>()); Entity result = resolver.getSliEntity(SIF_REF_ID_NULL_LIST, ZONE_ID2); Assert.assertNull(result); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public String getZoneSea(String zoneId) { synchronized (lock) { Map<String, SliEntityLocator> seaMap = zoneMapProvider.getZoneToSliIdMap(); SliEntityLocator locator = seaMap.get(zoneId); Entity seaEntity = fetchSliEntity(locator); if (seaEntity == null) { return null; } return seaEntity.getId(); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getZoneSeaShouldLookupSeaGuid() throws Exception { when(mockZoneMapProvider.getZoneToSliIdMap()).thenReturn(getDummySeaIdMap()); Entity seaEntity = Mockito.mock(Entity.class); when(seaEntity.getId()).thenReturn(SEA_ID2); List<Entity> queryResult = Arrays.asList(new Entity[] { seaEntity }); when(mockSlcInterface.read(eq(SLI_TYPE_SEA2), queryCaptor.capture())).thenReturn(queryResult); String seaId = resolver.getZoneSea(ZONE_ID2); Assert.assertEquals(1, queryCaptor.getAllValues().size()); Assert.assertEquals(SLI_VALUE_SEA2, queryCaptor.getAllValues().get(0).getParameters().get(SLI_FIELD_SEA2)); Assert.assertEquals(SEA_ID2, seaId); }
|
DeltaExtractor implements InitializingBean { public void execute(String tenant, File tenantDirectory, DateTime deltaUptoTime) { TenantContext.setTenantId(tenant); audit(securityEventUtil.createSecurityEvent(this.getClass().getName(), "Delta Extract Initiation", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0019, DATE_TIME_FORMATTER.print(deltaUptoTime))); Map<String, Set<String>> appsPerEdOrg = appsPerEdOrg(); ExtractFile publicDeltaExtractFile = createPublicExtractFile(tenantDirectory, deltaUptoTime); deltaEntityIterator.init(tenant, deltaUptoTime); while (deltaEntityIterator.hasNext()) { DeltaRecord delta = deltaEntityIterator.next(); if (delta.getOp() == Operation.UPDATE) { extractUpdate(delta, publicDeltaExtractFile, appsPerEdOrg, tenantDirectory, deltaUptoTime); } else if (delta.getOp() == Operation.DELETE) { extractDelete(delta, publicDeltaExtractFile, appsPerEdOrg, tenantDirectory, deltaUptoTime); } else if (delta.getOp() == Operation.PURGE) { extractPurge(delta, publicDeltaExtractFile, appsPerEdOrg, tenantDirectory, deltaUptoTime); } } logEntityCounts(); audit(securityEventUtil.createSecurityEvent(this.getClass().getName(), "Delta Extract Finished", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0021, DATE_TIME_FORMATTER.print(deltaUptoTime))); finalizeExtraction(tenant, deltaUptoTime); } @Override void afterPropertiesSet(); void execute(String tenant, File tenantDirectory, DateTime deltaUptoTime); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); static final DateTimeFormatter DATE_TIME_FORMATTER; static final String DATE_FIELD; static final String TIME_FIELD; }
|
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testPublicAndPrivate() { when(deltaEntityIterator.hasNext()).thenReturn(true, true, true, false); when(deltaEntityIterator.next()).thenReturn(buildUpdatePublicRecord(), buildDeleteRecord(), buildUpdatePrivateRecord()); extractor.execute("Midgar", null, new DateTime()); verify(entityExtractor, times(2)).write(any(Entity.class), any(ExtractFile.class), any(EntityExtractor.CollectionWrittenRecord.class), (Predicate) Mockito.isNull()); verify(entityWriteManager, times(14)).writeDeleteFile(any(Entity.class), any(ExtractFile.class)); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testPrivateOnly() { when(deltaEntityIterator.hasNext()).thenReturn(true, true, false); when(deltaEntityIterator.next()).thenReturn(buildUpdatePrivateRecord(), buildDeleteRecord()); extractor.execute("Midgar", null, new DateTime()); verify(entityExtractor, times(1)).write(any(Entity.class), any(ExtractFile.class), any(EntityExtractor.CollectionWrittenRecord.class), (Predicate) Mockito.isNull()); verify(entityWriteManager, times(8)).writeDeleteFile(any(Entity.class), any(ExtractFile.class)); }
@Test public void testPurge() { when(deltaEntityIterator.hasNext()).thenReturn(true, false); when(deltaEntityIterator.next()).thenReturn(buildPurgeRecord()); extractor.execute("Midgar", null, new DateTime()); verify(entityWriteManager, times(3)).writeDeleteFile(any(Entity.class), any(ExtractFile.class)); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public List<Entity> getSliEntityList(String sifId, String zoneId) { synchronized (lock) { String seaId = getZoneSea(zoneId); Map<String, List<SliEntityLocator>> idMap = customDataProvider.getIdMap(seaId); List<SliEntityLocator> locators = idMap.get(sifId); if (locators == null || locators.size() == 0) { LOG.error("No sif-sli mapping found for sifId: " + sifId); return new ArrayList<Entity>(); } List<Entity> entities = new ArrayList<Entity>(); for (SliEntityLocator locator : locators) { Entity entity = fetchSliEntity(locator); entities.add(entity); } return entities; } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliEntityListShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); List<Entity> expected = new ArrayList<Entity>(); Entity entity = new GenericEntity(SLI_TYPE3A, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3A), any(Query.class))).thenReturn(queryResult); expected.add(entity); entity = new GenericEntity(SLI_TYPE3B, new HashMap<String, Object>()); queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3B), any(Query.class))).thenReturn(queryResult); expected.add(entity); List<Entity> result = resolver.getSliEntityList(SIF_REF_ID3, ZONE_ID1); verify(mockSlcInterface, times(3)).read(Mockito.anyString(), any(Query.class)); verify(mockSlcInterface, times(1)).read(eq(SLI_TYPE3A), any(Query.class)); verify(mockSlcInterface, times(1)).read(eq(SLI_TYPE3B), any(Query.class)); Assert.assertEquals(expected.size(), result.size()); Assert.assertEquals(expected.get(0), result.get(0)); Assert.assertEquals(expected.get(1), result.get(1)); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId) { synchronized (lock) { return getSliEntity(sifId + "-" + sliType, zoneId); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliEntityFromOtherSifIdShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); Entity expected = new GenericEntity(SLI_TYPE4, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE4), any(Query.class))).thenReturn(queryResult); Entity result = resolver.getSliEntityFromOtherSifId(SIF_REF_ID4, SLI_TYPE4, ZONE_ID1); assertEquals(expected, result); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public String getSliGuid(String sifId, String zoneId) { synchronized (lock) { Entity entity = getSliEntity(sifId, zoneId); if (entity == null) { LOG.info("No sli id found for sifId(" + sifId + ")"); return null; } return entity.getId(); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliGuidShouldFindGuid() throws Exception { setupCustomDataMocking(); Entity expected = Mockito.mock(Entity.class); when(expected.getId()).thenReturn(SLI_ID1); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE1), any(Query.class))).thenReturn(queryResult); String result = resolver.getSliGuid(SIF_REF_ID1, ZONE_ID1); assertEquals(SLI_ID1, result); }
@Test public void getSliGuidShouldHandleNull() throws Exception { setupCustomDataMocking(); List<Entity> queryResult = Collections.emptyList(); when(mockSlcInterface.read(eq(SLI_TYPE1), any(Query.class))).thenReturn(queryResult); String result = resolver.getSliGuid(SIF_REF_ID1, ZONE_ID1); Assert.assertNull(result); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public List<String> getSliGuidList(String sifId, String zoneId) { synchronized (lock) { List<Entity> entityList = getSliEntityList(sifId, zoneId); List<String> idList = new ArrayList<String>(); for (Entity entity : entityList) { idList.add(entity.getId()); } return idList; } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliGuidListShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); List<Entity> expected = new ArrayList<Entity>(); Entity entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3A); List<Entity> queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3A), any(Query.class))).thenReturn(queryResult); expected.add(entity); entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3B); queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3B), any(Query.class))).thenReturn(queryResult); expected.add(entity); List<String> result = resolver.getSliGuidList(SIF_REF_ID3, ZONE_ID1); Assert.assertEquals(expected.size(), result.size()); Assert.assertEquals(SLI_ID3A, result.get(0)); Assert.assertEquals(SLI_ID3B, result.get(1)); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId) { synchronized (lock) { return getSliEntityList(sifId + "-" + sliType, zoneId); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliEntityListByTypeShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); List<Entity> expected = new ArrayList<Entity>(); Entity entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3A); List<Entity> queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3A), any(Query.class))).thenReturn(queryResult); expected.add(entity); entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3B); queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3B), any(Query.class))).thenReturn(queryResult); expected.add(entity); List<Entity> result = resolver.getSliEntityListByType(SIF_REF_ID3, SLI_TYPE3A, ZONE_ID1); verify(mockSlcInterface, times(3)).read(Mockito.anyString(), any(Query.class)); verify(mockSlcInterface, times(1)).read(eq(SLI_TYPE3A), any(Query.class)); verify(mockSlcInterface, times(1)).read(eq(SLI_TYPE3B), any(Query.class)); Assert.assertEquals(expected.size(), result.size()); Assert.assertEquals(expected.get(0), result.get(0)); Assert.assertEquals(expected.get(1), result.get(1)); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public Entity getSliEntityByType(String sifId, String sliType, String zoneId) { synchronized (lock) { return getSliEntity(sifId + "-" + sliType, zoneId); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliEntityByTypeShouldLookupSliEntities() throws Exception { setupCustomDataMocking(); Entity expected = new GenericEntity(SLI_TYPE4, new HashMap<String, Object>()); List<Entity> queryResult = Arrays.asList(new Entity[] { expected }); when(mockSlcInterface.read(eq(SLI_TYPE4), any(Query.class))).thenReturn(queryResult); Entity result = resolver.getSliEntityByType(SIF_REF_ID4, SLI_TYPE4, ZONE_ID1); assertEquals(expected, result); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public List<String> getSliGuidListByType(String sifId, String sliType, String zoneId) { synchronized (lock) { List<Entity> entityList = getSliEntityListByType(sifId, sliType, zoneId); List<String> idList = new ArrayList<String>(); for (Entity entity : entityList) { idList.add(entity.getId()); } return idList; } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliGuidListByTypeShouldLookupSliGuids() throws Exception { setupCustomDataMocking(); List<Entity> expected = new ArrayList<Entity>(); Entity entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3A); List<Entity> queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3A), any(Query.class))).thenReturn(queryResult); expected.add(entity); entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID3B); queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE3B), any(Query.class))).thenReturn(queryResult); expected.add(entity); List<String> result = resolver.getSliGuidListByType(SIF_REF_ID3, SLI_TYPE3A, ZONE_ID1); Assert.assertEquals(expected.size(), result.size()); Assert.assertEquals(SLI_ID3A, result.get(0)); Assert.assertEquals(SLI_ID3B, result.get(1)); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public String getSliGuidByType(String sifId, String sliType, String zoneId) { synchronized (lock) { Entity entity = getSliEntityFromOtherSifId(sifId, sliType, zoneId); if (entity == null) { return null; } return entity.getId(); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void getSliGuidByTypeShouldLookupSliGuid() throws Exception { setupCustomDataMocking(); Entity entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID4); List<Entity> queryResult = Arrays.asList(new Entity[] { entity }); when(mockSlcInterface.read(eq(SLI_TYPE4), any(Query.class))).thenReturn(queryResult); String result = resolver.getSliGuidByType(SIF_REF_ID4, SLI_TYPE4, ZONE_ID1); assertEquals(SLI_ID4, result); }
@Test public void getSliGuidByTypeShouldHandleNull() throws Exception { setupCustomDataMocking(); Entity entity = Mockito.mock(Entity.class); when(entity.getId()).thenReturn(SLI_ID4); List<Entity> queryResult = Arrays.asList(new Entity[] {}); when(mockSlcInterface.read(eq(SLI_TYPE4), any(Query.class))).thenReturn(queryResult); String result = resolver.getSliGuidByType(SIF_REF_ID4, SLI_TYPE4, ZONE_ID1); Assert.assertNull(result); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public void putSliGuid(String sifId, String sliType, String sliId, String zoneId) { synchronized (lock) { String seaGuid = getZoneSea(zoneId); Map<String, List<SliEntityLocator>> idMap = customDataProvider.getIdMap(seaGuid); SliEntityLocator id = new SliEntityLocator(sliType, sliId, ParameterConstants.ID); List<SliEntityLocator> existingIdList = idMap.get(sifId); if (existingIdList == null) { existingIdList = new ArrayList<SliEntityLocator>(); } else { for (SliEntityLocator locator : existingIdList) { if (locator.getField().equals(ParameterConstants.ID) && locator.getType().equals(sliType) && locator.getValue().equals(sliId)) { return; } } } existingIdList.add(id); idMap.put(sifId, existingIdList); customDataProvider.storeIdMap(seaGuid, idMap); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void putSliGuidStoreNewId() throws Exception { Map<String, List<SliEntityLocator>> idMap = setupCustomDataMocking(); when(mockSeaCustomDataProvider.getIdMap(SEA_ID1)).thenReturn(idMap); resolver.putSliGuid("newSifId", "sliType", "sliId", ZONE_ID1); List<SliEntityLocator> resultList = idMap.get("newSifId"); Assert.assertNotNull(resultList); Assert.assertEquals(1, resultList.size()); SliEntityLocator locator = resultList.get(0); Assert.assertEquals("sliType", locator.getType()); Assert.assertEquals("sliId", locator.getValue()); Assert.assertEquals(ParameterConstants.ID, locator.getField()); }
@Test public void putSliGuidStoreAdditionalId() throws Exception { Map<String, List<SliEntityLocator>> idMap = setupCustomDataMocking(); when(mockSeaCustomDataProvider.getIdMap(SEA_ID1)).thenReturn(idMap); resolver.putSliGuid(SIF_REF_ID1, SLI_TYPE1, "someNewId", ZONE_ID1); List<SliEntityLocator> resultList = idMap.get(SIF_REF_ID1); Assert.assertNotNull(resultList); Assert.assertEquals(2, resultList.size()); SliEntityLocator locator = resultList.get(1); Assert.assertEquals(SLI_TYPE1, locator.getType()); Assert.assertEquals("someNewId", locator.getValue()); Assert.assertEquals(ParameterConstants.ID, locator.getField()); }
@Test public void putSliGuidUpdatelId() throws Exception { Map<String, List<SliEntityLocator>> idMap = setupCustomDataMocking(); when(mockSeaCustomDataProvider.getIdMap(SEA_ID1)).thenReturn(idMap); resolver.putSliGuid(SIF_REF_ID1, SLI_TYPE1, SLI_VALUE1, ZONE_ID1); List<SliEntityLocator> resultList = idMap.get(SIF_REF_ID1); Assert.assertNotNull(resultList); Assert.assertEquals(1, resultList.size()); }
|
SifIdResolverCustomData implements SifIdResolver { @Override public void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId) { synchronized (lock) { String key = sifId + "-" + sliType; putSliGuid(key, sliType, sliId, zoneId); } } @Override String getSliGuid(String sifId, String zoneId); @Override List<String> getSliGuidList(String sifId, String zoneId); @Override String getSliGuidByType(String sifId, String sliType, String zoneId); @Override List<String> getSliGuidListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntityByType(String sifId, String sliType, String zoneId); @Override List<Entity> getSliEntityListByType(String sifId, String sliType, String zoneId); @Override Entity getSliEntity(String sifId, String zoneId); @Override List<Entity> getSliEntityList(String sifId, String zoneId); @Override String getZoneSea(String zoneId); @Override void putSliGuid(String sifId, String sliType, String sliId, String zoneId); @Override Entity getSliEntityFromOtherSifId(String sifId, String sliType, String zoneId); @Override void putSliGuidForOtherSifId(String sifId, String sliType, String sliId, String zoneId); }
|
@Test public void putSliGuidForOtherSifIdStoreNewId() throws Exception { Map<String, List<SliEntityLocator>> idMap = setupCustomDataMocking(); when(mockSeaCustomDataProvider.getIdMap(SEA_ID1)).thenReturn(idMap); resolver.putSliGuidForOtherSifId("newSifId", "sliType", "sliId", ZONE_ID1); List<SliEntityLocator> resultList = idMap.get("newSifId-sliType"); Assert.assertNotNull(resultList); Assert.assertEquals(1, resultList.size()); SliEntityLocator locator = resultList.get(0); Assert.assertEquals("sliType", locator.getType()); Assert.assertEquals("sliId", locator.getValue()); Assert.assertEquals(ParameterConstants.ID, locator.getField()); }
|
AgentManager { public void setup() throws Exception { System.setProperty("adk.log.file", logPath + File.separator + adkLogFile); ADK.initialize(); ADK.debug = ADK.DBG_ALL; agent.startAgent(); subscribeToZone(); } @PostConstruct void postConstruct(); void setup(); @PreDestroy void cleanup(); void setSubscribeTypeList(List<String> subscribeTypeList); List<String> getSubscribeTypeList(); void setSubscriberZoneName(String subscriberZoneName); String getSubscriberZoneName(); void setAgent(SifAgent agent); SifAgent getAgent(); String getLogPath(); void setLogPath(String logPath); String getAdkLogFile(); void setAdkLogFile(String adkLogFile); List<ElementDef> getSubscribeList(); void setSubscribeList(List<ElementDef> subscribeList); }
|
@Test public void shouldStartAgentOnSetup() throws Exception { agentManager.setup(); Mockito.verify(mockAgent, Mockito.times(1)).startAgent(); }
@Test public void shouldSubscribeToZoneOnSetup() throws Exception { agentManager.setup(); Mockito.verify(mockAgent, Mockito.times(1)).startAgent(); Mockito.verify(mockZone, Mockito.times(1)).setSubscriber(Mockito.any(SifSubscriber.class), Mockito.any(ElementDef.class), Mockito.any(SubscriptionOptions.class)); SifAgent agent = new SifAgent(); Assert.assertTrue("SifAgent should extend", agent instanceof Agent); }
|
AgentManager { @PreDestroy public void cleanup() throws ADKException { agent.shutdown(ADKFlags.PROV_NONE); } @PostConstruct void postConstruct(); void setup(); @PreDestroy void cleanup(); void setSubscribeTypeList(List<String> subscribeTypeList); List<String> getSubscribeTypeList(); void setSubscriberZoneName(String subscriberZoneName); String getSubscriberZoneName(); void setAgent(SifAgent agent); SifAgent getAgent(); String getLogPath(); void setLogPath(String logPath); String getAdkLogFile(); void setAdkLogFile(String adkLogFile); List<ElementDef> getSubscribeList(); void setSubscribeList(List<ElementDef> subscribeList); }
|
@Test public void shouldShutdownAgentOnCleanup() throws ADKException { agentManager.cleanup(); Mockito.verify(mockAgent, Mockito.times(1)).shutdown(Mockito.eq(ADKFlags.PROV_NONE)); }
|
SifAgent extends Agent { public void startAgent() throws Exception { super.initialize(); setProperties(); Zone[] allZones = getZoneFactory().getAllZones(); zoneConfigurator.configure(allZones); } SifAgent(); SifAgent(String id); SifAgent(String id, ZoneConfigurator zoneConfig, Properties agentProperties,
Properties httpProperties, Properties httpsProperties, String zoneId,
String zoneUrl, SIFVersion sifVersion); void startAgent(); void setConfigFilePath(String configFilePath); String getConfigFilePath(); void setZoneConfigurator(ZoneConfigurator zoneConfigurator); ZoneConfigurator getZoneConfigurator(); void setAgentProperties(Properties agentProperties); Properties getAgentProperties(); void setHttpProperties(Properties httpProperties); Properties getHttpProperties(); void setHttpsProperties(Properties httpsProperties); Properties getHttpsProperties(); void setSifVersion(SIFVersion sifVersion); SIFVersion getSifVersion(); }
|
@Test public void shouldCreateAndConfigureAgent() throws Exception { ZoneConfigurator mockZoneConfigurator = Mockito.mock(ZoneConfigurator.class); SifAgent agent = createSifAgent(mockZoneConfigurator); agent.startAgent(); AgentProperties props = agent.getProperties(); Assert.assertEquals("Push", props.getProperty("adk.messaging.mode")); Assert.assertEquals("http", props.getProperty("adk.messaging.transport")); Assert.assertEquals("30000", props.getProperty("adk.messaging.pullFrequency")); Assert.assertEquals("32000", props.getProperty("adk.messaging.maxBufferSize")); Assert.assertEquals("test.publisher.agent", agent.getId()); TransportManager transportManager = agent.getTransportManager(); Transport transport = transportManager.getTransport("http"); TransportProperties transportProperties = transport.getProperties(); Assert.assertEquals("25101", transportProperties.getProperty("port")); Zone[] allZones = agent.getZoneFactory().getAllZones(); Assert.assertNotNull("Agents zones should not be null", allZones); Assert.assertEquals("Agent should be configured with one zone", 1, allZones.length); Assert.assertNotNull("Agent's zone should not be null", allZones[0]); Assert.assertEquals("Agent's zone Id should be TestZone", "TestZone", allZones[0].getZoneId()); Assert.assertEquals("Agent's zone URL should be http: "http: Mockito.verify(mockZoneConfigurator, Mockito.times(1)).configure(Mockito.any(Zone[].class)); }
|
SifSubscriber implements Subscriber { @Override public void onEvent(Event event, Zone zone, MessageInfo info) throws ADKException { LOG.info("Received event:\n" + "\tEvent: " + event.getActionString() + "\n" + "\tZone: " + zone.getZoneId() + "\n" + "\tInfo: " + info); SIFDataObject sifData = inspectAndDestroyEvent(event); boolean tokenChecked = false; String token = slcInterface.sessionCheck(); if (token != null && token.length() > 0) { tokenChecked = true; LOG.info("Successfully executed session check with token " + token); } else { LOG.info("Session check failed"); } if (sifData != null && tokenChecked && event.getAction() != null) { List<SliEntity> entities = translationManager.translate(sifData, zone.getZoneId()); Entity matchedEntity; switch (event.getAction()) { case ADD: for (SliEntity sliEntity : entities) { matchedEntity = findCombiningEntity(sliEntity, zone.getZoneId()); if (matchedEntity != null) { changeEntity(sifData, sliEntity, zone.getZoneId(), matchedEntity); sifIdResolver.putSliGuid(sifData.getRefId(), matchedEntity.getEntityType(), matchedEntity.getId(), zone.getZoneId()); } else { addEntity(sifData, zone.getZoneId(), sliEntity); } } break; case CHANGE: List<Entity> matchedEntities = sifIdResolver.getSliEntityList(sifData.getRefId(), zone.getZoneId()); if (entities == null || entities.isEmpty()) { LOG.warn("Null or empty translated SIF entities: " + entities); } else if (matchedEntities == null || matchedEntities.isEmpty()) { LOG.warn("Null or empty SIF entities (no entity found to update): " + matchedEntities); } else { for (SliEntity sliEntity : entities) { for (Entity e : matchedEntities) { if (sliEntity.entityType().equals(e.getEntityType())) { changeEntity(sifData, sliEntity, zone.getZoneId(), e); } } } } break; case UNDEFINED: default: LOG.error("Unsupported SIF Action: " + event.getAction()); break; } } } @Override void onEvent(Event event, Zone zone, MessageInfo info); }
|
@Test public void shouldCallSessionCheckOnEvent() throws ADKException { SIFDataObject mockSifDataObject = createMockSifDataObject(); Event mockEvent = createMockSifEvent(false, mockSifDataObject); Zone mockZone = createMockZone(); MessageInfo mockInfo = createMockInfo(); subscriber.onEvent(mockEvent, mockZone, mockInfo); Mockito.verify(mockSlcInterface, Mockito.times(1)).sessionCheck(); }
@Test public void testAddEntityOnEvent() throws ADKException { SIFDataObject mockSifDataObject = createMockSifDataObject(); Event mockEvent = createMockSifEvent(false, mockSifDataObject); Zone mockZone = createMockZone(); MessageInfo mockInfo = createMockInfo(); SliEntity mockSliEntity = Mockito.mock(SliEntity.class); List<SliEntity> mockSliEntities = new ArrayList<SliEntity>(); mockSliEntities.add(mockSliEntity); GenericEntity mockGenericEntity = Mockito.mock(GenericEntity.class); Mockito.when(mockSliEntity.createGenericEntity()).thenReturn(mockGenericEntity); Mockito.when(mockSliEntity.entityType()).thenReturn(SLI_TYPE); Mockito.when(mockSliEntity.getOtherSifRefId()).thenReturn(OTHER_SIF_ID); Mockito.when(mockSliEntity.hasOtherSifRefId()).thenReturn(true); Mockito.when(mockSliEntity.isCreatedByOthers()).thenReturn(false); Mockito.when(sifIdResolver.getSliEntityFromOtherSifId(OTHER_SIF_ID, SLI_TYPE, ZONE_ID)).thenReturn(null); Mockito.when(mockTranslationManager.translate(mockSifDataObject, ZONE_ID)).thenReturn(mockSliEntities); Mockito.when(mockSlcInterface.create(Mockito.any(GenericEntity.class))).thenReturn(SLI_ID); subscriber.onEvent(mockEvent, mockZone, mockInfo); Mockito.verify(mockSlcInterface, Mockito.times(1)).create(mockGenericEntity); Mockito.verify(sifIdResolver, Mockito.times(1)).putSliGuid(SIF_ID, SLI_TYPE, SLI_ID, ZONE_ID); Mockito.verify(sifIdResolver, Mockito.times(1)).putSliGuidForOtherSifId(OTHER_SIF_ID, SLI_TYPE, SLI_ID, ZONE_ID); }
@Test public void testChangeEntityOnEvent() throws ADKException { SIFDataObject mockSifDataObject = createMockSifDataObject(); Event mockEvent = createMockSifEvent(true, mockSifDataObject); Zone mockZone = createMockZone(); MessageInfo mockInfo = createMockInfo(); SliEntity mockSliEntity = Mockito.mock(SliEntity.class); List<SliEntity> mockSliEntities = new ArrayList<SliEntity>(); mockSliEntities.add(mockSliEntity); Map<String, Object> mockBody = new HashMap<String, Object>(); Mockito.when(mockSliEntity.createBody()).thenReturn(mockBody); Mockito.when(mockSliEntity.entityType()).thenReturn(SLI_TYPE); Mockito.when(mockTranslationManager.translate(mockSifDataObject, ZONE_ID)).thenReturn(mockSliEntities); GenericEntity mockEntity = new GenericEntity(SLI_TYPE, mockBody); List<Entity> mockEntityList = new ArrayList<Entity>(); mockEntityList.add(mockEntity); Mockito.when(sifIdResolver.getSliEntityList(SIF_ID, ZONE_ID)).thenReturn(mockEntityList); subscriber.onEvent(mockEvent, mockZone, mockInfo); Mockito.verify(mockSlcInterface, Mockito.times(1)).update(mockEntity); Mockito.verify(sifIdResolver, Mockito.never()).putSliGuid(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString()); Mockito.verify(sifIdResolver, Mockito.never()).putSliGuidForOtherSifId(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString()); }
@Test public void testAddWithCommonCreatorCombine() throws ADKException { SIFDataObject mockSifDataObject = createMockSifDataObject(); Event mockEvent = createMockSifEvent(false, mockSifDataObject); Zone mockZone = createMockZone(); MessageInfo mockInfo = createMockInfo(); SliEntity mockSliEntity = Mockito.mock(SliEntity.class); List<SliEntity> mockSliEntities = new ArrayList<SliEntity>(); mockSliEntities.add(mockSliEntity); GenericEntity mockGenericEntity = Mockito.mock(GenericEntity.class); Mockito.when(mockSliEntity.createGenericEntity()).thenReturn(mockGenericEntity); Mockito.when(mockSliEntity.entityType()).thenReturn(SLI_TYPE); Mockito.when(mockSliEntity.hasOtherSifRefId()).thenReturn(false); Mockito.when(mockSliEntity.isCreatedByOthers()).thenReturn(true); Mockito.when(mockSliEntity.getCreatorRefId()).thenReturn(CREATOR_SIF_ID); Entity combiningEntity = Mockito.mock(Entity.class); Mockito.when(combiningEntity.getId()).thenReturn(SLI_ID); Mockito.when(combiningEntity.getEntityType()).thenReturn(SLI_TYPE); Mockito.when(sifIdResolver.getSliEntity(CREATOR_SIF_ID, ZONE_ID)).thenReturn(combiningEntity); Mockito.when(mockTranslationManager.translate(mockSifDataObject, ZONE_ID)).thenReturn(mockSliEntities); subscriber.onEvent(mockEvent, mockZone, mockInfo); Mockito.verify(mockSlcInterface, Mockito.times(1)).update(combiningEntity); Mockito.verify(sifIdResolver, Mockito.times(1)).putSliGuid(SIF_ID, SLI_TYPE, SLI_ID, ZONE_ID); Mockito.verify(sifIdResolver, Mockito.never()).putSliGuidForOtherSifId(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString()); }
@Test public void testAddWithCommonOtherIdCombine() throws ADKException { SIFDataObject mockSifDataObject = createMockSifDataObject(); Event mockEvent = createMockSifEvent(false, mockSifDataObject); Zone mockZone = createMockZone(); MessageInfo mockInfo = createMockInfo(); SliEntity mockSliEntity = Mockito.mock(SliEntity.class); List<SliEntity> mockSliEntities = new ArrayList<SliEntity>(); mockSliEntities.add(mockSliEntity); GenericEntity mockGenericEntity = Mockito.mock(GenericEntity.class); Mockito.when(mockSliEntity.createGenericEntity()).thenReturn(mockGenericEntity); Mockito.when(mockSliEntity.entityType()).thenReturn(SLI_TYPE); Mockito.when(mockSliEntity.hasOtherSifRefId()).thenReturn(true); Mockito.when(mockSliEntity.isCreatedByOthers()).thenReturn(false); Mockito.when(mockSliEntity.getOtherSifRefId()).thenReturn(OTHER_SIF_ID); Entity combiningEntity = Mockito.mock(Entity.class); Mockito.when(combiningEntity.getId()).thenReturn(SLI_ID); Mockito.when(combiningEntity.getEntityType()).thenReturn(SLI_TYPE); Mockito.when(sifIdResolver.getSliEntityFromOtherSifId(OTHER_SIF_ID, SLI_TYPE, ZONE_ID)).thenReturn(combiningEntity); Mockito.when(mockTranslationManager.translate(mockSifDataObject, ZONE_ID)).thenReturn(mockSliEntities); subscriber.onEvent(mockEvent, mockZone, mockInfo); Mockito.verify(mockSlcInterface, Mockito.times(1)).update(combiningEntity); Mockito.verify(sifIdResolver, Mockito.times(1)).putSliGuid(SIF_ID, SLI_TYPE, SLI_ID, ZONE_ID); Mockito.verify(sifIdResolver, Mockito.never()).putSliGuidForOtherSifId(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString()); }
|
StudentPersonalTranslationTask extends AbstractTranslationTask<StudentPersonal, StudentEntity> { private List<String> getHomeLanguages(LanguageList languageList) { Language[] languages = languageList == null ? null : languageList.getLanguages(); if (languages == null) { return null; } LanguageList homeList = new LanguageList(); for (Language language : languages) { if (language.getLanguageType() != null && LanguageType.HOME.valueEquals(language.getLanguageType())) { homeList.add(language); } } return homeList.size() == 0 ? null : languageListConverter.convert(homeList); } StudentPersonalTranslationTask(); @Override List<StudentEntity> doTranslate(StudentPersonal sifData, String zoneId); }
|
@Test public void testLanguages() throws SifTranslationException { StudentPersonal info = new StudentPersonal(); Demographics demographics = new Demographics(); LanguageList languageList = new LanguageList(); languageList.addLanguage(LanguageCode.ENGLISH); languageList.addLanguage(LanguageCode.CHINESE); demographics.setLanguageList(languageList); info.setDemographics(demographics); Mockito.when(mockLanguageListConverter.convert(Mockito.any(LanguageList.class))).thenReturn(Arrays.asList("English", "Chinese")); List<StudentEntity> result = translator.translate(info, null); Assert.assertEquals(1, result.size()); StudentEntity entity = result.get(0); List<String> list = entity.getLanguages(); Assert.assertEquals(2, list.size()); Assert.assertEquals("language[0] is expected to be 'English'", "English", list.get(0)); Assert.assertEquals("language[1] is expected to be 'Chinese'", "Chinese", list.get(1)); list = entity.getHomeLanguages(); Assert.assertNull("Home Languages was not null", list); }
|
EmploymentRecordToStaffEdOrgTranslationTask extends
AbstractTranslationTask<EmploymentRecord, StaffEducationOrganizationAssociationEntity> { @Override public List<StaffEducationOrganizationAssociationEntity> doTranslate(EmploymentRecord sifData, String zoneId) { List<StaffEducationOrganizationAssociationEntity> result = new ArrayList<StaffEducationOrganizationAssociationEntity>(); if (sifData == null) { return result; } sifData.setRefId(sifData.getSIF_RefId() + ":" + sifData.getSIF_RefObject() + ":" + sifData.getLEAInfoRefId()); Entity staff = sifIdResolver.getSliEntity(sifData.getSIF_RefId(), zoneId); Entity edOrg = sifIdResolver.getSliEntity(sifData.getLEAInfoRefId(), zoneId); if (staff == null || edOrg == null) { return result; } StaffEducationOrganizationAssociationEntity e = new StaffEducationOrganizationAssociationEntity(); e.setEducationOrganizationReference(edOrg.getId()); e.setStaffReference(staff.getId()); e.setPositionTitle(sifData.getPositionTitle()); e.setBeginDate(dateConverter.convert(sifData.getHireDate())); e.setEndDate(dateConverter.convert(sifData.getTerminationDate())); e.setStaffClassification("Other"); result.add(e); return result; } EmploymentRecordToStaffEdOrgTranslationTask(); @Override List<StaffEducationOrganizationAssociationEntity> doTranslate(EmploymentRecord sifData, String zoneId); }
|
@Test public void shouldNotReturnNull() { Entity entity = new GenericEntity("entityType", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(new EmploymentRecord(), "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); }
@Test public void shouldGenerateSifId() { EmploymentRecord er = new EmploymentRecord(); er.setSIF_RefId("staffId"); er.setSIF_RefObject("EmployeePersonal"); er.setLEAInfoRefId("leaInfoRefId"); Entity entity = new GenericEntity("entityType", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); translator.doTranslate(er, "zone"); Assert.assertEquals("staffId:EmployeePersonal:leaInfoRefId", er.getRefId()); }
@Test public void shouldReturnEmptyList() { List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(null, "zone"); Assert.assertNotNull(result); Assert.assertEquals(0, result.size()); }
@Test public void shouldReturnNothingWhenMissingStaff() { EmploymentRecord er = new EmploymentRecord(); er.setLEAInfoRefId("schoolId"); er.setSIF_RefId("teacherId"); Entity school = new GenericEntity("school", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity("schoolId", "zone")).thenReturn(school); Mockito.when(sifIdResolver.getSliEntity("teacherId", "zone")).thenReturn(null); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(0, result.size()); }
@Test public void shouldReturnNothingWhenMissingEdorg() { EmploymentRecord er = new EmploymentRecord(); er.setLEAInfoRefId("schoolId"); er.setSIF_RefId("teacherId"); Entity staff = new GenericEntity("teacher", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity("schoolId", "zone")).thenReturn(null); Mockito.when(sifIdResolver.getSliEntity("teacherId", "zone")).thenReturn(staff); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(0, result.size()); }
@Test public void shouldTranslateLeaRefId() { EmploymentRecord er = new EmploymentRecord(); er.setLEAInfoRefId("leaSifId"); Entity entity = new SimpleEntity("entityType", "leaSliGuid"); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); StaffEducationOrganizationAssociationEntity e = result.get(0); Assert.assertEquals("leaSliGuid", e.getEducationOrganizationReference()); }
@Test public void shouldTranslateStaffId() { EmploymentRecord er = new EmploymentRecord(); er.setSIF_RefId("sifStaffId"); Entity entity = new SimpleEntity("entityType", "staffSliGuid"); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); StaffEducationOrganizationAssociationEntity e = result.get(0); Assert.assertEquals("staffSliGuid", e.getStaffReference()); }
@Test public void shouldPopulateDefaultStaffClassification() { EmploymentRecord er = new EmploymentRecord(); Entity entity = new GenericEntity("entityType", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); StaffEducationOrganizationAssociationEntity e = result.get(0); Assert.assertEquals("Other", e.getStaffClassification()); }
@Test public void shouldTranslateTitle() { EmploymentRecord er = new EmploymentRecord(); er.setPositionTitle("title"); Entity entity = new GenericEntity("entityType", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); StaffEducationOrganizationAssociationEntity e = result.get(0); Assert.assertEquals("title", e.getPositionTitle()); }
@Test public void shouldTranslateDates() { EmploymentRecord er = new EmploymentRecord(); Calendar hire = new GregorianCalendar(2004, Calendar.FEBRUARY, 1); Calendar terminate = new GregorianCalendar(2005, Calendar.DECEMBER, 29); er.setHireDate(hire); er.setTerminationDate(terminate); Mockito.when(mockDateConverter.convert(hire)).thenReturn("hireDate"); Mockito.when(mockDateConverter.convert(terminate)).thenReturn("terminateDate"); Entity entity = new GenericEntity("entityType", new HashMap<String, Object>()); Mockito.when(sifIdResolver.getSliEntity(Mockito.anyString(), Mockito.anyString())).thenReturn(entity); List<StaffEducationOrganizationAssociationEntity> result = translator.doTranslate(er, "zone"); Assert.assertNotNull(result); Assert.assertEquals(1, result.size()); StaffEducationOrganizationAssociationEntity e = result.get(0); Assert.assertEquals("hireDate", e.getBeginDate()); Assert.assertEquals("terminateDate", e.getEndDate()); }
|
EdOrgExtractor { public void execute(String tenant, File tenantDirectory, DateTime startTime) { TenantContext.setTenantId(tenant); this.tenantDirectory = tenantDirectory; this.startTime = startTime; audit(securityEventUtil.createSecurityEvent(this.getClass().getName(), "Top-level extract initiated", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0008)); if (factory == null) { factory = new ExtractorFactory(); } if (edOrgToExtractFileMap == null) { edOrgToExtractFileMap = new ExtractFileMap(buildEdOrgToExtractFile()); } StudentExtractor student = factory.buildStudentExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); student.extractEntities(null); EntityDatedExtract attendanceExtractor = factory.buildAttendanceExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); attendanceExtractor.extractEntities(student.getStudentDatedCache()); EntityDatedExtract studentSchoolAssociation = factory.buildStudentSchoolAssociationExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); studentSchoolAssociation.extractEntities(student.getStudentDatedCache()); EntityDatedExtract studentAssessmentExtractor = factory.buildStudentAssessmentExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); studentAssessmentExtractor.extractEntities(student.getStudentDatedCache()); StudentGradebookEntryExtractor studentGradebookExtractor = factory.buildStudentGradebookEntryExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); studentGradebookExtractor.extractEntities(student.getStudentDatedCache()); EntityDatedExtract discipline = factory.buildDisciplineExtractor(entityExtractor, edOrgToExtractFileMap, repository, student.getStudentDatedCache()); discipline.extractEntities(student.getDiDateCache()); YearlyTranscriptExtractor yearlyTranscript = factory.buildYearlyTranscriptExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); yearlyTranscript.extractEntities(student.getStudentDatedCache()); EntityToEdOrgDateCache studentAcademicRecordDateCache = yearlyTranscript.getStudentAcademicRecordDateCache(); EntityDatedExtract courseTranscriptExtractor = factory.buildCourseTranscriptExtractor(entityExtractor, edOrgToExtractFileMap, repository, student.getStudentDatedCache()); courseTranscriptExtractor.extractEntities(studentAcademicRecordDateCache); EntityExtract genericExtractor = factory.buildParentExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); genericExtractor.extractEntities(student.getParentCache()); StaffEdorgAssignmentExtractor seoaExtractor = factory.buildStaffAssociationExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); seoaExtractor.extractEntities(null); EntityDatedExtract staffExtractor = factory.buildStaffExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); staffExtractor.extractEntities(seoaExtractor.getStaffDatedCache()); EntityDatedExtract teacherSchoolAssociationExtractor = factory.buildTeacherSchoolAssociationExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); teacherSchoolAssociationExtractor.extractEntities(seoaExtractor.getStaffDatedCache()); EntityDatedExtract staffProgramExtractor = factory.buildStaffProgramAssociationExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); staffProgramExtractor.extractEntities(seoaExtractor.getStaffDatedCache()); EntityDatedExtract staffCohortExtractor = factory.buildStaffCohortAssociationExtractor(entityExtractor, edOrgToExtractFileMap, repository, helper); staffCohortExtractor.extractEntities(seoaExtractor.getStaffDatedCache()); SectionEmbeddedDocsExtractor sectionExtractor = factory.buildSectionExtractor(entityExtractor, edOrgToExtractFileMap, repository, student.getStudentDatedCache(), helper, seoaExtractor.getStaffDatedCache()); sectionExtractor.extractEntities(studentGradebookExtractor.getGradebookEntryCache()); EntityDatedExtract studentCompetencyExtractor = factory.buildStudentCompetencyExtractor(entityExtractor, edOrgToExtractFileMap, repository); studentCompetencyExtractor.extractEntities(sectionExtractor.getStudentSectionAssociationDateCache()); edOrgToExtractFileMap.closeFiles(); edOrgToExtractFileMap.buildManifestFiles(startTime); edOrgToExtractFileMap.archiveFiles(); updateBulkExtractDb(tenant, startTime); LOG.info("Finished top-level extract in: {} seconds", (new DateTime().getMillis() - this.startTime.getMillis()) / 1000); audit(securityEventUtil.createSecurityEvent(this.getClass().getName(), "Marks the end of top-level extract", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0009)); } void execute(String tenant, File tenantDirectory, DateTime startTime); void setRepository(Repository<Entity> repository); void setEntityExtractor(EntityExtractor entityExtractor); void setEntitiesToCollections(Map<String, String> entitiesToCollections); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setHelper(EdOrgExtractHelper helper); void setFactory(ExtractorFactory factory); void setEdOrgToExtractMap(ExtractFileMap map); }
|
@Test @Ignore public void testExecute() { File tenantDir = Mockito.mock(File.class); Map<String, Object> registration = new HashMap<String, Object>(); registration.put("status", "APPROVED"); body.put("registration", registration); Mockito.when(repo.findAll(Mockito.eq("application"), Mockito.any(NeutralQuery.class))).thenReturn( Arrays.asList(mockEntity)); body.put("edorgs", Arrays.asList("lea-one", "lea-two", "lea-three")); Mockito.when(repo.findAll(Mockito.eq("applicationAuthorization"), Mockito.any(NeutralQuery.class))).thenReturn( Arrays.asList(mockEntity)); Entity edOrgOne = Mockito.mock(Entity.class); Mockito.when(edOrgOne.getEntityId()).thenReturn("edorg1"); Entity edOrgTwo = Mockito.mock(Entity.class); Mockito.when(edOrgTwo.getEntityId()).thenReturn("edorg2"); NeutralQuery baseQuery1 = new NeutralQuery(new NeutralCriteria(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, NeutralCriteria.CRITERIA_IN, Arrays.asList("lea-one"))); NeutralQuery baseQuery2 = new NeutralQuery(new NeutralCriteria(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, NeutralCriteria.CRITERIA_IN, Arrays.asList("lea-two"))); NeutralQuery baseQuery3 = new NeutralQuery(new NeutralCriteria(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, NeutralCriteria.CRITERIA_IN, Arrays.asList("lea-three"))); NeutralQuery childQuery = new NeutralQuery(new NeutralCriteria(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, NeutralCriteria.CRITERIA_IN, new HashSet<String>(Arrays.asList("edorg1", "edorg2")))); Mockito.when(repo.findAll(Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), Mockito.eq(baseQuery1))).thenReturn(new ArrayList<Entity>()); Mockito.when(repo.findAll(Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), Mockito.eq(baseQuery2))).thenReturn(Arrays.asList(edOrgOne, edOrgTwo)); Mockito.when(repo.findAll(Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), Mockito.eq(baseQuery3))).thenReturn(new ArrayList<Entity>()); Mockito.when(repo.findAll(Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), Mockito.eq(childQuery))).thenReturn(new ArrayList<Entity>()); extractor.execute("Midgar", tenantDir, new DateTime()); Mockito.verify(entityExtractor, Mockito.times(3)).extractEntities(Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), null); Mockito.verify(entityExtractor, Mockito.times(3)).setExtractionQuery(Mockito.any(NeutralQuery.class)); }
@Ignore @Test public void testExecuteAgain() { File tenantDir = Mockito.mock(File.class); DateTime time = new DateTime(); extractor.execute("Midgar", tenantDir, time); Mockito.verify(mockExtractMap, Mockito.times(1)).archiveFiles(); Mockito.verify(mockExtractMap, Mockito.times(1)).buildManifestFiles(time); Mockito.verify(mockExtractMap, Mockito.times(1)).closeFiles(); }
|
SifTranslationManager { public List<SliEntity> translate(SIFDataObject sifData, String zoneId) { List<SliEntity> entities = new ArrayList<SliEntity>(); List<TranslationTask> translationTasks = translationMap.get(sifData.getObjectType().toString()); if (translationTasks == null) { LOG.error("No TranslationTask found for sif type: " + sifData.getObjectType()); return entities; } for (TranslationTask translationTask : translationTasks) { try { entities.addAll(translationTask.translate(sifData, zoneId)); } catch (SifTranslationException e) { LOG.error("Sif translation exception: ", e); } } return entities; } void setTranslationMap(Map<String, List<TranslationTask>> translationMap); List<SliEntity> translate(SIFDataObject sifData, String zoneId); }
|
@Test public void shouldCreateOneToOneTranslatedEntities() { List<SliEntity> sliEntities = sifTranslationManager.translate(sifB, "zoneId"); Assert.assertEquals("Should translate to one sli entity", 1, sliEntities.size()); Assert.assertEquals("First translated entity not of correct", sliZ, sliEntities.get(0)); }
@Test public void shouldCreateOneToManyTranslatedEntities() { List<SliEntity> sliEntities = sifTranslationManager.translate(sifA, "zoneId"); Assert.assertEquals("Should translate to two sli entities", 2, sliEntities.size()); Assert.assertEquals("First translated entity not of correct", sliX, sliEntities.get(0)); Assert.assertEquals("First translated entity not of correct", sliY, sliEntities.get(1)); }
@Test public void shouldHandleSifTranslationExceptions() throws SifTranslationException { Mockito.when(mockTranslationBtoZ.translate(Mockito.eq(sifB), Mockito.anyString())).thenThrow( new SifTranslationException("test throw")); sifTranslationManager.translate(sifA, "zoneId"); }
|
PublishZoneConfigurator implements ZoneConfigurator { @Override public void configure(Zone[] allZones) { for (Zone zone : allZones) { try { LOG.info("- Connecting to zone \"" + zone.getZoneId() + "\" at " + zone.getZoneUrl()); zone.connect(ADKFlags.PROV_REGISTER | ADKFlags.PROV_PROVIDE); } catch (ADKException ex) { LOG.error(" " + ex.getMessage(), ex); } } } @Override void configure(Zone[] allZones); }
|
@Test public void testConfigure() throws ADKException { Zone[] zones = {zone1, zone2, zone3}; publishZoneConfigurator.configure(zones); Mockito.verify(zone1, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone2, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone3, Mockito.times(1)).connect(Mockito.anyInt()); Assert.assertTrue(publishZoneConfigurator instanceof ZoneConfigurator); }
|
SubscribeZoneConfigurator implements ZoneConfigurator { @Override public void configure(Zone[] allZones) { for (Zone zone : allZones) { try { LOG.info("- Connecting to zone \"" + zone.getZoneId() + "\" at " + zone.getZoneUrl()); zone.connect(ADKFlags.PROV_REGISTER | ADKFlags.PROV_SUBSCRIBE); } catch (ADKException ex) { LOG.error(" " + ex.getMessage(), ex); } } } @Override void configure(Zone[] allZones); }
|
@Test public void testConfigure() throws ADKException { Zone[] zones = {zone1, zone2, zone3}; subscribeZoneConfigurator.configure(zones); Mockito.verify(zone1, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone2, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone3, Mockito.times(1)).connect(Mockito.anyInt()); Assert.assertTrue(subscribeZoneConfigurator instanceof ZoneConfigurator); }
|
SliEntity { public Map<String, Object> createBody() { Map<String, Object> body = null; try { body = MAPPER. readValue(this.json(), new TypeReference<Map<String, Object>>() { }); clearNullValueKeys(body); } catch (JsonParseException e) { LOG.error("Entity map conversion error: ", e); } catch (JsonMappingException e) { LOG.error("Entity map conversion error: ", e); } catch (IOException e) { LOG.error("Entity map conversion error: ", e); } return body; } SliEntity(); abstract String entityType(); GenericEntity createGenericEntity(); Map<String, Object> createBody(); JsonNode json(); @JsonIgnore boolean isCreatedByOthers(); @JsonIgnore String getCreatorRefId(); @JsonIgnore void setCreatorRefId(String creatorRefId); @JsonIgnore String getZoneId(); @JsonIgnore void setZoneId(String zoneId); @JsonIgnore String getOtherSifRefId(); @JsonIgnore void setOtherSifRefId(String otherSifRefId); @JsonIgnore boolean hasOtherSifRefId(); @Override String toString(); }
|
@Test public void shouldTransformConcreteBodyToMap() { testSliEntity = new TestSliEntity(); Map<String, Object> body = testSliEntity.createBody(); Assert.assertEquals("Body should contain 2 elements", 2, body.size()); Assert.assertEquals("Incorrect map element", "1", body.get("fieldOne")); @SuppressWarnings("unchecked") Map<String, Object> subObjectMap = (Map<String, Object>) body.get("testSubObject"); Assert.assertNotNull("SubObject map null", subObjectMap); Assert.assertEquals("subObject should contain 2 elements", 2, subObjectMap.size()); Assert.assertEquals("Incorrect map element", "A", subObjectMap.get("subFieldA")); Assert.assertEquals("Incorrect map element", "B", subObjectMap.get("subFieldB")); }
|
SliEntity { public GenericEntity createGenericEntity() { GenericEntity entity = new GenericEntity(entityType(), createBody()); return entity; } SliEntity(); abstract String entityType(); GenericEntity createGenericEntity(); Map<String, Object> createBody(); JsonNode json(); @JsonIgnore boolean isCreatedByOthers(); @JsonIgnore String getCreatorRefId(); @JsonIgnore void setCreatorRefId(String creatorRefId); @JsonIgnore String getZoneId(); @JsonIgnore void setZoneId(String zoneId); @JsonIgnore String getOtherSifRefId(); @JsonIgnore void setOtherSifRefId(String otherSifRefId); @JsonIgnore boolean hasOtherSifRefId(); @Override String toString(); }
|
@Test public void shouldCreateGenericEntity() { testSliEntity = new TestSliEntity(); GenericEntity entity = testSliEntity.createGenericEntity(); Assert.assertNotNull("GenericEntity null", entity); Assert.assertNotNull("Entity body null", entity.getData()); Assert.assertEquals("Incorrect entity type", "TestEntity", entity.getEntityType()); }
|
OtherIdListConverter { public List<StaffIdentificationCode> convert(OtherIdList otherIdList) { if (otherIdList == null) { return null; } return toSliStaffIdentificationCodeList(otherIdList.getOtherIds()); } List<StaffIdentificationCode> convert(OtherIdList otherIdList); }
|
@Test public void testNullObject() { List<StaffIdentificationCode> result = converter.convert((OtherIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); result = converter.convert((OtherIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); }
@Test public void testEmptyOtherIdList() { OtherIdList list = new OtherIdList(); list.setOtherIds(new OtherId[0]); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyOtherId4OtherIdList() { OtherIdList list = new OtherIdList(); OtherId original = new OtherId(); list.add(original); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(1, result.size()); StaffIdentificationCode it = result.get(0); Assert.assertEquals(original.getValue(), it.getID()); Assert.assertEquals("Other", it.getIdentificationSystem()); }
@Test public void testMappings() { map.clear(); map.put(OtherIdType.ACT_INST, "Other"); map.put(OtherIdType.ACT_PROG, "Other"); map.put(OtherIdType.ATP, "Other"); map.put(OtherIdType.CA_SIN, "Canadian SIN"); map.put(OtherIdType.CERTIFICATE, "Professional Certificate"); map.put(OtherIdType.CONTRACTOR, "Other"); map.put(OtherIdType.DISTRICT_ASSIGNED, "District"); map.put(OtherIdType.DRIVERS_LICENSE, "Drivers License"); map.put(OtherIdType.DUNS, "Other"); map.put(OtherIdType.FAMILY_UNIT, "Other"); map.put(OtherIdType.FEDERAL, "Federal"); map.put(OtherIdType.HEALTH_RECORD, "Health Record"); map.put(OtherIdType.IPEDS, "Other"); map.put(OtherIdType.LEA_SCHOOL, "School"); map.put(OtherIdType.MEDICAID, "Medicaid"); map.put(OtherIdType.MIGRANT, "Other"); map.put(OtherIdType.NCES_LEA, "Other"); map.put(OtherIdType.NCES_LEA, "Other"); map.put(OtherIdType.OTHER, "Other"); map.put(OtherIdType.OTHER_AGENCY, "Other"); map.put(OtherIdType.OTHER_FEDERAL, "Other Federal"); map.put(OtherIdType.PERSONAL, "Other"); map.put(OtherIdType.SCHOOL_ASSIGNED, "School"); map.put(OtherIdType.SEA_LEA, "State"); map.put(OtherIdType.SEA_SCHOOL, "State"); map.put(OtherIdType.SELECTIVE_SERVICE, "Other"); map.put(OtherIdType.SIF1x_DISTRICT_ASSIGNED_NUM, "District"); map.put(OtherIdType.SIF1x_DRIVERS_LICENSE, "Drivers License"); map.put(OtherIdType.SIF1x_FAMILY_UNIT, "Other"); map.put(OtherIdType.SIF1x_HEATH_RECORD, "Health Record"); map.put(OtherIdType.SIF1x_MEDICAID, "Medicaid"); map.put(OtherIdType.SIF1x_MIGRANT, "Other"); map.put(OtherIdType.SIF1x_OTHER, "Other"); map.put(OtherIdType.SIF1x_PIN, "PIN"); map.put(OtherIdType.SIF1x_PROFESSIONAL_LICENSE, "Professional Certificate"); map.put(OtherIdType.SIF1x_SCHOOL_ASSIGNED_NUM, "School"); map.put(OtherIdType.SIF1x_SELECTIVE_SERVICE, "Selective Service"); map.put(OtherIdType.SIF1x_SSN, "SSN"); map.put(OtherIdType.SIF1x_STATE_ASSIGNED_NUM, "State"); map.put(OtherIdType.SIF1x_VISA, "US Visa"); OtherIdList list = getOtherIdList(); List<StaffIdentificationCode> results = converter.convert(list); Assert.assertEquals(list.size(), results.size()); int newCounter = 0; for (StaffIdentificationCode it : results) { Assert.assertNotNull(it); OtherId original = list.get(newCounter++); testMapping(original, it); } OtherIdList list2 = getOtherIdList(); List<StaffIdentificationCode> results2 = converter.convert(list2); Assert.assertEquals(list2.size(), results2.size()); newCounter = 0; for (StaffIdentificationCode it : results2) { Assert.assertNotNull(it); OtherId original = list2.get(newCounter++); testMapping(original, it); } }
|
YesNoUnknownConverter { public Boolean convert(String value) { return value == null ? null : BOOLEAN_MAP.get(value); } Boolean convert(String value); }
|
@Test public void testNullObject() { Boolean result = converter.convert(null); Assert.assertNull("Race list should be null", result); }
@Test public void testYes() { Boolean result = converter.convert("Yes"); Assert.assertEquals(Boolean.TRUE, result); }
@Test public void testNo() { Boolean result = converter.convert("No"); Assert.assertEquals(Boolean.FALSE, result); }
@Test public void testUnknown() { Boolean result = converter.convert("Unknown"); Assert.assertNull(result); }
|
YesNoConverter { public Boolean convert(YesNo value) { return value == null ? null : BOOLEAN_MAP.get(value); } Boolean convert(YesNo value); }
|
@Test public void testNullObject() { Boolean result = converter.convert(null); Assert.assertNull("Result should be null", result); }
@Test public void testYes() { Boolean result = converter.convert(YesNo.YES); Assert.assertEquals(Boolean.TRUE, result); }
@Test public void testNo() { Boolean result = converter.convert(YesNo.NO); Assert.assertEquals(Boolean.FALSE, result); }
@Test public void testUnknown() { Boolean result = converter.convert(YesNo.wrap("Unknown")); Assert.assertNull(result); }
|
EntityExtractor { public void extractEntities(ExtractFile archiveFile, String collectionName, Predicate<Entity> filter) { audit(securityEventUtil.createSecurityEvent(this.getClass().getName(), " Entity extraction", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0024, collectionName)); if (extractionQuery == null) { extractionQuery = new NeutralQuery(); } Iterator<Entity> cursor = entityRepository.findEach(collectionName, extractionQuery); if (cursor.hasNext()) { LOG.info("Extracting from " + collectionName); CollectionWrittenRecord collectionRecord = new CollectionWrittenRecord(collectionName); while (cursor.hasNext()) { Entity entity = cursor.next(); write(entity, archiveFile, collectionRecord, filter); } LOG.info("Finished extracting " + collectionRecord.toString()); } } void extractEntities(ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName); void extractEmbeddedEntities(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void write(Entity entity, ExtractFile archiveFile, CollectionWrittenRecord collectionRecord, Predicate<Entity> filter); void setEntityRepository(Repository<Entity> entityRepository); void setExtractionQuery(NeutralQuery extractionQuery); void setWriter(EntityWriterManager writer); }
|
@SuppressWarnings("unchecked") @Test public void testExtractEntities() throws IOException { String testTenant = "Midgar"; String testEntity = "student"; Iterator<Entity> cursor = Mockito.mock(Iterator.class); List<Entity> students = TestUtils.createStudents(); Mockito.when(cursor.hasNext()).thenReturn(true, true, true, false); Mockito.when(cursor.next()).thenReturn(students.get(0), students.get(1)); Mockito.when(mongoEntityRepository.findEach(Matchers.eq(testEntity), Matchers.any(NeutralQuery.class))).thenReturn(cursor); extractor.extractEntities(archiveFile, testEntity, null); Mockito.verify(mongoEntityRepository, Mockito.times(1)).findEach("student", new NeutralQuery()); Mockito.verify(writer, Mockito.times(2)).write(Mockito.any(Entity.class), Mockito.any(ExtractFile.class)); }
|
DateConverter { public String convert(Calendar date) { if (date == null) { return null; } return dateFormat.format(date.getTime()); } String convert(Calendar date); }
|
@Test public void shouldConvertWithCorrectFormat() { Calendar date = new GregorianCalendar(2004, Calendar.FEBRUARY, 29); String result = converter.convert(date); Assert.assertEquals("2004-02-29", result); }
@Test public void shouldHandleNullDate() { String result = converter.convert(null); Assert.assertNull(result); }
|
ElectronicIdListConverter { public List<StaffIdentificationCode> convert(ElectronicIdList electronicIdList) { if (electronicIdList == null) { return null; } return toSliStaffIdentificationCodeList(electronicIdList.getElectronicIds()); } List<StaffIdentificationCode> convert(ElectronicIdList electronicIdList); }
|
@Test public void testNullObject() { List<StaffIdentificationCode> result = converter.convert((ElectronicIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); result = converter.convert((ElectronicIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); }
@Test public void testEmptyElectronicIdList() { ElectronicIdList list = new ElectronicIdList(); list.setElectronicIds(new ElectronicId[0]); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyElectronicId4ElectronicIdList() { ElectronicIdList list = new ElectronicIdList(); ElectronicId original = new ElectronicId(); list.add(original); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(1, result.size()); StaffIdentificationCode it = result.get(0); Assert.assertEquals(original.getValue(), it.getID()); Assert.assertEquals("Other", it.getIdentificationSystem()); }
@Test public void testMappings() { map.clear(); map.put(ElectronicIdType.BARCODE, "Other"); map.put(ElectronicIdType.MAGSTRIPE, "Other"); map.put(ElectronicIdType.PIN, "PIN"); map.put(ElectronicIdType.RFID, "Other"); ElectronicIdList list = getElectronicIdList(); List<StaffIdentificationCode> results = converter.convert(list); Assert.assertEquals(list.size(), results.size()); int newCounter = 0; for (StaffIdentificationCode it : results) { Assert.assertNotNull(it); ElectronicId original = list.get(newCounter++); testMapping(original, it); } ElectronicIdList list2 = getElectronicIdList(); List<StaffIdentificationCode> results2 = converter.convert(list2); Assert.assertEquals(list2.size(), results2.size()); newCounter = 0; for (StaffIdentificationCode it : results2) { Assert.assertNotNull(it); ElectronicId original = list2.get(newCounter++); testMapping(original, it); } }
|
SchoolFocusConverter { public String convert(SchoolFocusList schoolFocusList) { if (schoolFocusList == null || schoolFocusList.getSchoolFocuses().length == 0) { return null; } SchoolFocus[] schoolFocus = schoolFocusList.getSchoolFocuses(); String result = SCHOOL_FOCUS_MAP.get(schoolFocus[0].getValue()); if (result != null) { return result; } return NOT_SUPPORTED; } String convert(SchoolFocusList schoolFocusList); }
|
@Test public void testNullList() { String result = converter.convert(null); Assert.assertNull("school type should be null", result); }
@Test public void testEmptyList() { SchoolFocusList list = new SchoolFocusList(); String result = converter.convert(list); Assert.assertNull("school type should be null", result); }
@Test public void testEmptySchoolFocus() { SchoolFocusList list = new SchoolFocusList(new SchoolFocus()); String result = converter.convert(list); Assert.assertEquals("Not Supported", result); }
|
EntityExtractor { public void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter) { if (archiveFile != null) { write(entity, archiveFile, new CollectionWrittenRecord(collectionName), filter); } } void extractEntities(ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName); void extractEmbeddedEntities(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void write(Entity entity, ExtractFile archiveFile, CollectionWrittenRecord collectionRecord, Predicate<Entity> filter); void setEntityRepository(Repository<Entity> entityRepository); void setExtractionQuery(NeutralQuery extractionQuery); void setWriter(EntityWriterManager writer); }
|
@Test public void testExtractEntity() throws IOException { extractor.extractEntity(Mockito.mock(Entity.class), Mockito.mock(ExtractFile.class), "BLOOP"); Mockito.verify(writer, Mockito.times(1)).write(Mockito.any(Entity.class), Mockito.any(ExtractFile.class)); }
|
JobClassificationConverter { public String convert(JobClassification jobClassification) { if (jobClassification == null) { return null; } return toSliEntryType(JobClassificationCode.wrap(jobClassification.getCode())); } String convert(JobClassification jobClassification); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Entry Type should be null", result); }
@Test public void testMappings() { Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.ATHLETIC_TRAINER)), "Athletic Trainer"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.INTERPRETER)), "Certified Interpreter"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.COUNSELOR)), "Counselor"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.TEACHING_CLASSROOM_AIDE)), "Instructional Aide"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.LIBRARIAN_MEDIA_CONSULTANT)), "Librarians/Media Specialists"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.PRINCIPAL_HEADMASTER_HEADMISTRESS)), "Principal"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.PHYSICAL_THERAPIST)), "Physical Therapist"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.RESPIRATORY_THERAPIST)), "Physical Therapist"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.TEACHER)), "Teacher"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.SUPERINTENDENT_COMMISSIONER)), "Superintendent"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.NURSE_PRACTITIONER)), "School Nurse"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.LICENSED_PRACTICAL_NURSE)), "School Nurse"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.REGISTERED_NURSE)), "School Nurse"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.OFFICIAL_ADMINISTRATIVE)), "School Administrator"); Assert.assertEquals(converter.convert(getJobClassification(JobClassificationCode.OFFICE_CLERICAL_ADMINISTRATIVE)), "School Administrative Support Staff"); }
|
TeachingAssignmentConverter { public List<String> convert(TeachingAssignment source) { if (source == null) { return null; } List<String> list = new ArrayList<String>(0); list.add(toSliAcademicSubjectType(TeachingArea.wrap(source.getCode()))); return list; } List<String> convert(TeachingAssignment source); }
|
@Test public void testNullObject() { List<String> result = converter.convert(null); Assert.assertNull("Teaching Assignment list should be null", result); }
@Test public void testEmptyList() { TeachingAssignment list = new TeachingAssignment(); List<String> result = converter.convert(list); Assert.assertEquals(1, result.size()); String academicSubjectType = result.get(0); Assert.assertEquals("Not Available", academicSubjectType); }
@Test public void testMappings() { map.clear(); map.put(TeachingArea.ACCOUNTING, "Business and Marketing"); map.put(TeachingArea.AGRICULTURE_OR_NATURAL, "Agriculture, Food, and Natural Resources"); map.put(TeachingArea.AMERICAN_INDIAN_NATIVE, "Other"); map.put(TeachingArea.ANTHROPOLOGY, "Other"); map.put(TeachingArea.AUTISM, "Other"); map.put(TeachingArea.BASIC_SKILLS_OR_REMEDIAL, "Other"); map.put(TeachingArea.BILINGUAL_EDUCATION, "Other"); map.put(TeachingArea.BIOLOGY_OR_LIFE_SCIENCE, "Science"); map.put(TeachingArea.BUSINESS_AND_MANAGEMENT, "Business and Marketing"); map.put(TeachingArea.BUSINESS_OFFICE, "Other"); map.put(TeachingArea.CAREER_EDUCATION, "Other"); map.put(TeachingArea.CHEMISTRY, "Science"); map.put(TeachingArea.CHINESE, "Foreign Language and Literature"); map.put(TeachingArea.CIVICS, "Other"); map.put(TeachingArea.COMMUNICATIONS_TECH, "Communication and Audio/Visual Technology"); map.put(TeachingArea.COMPUTER_SCIENCE, "Computer and Information Sciences"); map.put(TeachingArea.COSMETOLOGY, "Other"); map.put(TeachingArea.DANCE, "Other"); map.put(TeachingArea.DEAF_AND_HARD_OF_HEARING, "Other"); map.put(TeachingArea.DESIGN, "Other"); map.put(TeachingArea.DEVELOPMENTALLY_DELAYED, "Other"); map.put(TeachingArea.DRAMA_TEACHER, "Other"); map.put(TeachingArea.EARLY_CHILDHOOD, "Other"); map.put(TeachingArea.EARLY_CHILDHOOD_SPECIAL, "Other"); map.put(TeachingArea.EARTH_SPACE_SCIENCE_GEOLOGY, "Science"); map.put(TeachingArea.ECONOMICS, "Business and Marketing"); map.put(TeachingArea.ELEMENTARY, "Other"); map.put(TeachingArea.EMOTIONALLY_DISTURBED, "Other"); map.put(TeachingArea.ENGLISH_OR_LANG_ARTS, "English Language and Literature"); map.put(TeachingArea.ESL, "English"); map.put(TeachingArea.FAMILY_AND_CONSUMER_SCIENCE, "Other"); map.put(TeachingArea.FOOD_SERVICES, "Other"); map.put(TeachingArea.FRENCH, "Foreign Language and Literature"); map.put(TeachingArea.GENERAL_SCIENCE, "Science"); map.put(TeachingArea.GEOGRAPHY, "Science"); map.put(TeachingArea.GERMAN, "Foreign Language and Literature"); map.put(TeachingArea.GIFTED_AND_TALENTED, "Other"); map.put(TeachingArea.HEALTH_EDUCATION, "Physical, Health, and Safety Education"); map.put(TeachingArea.HEALTH_PROFESSIONS, "Health Care Sciences"); map.put(TeachingArea.HISTORY, "Social Sciences and History"); map.put(TeachingArea.HUMANITIES, "Human Services"); map.put(TeachingArea.ITALIAN, "Foreign Language and Literature"); map.put(TeachingArea.JAPANESE, "Foreign Language and Literature"); map.put(TeachingArea.JOURNALISM_COMMUNICATIONS, "Communication and Audio/Visual Technology"); map.put(TeachingArea.KINDERGARTEN, "Other"); map.put(TeachingArea.LATIN, "Foreign Language and Literature"); map.put(TeachingArea.LAW, "Public, Protective, and Government Service"); map.put(TeachingArea.LEARNING_DISABILITIES, "Other"); map.put(TeachingArea.MATHEMATICS, "Mathematics"); map.put(TeachingArea.MENTALLY_DISABLED, "Other"); map.put(TeachingArea.MILDLY_MODERATELY_DISABLED, "Other"); map.put(TeachingArea.MILITARY_SCIENCE, "Military Science"); map.put(TeachingArea.MUSIC, "Other"); map.put(TeachingArea.ORTHOPEDICALLY_IMPAIRED, "Other"); map.put(TeachingArea.OTHER, "Other"); map.put(TeachingArea.OTHER_AREA_OR_ETHNIC, "Other"); map.put(TeachingArea.OTHER_BUSINESS, "Other"); map.put(TeachingArea.OTHER_LANGUAGES, "Foreign Language and Literature"); map.put(TeachingArea.OTHER_NATURAL_SCIENCES, "Life and Physical Sciences"); map.put(TeachingArea.OTHER_SOCIAL_STUDIES, "Other"); map.put(TeachingArea.OTHER_SPECIAL_ED, "Other"); map.put(TeachingArea.OTHER_VOCATIONAL_TECH, "Other"); map.put(TeachingArea.PHILOSOPHY, "Other"); map.put(TeachingArea.PHYSICAL_EDUCATION, "Physical, Health, and Safety Education"); map.put(TeachingArea.PHYSICAL_SCIENCE, "Science"); map.put(TeachingArea.PHYSICS, "Science"); map.put(TeachingArea.POLITICAL_SCIENCE_AND, "Other"); map.put(TeachingArea.PSYCHOLOGY, "Other"); map.put(TeachingArea.READING, "Reading"); map.put(TeachingArea.RELIGION, "Religious Education and Theology"); map.put(TeachingArea.RUSSIAN, "Foreign Language and Literature"); map.put(TeachingArea.SOCIAL_STUDIES, "Social Studies"); map.put(TeachingArea.SOCIOLOGY, "Social Studies"); map.put(TeachingArea.SPANISH, "Foreign Language and Literature"); map.put(TeachingArea.SPECIAL_EDUCATION, "Other"); map.put(TeachingArea.SPEECH, "Other"); map.put(TeachingArea.SPEECH_LANGUAGE_IMPAIRED, "Other"); map.put(TeachingArea.TRADES_AND_INDUSTR, "Other"); map.put(TeachingArea.TRAUMATICALLY_BRAIN_INJURED, "Other"); map.put(TeachingArea.VISUAL_ARTS, "Fine and Performing Arts"); map.put(TeachingArea.VISUALLY_IMPAIRED, "Other"); List<TeachingAssignment> list = getTeachingAssignments(); int newCounter = 0; for (TeachingAssignment ta : list) { List<String> results = converter.convert(ta); Assert.assertEquals(1, results.size()); TeachingAssignment original = list.get(newCounter++); testMapping(original.getCode(), results.get(0)); } }
|
EmailListConverter { public List<ElectronicMail> convert(EmailList list) { if (list == null) { return null; } List<ElectronicMail> result = new ArrayList<ElectronicMail>(); for (Email sifEmail : list) { ElectronicMail sliEmail = new ElectronicMail(); sliEmail.setEmailAddress(sifEmail.getValue()); result.add(sliEmail); } return result; } List<ElectronicMail> convert(EmailList list); }
|
@Test public void testNullObject() { List<ElectronicMail> result = converter.convert(null); Assert.assertNull("Address list should be null", result); }
@Test public void testEmptyList() { EmailList list = new EmailList(); List<ElectronicMail> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyEmail() { EmailList list = new EmailList(); list.add(new Email()); List<ElectronicMail> result = converter.convert(list); Assert.assertEquals(1, result.size()); ElectronicMail sliEmail = result.get(0); Assert.assertNull(sliEmail.getEmailAddressType()); Assert.assertNull(sliEmail.getEmailAddress()); }
@Test public void testMappings() { EmailList emails = createEmailList(); List<ElectronicMail> result = converter.convert(emails); Assert.assertEquals("Should map 5 emails", 5, result.size()); for (int i = 0; i < 5; i++) { Assert.assertNotNull(result.get(i)); Assert.assertEquals(result.get(i).getEmailAddress(), "email" + i); Assert.assertEquals(result.get(i).getEmailAddressType(), null); } }
|
TreatmentApplicator implements Treatment { @Override public Entity apply(Entity entity) { Entity treated = entity; for (Treatment treatment : treatments) { treated = treatment.apply(treated); } return treated; } @Override Entity apply(Entity entity); List<Treatment> getTreatments(); void setTreatments(List<Treatment> treatments); }
|
@Test public void testApplyAll() { Entity student = Mockito.mock(Entity.class); applicator.apply(student); Mockito.verify(treatment1,Mockito.atLeast(1)).apply(Mockito.any(Entity.class)); Mockito.verify(treatment2,Mockito.atLeast(1)).apply(Mockito.any(Entity.class)); }
|
DemographicsToBirthDataConverter { public BirthData convert(Demographics sifDemographics) { if (sifDemographics == null) { return null; } BirthData sliBirthData = new BirthData(); sliBirthData.setCountryOfBirthCode(sifDemographics.getCountryOfBirth()); sliBirthData.setCityOfBirth(sifDemographics.getPlaceOfBirth()); if (SLI_STATE_CODES.contains(sifDemographics.getStateOfBirth())) { sliBirthData.setStateOfBirthAbbreviation(sifDemographics.getStateOfBirth()); } SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); if (sifDemographics.getBirthDate() != null) { sliBirthData.setBirthDate(dateFormat.format(sifDemographics.getBirthDate().getTime())); } if (sifDemographics.getCountryArrivalDate() != null) { sliBirthData.setDateEnteredUS(dateFormat.format(sifDemographics.getCountryArrivalDate().getTime())); } return sliBirthData; } BirthData convert(Demographics sifDemographics); }
|
@Test public void nullNameShouldReturnNull() { openadk.library.common.Demographics sifDemographics = null; BirthData sliName = converter.convert(sifDemographics); Assert.assertNull(sliName); }
@Test public void emptySifDemographicShouldMapToNullBirthDataValues() { openadk.library.common.Demographics sifDemographics = new openadk.library.common.Demographics(); BirthData sliBirthData = converter.convert(sifDemographics); Assert.assertNotNull(sliBirthData); Assert.assertNull(sliBirthData.getCityOfBirth()); Assert.assertNull(sliBirthData.getCountryOfBirthCode()); Assert.assertNull(sliBirthData.getStateOfBirthAbbreviation()); Assert.assertNull(sliBirthData.getBirthDate()); Assert.assertNull(sliBirthData.getDateEnteredUS()); }
@Test public void shouldMapSifDemographicToSliBirthData() { for (String state : SLI_STATE_CODES) { BirthData sliBirthData = converter.convert(createSifDemographics(state)); Assert.assertNotNull(sliBirthData); Assert.assertEquals(placeOfBirth, sliBirthData.getCityOfBirth()); Assert.assertEquals(countryOfBirth, sliBirthData.getCountryOfBirthCode()); Assert.assertEquals(state, sliBirthData.getStateOfBirthAbbreviation()); Assert.assertEquals(DATE_FORMAT.format(birthDate.getTime()), sliBirthData.getBirthDate()); Assert.assertEquals(DATE_FORMAT.format(countryArrivalDate.getTime()), sliBirthData.getDateEnteredUS()); } BirthData sliBirthData = converter.convert(createSifDemographics("invlaid_state")); Assert.assertNotNull(sliBirthData); Assert.assertNull(sliBirthData.getStateOfBirthAbbreviation()); }
|
EntryTypeConverter { public String convert(EntryType entryType) { if (entryType == null) { return null; } return toSliEntryType(EntryTypeCode.wrap(entryType.getCode())); } String convert(EntryType entryType); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Entry Type should be null", result); }
@Test public void testMappings() { Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1821)), "Transfer from a public school in the same local education agency"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1822)), "Transfer from a public school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1823)), "Transfer from a public school in a different state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1824)), "Transfer from a private, non-religiously-affiliated school in the same local education agency"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1825)), "Transfer from a private, non-religiously-affiliated school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1826)), "Transfer from a private, non-religiously-affiliated school in a different state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1827)), "Transfer from a private, religiously-affiliated school in the same local education agency"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1828)), "Transfer from a private, religiously-affiliated school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1829)), "Transfer from a private, religiously-affiliated school in a different state"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1830)), "Transfer from a school outside of the country"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1831)), "Transfer from an institution"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1832)), "Transfer from a charter school"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1833)), "Transfer from home schooling"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1835)), "Re-entry from the same school with no interruption of schooling"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1836)), "Re-entry after a voluntary withdrawal"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1837)), "Re-entry after an involuntary withdrawal"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1838)), "Original entry into a United States school"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1839)), "Original entry into a United States school from a foreign country with no interruption in schooling"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_1840)), "Original entry into a United States school from a foreign country with an interruption in schooling"); Assert.assertEquals(converter.convert(getEntryType(EntryTypeCode._0619_9999)), "Other"); }
|
AddressListConverter { public List<Address> convert(AddressList addressList) { if (addressList == null) { return null; } return toSliAddressList(addressList.getAddresses()); } List<Address> convert(AddressList addressList); List<Address> convert(StudentAddressList addressList); }
|
@Test public void testNullObject() { List<Address> result = converter.convert((AddressList) null); Assert.assertNull("Address list should be null", result); }
@Test public void testEmptyList() { AddressList list = new AddressList(); List<Address> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyAddress() { AddressList list = new AddressList(); openadk.library.common.Address original = new openadk.library.common.Address(); list.add(original); List<Address> result = converter.convert(list); Assert.assertEquals(1, result.size()); Address address = result.get(0); Assert.assertEquals("Other", address.getAddressType()); Assert.assertNull(address.getCity()); Assert.assertNull(address.getCountryCode()); Assert.assertNull(address.getPostalCode()); Assert.assertNull(address.getStateAbbreviation()); Assert.assertNull(address.getStreetNumberName()); }
@Test public void testConversion() { map.clear(); map.put(AddressType._0369_CAMPUS, "Other"); map.put(AddressType._0369_EMPLOYER, "Other"); map.put(AddressType._0369_EMPLOYMENT, "Work"); map.put(AddressType._0369_MAILING, "Mailing"); map.put(AddressType._0369_ORGANIZATION, "Other"); map.put(AddressType._0369_OTHER, "Other"); map.put(AddressType._0369_PERMANENT, "Other"); map.put(AddressType.EMPLOYERS, "Other"); map.put(AddressType.EMPLOYMENT, "Work"); map.put(AddressType.MAILING, "Mailing"); map.put(AddressType.OTHER_HOME, "Home"); map.put(AddressType.OTHER_ORGANIZATION, "Other"); map.put(AddressType.PHYSICAL_LOCATION, "Physical"); map.put(AddressType.SHIPPING, "Other"); map.put(AddressType.SIF15_CAMPUS, "Other"); map.put(AddressType.SIF15_EMPLOYER, "Other"); map.put(AddressType.SIF15_EMPLOYMENT, "Work"); map.put(AddressType.SIF15_MAILING, "Mailing"); map.put(AddressType.SIF15_ORGANIZATION, "Other"); map.put(AddressType.SIF15_OTHER, "Other"); map.put(AddressType.SIF15_PERMANENT, "Other"); map.put(AddressType.wrap("something else"), "Other"); addressTypes.addAll(map.keySet()); AddressList originalList = new AddressList(); for (int i = 0; i < addressTypes.size(); i++) { openadk.library.common.Address address = getAddress(i); originalList.add(address); } List<Address> convertedList = converter.convert(originalList); Assert.assertEquals(originalList.size(), convertedList.size()); int i = 0; for (Address converted : convertedList) { openadk.library.common.Address original = originalList.get(i++); testMapping(original, converted); } }
|
AttendanceTreatment implements Treatment { @Override public Entity apply(Entity entity) { if (entity.getBody().containsKey("schoolYearAttendance")) { LOG.debug("Treatment has already been applied to attendance entity: {}", new Object[] { entity.getEntityId() }); return entity; } Map<String,Object> treated = AttendanceStrategyHelper.wrap(entity.getBody()); entity.getBody().clear(); entity.getBody().putAll(treated); return entity; } @Override Entity apply(Entity entity); }
|
@Test public void testApply() { Map<String, Object> body = new HashMap<String, Object>(); body.put("schoolYear", "schoolYear"); List<Map<String,Object>> attendanceEvent = new ArrayList<Map<String,Object>>(); body.put("attendanceEvent", attendanceEvent); Entity entity = new BulkExtractEntity(body, "student"); Entity treated = treat.apply(entity); Assert.assertNotNull(treated.getBody().get("schoolYearAttendance")); List<Map<String, Object>> attendances = new ArrayList<Map<String, Object>>(); Map<String, Object> schoolYearAttendance = new HashMap<String, Object>(); attendances = (List<Map<String, Object>>) treated.getBody().get("schoolYearAttendance"); schoolYearAttendance = attendances.get(0); Assert.assertNotNull(schoolYearAttendance.get("schoolYear")); Assert.assertNotNull(schoolYearAttendance.get("attendanceEvent")); Assert.assertEquals("schoolYear", schoolYearAttendance.get("schoolYear")); Assert.assertNotNull(schoolYearAttendance.get("attendanceEvent")); }
@Test public void testDuplicateApplication() { Map<String, Object> body = new HashMap<String, Object>(); body.put("schoolYearAttendance", new Object()); Entity entity = new BulkExtractEntity(body, "student"); Entity treated = treat.apply(entity); Assert.assertEquals(entity, treated); }
|
PhoneNumberListConverter { public List<InstitutionTelephone> convertInstitutionTelephone(PhoneNumberList phoneNumberList) { if (phoneNumberList == null) { return null; } return toSliInstitutionTelephoneList(phoneNumberList.getPhoneNumbers()); } List<InstitutionTelephone> convertInstitutionTelephone(PhoneNumberList phoneNumberList); List<PersonalTelephone> convertPersonalTelephone(PhoneNumberList phoneNumberList); }
|
@Test public void testNullObject() { List<InstitutionTelephone> result = converter.convertInstitutionTelephone(null); Assert.assertNull("Telephone list should be null", result); }
@Test public void testEmptyList() { PhoneNumberList list = new PhoneNumberList(); list.setPhoneNumbers(new PhoneNumber[0]); List<InstitutionTelephone> result = converter.convertInstitutionTelephone(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyPhoneNumber() { PhoneNumberList list = new PhoneNumberList(); PhoneNumber original = new PhoneNumber(); list.add(original); List<InstitutionTelephone> result = converter.convertInstitutionTelephone(list); Assert.assertEquals(1, result.size()); InstitutionTelephone it = result.get(0); Assert.assertEquals(original.getNumber(), it.getTelephoneNumber()); Assert.assertEquals("Other", it.getInstitutionTelephoneNumberType()); }
@Test public void testMappings() { map.clear(); map.put(PhoneNumberType.ALT, "Other"); map.put(PhoneNumberType.ANSWERING_SERVICE, "Other"); map.put(PhoneNumberType.APPOINTMENT, "Other"); map.put(PhoneNumberType.BEEPER, "Other"); map.put(PhoneNumberType.FAX, "Fax"); map.put(PhoneNumberType.INSTANT_MESSAGING, "Other"); map.put(PhoneNumberType.MEDIA_CONFERENCE, "Other"); map.put(PhoneNumberType.PRIMARY, "Main"); map.put(PhoneNumberType.SIF1x_ALT, "Other"); map.put(PhoneNumberType.SIF1x_ANSWERING_SERVICE, "Other"); map.put(PhoneNumberType.SIF1x_APPT_NUMBER, "Other"); map.put(PhoneNumberType.SIF1x_BEEPER, "Other"); map.put(PhoneNumberType.SIF1x_EXT, "Other"); map.put(PhoneNumberType.SIF1x_HOME_FAX, "Fax"); map.put(PhoneNumberType.SIF1x_HOME_PHONE, "Other"); map.put(PhoneNumberType.SIF1x_NIGHT_PHONE, "Other"); map.put(PhoneNumberType.SIF1x_OTHER_RES_FAX, "Other"); map.put(PhoneNumberType.SIF1x_OTHER_RES_PHONE, "Other"); map.put(PhoneNumberType.SIF1x_PERSONAL_CELL, "Other"); map.put(PhoneNumberType.SIF1x_PERSONAL_PHONE, "Other"); map.put(PhoneNumberType.SIF1x_TELEMAIL, "Other"); map.put(PhoneNumberType.SIF1x_TELEX, "Other"); map.put(PhoneNumberType.SIF1x_VOICEMAIL, "Other"); map.put(PhoneNumberType.SIF1x_WORK_CELL, "Other"); map.put(PhoneNumberType.SIF1x_WORK_FAX, "Other"); map.put(PhoneNumberType.SIF1x_WORK_PHONE, "Other"); map.put(PhoneNumberType.TELEMAIL, "Other"); map.put(PhoneNumberType.TELEX, "Other"); map.put(PhoneNumberType.VOICE_MAIL, "Other"); PhoneNumberList list = getPhoneNumberList(); List<InstitutionTelephone> results = converter.convertInstitutionTelephone(list); Assert.assertEquals(list.size(), results.size()); int newCounter = 0; for (InstitutionTelephone it : results) { Assert.assertNotNull(it); PhoneNumber original = list.get(newCounter++); testMapping(original, it); } }
|
RaceListConverter { public List<String> convert(RaceList raceList) { if (raceList == null) { return null; } return toSliRaceList(raceList.getRaces()); } List<String> convert(RaceList raceList); }
|
@Test public void testNullObject() { List<String> result = converter.convert(null); Assert.assertNull("Race list should be null", result); }
@Test public void testEmptyList() { RaceList list = new RaceList(); List<String> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testConversion() { for (RaceType rt : map.keySet()) { RaceList rl = new RaceList(); Race r = new Race(); r.setCode(rt); rl.add(r); List<String> convertedList = converter.convert(rl); Assert.assertEquals(1, convertedList.size()); Assert.assertEquals(map.get(rt), convertedList.get(0)); } }
@Test public void testListConversion() { RaceList rl = new RaceList(); for (RaceType rt : map.keySet()) { Race r = new Race(); r.setCode(rt); rl.add(r); } List<String> convertedList = converter.convert(rl); List<String> expectedList = new ArrayList<String>(); expectedList.addAll(map.values()); Collections.sort(convertedList); Collections.sort(expectedList); Assert.assertEquals(expectedList.size(), convertedList.size()); for (int i = 0; i < expectedList.size(); i++) { Assert.assertEquals(expectedList.get(i), convertedList.get(i)); } }
|
GradeLevelsConverter { public List<String> convert(GradeLevels source) { if (source == null) { return null; } return toSliGradeList(source.getGradeLevels()); } List<String> convert(GradeLevels source); String convert(GradeLevel source); }
|
@Test public void testNullObject() { List<String> result = converter.convert((GradeLevels) null); Assert.assertNull("Grade levels list should be null", result); }
@Test public void testEmptyList() { GradeLevels list = new GradeLevels(); list.setGradeLevels(new GradeLevel[0]); List<String> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyGradeLevel() { GradeLevels list = new GradeLevels(); GradeLevel original = new GradeLevel(); list.add(original); List<String> result = converter.convert(list); Assert.assertEquals(1, result.size()); String gradeLevel = result.get(0); Assert.assertEquals("Not Available", gradeLevel); }
@Test public void testMappings() { map.clear(); map.put(GradeLevelCode._01, "First grade"); map.put(GradeLevelCode._02, "Second grade"); map.put(GradeLevelCode._03, "Third grade"); map.put(GradeLevelCode._04, "Fourth grade"); map.put(GradeLevelCode._05, "Fifth grade"); map.put(GradeLevelCode._06, "Sixth grade"); map.put(GradeLevelCode._07, "Seventh grade"); map.put(GradeLevelCode._08, "Eighth grade"); map.put(GradeLevelCode._09, "Ninth grade"); map.put(GradeLevelCode._10, "Tenth grade"); map.put(GradeLevelCode._11, "Eleventh grade"); map.put(GradeLevelCode._12, "Twelfth grade"); map.put(GradeLevelCode.KG, "Kindergarten"); map.put(GradeLevelCode.OTHER, "Other"); map.put(GradeLevelCode.PG, "Postsecondary"); map.put(GradeLevelCode.PK, "Preschool/Prekindergarten"); map.put(GradeLevelCode.UN, "Ungraded"); map.put(GradeLevelCode.UNKNOWN, "Not Available"); GradeLevels list = getGradeLevels(); List<String> results = converter.convert(list); Assert.assertEquals(list.size(), results.size()); int newCounter = 0; for (String gradeLevel : results) { Assert.assertNotNull(gradeLevel); GradeLevel original = list.get(newCounter++); testMapping(original.getCode(), gradeLevel); } }
|
OtherNamesConverter { public List<OtherName> convert(OtherNames sifOtherNames) { if (sifOtherNames == null) { return null; } List<OtherName> sliNames = new ArrayList<OtherName>(); for (openadk.library.common.Name sifName : sifOtherNames) { OtherName sliName = new OtherName(); nameConverter.mapSifNameIntoSliName(sifName, sliName); sliName.setOtherNameType(NAME_TYPE_MAP.get(sifName.getType())); sliNames.add(sliName); } return sliNames; } List<OtherName> convert(OtherNames sifOtherNames); void setNameConverter(NameConverter nameConverter); }
|
@Test public void testNullObject() { OtherNames sifOtherNames = null; List<OtherName> result = converter.convert(sifOtherNames); Assert.assertNull("OtherName list should be null", result); }
@Test public void testEmptyList() { OtherNames sifOtherNames = new OtherNames(); List<OtherName> result = converter.convert(sifOtherNames); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyEmail() { OtherNames sifOtherNames = new OtherNames(); sifOtherNames.add(new Name()); List<OtherName> result = converter.convert(sifOtherNames); Assert.assertEquals(1, result.size()); OtherName sliOtherName = result.get(0); Assert.assertNull(sliOtherName.getOtherNameType()); Assert.assertNotNull(sliOtherName.getFirstName()); Assert.assertEquals(defaultName, sliOtherName.getFirstName()); Assert.assertNotNull(sliOtherName.getLastSurname()); Assert.assertEquals(defaultName, sliOtherName.getLastSurname()); Assert.assertNull(sliOtherName.getMiddleName()); Assert.assertNull(sliOtherName.getPersonalTitlePrefix()); Assert.assertNull(sliOtherName.getGenerationCodeSuffix()); }
@Test public void testMappings() { OtherNames otherNames = createOtherNames(); List<OtherName> result = converter.convert(otherNames); Assert.assertEquals("Should map 6 othernames", 6, result.size()); Iterator<OtherName> resIt = result.iterator(); for (String sliNameType : nameTypeMap.values()) { OtherName sliName = resIt.next(); Assert.assertNotNull(sliName); Assert.assertEquals(sliNameType, sliName.getOtherNameType()); Assert.assertEquals(firstName, sliName.getFirstName()); Assert.assertEquals(lastName, sliName.getLastSurname()); Assert.assertEquals(middleName, sliName.getMiddleName()); Assert.assertEquals(suffix, sliName.getGenerationCodeSuffix()); Assert.assertEquals(prefix, sliName.getPersonalTitlePrefix()); } }
|
ExitTypeConverter { public String convert(ExitType exitType) { if (exitType == null) { return null; } return toSliExitType(ExitTypeCode.wrap(exitType.getCode())); } String convert(ExitType exitType); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Entry Type should be null", result); }
@Test public void testMappings() { Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1907_TRANSFERRED_IN_LEA)), "Student is in a different public school in the same local education agency"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1908_TRANSFERRED_IN_STATE)), "Transferred to a public school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1909_TRANSFERRED_DIFFERENT_STATE)), "Transferred to a public school in a different state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1910_TRANSFERRED_PRIVATE_IN_LEA)), "Transferred to a private, non-religiously-affiliated school in the same local education agency"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1911_TRANSFERRED_PRIVATE_IN_STATE)), "Transferred to a private, non-religiously-affiliated school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1912_TRANSFERRED_PRIVATE_IN_COUNTRY)), "Transferred to a private, non-religiously-affiliated school in a different state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1913_TRANSFERRED_RELIGEOUS_IN_LEA)), "Transferred to a private, religiously-affiliated school in the same local education agency"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1914_TRANSFERRED_RELIGEOUS_IN_STATE)), "Transferred to a private, religiously-affiliated school in a different local education agency in the same state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1915_TRANSFERRED_RELIGEOUS_IN_COUNTRY)), "Transferred to a private, religiously-affiliated school in a different state"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1916_TRANSFERRED_OUT_OF_COUNTRY)), "Transferred to a school outside of the country"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1917_TRANSFERRED_TO_AN_INSTITUTION)), "Transferred to an institution"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1918_TRANSFERRED_TO_HOME_SCHOOLING)), "Transferred to home schooling"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1919_TRANSFERRED_TO_A_CHARTER)), "Transferred to a charter school"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1921_GRADUATED_WITH_DEGREE)), "Graduated with regular, advanced, International Baccalaureate, or other type of diploma"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1922_COMPLETED_SCHOOL_WITH_OTHER)), "Completed school with other credentials"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1923_DIED_OR_INCAPACITATED)), "Died or is permanently incapacitated"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1924_WITHDRAWN_ILLNESS)), "Withdrawn due to illness"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1925_EXPELLED_OR_INVOLUNTARY)), "Expelled or involuntarily withdrawn"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1926_REACHED_MAXIMUM_AGE)), "Reached maximum age for services"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1927_DISCONTINUED_SCHOOLING)), "Discontinued schooling"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1928_COMPLETED_GRADE_12_NOT_GRADUATED)), "Completed grade 12, but did not meet all graduation requirements"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1930_ENROLLED_IN_A_POSTSECONDARY)), "Enrolled in a postsecondary early admission program, eligible to return"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._1931_NOT_ENROLLED_UNKNOWN)), "Not enrolled, unknown status"); Assert.assertEquals( converter.convert(getExitType(ExitTypeCode._3499_STUDENT_IS_IN_THE_SAME_LOCAL)), "Student is in the same local education agency and receiving education servi, but is not assigned to a particular school"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3500_ENROLLED_IN_AN_ADULT)), "Enrolled in an adult education or training program"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3501_COMPLETED_A_STATE_RECOGNIZED)), "Completed a state-recognized vocational education program"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3502_NOT_ENROLLED_ELIGIBLE_TO)), "Not enrolled, eligible to return"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3503_ENROLLED_IN_A_FOREIGN)), "Enrolled in a foreign exchange program, eligible to return"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3504_WITHDRAWN_FROM_SCHOOL_UNDER)), "Withdrawn from school, under the age for compulsory attendance; eligible to return"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3505_EXITED)), "Exited"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3508_STUDENT_IS_IN_A_CHARTER)), "Student is in a charter school managed by the same local education agency"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._3509_COMPLETED_WITH_A_STATE)), "Completed with a state-recognized equivalency certificate"); Assert.assertEquals(converter.convert(getExitType(ExitTypeCode._9999_OTHER)), "Other"); }
|
EnglishProficiencyConverter { public String convert(EnglishProficiency ep) { if (ep == null) { return null; } EnglishProficiencyCode code = EnglishProficiencyCode.wrap(ep.getCode()); return ENGLISH_PROFICIENCY_MAP.get(code); } String convert(EnglishProficiency ep); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("English Proficiency should be null", result); }
@Test public void testNativeEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.NATIVE_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); }
@Test public void testFluentEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.FLUENT_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); }
@Test public void testNonEnglishSpeaking() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.NON_ENGLISH_SPEAKING); String result = converter.convert(ep); Assert.assertEquals("Limited", result); }
@Test public void testRedesignatedAsFluent() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.REDESIGNATED_AS_FLUENT); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); }
@Test public void testLimitedEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.LIMITED_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("Limited", result); }
@Test public void testUnknown() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.STATUS_UNKNOWN); String result = converter.convert(ep); Assert.assertNull(result); }
|
SimpleExtractVerifier implements ExtractVerifier { @Override public boolean shouldExtract(Entity entity, DateTime upToDate) { String entityDate = EntityDateHelper.retrieveDate(entity); return EntityDateHelper.isPastOrCurrentDate(entityDate, upToDate, entity.getType()); } @Override boolean shouldExtract(Entity entity, DateTime upToDate); }
|
@Test public void testShouldExtract() { Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "01-01-01"); Entity studentProgramAssociation = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); Assert.assertTrue( "01-01-01",simpleExtractVerifier.shouldExtract(studentProgramAssociation, DateTime.parse("2000-01-01", DateHelper.getDateTimeFormat()))); Assert.assertTrue( "01-01-01",simpleExtractVerifier.shouldExtract(studentProgramAssociation, DateTime.parse("1999-01-01", DateHelper.getDateTimeFormat()))); }
@Test public void testshouldExtractSchoolYear() { Map<String, Object> gradeBody = new HashMap<String, Object>(); gradeBody.put(ParameterConstants.SCHOOL_YEAR, "2009-2010"); Entity grade = new MongoEntity(EntityNames.GRADE, gradeBody); Assert.assertTrue(simpleExtractVerifier.shouldExtract(grade, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(simpleExtractVerifier.shouldExtract(grade, DateTime.parse("2010-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(simpleExtractVerifier.shouldExtract(grade, null)); Assert.assertFalse(simpleExtractVerifier.shouldExtract(grade, DateTime.parse("2009-05-24", DateHelper.getDateTimeFormat()))); Assert.assertFalse(simpleExtractVerifier.shouldExtract(grade, DateTime.parse("2008-05-24", DateHelper.getDateTimeFormat()))); }
@Test public void testshouldExtractBeginDate() { Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "2001-01-01"); Entity studentProgramAssociation = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); Assert.assertEquals(true, simpleExtractVerifier.shouldExtract(studentProgramAssociation, DateTime.parse("2001-01-01", DateHelper.getDateTimeFormat()))); Assert.assertEquals(true, simpleExtractVerifier.shouldExtract(studentProgramAssociation, null)); Assert.assertEquals(false, simpleExtractVerifier.shouldExtract(studentProgramAssociation, DateTime.parse("2000-01-01", DateHelper.getDateTimeFormat()))); }
|
SchoolYearConverter { public String convert(Integer schoolYear) { if (schoolYear == null) { return null; } Integer priorSchoolYear = schoolYear - 1; return priorSchoolYear.toString() + "-" + schoolYear.toString(); } String convert(Integer schoolYear); }
|
@Test public void testNullList() { String result = converter.convert(null); Assert.assertNull("school year should be null", result); }
@Test public void test() { Assert.assertEquals(converter.convert(2011), "2010-2011"); Assert.assertEquals(converter.convert(2013), "2012-2013"); }
|
NameConverter { public Name convert(openadk.library.common.Name sifName) { if (sifName == null) { return null; } Name sliName = new Name(); mapSifNameIntoSliName(sifName, sliName); return sliName; } Name convert(openadk.library.common.Name sifName); void mapSifNameIntoSliName(openadk.library.common.Name sifName, Name sliName); }
|
@Test public void nullNameShouldReturnNull() { openadk.library.common.Name sifName = null; Name sliName = converter.convert(sifName); Assert.assertNull(sliName); }
@Test public void emptySifNameShouldMapToNullAndDefaultValues() { openadk.library.common.Name sifName = new openadk.library.common.Name(); Name sliName = converter.convert(sifName); Assert.assertNotNull(sliName); Assert.assertEquals("Missing first name should map to Unknown", defaultName, sliName.getFirstName()); Assert.assertEquals("Missing last name should map to Unknown", defaultName, sliName.getLastSurname()); Assert.assertNull("Missing optional fields should map to null", sliName.getGenerationCodeSuffix()); Assert.assertNull("Missing optional fields should map to null", sliName.getMiddleName()); Assert.assertNull("Missing optional fields should map to null", sliName.getPersonalTitlePrefix()); }
@Test public void shouldMapSifNameToSliName() { Name sliName = converter.convert(createSifName(prefixes.get(0), suffixes.get(0))); Assert.assertNotNull(sliName); Assert.assertEquals("Incorrect prefix mapping", prefixes.get(0), sliName.getPersonalTitlePrefix()); Assert.assertEquals("Incorrect firstName mapping", firstName, sliName.getFirstName()); Assert.assertEquals("Incorrect lastName mapping", lastName, sliName.getLastSurname()); Assert.assertEquals("Incorrect middleName mapping", middleName, sliName.getMiddleName()); Assert.assertEquals("Incorrect suffix", suffixes.get(0), sliName.getGenerationCodeSuffix()); for (String prefix : prefixes) { sliName = converter.convert(createSifName(prefix, suffixes.get(0))); Assert.assertNotNull(sliName); Assert.assertEquals("Incorrect prefix mapping", prefix, sliName.getPersonalTitlePrefix()); } for (String suffix : suffixes) { sliName = converter.convert(createSifName(prefixes.get(0), suffix)); Assert.assertNotNull(sliName); Assert.assertEquals("Incorrect suffix", suffix, sliName.getGenerationCodeSuffix()); } sliName = converter.convert(createSifName("unsupported", suffixes.get(0))); Assert.assertNotNull(sliName); Assert.assertNull("Unsupported prefix should map to null", sliName.getPersonalTitlePrefix()); sliName = converter.convert(createSifName(prefixes.get(0), "unsupported")); Assert.assertNotNull(sliName); Assert.assertNull("Unsupported suffix should map to null", sliName.getGenerationCodeSuffix()); }
|
HRProgramTypeConverter { public String convert(HRProgramType hrProgramType) { if (hrProgramType == null) { return null; } return toSliProgramAssignment(ProgramTypeCode.wrap(hrProgramType.getCode())); } String convert(HRProgramType hrProgramType); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Teaching Assignment list should be null", result); }
@Test public void testMappings() { map.clear(); map.put(ProgramTypeCode.ADULT_BASIC_EDUCATION, "Title I-Non-Academic"); map.put(ProgramTypeCode.ADULT_CONTINUING_EDUCATION, "Title I-Non-Academic"); map.put(ProgramTypeCode.ADULT_ENGLISH_AS_A_SECOND, "Bilingual/English as a Second Language"); map.put(ProgramTypeCode.ADVANCED_ADULT_BASIC_EDUCATION, "Title I-Non-Academic"); map.put(ProgramTypeCode.AGRICULTURE, "Title I-Non-Academic"); map.put(ProgramTypeCode.ALTERNATIVE_EDUCATION, "Special Education"); map.put(ProgramTypeCode.ATHLETICS, "Title I-Non-Academic"); map.put(ProgramTypeCode.AUTISM, "Special Education"); map.put(ProgramTypeCode.BILINGUAL_EDUCATION_PROGRAM, "Bilingual/English as a Second Language"); map.put(ProgramTypeCode.BRAIN_INJURY, "Special Education"); map.put(ProgramTypeCode.BUSINESS, "Title I-Academic"); map.put(ProgramTypeCode.CIVIC_SERVICES, "Title I-Non-Academic"); map.put(ProgramTypeCode.COCURRICULAR_PROGRAMS, "Regular Education"); map.put(ProgramTypeCode.COLLEGE_PREPARATORY, "Regular Education"); map.put(ProgramTypeCode.COMMUNITY_JUNIOR_COLLEGE, "Regular Education"); map.put(ProgramTypeCode.COMMUNITY_RECREATION, "Title I-Non-Academic"); map.put(ProgramTypeCode.COMMUNITY_SERVICES_PROGRAM, "Title I-Non-Academic"); map.put(ProgramTypeCode.COMPENSATORY_DISADVANTAGED, "Special Education"); map.put(ProgramTypeCode.CONSUMER_AND_HOME_MAKING, "Title I-Non-Academic"); map.put(ProgramTypeCode.CONTENT_ESL, "Bilingual/English as a Second Language"); map.put(ProgramTypeCode.COORDINATION_OF_CASEWORK, "Title I-Non-Academic"); map.put(ProgramTypeCode.COUNSELING_SERVICES, "Title I-Non-Academic"); map.put(ProgramTypeCode.CROSS_CATEGORICAL, "Title I-Non-Academic"); map.put(ProgramTypeCode.CURRICULUM_CONTENT_IN_NATIVE, "Title I-Academic"); map.put(ProgramTypeCode.CUSTODY_AND_CHILD_CARE, "Title I-Non-Academic"); map.put(ProgramTypeCode.DEAF_BLIND, "Special Education"); map.put(ProgramTypeCode.DEVELOPMENTAL_BILINGUAL, "Special Education"); map.put(ProgramTypeCode.DEVELOPMENTAL_DELAY, "Special Education"); map.put(ProgramTypeCode.EARLY_IDENTIFICATION, "Special Education"); map.put(ProgramTypeCode.EARLY_INTERVENTION, "Special Education"); map.put(ProgramTypeCode.EMOTIONAL_DISTURBANCE, "Special Education"); map.put(ProgramTypeCode.ENGLISH_AS_A_SECOND_LANGUAGE, "Bilingual/English as a Second Language"); map.put(ProgramTypeCode.EVEN_START, "Special Education"); map.put(ProgramTypeCode.EXTENDED_DAY_CHILD_CARE, "Special Education"); map.put(ProgramTypeCode.GENERAL_EDUCATIONAL_DEVELOPMEN, "Title I-Academic"); map.put(ProgramTypeCode.GIFTED_AND_TALENTED, "Special Education"); map.put(ProgramTypeCode.HEAD_START, "Special Education"); map.put(ProgramTypeCode.HEALTH, "Title I-Non-Academic"); map.put(ProgramTypeCode.HEALTH_SERVICES, "Title I-Non-Academic"); map.put(ProgramTypeCode.HEARING_IMPAIRMENT, "Special Education"); map.put(ProgramTypeCode.IMMIGRANT_EDUCATION, "Special Education"); map.put(ProgramTypeCode.INDIAN_EDUCATION, "Special Education"); map.put(ProgramTypeCode.INTERNATIONAL_BACCALAUREATE, "Special Education"); map.put(ProgramTypeCode.LEARNING_DISABILITIES, "Special Education"); map.put(ProgramTypeCode.LIBRARY_MEDIA_SERVICES, "Title I-Non-Academic"); map.put(ProgramTypeCode.LIFE_ENRICHMENT, "Title I-Non-Academic"); map.put(ProgramTypeCode.MAGNET_SPECIAL_PROGRAM, "Special Education"); map.put(ProgramTypeCode.MARKETING, "Title I-Non-Academic"); map.put(ProgramTypeCode.MENTAL_RETARDATION, "Special Education"); map.put(ProgramTypeCode.MIGRANT_EDUCATION, "Special Education"); map.put(ProgramTypeCode.MULTIPLE_DISABILITIES, "Special Education"); map.put(ProgramTypeCode.NATIVE_LANGUAGE_SUPPORT, "Title I-Academic"); map.put(ProgramTypeCode.OCCUPATIONAL, "Special Education"); map.put(ProgramTypeCode.OCCUPATIONAL_HOME_ECONOMICS, "Special Education"); map.put(ProgramTypeCode.ORTH_IMPAIRMENT, "Special Education"); map.put(ProgramTypeCode.OTHER, "Special Education"); map.put(ProgramTypeCode.OTHER_ADULT_CONTINUING, "Special Education"); map.put(ProgramTypeCode.OTHER_COMMUNITY_SERVICES, "Special Education"); map.put(ProgramTypeCode.OTHER_SP_ED, "Special Education"); map.put(ProgramTypeCode.OTHER_VOCATIONAL_EDUCATION, "Special Education"); map.put(ProgramTypeCode.PSYCHOLOGICAL_SERVICE, "Title I-Non-Academic"); map.put(ProgramTypeCode.PUBLIC_LIBRARY_SERVICES, "Title I-Non-Academic"); map.put(ProgramTypeCode.REGULAR_EDUCATION, "Regular Education"); map.put(ProgramTypeCode.REMEDIAL_EDUCATION, "Special Education"); map.put(ProgramTypeCode.RETRAINING_FOR_NEW_OCCUPATION, "Title I-Non-Academic"); map.put(ProgramTypeCode.SCHOOL_TO_WORK_OPPORTUNITIES, "Special Education"); map.put(ProgramTypeCode.SERVICE_LEARNING, "Title I-Non-Academic"); map.put(ProgramTypeCode.SPECIAL_EDUCATION_SERVICES, "Special Education"); map.put(ProgramTypeCode.SPECIAL_INTEREST, "Special Education"); map.put(ProgramTypeCode.SPEECH_IMPAIREMENT, "Special Education"); map.put(ProgramTypeCode.STUDENT_RETENTION, "Special Education"); map.put(ProgramTypeCode.SUBSTANCE_ABUSE_EDUCATION, "Special Education"); map.put(ProgramTypeCode.TECHNICAL, "Title I-Non-Academic"); map.put(ProgramTypeCode.TECHNICAL_PREPARATORY, "Title I-Non-Academic"); map.put(ProgramTypeCode.TECHNOLOGY_INDUSTRIAL, "Title I-Non-Academic"); map.put(ProgramTypeCode.TRADE_AND_INDUSTRIAL, "Title I-Non-Academic"); map.put(ProgramTypeCode.TWO_WAY_BILINGUAL_EDUCATION, "Bilingual/English as a Second Language"); map.put(ProgramTypeCode.UPGRADING_IN_CURRENT_OCCUPATIO, "Title I-Non-Academic"); map.put(ProgramTypeCode.VISUAL_IMPAIRMENT, "Special Education"); map.put(ProgramTypeCode.VOCATIONAL_EDUCATION, "Regular Education"); map.put(ProgramTypeCode.WELFARE_ACTIVITIES, "Title I-Non-Academic"); List<HRProgramType> list = getHRProgramTypes(); for (HRProgramType hrt : list) { testMapping(hrt.getCode(), converter.convert(hrt)); } }
|
GenderConverter { public String convert(String gender) { return GENDER_TYPE_MAP.get(gender); } String convert(String gender); }
|
@Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Race list should be null", result); }
@Test public void testMale() { String result = converter.convert("M"); Assert.assertEquals("Male", result); }
@Test public void testFemale() { String result = converter.convert("F"); Assert.assertEquals("Female", result); }
@Test public void testUnknown() { String result = converter.convert("U"); Assert.assertNull(result); }
|
OperationalStatusConverter { public String convert(OperationalStatus operationalStatus) { if (operationalStatus == null || operationalStatus.getValue() == null || operationalStatus.getValue().isEmpty()) { return null; } return OPERATIONAL_STATUS_MAP.get(operationalStatus); } String convert(OperationalStatus operationalStatus); }
|
@Test public void testNull() { String result = converter.convert(null); Assert.assertNull("Operational status should be null", result); }
@Test public void testEmpty() { OperationalStatus status = OperationalStatus.wrap(""); String result = converter.convert(status); Assert.assertNull("Operational status should be null", result); }
@Test public void testMappings() { map.clear(); map.put(OperationalStatus.AGENCY_CHANGED, "Changed Agency"); map.put(OperationalStatus.AGENCY_CLOSED, "Closed"); map.put(OperationalStatus.AGENCY_FUTURE, "Future"); map.put(OperationalStatus.AGENCY_INACTIVE, "Inactive"); map.put(OperationalStatus.AGENCY_NEW, "New"); map.put(OperationalStatus.AGENCY_OPEN, "Active"); map.put(OperationalStatus.CHANGED_BOUNDARY, null); map.put(OperationalStatus.SCHOOL_CLOSED, "Closed"); map.put(OperationalStatus.SCHOOL_FUTURE, "Future"); map.put(OperationalStatus.SCHOOL_INACTIVE, "Inactive"); map.put(OperationalStatus.SCHOOL_NEW, "New"); map.put(OperationalStatus.SCHOOL_OPEN, "Active"); for (OperationalStatus status : map.keySet()) { String expected = map.get(status); String result = converter.convert(status); Assert.assertEquals(expected, result); } String result = converter.convert(OperationalStatus.wrap("something else")); Assert.assertNull(result); }
|
SchoolLevelTypeConverter { public String convert(SchoolLevelType schoolLevelType) { if (schoolLevelType == null) { return null; } return SCHOOL_LEVEL_TYPE_MAP.get(schoolLevelType); } String convert(SchoolLevelType schoolLevelType); List<String> convertAsList(SchoolLevelType schoolLevelType); }
|
@Test public void testNull() { String result = converter.convert(null); Assert.assertNull("School category should be null", result); }
@Test public void testEmpty() { SchoolLevelType type = SchoolLevelType.wrap(""); String result = converter.convert(type); Assert.assertNull(result); }
|
SchoolLevelTypeConverter { public List<String> convertAsList(SchoolLevelType schoolLevelType) { if (schoolLevelType == null) { return null; } ArrayList<String> list = new ArrayList<String>(); String category = SCHOOL_LEVEL_TYPE_MAP.get(schoolLevelType); if (category != null) { list.add(category); } return list; } String convert(SchoolLevelType schoolLevelType); List<String> convertAsList(SchoolLevelType schoolLevelType); }
|
@Test public void testListNull() { List<String> result = converter.convertAsList(null); Assert.assertNull("School category should be null", result); }
@Test public void testListEmpty() { SchoolLevelType type = SchoolLevelType.wrap(""); List<String> result = converter.convertAsList(type); Assert.assertEquals(0, result.size()); }
|
HrOtherIdListConverter { public List<StaffIdentificationCode> convert(HrOtherIdList hrOtherIdList) { if (hrOtherIdList == null) { return null; } return toSliStaffIdentificationCodeList(hrOtherIdList.getOtherIds()); } List<StaffIdentificationCode> convert(HrOtherIdList hrOtherIdList); List<StaffIdentificationCode> convert(OtherIdList otherIdList); }
|
@Test public void testNullObject() { List<StaffIdentificationCode> result = converter.convert((HrOtherIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); result = converter.convert((OtherIdList) null); Assert.assertNull("StaffIdentificationCode list should be null", result); }
@Test public void testEmptyHrOtherIdList() { HrOtherIdList list = new HrOtherIdList(); list.setOtherIds(new OtherId[0]); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyOtherIdList() { OtherIdList list = new OtherIdList(); list.setOtherIds(new OtherId[0]); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyOtherId4HrOtherIdList() { HrOtherIdList list = new HrOtherIdList(); OtherId original = new OtherId(); list.add(original); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(1, result.size()); StaffIdentificationCode it = result.get(0); Assert.assertEquals(original.getValue(), it.getID()); Assert.assertEquals("Other", it.getIdentificationSystem()); }
@Test public void testEmptyOtherId4OtherIdList() { OtherIdList list = new OtherIdList(); OtherId original = new OtherId(); list.add(original); List<StaffIdentificationCode> result = converter.convert(list); Assert.assertEquals(1, result.size()); StaffIdentificationCode it = result.get(0); Assert.assertEquals(original.getValue(), it.getID()); Assert.assertEquals("Other", it.getIdentificationSystem()); }
@Test public void testMappings() { map.clear(); map.put(OtherIdType.ACT_INST, "Other"); map.put(OtherIdType.ACT_PROG, "Other"); map.put(OtherIdType.ATP, "Other"); map.put(OtherIdType.CA_SIN, "Canadian SIN"); map.put(OtherIdType.CERTIFICATE, "Professional Certificate"); map.put(OtherIdType.CONTRACTOR, "Other"); map.put(OtherIdType.DISTRICT_ASSIGNED, "District"); map.put(OtherIdType.DRIVERS_LICENSE, "Drivers License"); map.put(OtherIdType.DUNS, "Other"); map.put(OtherIdType.FAMILY_UNIT, "Other"); map.put(OtherIdType.FEDERAL, "Federal"); map.put(OtherIdType.HEALTH_RECORD, "Health Record"); map.put(OtherIdType.IPEDS, "Other"); map.put(OtherIdType.LEA_SCHOOL, "School"); map.put(OtherIdType.MEDICAID, "Medicaid"); map.put(OtherIdType.MIGRANT, "Other"); map.put(OtherIdType.NCES_LEA, "Other"); map.put(OtherIdType.NCES_LEA, "Other"); map.put(OtherIdType.OTHER, "Other"); map.put(OtherIdType.OTHER_AGENCY, "Other"); map.put(OtherIdType.OTHER_FEDERAL, "Other Federal"); map.put(OtherIdType.PERSONAL, "Other"); map.put(OtherIdType.SCHOOL_ASSIGNED, "School"); map.put(OtherIdType.SEA_LEA, "State"); map.put(OtherIdType.SEA_SCHOOL, "State"); map.put(OtherIdType.SELECTIVE_SERVICE, "Other"); map.put(OtherIdType.SIF1x_DISTRICT_ASSIGNED_NUM, "District"); map.put(OtherIdType.SIF1x_DRIVERS_LICENSE, "Drivers License"); map.put(OtherIdType.SIF1x_FAMILY_UNIT, "Other"); map.put(OtherIdType.SIF1x_HEATH_RECORD, "Health Record"); map.put(OtherIdType.SIF1x_MEDICAID, "Medicaid"); map.put(OtherIdType.SIF1x_MIGRANT, "Other"); map.put(OtherIdType.SIF1x_OTHER, "Other"); map.put(OtherIdType.SIF1x_PIN, "PIN"); map.put(OtherIdType.SIF1x_PROFESSIONAL_LICENSE, "Professional Certificate"); map.put(OtherIdType.SIF1x_SCHOOL_ASSIGNED_NUM, "School"); map.put(OtherIdType.SIF1x_SELECTIVE_SERVICE, "Selective Service"); map.put(OtherIdType.SIF1x_SSN, "SSN"); map.put(OtherIdType.SIF1x_STATE_ASSIGNED_NUM, "State"); map.put(OtherIdType.SIF1x_VISA, "US Visa"); HrOtherIdList list = getHrOtherIdList(); List<StaffIdentificationCode> results = converter.convert(list); Assert.assertEquals(list.size(), results.size()); int newCounter = 0; for (StaffIdentificationCode it : results) { Assert.assertNotNull(it); OtherId original = list.get(newCounter++); testMapping(original, it); } OtherIdList list2 = getOtherIdList(); List<StaffIdentificationCode> results2 = converter.convert(list2); Assert.assertEquals(list2.size(), results2.size()); newCounter = 0; for (StaffIdentificationCode it : results2) { Assert.assertNotNull(it); OtherId original = list2.get(newCounter++); testMapping(original, it); } }
|
LanguageListConverter { public List<String> convert(LanguageList languageList) { if (languageList == null) { return null; } return toSliLanguageList(languageList.getLanguages()); } List<String> convert(LanguageList languageList); }
|
@Test public void testNullObject() { List<String> result = converter.convert(null); Assert.assertNull("Address list should be null", result); }
@Test public void testEmptyList() { List<String> result = converter.convert(new LanguageList()); Assert.assertEquals(0, result.size()); }
@Test public void testEmptyLanguage() { LanguageList list = new LanguageList(); openadk.library.common.Language original = new openadk.library.common.Language(); list.add(original); List<String> result = converter.convert(list); Assert.assertEquals(1, result.size()); String language = result.get(0); Assert.assertEquals("Other", language); }
@Test public void testConversion() { map.clear(); map.put(LanguageCode.CHECHEN, "Other languages"); map.put(LanguageCode.CHEROKEE, "Cherokee"); map.put(LanguageCode.CHINESE, "Mandarin (Chinese)"); map.put(LanguageCode.ENGLISH, "English"); map.put(LanguageCode.FRENCH, "French"); map.put(LanguageCode.GERMAN, "German"); map.put(LanguageCode.HAWAIIAN, "Other languages"); map.put(LanguageCode.HEBREW, "Hebrew"); map.put(LanguageCode.ITALIAN, "Italian"); map.put(LanguageCode.JAPANESE, "Japanese"); map.put(LanguageCode.KOREAN, "Korean"); map.put(LanguageCode.MOHAWK, "Other languages"); map.put(LanguageCode.MULTIPLE, "Other languages"); map.put(LanguageCode.SPANISH, "Spanish"); map.put(LanguageCode.wrap("something else"), "Other"); List<LanguageCode> languageCodes = new ArrayList<LanguageCode>(); languageCodes.addAll(map.keySet()); LanguageList originalList = new LanguageList(); for (LanguageCode languageCode : languageCodes) { originalList.add(new Language(languageCode)); } List<String> convertedList = converter.convert(originalList); Assert.assertEquals(originalList.size(), convertedList.size()); int i = 0; for (String converted : convertedList) { LanguageCode original = languageCodes.get(i++); Assert.assertEquals(converted, map.get(original)); } }
|
TeacherSchoolAssociationExtractVerifier implements ExtractVerifier { @Override public boolean shouldExtract(Entity entity, DateTime upToDate) { Iterable<Entity> seaos = edOrgExtractHelper.retrieveSEOAS((String) entity.getBody().get(ParameterConstants.TEACHER_ID), (String) entity.getBody().get(ParameterConstants.SCHOOL_ID)); return shouldExtract(seaos, upToDate); } @Override boolean shouldExtract(Entity entity, DateTime upToDate); }
|
@Test public void testSholdExtractEntities() { List<Entity> seaos = new ArrayList<Entity>(); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "2001-05-24"); Entity entity1 = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); Map<String, Object> body2 = new HashMap<String, Object>(); body2.put(ParameterConstants.BEGIN_DATE, "2009-01-01"); Entity entity2 = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); seaos.add(entity1); seaos.add(entity2); seaos.add(createSEOA("2002-01-01", "2003-01-01")); seaos.add(createSEOA("2005-01-01", "2008-01-01")); Assert.assertFalse(tsaev.shouldExtract(seaos, DateTime.parse("2001-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(seaos, DateTime.parse("2010-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(seaos, DateTime.parse("2006-05-23", DateHelper.getDateTimeFormat()))); }
@Test public void testshouldExtractTeacherSchoolAssociation() { Entity mSeoa = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "2009-09-02"); body.put(ParameterConstants.END_DATE, "2010-05-31"); Mockito.when(mSeoa.getBody()).thenReturn(body); Mockito.when(mSeoa.getType()).thenReturn(EntityNames.STAFF_ED_ORG_ASSOCIATION); Mockito.when(edOrgExtractHelper.retrieveSEOAS(Matchers.eq("Staff1"), Matchers.eq("LEA"))).thenReturn(Arrays.asList(mSeoa)); Map<String, Object> tsaBody = new HashMap<String, Object>(); tsaBody.put(ParameterConstants.TEACHER_ID, "Staff1"); tsaBody.put(ParameterConstants.SCHOOL_ID, "LEA"); Entity tsa = Mockito.mock(Entity.class); Mockito.when(tsa.getBody()).thenReturn(tsaBody); Mockito.when(tsa.getType()).thenReturn(EntityNames.TEACHER_SCHOOL_ASSOCIATION); Assert.assertTrue(tsaev.shouldExtract(tsa, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(tsa, DateTime.parse("2009-09-02", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(tsa, null)); Assert.assertFalse(tsaev.shouldExtract(tsa, DateTime.parse("2009-09-01", DateHelper.getDateTimeFormat()))); Assert.assertFalse(tsaev.shouldExtract(tsa, DateTime.parse("2008-05-24", DateHelper.getDateTimeFormat()))); }
|
MockZis { public String createAckString() { SIF_Message message = new SIF_Message(); SIF_Ack ack = message.ackStatus(0); return sifElementToString(ack); } void parseSIFMessage(String sifString); void broadcastMessage(String xmlMessage); @PostConstruct void setup(); String createAckString(); void getAgentUrls(Set<String> agentCallbackUrls); Set<String> getAgentUrls(); }
|
@Test public void shouldCreateAckMessages() throws ADKException, IOException { String ackString = mockZis.createAckString(); SIFParser parser = SIFParser.newInstance(); SIFElement sifElem = parser.parse(ackString); Assert.assertTrue("Should create a SIF message", (sifElem instanceof SIF_Ack)); }
|
CustomEventGenerator { public static Event generateEvent(String messageFile, EventAction eventAction) { FileReader in = null; Event event = null; try { SIFParser p = SIFParser.newInstance(); in = new FileReader(messageFile); StringBuffer xml = new StringBuffer(); int bufSize = 4096; char[] buf = new char[bufSize]; while (in.ready()) { bufSize = in.read(buf, 0, buf.length); xml.append(buf, 0, bufSize); } SIFDataObject generic = (SIFDataObject) p.parse(xml.toString(), null, 0, SIFVersion.SIF23); event = new Event(generic, eventAction); } catch (SIFException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (ADKParsingException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (ADKException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (IOException e) { LOG.error("Caught exception trying to load entity from file", e); } finally { if (in != null) { try { in.close(); } catch (IOException e) { LOG.warn("Unable to close file", e); } } } return event; } static Event generateEvent(String messageFile, EventAction eventAction); }
|
@Test public void testGenerateStudentPersonalDefaultEvent() throws ADKException { String messageFile = getPathForFile("/element_xml/StudentPersonal.xml"); Event studentPersonalEvent = CustomEventGenerator.generateEvent(messageFile, EventAction.ADD); EventAction eventAction = studentPersonalEvent.getAction(); Assert.assertEquals(EventAction.ADD, eventAction); checkStudentPersonal(studentPersonalEvent); }
@Test public void testGenerateLeaInfoDefaultEvent() throws ADKException { String messageFile = getPathForFile("/element_xml/LEAInfo.xml"); Event leaInfoEvent = CustomEventGenerator.generateEvent(messageFile, EventAction.ADD); EventAction eventAction = leaInfoEvent.getAction(); Assert.assertEquals(EventAction.ADD, eventAction); checkLeaInfo(leaInfoEvent); }
|
SifEntityGenerator { public static SchoolInfo generateTestSchoolInfo() { SchoolInfo info = new SchoolInfo(); info.setRefId(TEST_SCHOOLINFO_REFID); info.setStateProvinceId("Daybreak West High"); info.setNCESId("421575003045"); info.setSchoolName("Daybreak West High"); info.setLEAInfoRefId(TEST_LEAINFO_REFID); SchoolFocusList schoolFocusList = new SchoolFocusList(); schoolFocusList.add(new SchoolFocus(SchoolFocusType.REGULAR)); info.setSchoolFocusList(schoolFocusList); info.setSchoolURL("http: info.setOperationalStatus(OperationalStatus.SCHOOL_CLOSED); info.setSchoolType(SchoolLevelType._0031_2402_HIGH_SCHOOL); GradeLevels gradeLevels = new GradeLevels(); gradeLevels.addGradeLevel(GradeLevelCode._09); gradeLevels.addGradeLevel(GradeLevelCode._10); gradeLevels.addGradeLevel(GradeLevelCode._11); gradeLevels.addGradeLevel(GradeLevelCode._12); info.setGradeLevels(gradeLevels); Address address = new Address(); address.setCity("Salt Lake City"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("84102"); Street street = new Street(); street.setLine1("1 IBM Plaza"); street.setApartmentNumber("2000"); street.setLine2("Suite 2000"); street.setLine3("Salt Lake City, IL 84102"); street.setStreetName("IBM way"); street.setStreetNumber("1"); street.setStreetType("Plaza"); street.setApartmentType("Suite"); address.setStreet(street); address.setType(AddressType.MAILING); AddressList addressList = new AddressList(); addressList.add(address); info.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-1234"); phoneNumberList.addPhoneNumber(PhoneNumberType.FAX, "(312) 555-2364"); info.setPhoneNumberList(phoneNumberList); return info; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestSchoolInfo() { SchoolInfo schoolInfo = SifEntityGenerator.generateTestSchoolInfo(); Assert.assertEquals(SifEntityGenerator.TEST_SCHOOLINFO_REFID, schoolInfo.getRefId()); Assert.assertEquals("Daybreak West High", schoolInfo.getStateProvinceId()); Assert.assertEquals("421575003045", schoolInfo.getNCESId()); Assert.assertEquals("Daybreak West High", schoolInfo.getSchoolName()); Assert.assertEquals(SifEntityGenerator.TEST_LEAINFO_REFID, schoolInfo.getLEAInfoRefId()); Assert.assertEquals("http: Assert.assertEquals(OperationalStatus.SCHOOL_CLOSED.getValue(), schoolInfo.getOperationalStatus()); Assert.assertEquals(SchoolLevelType._0031_2402_HIGH_SCHOOL.getValue(), schoolInfo.getSchoolType()); SchoolFocusList schoolFocusList = schoolInfo.getSchoolFocusList(); Assert.assertEquals(1, schoolFocusList.size()); SchoolFocus schoolFocus = schoolFocusList.get(0); Assert.assertEquals(SchoolFocusType.REGULAR.getValue(), schoolFocus.getValue()); GradeLevels gradeLevels = schoolInfo.getGradeLevels(); Assert.assertEquals(4, gradeLevels.size()); GradeLevel gradeLevel1 = gradeLevels.get(0); Assert.assertEquals(GradeLevelCode._09.getValue(), gradeLevel1.getCode()); GradeLevel gradeLevel2 = gradeLevels.get(1); Assert.assertEquals(GradeLevelCode._10.getValue(), gradeLevel2.getCode()); GradeLevel gradeLevel3 = gradeLevels.get(2); Assert.assertEquals(GradeLevelCode._11.getValue(), gradeLevel3.getCode()); GradeLevel gradeLevel4 = gradeLevels.get(3); Assert.assertEquals(GradeLevelCode._12.getValue(), gradeLevel4.getCode()); AddressList addressList = schoolInfo.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals("Salt Lake City", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("84102", address.getPostalCode()); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Street street = address.getStreet(); Assert.assertEquals("1 IBM Plaza", street.getLine1()); Assert.assertEquals("2000", street.getApartmentNumber()); Assert.assertEquals("Suite 2000", street.getLine2()); Assert.assertEquals("Salt Lake City, IL 84102", street.getLine3()); Assert.assertEquals("IBM way", street.getStreetName()); Assert.assertEquals("1", street.getStreetNumber()); Assert.assertEquals("Plaza", street.getStreetType()); Assert.assertEquals("Suite", street.getApartmentType()); PhoneNumberList phoneNumberList = schoolInfo.getPhoneNumberList(); Assert.assertEquals(2, phoneNumberList.size()); PhoneNumber phoneNumber1 = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber1.getType()); Assert.assertEquals("(312) 555-1234", phoneNumber1.getNumber()); PhoneNumber phoneNumber2 = phoneNumberList.get(1); Assert.assertEquals(PhoneNumberType.FAX.getValue(), phoneNumber2.getType()); Assert.assertEquals("(312) 555-2364", phoneNumber2.getNumber()); }
|
SifEntityGenerator { public static LEAInfo generateTestLEAInfo() { LEAInfo info = new LEAInfo(); info.setRefId(TEST_LEAINFO_REFID); info.setStateProvinceId("IL-DAYBREAK"); info.setNCESId("4215750"); info.setLEAName("Daybreak School District 4530"); info.setLEAURL("http: info.setEducationAgencyType(EducationAgencyTypeCode.REG_DISTRICT); info.setOperationalStatus(OperationalStatus.SCHOOL_CLOSED); GradeLevels gradeLevels = new GradeLevels(); gradeLevels.addGradeLevel(GradeLevelCode._09); gradeLevels.addGradeLevel(GradeLevelCode._10); gradeLevels.addGradeLevel(GradeLevelCode._11); gradeLevels.addGradeLevel(GradeLevelCode._12); info.setGradeLevels(gradeLevels); Address address = new Address(); address.setCity("Salt Lake City"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("84102"); Street street = new Street(); street.setLine1("1 IBM Plaza"); street.setApartmentNumber("2000"); street.setLine2("Suite 2000"); street.setLine3("Salt Lake City, IL 84102"); street.setStreetName("IBM way"); street.setStreetNumber("1"); street.setStreetType("Plaza"); street.setApartmentType("Suite"); address.setStreet(street); address.setType(AddressType.MAILING); AddressList addressList = new AddressList(); addressList.add(address); info.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-1234"); phoneNumberList.addPhoneNumber(PhoneNumberType.FAX, "(312) 555-2364"); info.setPhoneNumberList(phoneNumberList); return info; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestLeaInfo() { LEAInfo leaInfo = SifEntityGenerator.generateTestLEAInfo(); Assert.assertEquals(SifEntityGenerator.TEST_LEAINFO_REFID, leaInfo.getRefId()); Assert.assertEquals("IL-DAYBREAK", leaInfo.getStateProvinceId()); Assert.assertEquals("4215750", leaInfo.getNCESId()); Assert.assertEquals("Daybreak School District 4530", leaInfo.getLEAName()); Assert.assertEquals("http: Assert.assertEquals(OperationalStatus.SCHOOL_CLOSED.getValue(), leaInfo.getOperationalStatus()); Assert.assertEquals(EducationAgencyTypeCode.REG_DISTRICT.getValue(), leaInfo.getEducationAgencyType().getCode()); GradeLevels gradeLevels = leaInfo.getGradeLevels(); Assert.assertEquals(4, gradeLevels.size()); GradeLevel gradeLevel1 = gradeLevels.get(0); Assert.assertEquals(GradeLevelCode._09.getValue(), gradeLevel1.getCode()); GradeLevel gradeLevel2 = gradeLevels.get(1); Assert.assertEquals(GradeLevelCode._10.getValue(), gradeLevel2.getCode()); GradeLevel gradeLevel3 = gradeLevels.get(2); Assert.assertEquals(GradeLevelCode._11.getValue(), gradeLevel3.getCode()); GradeLevel gradeLevel4 = gradeLevels.get(3); Assert.assertEquals(GradeLevelCode._12.getValue(), gradeLevel4.getCode()); AddressList addressList = leaInfo.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals("Salt Lake City", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("84102", address.getPostalCode()); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Street street = address.getStreet(); Assert.assertEquals("1 IBM Plaza", street.getLine1()); Assert.assertEquals("2000", street.getApartmentNumber()); Assert.assertEquals("Suite 2000", street.getLine2()); Assert.assertEquals("Salt Lake City, IL 84102", street.getLine3()); Assert.assertEquals("IBM way", street.getStreetName()); Assert.assertEquals("1", street.getStreetNumber()); Assert.assertEquals("Plaza", street.getStreetType()); Assert.assertEquals("Suite", street.getApartmentType()); PhoneNumberList phoneNumberList = leaInfo.getPhoneNumberList(); Assert.assertEquals(2, phoneNumberList.size()); PhoneNumber phoneNumber1 = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber1.getType()); Assert.assertEquals("(312) 555-1234", phoneNumber1.getNumber()); PhoneNumber phoneNumber2 = phoneNumberList.get(1); Assert.assertEquals(PhoneNumberType.FAX.getValue(), phoneNumber2.getType()); Assert.assertEquals("(312) 555-2364", phoneNumber2.getNumber()); }
|
SifEntityGenerator { public static SEAInfo generateTestSEAInfo() { SEAInfo info = new SEAInfo(); info.setRefId(TEST_SEAINFO_REFID); info.setSEAName("Illinois State Board of Education"); info.setSEAURL("http: Address address = new Address(); address.setCity("Salt Lake City"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("84102"); Street street = new Street(); street.setLine1("1 IBM Plaza"); street.setApartmentNumber("2000"); street.setLine2("Suite 2000"); street.setLine3("Salt Lake City, IL 84102"); street.setStreetName("IBM way"); street.setStreetNumber("1"); street.setStreetType("Plaza"); street.setApartmentType("Suite"); address.setStreet(street); address.setType(AddressType.MAILING); AddressList addressList = new AddressList(); addressList.add(address); info.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-1234"); phoneNumberList.addPhoneNumber(PhoneNumberType.FAX, "(312) 555-2364"); info.setPhoneNumberList(phoneNumberList); return info; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestSeaInfo() { SEAInfo seaInfo = SifEntityGenerator.generateTestSEAInfo(); Assert.assertEquals(SifEntityGenerator.TEST_SEAINFO_REFID, seaInfo.getRefId()); Assert.assertEquals("Illinois State Board of Education", seaInfo.getSEAName()); Assert.assertEquals("http: AddressList addressList = seaInfo.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals("Salt Lake City", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("84102", address.getPostalCode()); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Street street = address.getStreet(); Assert.assertEquals("1 IBM Plaza", street.getLine1()); Assert.assertEquals("2000", street.getApartmentNumber()); Assert.assertEquals("Suite 2000", street.getLine2()); Assert.assertEquals("Salt Lake City, IL 84102", street.getLine3()); Assert.assertEquals("IBM way", street.getStreetName()); Assert.assertEquals("1", street.getStreetNumber()); Assert.assertEquals("Plaza", street.getStreetType()); Assert.assertEquals("Suite", street.getApartmentType()); PhoneNumberList phoneNumberList = seaInfo.getPhoneNumberList(); Assert.assertEquals(2, phoneNumberList.size()); PhoneNumber phoneNumber1 = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber1.getType()); Assert.assertEquals("(312) 555-1234", phoneNumber1.getNumber()); PhoneNumber phoneNumber2 = phoneNumberList.get(1); Assert.assertEquals(PhoneNumberType.FAX.getValue(), phoneNumber2.getType()); Assert.assertEquals("(312) 555-2364", phoneNumber2.getNumber()); }
|
SifEntityGenerator { public static StudentSchoolEnrollment generateTestStudentSchoolEnrollment() { StudentSchoolEnrollment retVal = new StudentSchoolEnrollment(); retVal.setRefId(TEST_STUDENTSCHOOLENROLLMENT_REFID); retVal.setSchoolInfoRefId(TEST_SCHOOLINFO_REFID); retVal.setStudentPersonalRefId(TEST_STUDENTPERSONAL_REFID); retVal.setMembershipType(MembershipType.HOME); retVal.setTimeFrame(TimeFrame.CURRENT); retVal.setSchoolYear(2012); retVal.setExitType(ExitTypeCode._3502_NOT_ENROLLED_ELIGIBLE_TO); retVal.setExitDate(new GregorianCalendar(2012, 9, 17)); retVal.setEntryDate(new GregorianCalendar(2012, 8, 16)); retVal.setEntryType(EntryTypeCode._0619_1838); retVal.setGradeLevel(GradeLevelCode._10); retVal.setFTE(new BigDecimal(1.00)); retVal.setFTPTStatus(FTPTStatus.FULLTIME); ResidencyStatus rs = new ResidencyStatus(); rs.setCode(PublicSchoolResidenceStatus._0598_1653); retVal.setResidencyStatus(rs); retVal.setNonResidentAttendReason(NonResidentAttendRationale.VOCATIONAL); return retVal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestStudentSchoolEnrollment() { StudentSchoolEnrollment studentSchoolEnrollment = SifEntityGenerator.generateTestStudentSchoolEnrollment(); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTSCHOOLENROLLMENT_REFID, studentSchoolEnrollment.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_SCHOOLINFO_REFID, studentSchoolEnrollment.getSchoolInfoRefId()); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTPERSONAL_REFID, studentSchoolEnrollment.getStudentPersonalRefId()); Assert.assertEquals(MembershipType.HOME.getValue(), studentSchoolEnrollment.getMembershipType()); Assert.assertEquals(TimeFrame.CURRENT.getValue(), studentSchoolEnrollment.getTimeFrame()); Assert.assertEquals(2012, studentSchoolEnrollment.getSchoolYear().intValue()); Assert.assertEquals(ExitTypeCode._3502_NOT_ENROLLED_ELIGIBLE_TO.getValue(), studentSchoolEnrollment.getExitType().getCode()); Assert.assertEquals(EntryTypeCode._0619_1838.getValue(), studentSchoolEnrollment.getEntryType().getCode()); Assert.assertEquals(GradeLevelCode._10.getValue(), studentSchoolEnrollment.getGradeLevel().getCode()); Assert.assertEquals(new BigDecimal(1.00), studentSchoolEnrollment.getFTE()); Assert.assertEquals(FTPTStatus.FULLTIME.getValue(), studentSchoolEnrollment.getFTPTStatus()); Assert.assertEquals(PublicSchoolResidenceStatus._0598_1653.getValue(), studentSchoolEnrollment.getResidencyStatus().getCode()); Assert.assertEquals(NonResidentAttendRationale.VOCATIONAL.getValue(), studentSchoolEnrollment.getNonResidentAttendReason()); Calendar exitDate = studentSchoolEnrollment.getExitDate(); Assert.assertEquals(2012, exitDate.get(Calendar.YEAR)); Assert.assertEquals(9, exitDate.get(Calendar.MONTH)); Assert.assertEquals(17, exitDate.get(Calendar.DATE)); Calendar entryDate = studentSchoolEnrollment.getEntryDate(); Assert.assertEquals(2012, entryDate.get(Calendar.YEAR)); Assert.assertEquals(8, entryDate.get(Calendar.MONTH)); Assert.assertEquals(16, entryDate.get(Calendar.DATE)); }
|
SifEntityGenerator { public static StudentLEARelationship generateTestStudentLeaRelationship() { StudentLEARelationship retVal = new StudentLEARelationship(); retVal.setRefId(TEST_STUDENTLEARELATIONSHIP_REFID); retVal.setStudentPersonalRefId(TEST_STUDENTPERSONAL_REFID); retVal.setLEAInfoRefId(TEST_LEAINFO_REFID); retVal.setSchoolYear(2012); retVal.setMembershipType(MembershipType.HOME); OrganizationRelationshipType ort = new OrganizationRelationshipType(); ResidencyStatus rs = new ResidencyStatus(); rs.setCode(PublicSchoolResidenceStatus.RESIDENT); ort.setResidencyStatus(rs); ort.setProvidingInstruction(true); ort.setProvidingServices(true); ort.setFinanciallyResponsible(true); retVal.setLEARelationshipType(ort); retVal.setEntryDate(new GregorianCalendar(2012, 8, 16)); retVal.setEntryType(EntryTypeCode._0619_1838); retVal.setGradeLevel(GradeLevelCode._10); return retVal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestStudentLeaRelationship() { StudentLEARelationship studentLeaRelationship = SifEntityGenerator.generateTestStudentLeaRelationship(); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTLEARELATIONSHIP_REFID, studentLeaRelationship.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_LEAINFO_REFID, studentLeaRelationship.getLEAInfoRefId()); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTPERSONAL_REFID, studentLeaRelationship.getStudentPersonalRefId()); Assert.assertEquals(2012, studentLeaRelationship.getSchoolYear().intValue()); Assert.assertEquals(MembershipType.HOME.getValue(), studentLeaRelationship.getMembershipType()); Assert.assertEquals(EntryTypeCode._0619_1838.getValue(), studentLeaRelationship.getEntryType().getCode()); Assert.assertEquals(GradeLevelCode._10.getValue(), studentLeaRelationship.getGradeLevel().getCode()); OrganizationRelationshipType organizationRelationshipType = studentLeaRelationship.getLEARelationshipType(); Assert.assertEquals(PublicSchoolResidenceStatus.RESIDENT.getValue(), organizationRelationshipType.getResidencyStatus().getCode()); Assert.assertTrue(organizationRelationshipType.getProvidingInstruction().booleanValue()); Assert.assertTrue(organizationRelationshipType.getProvidingServices().booleanValue()); Assert.assertTrue(organizationRelationshipType.getFinanciallyResponsible().booleanValue()); Calendar entryDate = studentLeaRelationship.getEntryDate(); Assert.assertEquals(2012, entryDate.get(Calendar.YEAR)); Assert.assertEquals(8, entryDate.get(Calendar.MONTH)); Assert.assertEquals(16, entryDate.get(Calendar.DATE)); }
|
SifEntityGenerator { public static StudentPersonal generateTestStudentPersonal() { StudentPersonal studentPersonal = new StudentPersonal(); studentPersonal.setRefId(TEST_STUDENTPERSONAL_REFID); studentPersonal.setStateProvinceId("IL-DAYBREAK-54321"); Name name = new Name(NameType.NAME_OF_RECORD, "Smith", "Joe"); name.setMiddleName(""); name.setPreferredName("Joe"); studentPersonal.setName(name); EmailList emailList = new EmailList(); emailList.addEmail(EmailType.PRIMARY, "joe.student@anyschool.edu"); studentPersonal.setEmailList(emailList); studentPersonal.setGraduationDate("1982"); Demographics demographics = new Demographics(); Calendar calendar = Calendar.getInstance(); calendar.set(1981, 11, 20); demographics.setBirthDate(calendar); demographics.setCitizenshipStatus(CitizenshipStatus.USCITIZEN); demographics.setCountryOfBirth(CountryCode.US); demographics.setStateOfBirth(StatePrCode.AK); demographics.setGender(Gender.MALE); studentPersonal.setDemographics(demographics); Address address = new Address(); address.setCity("Salt Lake City"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("84102"); Street street = new Street(); street.setLine1("1 IBM Plaza"); street.setApartmentNumber("2000"); street.setLine2("Suite 2000"); street.setLine3("Salt Lake City, IL 84102"); street.setStreetName("IBM way"); street.setStreetNumber("1"); street.setStreetType("Plaza"); street.setApartmentType("Suite"); address.setStreet(street); address.setType(AddressType.MAILING); StudentAddressList addressList = new StudentAddressList(); addressList.add(address); studentPersonal.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-1234"); studentPersonal.setPhoneNumberList(phoneNumberList); studentPersonal.setMigrant(YesNoUnknown.NO); return studentPersonal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestStudentPersonal() { StudentPersonal studentPersonal = SifEntityGenerator.generateTestStudentPersonal(); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTPERSONAL_REFID, studentPersonal.getRefId()); Assert.assertEquals("1982", studentPersonal.getGraduationDate().getValue()); Assert.assertEquals(YesNoUnknown.NO.getValue(), studentPersonal.getMigrant()); Name name = studentPersonal.getName(); Assert.assertEquals(NameType.NAME_OF_RECORD.getValue(), name.getType()); Assert.assertEquals("Smith", name.getLastName()); Assert.assertEquals("Joe", name.getFirstName()); Assert.assertEquals("", name.getMiddleName()); Assert.assertEquals("Joe", name.getPreferredName()); EmailList emailList = studentPersonal.getEmailList(); Assert.assertEquals(1, emailList.size()); Email email = emailList.get(0); Assert.assertEquals(EmailType.PRIMARY.getValue(), email.getType()); Assert.assertEquals("joe.student@anyschool.edu", email.getValue()); Demographics demographics = studentPersonal.getDemographics(); Assert.assertEquals(CitizenshipStatus.USCITIZEN.getValue(), demographics.getCitizenshipStatus()); Assert.assertEquals(CountryCode.US.getValue(), demographics.getCountryOfBirth()); Assert.assertEquals(StatePrCode.AK.getValue(), demographics.getStateOfBirth()); Calendar birthDate = demographics.getBirthDate(); Assert.assertEquals(1981, birthDate.get(Calendar.YEAR)); Assert.assertEquals(11, birthDate.get(Calendar.MONTH)); Assert.assertEquals(20, birthDate.get(Calendar.DATE)); StudentAddressList addressList = studentPersonal.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals("Salt Lake City", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("84102", address.getPostalCode()); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Street street = address.getStreet(); Assert.assertEquals("1 IBM Plaza", street.getLine1()); Assert.assertEquals("2000", street.getApartmentNumber()); Assert.assertEquals("Suite 2000", street.getLine2()); Assert.assertEquals("Salt Lake City, IL 84102", street.getLine3()); Assert.assertEquals("IBM way", street.getStreetName()); Assert.assertEquals("1", street.getStreetNumber()); Assert.assertEquals("Plaza", street.getStreetType()); Assert.assertEquals("Suite", street.getApartmentType()); PhoneNumberList phoneNumberList = studentPersonal.getPhoneNumberList(); Assert.assertEquals(1, phoneNumberList.size()); PhoneNumber phoneNumber = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber.getType()); Assert.assertEquals("(312) 555-1234", phoneNumber.getNumber()); }
|
SifEntityGenerator { public static StaffPersonal generateTestStaffPersonal() { StaffPersonal staffPersonal = new StaffPersonal(); staffPersonal.setRefId(TEST_STAFFPERSONAL_REFID); staffPersonal.setEmployeePersonalRefId(TEST_EMPLOYEEPERSONAL_REFID); staffPersonal.setLocalId("946379881"); staffPersonal.setStateProvinceId("C2345681"); staffPersonal.setTitle("Principal"); ElectronicId electronicId = new ElectronicId(ElectronicIdType.BARCODE, "206655"); ElectronicIdList electronicIdList = new ElectronicIdList(electronicId); staffPersonal.setElectronicIdList(electronicIdList); OtherId otherId = new OtherId(OtherIdType.SOCIALSECURITY, "333333333"); OtherIdList otherIdList = new OtherIdList(otherId); staffPersonal.setOtherIdList(otherIdList); Name name = new Name(); name.setType(NameType.NAME_OF_RECORD); name.setPrefix("Mr."); name.setLastName("Woodall"); name.setFirstName("Charles"); name.setMiddleName("William"); name.setPreferredName("Chuck"); staffPersonal.setName(name); Demographics demographics = new Demographics(); demographics.setGender(Gender.M); staffPersonal.setDemographics(demographics); Address address = new Address(); address.setType(AddressType.MAILING); address.setCity("Chicago"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("60660"); Street street = new Street(); street.setLine1("6799 33rd Ave."); street.setStreetNumber("6799"); street.setStreetName("33rd"); street.setStreetType("Ave."); address.setStreet(street); AddressList addressList = new AddressList(address); staffPersonal.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-1234"); staffPersonal.setPhoneNumberList(phoneNumberList); EmailList emailList = new EmailList(); emailList.addEmail(EmailType.PRIMARY, "chuckw@imginc.com"); staffPersonal.setEmailList(emailList); return staffPersonal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestStaffPersonal() { StaffPersonal staffPersonal = SifEntityGenerator.generateTestStaffPersonal(); Assert.assertEquals(SifEntityGenerator.TEST_STAFFPERSONAL_REFID, staffPersonal.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYEEPERSONAL_REFID, staffPersonal.getEmployeePersonalRefId()); Assert.assertEquals("946379881", staffPersonal.getLocalId()); Assert.assertEquals("C2345681", staffPersonal.getStateProvinceId()); Assert.assertEquals("Principal", staffPersonal.getTitle()); ElectronicIdList electronicIdList = staffPersonal.getElectronicIdList(); Assert.assertEquals(1, electronicIdList.size()); ElectronicId electronicId = electronicIdList.get(0); Assert.assertEquals(ElectronicIdType.BARCODE.getValue(), electronicId.getType()); Assert.assertEquals("206655", electronicId.getValue()); OtherIdList otherIdList = staffPersonal.getOtherIdList(); Assert.assertEquals(1, otherIdList.size()); OtherId otherId = otherIdList.get(0); Assert.assertEquals(OtherIdType.SOCIALSECURITY.getValue(), otherId.getType()); Assert.assertEquals("333333333", otherId.getValue()); Name name = staffPersonal.getName(); Assert.assertEquals(NameType.NAME_OF_RECORD.getValue(), name.getType()); Assert.assertEquals("Mr.", name.getPrefix()); Assert.assertEquals("Woodall", name.getLastName()); Assert.assertEquals("Charles", name.getFirstName()); Assert.assertEquals("William", name.getMiddleName()); Assert.assertEquals("Chuck", name.getPreferredName()); Demographics demographics = staffPersonal.getDemographics(); Assert.assertEquals(Gender.M.getValue(), demographics.getGender()); AddressList addressList = staffPersonal.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Assert.assertEquals("Chicago", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("60660", address.getPostalCode()); Street street = address.getStreet(); Assert.assertEquals("6799 33rd Ave.", street.getLine1()); Assert.assertEquals("6799", street.getStreetNumber()); Assert.assertEquals("33rd", street.getStreetName()); Assert.assertEquals("Ave.", street.getStreetType()); PhoneNumberList phoneNumberList = staffPersonal.getPhoneNumberList(); Assert.assertEquals(1, phoneNumberList.size()); PhoneNumber phoneNumber = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber.getType()); Assert.assertEquals("(312) 555-1234", phoneNumber.getNumber()); EmailList emailList = staffPersonal.getEmailList(); Assert.assertEquals(1, emailList.size()); Email email = emailList.get(0); Assert.assertEquals(EmailType.PRIMARY.getValue(), email.getType()); Assert.assertEquals("chuckw@imginc.com", email.getValue()); }
|
SifEntityGenerator { public static EmployeePersonal generateTestEmployeePersonal() { EmployeePersonal employeePersonal = new EmployeePersonal(); employeePersonal.setRefId(TEST_EMPLOYEEPERSONAL_REFID); employeePersonal.setStateProvinceId("C2345681"); OtherId otherId1 = new OtherId(OtherIdType.SOCIALSECURITY, "333333333"); OtherId otherId2 = new OtherId(OtherIdType.OTHER, "3333"); HrOtherIdList hrOtherIdList = new HrOtherIdList(); hrOtherIdList.add(otherId1); hrOtherIdList.add(otherId2); employeePersonal.setOtherIdList(hrOtherIdList); Name name = new Name(); name.setType(NameType.NAME_OF_RECORD); name.setLastName("Woodall"); name.setFirstName("Charles"); employeePersonal.setName(name); Demographics demographics = new Demographics(); demographics.setGender(Gender.M); employeePersonal.setDemographics(demographics); Address address = new Address(); address.setType(AddressType.MAILING); address.setCity("Chicago"); address.setStateProvince(StatePrCode.IL); address.setCountry(CountryCode.US); address.setPostalCode("60660"); Street street = new Street(); street.setLine1("6799 33rd Ave."); address.setStreet(street); AddressList addressList = new AddressList(address); employeePersonal.setAddressList(addressList); PhoneNumberList phoneNumberList = new PhoneNumberList(); phoneNumberList.addPhoneNumber(PhoneNumberType.PRIMARY, "(312) 555-9876"); employeePersonal.setPhoneNumberList(phoneNumberList); EmailList emailList = new EmailList(); emailList.addEmail(EmailType.PRIMARY, "chuckw@imginc.com"); employeePersonal.setEmailList(emailList); return employeePersonal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestEmployeePersonal() { EmployeePersonal employeePersonal = SifEntityGenerator.generateTestEmployeePersonal(); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYEEPERSONAL_REFID, employeePersonal.getRefId()); HrOtherIdList hrOtherIdList = employeePersonal.getOtherIdList(); Assert.assertEquals(2, hrOtherIdList.size()); OtherId otherId1 = hrOtherIdList.get(0); Assert.assertEquals(OtherIdType.SOCIALSECURITY.getValue(), otherId1.getType()); Assert.assertEquals("333333333", otherId1.getValue()); OtherId otherId2 = hrOtherIdList.get(1); Assert.assertEquals(OtherIdType.OTHER.getValue(), otherId2.getType()); Assert.assertEquals("3333", otherId2.getValue()); Name name = employeePersonal.getName(); Assert.assertEquals(NameType.NAME_OF_RECORD.getValue(), name.getType()); Assert.assertEquals("Woodall", name.getLastName()); Assert.assertEquals("Charles", name.getFirstName()); Demographics demographics = employeePersonal.getDemographics(); Assert.assertEquals(Gender.M.getValue(), demographics.getGender()); AddressList addressList = employeePersonal.getAddressList(); Assert.assertEquals(1, addressList.size()); Address address = addressList.get(0); Assert.assertEquals(AddressType.MAILING.getValue(), address.getType()); Assert.assertEquals("Chicago", address.getCity()); Assert.assertEquals(StatePrCode.IL.getValue(), address.getStateProvince()); Assert.assertEquals(CountryCode.US.getValue(), address.getCountry()); Assert.assertEquals("60660", address.getPostalCode()); Street street = address.getStreet(); Assert.assertEquals("6799 33rd Ave.", street.getLine1()); PhoneNumberList phoneNumberList = employeePersonal.getPhoneNumberList(); Assert.assertEquals(1, phoneNumberList.size()); PhoneNumber phoneNumber = phoneNumberList.get(0); Assert.assertEquals(PhoneNumberType.PRIMARY.getValue(), phoneNumber.getType()); Assert.assertEquals("(312) 555-9876", phoneNumber.getNumber()); EmailList emailList = employeePersonal.getEmailList(); Assert.assertEquals(1, emailList.size()); Email email = emailList.get(0); Assert.assertEquals(EmailType.PRIMARY.getValue(), email.getType()); Assert.assertEquals("chuckw@imginc.com", email.getValue()); }
|
SifEntityGenerator { public static StaffAssignment generateTestStaffAssignment() { StaffAssignment staffAssignment = new StaffAssignment(); staffAssignment.setRefId(TEST_STAFFASSIGNMENT_REFID); staffAssignment.setSchoolInfoRefId(TEST_SCHOOLINFO_REFID); staffAssignment.setStaffPersonalRefId(TEST_STAFFPERSONAL_REFID); staffAssignment.setEmployeePersonalRefId(TEST_EMPLOYEEPERSONAL_REFID); staffAssignment.setSchoolYear(new Integer(2013)); staffAssignment.setDescription("Twelfth grade computer science teacher"); staffAssignment.setPrimaryAssignment(YesNo.YES); staffAssignment.setJobStartDate(new GregorianCalendar(2010, 7, 1)); staffAssignment.setJobEndDate(new GregorianCalendar(2013, 6, 31)); staffAssignment.setJobFTE(new BigDecimal(1.00)); staffAssignment.setJobFunction(new JobFunction(JobFunctionCode.INSTRUCTION)); staffAssignment.setTeachingAssignment(new TeachingAssignment(TeachingArea.COMPUTER_SCIENCE)); staffAssignment.setGradeLevels(new GradeLevels(new GradeLevel(GradeLevelCode._12))); staffAssignment.setItinerantTeacher(YesNo.NO); InstructionalLevel instructionalLevel = new InstructionalLevel(); instructionalLevel.setCode(InstructionalLevelCode.COLLEGE_LEVEL); staffAssignment.setInstructionalLevel(instructionalLevel); return staffAssignment; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestStaffAssignment() { StaffAssignment staffAssignment = SifEntityGenerator.generateTestStaffAssignment(); Assert.assertEquals(SifEntityGenerator.TEST_STAFFASSIGNMENT_REFID, staffAssignment.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_SCHOOLINFO_REFID, staffAssignment.getSchoolInfoRefId()); Assert.assertEquals(SifEntityGenerator.TEST_STAFFPERSONAL_REFID, staffAssignment.getStaffPersonalRefId()); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYEEPERSONAL_REFID, staffAssignment.getEmployeePersonalRefId()); Assert.assertEquals(2013, staffAssignment.getSchoolYear().intValue()); Assert.assertEquals("Twelfth grade computer science teacher", staffAssignment.getDescription()); Assert.assertEquals(YesNo.YES.getValue(), staffAssignment.getPrimaryAssignment()); Calendar jobStartDate = staffAssignment.getJobStartDate(); Assert.assertEquals(2010, jobStartDate.get(Calendar.YEAR)); Assert.assertEquals(7, jobStartDate.get(Calendar.MONTH)); Assert.assertEquals(1, jobStartDate.get(Calendar.DATE)); Calendar jobEndDate = staffAssignment.getJobEndDate(); Assert.assertEquals(2013, jobEndDate.get(Calendar.YEAR)); Assert.assertEquals(6, jobEndDate.get(Calendar.MONTH)); Assert.assertEquals(31, jobEndDate.get(Calendar.DATE)); Assert.assertEquals(new BigDecimal(1.00), staffAssignment.getJobFTE()); JobFunction jobFunction = staffAssignment.getJobFunction(); Assert.assertEquals(JobFunctionCode.INSTRUCTION.getValue(), jobFunction.getCode()); TeachingAssignment teachingAssignment = staffAssignment.getTeachingAssignment(); Assert.assertEquals(TeachingArea.COMPUTER_SCIENCE.getValue(), teachingAssignment.getCode()); GradeLevels gradeLevels = staffAssignment.getGradeLevels(); Assert.assertEquals(1, gradeLevels.size()); GradeLevel gradeLevel1 = gradeLevels.get(0); Assert.assertEquals(GradeLevelCode._12.getValue(), gradeLevel1.getCode()); Assert.assertEquals(YesNo.NO.getValue(), staffAssignment.getItinerantTeacher()); InstructionalLevel instructionalLevel = staffAssignment.getInstructionalLevel(); Assert.assertEquals(InstructionalLevelCode.COLLEGE_LEVEL.getValue(), instructionalLevel.getCode()); }
|
SifEntityGenerator { public static EmploymentRecord generateTestEmploymentRecord() { EmploymentRecord employmentRecord = new EmploymentRecord(); employmentRecord.setRefId(TEST_EMPLOYMENTRECORD_REFID); employmentRecord.setSIF_RefId(TEST_STAFFPERSONAL_REFID); employmentRecord.setSIF_RefObject("StaffPersonal"); employmentRecord.setLEAInfoRefId(TEST_LEAINFO_REFID); employmentRecord.setActive(true); employmentRecord.setFullTimeStatus(FullTimeStatus.FULLTIME); employmentRecord.setHireDate(new GregorianCalendar(2010, 7, 1)); employmentRecord.setTerminationDate(new GregorianCalendar(2012, 6, 31)); employmentRecord.setTotalYearsExperience(20); employmentRecord.setPositionTitle("Senior Staff"); employmentRecord.setPositionNumber("10"); employmentRecord.setSeniorityDate(new GregorianCalendar(2011, 1, 1)); employmentRecord.setTenureDate(new GregorianCalendar(2011, 7, 1)); return employmentRecord; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestEmploymentRecord() { EmploymentRecord employmentRecord = SifEntityGenerator.generateTestEmploymentRecord(); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYMENTRECORD_REFID, employmentRecord.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_STAFFPERSONAL_REFID, employmentRecord.getSIF_RefId()); Assert.assertEquals("StaffPersonal", employmentRecord.getSIF_RefObject()); Assert.assertEquals(SifEntityGenerator.TEST_LEAINFO_REFID, employmentRecord.getLEAInfoRefId()); Assert.assertTrue(employmentRecord.getActive()); Assert.assertEquals(FullTimeStatus.FULLTIME.getValue(), employmentRecord.getFullTimeStatus()); Calendar hireDate = employmentRecord.getHireDate(); Assert.assertEquals(2010, hireDate.get(Calendar.YEAR)); Assert.assertEquals(7, hireDate.get(Calendar.MONTH)); Assert.assertEquals(1, hireDate.get(Calendar.DATE)); Calendar terminationDate = employmentRecord.getTerminationDate(); Assert.assertEquals(2012, terminationDate.get(Calendar.YEAR)); Assert.assertEquals(6, terminationDate.get(Calendar.MONTH)); Assert.assertEquals(31, terminationDate.get(Calendar.DATE)); Assert.assertEquals(20, employmentRecord.getTotalYearsExperience().intValue()); Assert.assertEquals("Senior Staff", employmentRecord.getPositionTitle()); Assert.assertEquals("10", employmentRecord.getPositionNumber()); Calendar seniorityDate = employmentRecord.getSeniorityDate(); Assert.assertEquals(2011, seniorityDate.get(Calendar.YEAR)); Assert.assertEquals(1, seniorityDate.get(Calendar.MONTH)); Assert.assertEquals(1, seniorityDate.get(Calendar.DATE)); Calendar tenureDate = employmentRecord.getTenureDate(); Assert.assertEquals(2011, tenureDate.get(Calendar.YEAR)); Assert.assertEquals(7, tenureDate.get(Calendar.MONTH)); Assert.assertEquals(1, tenureDate.get(Calendar.DATE)); }
|
SifEntityGenerator { public static EmployeeAssignment generateTestEmployeeAssignment() { EmployeeAssignment employeeAssignment = new EmployeeAssignment(); employeeAssignment.setRefId(TEST_EMPLOYEEASSIGNMENT_REFID); employeeAssignment.setEmployeePersonalRefId(TEST_EMPLOYEEPERSONAL_REFID); employeeAssignment.setDescription("Twelfth grade computer science teacher"); employeeAssignment.setPrimaryAssignment(YesNo.YES); employeeAssignment.setJobStartDate(new GregorianCalendar(2010, 7, 1)); employeeAssignment.setJobEndDate(new GregorianCalendar(2013, 6, 31)); employeeAssignment.setJobFTE(new BigDecimal(1.00)); JobClassification jobClassification = new JobClassification(JobClassificationCode.TEACHER); OtherCode jobClassificationOtherCode = new OtherCode(); jobClassificationOtherCode.setValue("12345"); jobClassification.setOtherCodeList(new OtherCodeList(jobClassificationOtherCode)); employeeAssignment.setJobClassification(jobClassification); HRProgramType programType = new HRProgramType(); programType.setCode(ProgramTypeCode.REGULAR_EDUCATION); OtherCode programTypeOtherCode = new OtherCode(); programTypeOtherCode.setValue("67890"); programType.setOtherCodeList(new OtherCodeList(programTypeOtherCode)); employeeAssignment.setProgramType(programType); ProgramFundingSource programFundingSource = new ProgramFundingSource(); programFundingSource.setCode("0617"); OtherCode programFundingSourceOtherCode = new OtherCode(); programFundingSourceOtherCode.setValue("54321"); programFundingSource.setOtherCodeList(new OtherCodeList(programFundingSourceOtherCode)); employeeAssignment.setFundingSource(programFundingSource); return employeeAssignment; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }
|
@Test public void testGenerateTestEmployeeAssignment() { EmployeeAssignment employeeAssignment = SifEntityGenerator.generateTestEmployeeAssignment(); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYEEASSIGNMENT_REFID, employeeAssignment.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_EMPLOYEEPERSONAL_REFID, employeeAssignment.getEmployeePersonalRefId()); Assert.assertEquals("Twelfth grade computer science teacher", employeeAssignment.getDescription()); Assert.assertEquals(YesNo.YES.getValue(), employeeAssignment.getPrimaryAssignment()); Calendar jobStartDate = employeeAssignment.getJobStartDate(); Assert.assertEquals(2010, jobStartDate.get(Calendar.YEAR)); Assert.assertEquals(7, jobStartDate.get(Calendar.MONTH)); Assert.assertEquals(1, jobStartDate.get(Calendar.DATE)); Calendar jobEndDate = employeeAssignment.getJobEndDate(); Assert.assertEquals(2013, jobEndDate.get(Calendar.YEAR)); Assert.assertEquals(6, jobEndDate.get(Calendar.MONTH)); Assert.assertEquals(31, jobEndDate.get(Calendar.DATE)); Assert.assertEquals(new BigDecimal(1.00), employeeAssignment.getJobFTE()); JobClassification jobClassification = employeeAssignment.getJobClassification(); Assert.assertEquals(JobClassificationCode.TEACHER.getValue(), jobClassification.getCode()); OtherCodeList jobClassificationOtherCodeList = jobClassification.getOtherCodeList(); Assert.assertEquals(1, jobClassificationOtherCodeList.size()); OtherCode jobClassificationOtherCode = jobClassificationOtherCodeList.get(0); Assert.assertEquals("12345", jobClassificationOtherCode.getValue()); HRProgramType programType = employeeAssignment.getProgramType(); Assert.assertEquals(ProgramTypeCode.REGULAR_EDUCATION.getValue(), programType.getCode()); OtherCodeList programTypeOtherCodeList = programType.getOtherCodeList(); Assert.assertEquals(1, programTypeOtherCodeList.size()); OtherCode programTypeOtherCode = programTypeOtherCodeList.get(0); Assert.assertEquals("67890", programTypeOtherCode.getValue()); ProgramFundingSource programFundingSource = employeeAssignment.getFundingSource(); Assert.assertEquals("0617", programFundingSource.getCode()); OtherCodeList programFundingSourceOtherCodeList = programFundingSource.getOtherCodeList(); Assert.assertEquals(1, programFundingSourceOtherCodeList.size()); OtherCode programFundingSourceOtherCode = programFundingSourceOtherCodeList.get(0); Assert.assertEquals("54321", programFundingSourceOtherCode.getValue()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.