method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Event { @android.support.annotation.NonNull public String getTag() { return mTag; } @SuppressWarnings("ConstantConditions") Event(@android.support.annotation.NonNull String tag); @SuppressWarnings("ConstantConditions") Event(@android.support.annotation.NonNull Object o); @android.support.annotation.NonNull String getTag(); Object getObject(); }### Answer:
@Test public void getTag() throws Exception { String mockTag = "Test"; Event event = new Event(mockTag); assertEquals(event.getTag(), mockTag); Integer mockObj = 34; event = new Event(mockObj); assertEquals(event.getTag(), mockObj.getClass().getSimpleName()); } |
### Question:
Event { public Object getObject() { return mObject; } @SuppressWarnings("ConstantConditions") Event(@android.support.annotation.NonNull String tag); @SuppressWarnings("ConstantConditions") Event(@android.support.annotation.NonNull Object o); @android.support.annotation.NonNull String getTag(); Object getObject(); }### Answer:
@Test public void getObject() throws Exception { Integer mockObj = 34; Event event = new Event(mockObj); assertEquals(event.getObject(), mockObj); } |
### Question:
InfoModel { public String getLabel() { return label; } InfoModel(@NonNull String label); String getInfo(); void setInfo(@NonNull String info); String getImageUrl(); void setImageUrl(String imageUrl); String getLabel(); }### Answer:
@SuppressWarnings("ConstantConditions") @Test public void checkLLabel() throws Exception { try { new InfoModel(null); fail(); } catch (IllegalArgumentException e) { } InfoModel infoModel = new InfoModel(MOCK_LABEL); assertEquals(infoModel.getLabel(), MOCK_LABEL); } |
### Question:
BarcodeInfo { Contact getContact() { return mContact; } void setBoundingBox(Rect boundingBox); void setContact(Contact contact); void setUrlBookmark(UrlBookmark urlBookmark); void setSms(Sms sms); void setGeoPoint(GeoPoint geoPoint); void setCalendarEvent(CalendarEvent calendarEvent); void setPhone(Phone phone); void setRawValue(String rawValue); }### Answer:
@Test public void getContact() throws Exception { BarcodeInfo.Contact contact = new BarcodeInfo.Contact(); BarcodeInfo barcodeInfo = new BarcodeInfo(); barcodeInfo.setContact(contact); assertEquals(barcodeInfo.getContact(), contact); } |
### Question:
BarcodeInfo { UrlBookmark getUrlBookmark() { return mUrlBookmark; } void setBoundingBox(Rect boundingBox); void setContact(Contact contact); void setUrlBookmark(UrlBookmark urlBookmark); void setSms(Sms sms); void setGeoPoint(GeoPoint geoPoint); void setCalendarEvent(CalendarEvent calendarEvent); void setPhone(Phone phone); void setRawValue(String rawValue); }### Answer:
@Test public void getUrlBookmark() throws Exception { BarcodeInfo.UrlBookmark urlBookmark = new BarcodeInfo.UrlBookmark("Google", "www.google.com"); BarcodeInfo barcodeInfo = new BarcodeInfo(); barcodeInfo.setUrlBookmark(urlBookmark); assertEquals(barcodeInfo.getUrlBookmark(), urlBookmark); } |
### Question:
BarcodeInfo { Sms getSms() { return mSms; } void setBoundingBox(Rect boundingBox); void setContact(Contact contact); void setUrlBookmark(UrlBookmark urlBookmark); void setSms(Sms sms); void setGeoPoint(GeoPoint geoPoint); void setCalendarEvent(CalendarEvent calendarEvent); void setPhone(Phone phone); void setRawValue(String rawValue); }### Answer:
@Test public void getSms() throws Exception { BarcodeInfo.Sms sms = new BarcodeInfo.Sms("This is test message.", "1234567890"); BarcodeInfo info = new BarcodeInfo(); info.setSms(sms); assertEquals(info.getSms(), sms); } |
### Question:
BarcodeInfo { GeoPoint getGeoPoint() { return mGeoPoint; } void setBoundingBox(Rect boundingBox); void setContact(Contact contact); void setUrlBookmark(UrlBookmark urlBookmark); void setSms(Sms sms); void setGeoPoint(GeoPoint geoPoint); void setCalendarEvent(CalendarEvent calendarEvent); void setPhone(Phone phone); void setRawValue(String rawValue); }### Answer:
@Test public void getGeoPoint() throws Exception { BarcodeInfo.GeoPoint geoPoint = new BarcodeInfo.GeoPoint(23.0225, 72.5714); BarcodeInfo info = new BarcodeInfo(); info.setGeoPoint(geoPoint); assertEquals(info.getGeoPoint(), geoPoint); } |
### Question:
BarcodeInfo { CalendarEvent getCalendarEvent() { return mCalendarEvent; } void setBoundingBox(Rect boundingBox); void setContact(Contact contact); void setUrlBookmark(UrlBookmark urlBookmark); void setSms(Sms sms); void setGeoPoint(GeoPoint geoPoint); void setCalendarEvent(CalendarEvent calendarEvent); void setPhone(Phone phone); void setRawValue(String rawValue); }### Answer:
@Test public void getCalendarEvent() throws Exception { BarcodeInfo.CalendarEvent calendarEvent = new BarcodeInfo.CalendarEvent(); BarcodeInfo barcodeInfo = new BarcodeInfo(); barcodeInfo.setCalendarEvent(calendarEvent); assertEquals(barcodeInfo.getCalendarEvent(), calendarEvent); } |
### Question:
ClasspathUtils { @SuppressWarnings("unchecked") public static <T> Class<? extends T> findImplementationClass(Class<T> clazz) { if (!Modifier.isAbstract(clazz.getModifiers())) return clazz; String implementationClass = String.format("%s.impl.%sImpl", clazz.getPackage().getName(), clazz.getSimpleName()); try { return (Class<? extends T>) Class.forName(implementationClass); } catch (ClassNotFoundException e) { throw new NoImplementationClassFoundException(clazz, e); } } private ClasspathUtils(); @SuppressWarnings("unchecked") static Class<? extends T> findImplementationClass(Class<T> clazz); }### Answer:
@Test public void shouldFindImplementation() { Class<? extends DummyComponent> clazz = ClasspathUtils .findImplementationClass(DummyComponent.class); assertEquals(clazz, DummyComponentImpl.class); }
@Test(expectedExceptions = RuntimeException.class) public void shouldThrowExceptionWhenNoImplementationIsFound() { ClasspathUtils.findImplementationClass(List.class); } |
### Question:
WisePageFactory { public static <T> T initElements(WebDriver driver, Class<T> clazz) { T instance = instantiatePage(driver, clazz); return initElements(driver, instance); } private WisePageFactory(); static T initElements(WebDriver driver, Class<T> clazz); static T initElements(SearchContext searchContext, T instance); }### Answer:
@Test public void shouldCreatePageWithWebDriverConstructorAndInitElements() { DummyPageWithWebDriverConstructor page = WisePageFactory.initElements( this.driver, DummyPageWithWebDriverConstructor.class); assertNotNull(page.getDummyComponent()); }
@Test public void shouldCreatePageWithNoArgConstructorAndInitElements() { DummyPageWithNoArgConstructor page = WisePageFactory.initElements(this.driver, DummyPageWithNoArgConstructor.class); assertNotNull(page.getDummyComponent()); }
@Test public void shouldInitElementsOfInstance() { DummyPageWithWebDriverConstructor page = new DummyPageWithWebDriverConstructor(this.driver); WisePageFactory.initElements(this.driver, page); assertNotNull(page.getDummyComponent()); }
@Test(expectedExceptions = PageInstantiationException.class) public void shouldThrowExceptionWhileInstantiatingPageWithoutProperConstructor() { WisePageFactory.initElements(this.driver, DummyPageWithoutProperConstructor.class); } |
### Question:
Wiselenium { public static <E> E findElement(Class<E> clazz, By by, SearchContext searchContext) { WebElement webElement = searchContext.findElement(by); return decorateElement(clazz, webElement); } private Wiselenium(); static E findElement(Class<E> clazz, By by, SearchContext searchContext); static List<E> findElements(Class<E> clazz, By by, SearchContext searchContext); static E decorateElement(Class<E> clazz, WebElement webElement); static List<E> decorateElements(Class<E> clazz, List<WebElement> webElements); }### Answer:
@Test public void shouldFindElement() { DummyComponent select = Wiselenium.findElement(DummyComponent.class, BY_SELECT1, this.driver); assertNotNull(select); }
@Test(expectedExceptions = NoSuchElementException.class) public void shouldThrowExceptionWhenElementIsntFound() { Wiselenium.findElement(DummyComponent.class, By.id("inexistent"), this.driver); } |
### Question:
Wiselenium { public static <E> List<E> findElements(Class<E> clazz, By by, SearchContext searchContext) { List<WebElement> webElements = searchContext.findElements(by); if (webElements.isEmpty()) return Lists.newArrayList(); WiseDecorator decorator = new WiseDecorator(new DefaultElementLocatorFactory(searchContext)); return decorator.decorate(clazz, webElements); } private Wiselenium(); static E findElement(Class<E> clazz, By by, SearchContext searchContext); static List<E> findElements(Class<E> clazz, By by, SearchContext searchContext); static E decorateElement(Class<E> clazz, WebElement webElement); static List<E> decorateElements(Class<E> clazz, List<WebElement> webElements); }### Answer:
@SuppressWarnings("null") @Test public void shouldFindElements() { List<DummyComponent> elements = Wiselenium.findElements( DummyComponent.class, BY_RADIOBUTTON, this.driver); assertTrue(elements != null && !elements.isEmpty()); for (DummyComponent element : elements) { assertNotNull(element); } }
@Test public void shouldReturnEmptyListWhenElementsAreNotFound() { List<DummyComponent> selects = Wiselenium.findElements( DummyComponent.class, By.id("inexistent"), this.driver); assertTrue(selects != null && selects.isEmpty()); } |
### Question:
LexerStream extends LineNumberReader { public int peek() throws IOException { super.mark(1); int c = super.read(); super.reset(); return c; } LexerStream(Reader in_stream); int getLine(); int getCol(); int getPosition(); @Override int read(); @Override String readLine(); int peek(); int peek(int ahead); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override void mark(int readAheadLimit); @Override void reset(); }### Answer:
@Test public void peek() throws Exception { Reader in = new StringReader("I see you"); LexerStream ls = new LexerStream(in); assertEquals(1, ls.getLine()); assertEquals(1, ls.getCol()); int c = ls.peek(); assertEquals('I', (char)c); assertTrue(1 == ls.getLine() && 1 == ls.getCol()); c = ls.peek(2); assertEquals(' ', (char)c); assertTrue(1 == ls.getLine() && 1 == ls.getCol()); c = ls.peek(4); assertEquals('e', (char)c); assertTrue(1 == ls.getLine() && 1 == ls.getCol()); c = ls.peek(8); assertEquals('o', (char)c); assertTrue(1 == ls.getLine() && 1 == ls.getCol()); c = ls.read(); assertEquals('I', (char)c); assertTrue(1 == ls.getLine() && 2 == ls.getCol()); } |
### Question:
LexerStream extends LineNumberReader { @Override public String readLine() throws IOException { String ln = super.readLine(); if (ln != null) { index += ln.length(); } line = super.getLineNumber(); col = 1; return ln; } LexerStream(Reader in_stream); int getLine(); int getCol(); int getPosition(); @Override int read(); @Override String readLine(); int peek(); int peek(int ahead); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override void mark(int readAheadLimit); @Override void reset(); }### Answer:
@Test public void readLine() throws Exception { Reader in = new StringReader("line1\nline2\n3line\n\nline5"); LexerStream ls = new LexerStream(in); assertEquals(1, ls.getLine()); assertEquals(1, ls.getCol()); assertEquals('l', (char)ls.read()); assertEquals(1, ls.getLine()); assertEquals(2, ls.getCol()); assertEquals("ine1", ls.readLine()); assertEquals(2, ls.getLine()); assertEquals(1, ls.getCol()); assertEquals("line2", ls.readLine()); assertEquals(3, ls.getLine()); assertEquals(1, ls.getCol()); assertEquals('3', (char)ls.read()); assertEquals(3, ls.getLine()); assertEquals(2, ls.getCol()); assertEquals("line", ls.readLine()); assertEquals(4, ls.getLine()); assertEquals(1, ls.getCol()); assertEquals("", ls.readLine()); assertEquals(5, ls.getLine()); assertEquals(1, ls.getCol()); assertEquals("line5", ls.readLine()); assertEquals(6, ls.getLine()); assertEquals(1, ls.getCol()); assertNull(ls.readLine()); assertEquals(-1, ls.read()); } |
### Question:
MCacheDb extends AbstractActor { public String getValue(String key) { return this.map.get(key); } @Override Receive createReceive(); String getValue(String key); }### Answer:
@Test public void testPut() { TestActorRef<MCacheDb> actorRef = TestActorRef.create(actorSystem, Props.create(MCacheDb.class)); actorRef.tell(new SetRequest("key", "value"), ActorRef.noSender()); MCacheDb mCacheDb = actorRef.underlyingActor(); Assert.assertEquals(mCacheDb.getValue("key"), "value"); } |
### Question:
HelloWorldImpl implements HelloWorldPortType { @Override public Greeting sayHello(Person person) { String firstName = person.getFirstName(); LOGGER.info("firstName={}", firstName); String lasttName = person.getLastName(); LOGGER.info("lastName={}", lasttName); ObjectFactory factory = new ObjectFactory(); Greeting response = factory.createGreeting(); String greeting = "Hello " + firstName + " " + lasttName + "!"; LOGGER.info("greeting={}", greeting); response.setText(greeting); return response; } @Override Greeting sayHello(Person person); }### Answer:
@Test public void testSayHelloProxy() { Person person = new Person(); person.setFirstName("Jane"); person.setLastName("Doe"); Greeting greeting = helloWorldRequesterProxy.sayHello(person); assertEquals("Hello Jane Doe!", greeting.getText()); } |
### Question:
RemoverInvoker { public void executeInvokerForSingleTask(long taskId, boolean shouldRemoveErrors) { remover.removeNotifications(taskId); LOGGER.info("Logs for task Id:" + taskId + " were removed successfully"); LOGGER.info("Removing statistics for:" + taskId + " was started. This step could take times depending on the size of the task"); remover.removeStatistics(taskId); LOGGER.info("Statistics for task Id:" + taskId + " were removed successfully"); if (shouldRemoveErrors) { remover.removeErrorReports(taskId); LOGGER.info("Error reports for task Id:" + taskId + " were removed successfully"); } } RemoverInvoker(Remover remover); void executeInvokerForSingleTask(long taskId, boolean shouldRemoveErrors); void executeInvokerForListOfTasks(String filePath, boolean shouldRemoveErrors); }### Answer:
@Test public void shouldInvokeAllTheRemovalStepsExcludingErrorReports() { removerInvoker.executeInvokerForSingleTask(TASK_ID, false); verify(remover, times(1)).removeNotifications((eq(TASK_ID))); verify(remover, times(1)).removeStatistics((eq(TASK_ID))); verify(remover, times(0)).removeErrorReports((eq(TASK_ID))); }
@Test public void shouldInvokeAllTheRemovalStepsIncludingErrorReports() { removerInvoker.executeInvokerForSingleTask(TASK_ID, true); verify(remover, times(1)).removeNotifications((eq(TASK_ID))); verify(remover, times(1)).removeStatistics((eq(TASK_ID))); verify(remover, times(1)).removeErrorReports((eq(TASK_ID))); } |
### Question:
ReadFileBolt extends AbstractDpsBolt { private InputStream getFile(FileServiceClient fileClient, String file, String authorization) throws MCSException, IOException { int retries = DEFAULT_RETRIES; while (true) { try { return fileClient.getFile(file, AUTHORIZATION, authorization); } catch (Exception e) { if (retries-- > 0) { LOGGER.warn("Error while getting a file. Retries left:{} ", retries); waitForSpecificTime(); } else { LOGGER.error("Error while getting a file."); throw e; } } } } ReadFileBolt(String ecloudMcsAddress); @Override void prepare(); @Override void execute(Tuple anchorTuple, StormTaskTuple t); }### Answer:
@Test public void shouldEmmitNotificationWhenDataSetListHasOneElement() throws MCSException, IOException { when(fileServiceClient.getFile(eq(FILE_URL),eq(AUTHORIZATION), eq(AUTHORIZATION_HEADER))).thenReturn(null); verifyMethodExecutionNumber(1, 0, FILE_URL); }
@Test public void shouldRetry3TimesBeforeFailingWhenThrowingMCSException() throws MCSException, IOException { doThrow(MCSException.class).when(fileServiceClient).getFile(eq(FILE_URL),eq(AUTHORIZATION), eq(AUTHORIZATION_HEADER)); verifyMethodExecutionNumber(4, 1, FILE_URL); }
@Test public void shouldRetry3TimesBeforeFailingWhenThrowingDriverException() throws MCSException, IOException { doThrow(DriverException.class).when(fileServiceClient).getFile(eq(FILE_URL),eq(AUTHORIZATION), eq(AUTHORIZATION_HEADER)); verifyMethodExecutionNumber(4, 1, FILE_URL); } |
### Question:
RemoverInvoker { public void executeInvokerForListOfTasks(String filePath, boolean shouldRemoveErrors) throws IOException { TaskIdsReader reader = new CommaSeparatorReaderImpl(); List<String> taskIds = reader.getTaskIds(filePath); for (String taskId : taskIds) { executeInvokerForSingleTask(Long.valueOf(taskId), shouldRemoveErrors); } } RemoverInvoker(Remover remover); void executeInvokerForSingleTask(long taskId, boolean shouldRemoveErrors); void executeInvokerForListOfTasks(String filePath, boolean shouldRemoveErrors); }### Answer:
@Test public void shouldExecuteTheRemovalOnListOfTASKS() throws IOException { removerInvoker.executeInvokerForListOfTasks("src/test/resources/taskIds.csv", true); verify(remover, times(6)).removeNotifications(anyLong()); verify(remover, times(6)).removeStatistics((anyLong())); verify(remover, times(6)).removeErrorReports((anyLong())); } |
### Question:
AddResultToDataSetBolt extends AbstractDpsBolt { private void assignRepresentationToDataSet(DataSet dataSet, Representation resultRepresentation, String authorizationHeader) throws MCSException { int retries = DEFAULT_RETRIES; while (true) { try { dataSetServiceClient.assignRepresentationToDataSet( dataSet.getProviderId(), dataSet.getId(), resultRepresentation.getCloudId(), resultRepresentation.getRepresentationName(), resultRepresentation.getVersion(), AUTHORIZATION, authorizationHeader); break; } catch (Exception e) { if (retries-- > 0) { LOGGER.warn("Error while assigning record to dataset. Retries left: {}", retries); waitForSpecificTime(); } else { LOGGER.error("Error while assigning record to dataset."); throw e; } } } } AddResultToDataSetBolt(String ecloudMcsAddress); @Override void prepare(); @Override void execute(Tuple anchorTuple, StormTaskTuple stormTaskTuple); }### Answer:
@Test public void shouldRetry3TimesBeforeFailingWhenThrowingMCSException() throws MCSException { stormTaskTuple = prepareTupleWithSingleDataSet(); doThrow(MCSException.class).when(dataSetServiceClient).assignRepresentationToDataSet(anyString(), anyString(), anyString(), anyString(), anyString(),eq(AUTHORIZATION),eq(AUTHORIZATION)); verifyMethodExecutionNumber(4, 1); }
@Test public void shouldRetry3TimesBeforeFailingWhenThrowingDriverException() throws MCSException { stormTaskTuple = prepareTupleWithSingleDataSet(); doThrow(DriverException.class).when(dataSetServiceClient).assignRepresentationToDataSet(anyString(), anyString(), anyString(), anyString(), anyString(),eq(AUTHORIZATION),eq(AUTHORIZATION)); verifyMethodExecutionNumber(4, 1); } |
### Question:
FileUtil { public static String createFilePath(String folderPath, String fileName, String extension) { String filePtah = folderPath + fileName; if ("".equals(FilenameUtils.getExtension(fileName))) filePtah = filePtah + extension; return filePtah; } static void persistStreamToFile(InputStream inputStream, String folderPath, String fileName, String extension); static String createFilePath(String folderPath, String fileName, String extension); static String createFolder(); static String createZipFolderPath(Date date); }### Answer:
@Test public void shouldCreateTheCorrectFilePath() throws Exception { String filePath = FileUtil.createFilePath(FOLDER_PATH, FILE_NAME_WITHOUT_EXTENSION, EXTENSION); assertEquals(filePath, FILE_PATH); filePath = FileUtil.createFilePath(FOLDER_PATH, FILE_NAME_WITH_EXTENSION, EXTENSION); assertEquals(filePath, FILE_PATH); } |
### Question:
PropertyFileLoader { public void loadDefaultPropertyFile(String defaultPropertyFile, Properties topologyProperties) throws IOException { InputStream propertiesInputStream = Thread.currentThread() .getContextClassLoader().getResourceAsStream(defaultPropertyFile); if (propertiesInputStream == null) throw new FileNotFoundException(); topologyProperties.load(propertiesInputStream); } static void loadPropertyFile(String defaultPropertyFile, String providedPropertyFile, Properties topologyProperties); void loadDefaultPropertyFile(String defaultPropertyFile, Properties topologyProperties); void loadProvidedPropertyFile(String fileName, Properties topologyProperties); }### Answer:
@Test public void testLoadingDefaultPropertiesFile() throws FileNotFoundException, IOException { reader.loadDefaultPropertyFile(DEFAULT_PROPERTIES_FILE, topologyProperties); assertNotNull(topologyProperties); assertFalse(topologyProperties.isEmpty()); for (final Map.Entry<Object, Object> e : topologyProperties.entrySet()) { assertNotNull(e.getKey()); } }
@Test(expected = FileNotFoundException.class) public void testLoadingNonExistedDefaultFile() throws FileNotFoundException, IOException { reader.loadDefaultPropertyFile("NON_EXISTED_FILE", topologyProperties); } |
### Question:
PropertyFileLoader { public void loadProvidedPropertyFile(String fileName, Properties topologyProperties) throws IOException { File file = new File(fileName); FileInputStream fileInput = new FileInputStream(file); topologyProperties.load(fileInput); fileInput.close(); } static void loadPropertyFile(String defaultPropertyFile, String providedPropertyFile, Properties topologyProperties); void loadDefaultPropertyFile(String defaultPropertyFile, Properties topologyProperties); void loadProvidedPropertyFile(String fileName, Properties topologyProperties); }### Answer:
@Test public void testLoadingProvidedPropertiesFile() throws FileNotFoundException, IOException { reader.loadProvidedPropertyFile(PROVIDED_PROPERTIES_FILE, topologyProperties); assertNotNull(topologyProperties); assertFalse(topologyProperties.isEmpty()); for (final Map.Entry<Object, Object> e : topologyProperties.entrySet()) { assertNotNull(e.getKey()); } }
@Test(expected = FileNotFoundException.class) public void testLoadingNonExistedProvidedFile() throws FileNotFoundException, IOException { reader.loadProvidedPropertyFile("NON_EXISTED_FILE", topologyProperties); } |
### Question:
FileUtil { public static String createZipFolderPath(Date date) { String folderName = generateFolderName(date); return System.getProperty("user.dir") + "/" + folderName + ZIP_FORMAT_EXTENSION; } static void persistStreamToFile(InputStream inputStream, String folderPath, String fileName, String extension); static String createFilePath(String folderPath, String fileName, String extension); static String createFolder(); static String createZipFolderPath(Date date); }### Answer:
@Test public void testCreateZipFolderPath() { Date date = new Date(); DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-ssss"); String expectedFolderName = ECLOUD_SUFFIX + "-" + dateFormat.format(date); String folderPath = FileUtil.createZipFolderPath(date); String extension = FilenameUtils.getExtension(folderPath); String folderName = FilenameUtils.getBaseName(folderPath); assertEquals(extension, ZIP_EXTENSION); assertEquals(folderName, expectedFolderName); } |
### Question:
PropertyFileLoader { public static void loadPropertyFile(String defaultPropertyFile, String providedPropertyFile, Properties topologyProperties) { try { PropertyFileLoader reader = new PropertyFileLoader(); reader.loadDefaultPropertyFile(defaultPropertyFile, topologyProperties); if (!"".equals(providedPropertyFile)) { reader.loadProvidedPropertyFile(providedPropertyFile, topologyProperties); } } catch (IOException e) { LOGGER.error(Throwables.getStackTraceAsString(e)); } } static void loadPropertyFile(String defaultPropertyFile, String providedPropertyFile, Properties topologyProperties); void loadDefaultPropertyFile(String defaultPropertyFile, Properties topologyProperties); void loadProvidedPropertyFile(String fileName, Properties topologyProperties); }### Answer:
@Test public void testLoadingFileWhenProvidedPropertyFileNotExisted() throws FileNotFoundException, IOException { PropertyFileLoader.loadPropertyFile(DEFAULT_PROPERTIES_FILE, "NON_EXISTED_PROVIDED_FILE", topologyProperties); assertNotNull(topologyProperties); assertFalse(topologyProperties.isEmpty()); for (final Map.Entry<Object, Object> e : topologyProperties.entrySet()) { assertNotNull(e.getKey()); } }
@Test public void testLoadingFileWhenDefaultFileNotExists() throws FileNotFoundException, IOException { PropertyFileLoader.loadPropertyFile("NON_EXISTED_DEFAULT_FILE", PROVIDED_PROPERTIES_FILE, topologyProperties); assertTrue(topologyProperties.isEmpty()); } |
### Question:
TaskStatusChecker { public boolean hasKillFlag(long taskId) { try { return cache.get(taskId); } catch (ExecutionException e) { LOGGER.info(e.getMessage()); return false; } } private TaskStatusChecker(CassandraConnectionProvider cassandraConnectionProvider); TaskStatusChecker(CassandraTaskInfoDAO taskDAO); static synchronized TaskStatusChecker getTaskStatusChecker(); static synchronized void init(CassandraConnectionProvider cassandraConnectionProvider); boolean hasKillFlag(long taskId); static final int CHECKING_INTERVAL_IN_SECONDS; static final int CONCURRENCY_LEVEL; static final int SIZE; }### Answer:
@Test public void testExecutionWithMultipleTasks() throws Exception { when(taskInfoDAO.hasKillFlag(TASK_ID)).thenReturn(false, false, false, true, true); when(taskInfoDAO.hasKillFlag(TASK_ID2)).thenReturn(false, false, true); boolean task1killedFlag = false; boolean task2killedFlag = false; for (int i = 0; i < 8; i++) { if (i < 4) assertFalse(task1killedFlag); if (i < 3) assertFalse(task2killedFlag); task1killedFlag = taskStatusChecker.hasKillFlag(TASK_ID); if (i < 5) task2killedFlag = taskStatusChecker.hasKillFlag(TASK_ID2); Thread.sleep(6000); } verify(taskInfoDAO, times(8)).hasKillFlag(eq(TASK_ID)); verify(taskInfoDAO, times(5)).hasKillFlag(eq(TASK_ID2)); assertTrue(task1killedFlag); assertTrue(task2killedFlag); Thread.sleep(20000); verifyNoMoreInteractions(taskInfoDAO); } |
### Question:
TaskTupleUtility { protected static boolean isProvidedAsParameter(StormTaskTuple stormTaskTuple, String parameter) { if (stormTaskTuple.getParameter(parameter) != null) { return true; } else { return false; } } static String getParameterFromTuple(StormTaskTuple stormTaskTuple, String parameter); }### Answer:
@Test public void parameterIsProvidedTest() { stormTaskTuple.addParameter(PluginParameterKeys.MIME_TYPE, MIME_TYPE); assertTrue(TaskTupleUtility.isProvidedAsParameter(stormTaskTuple, PluginParameterKeys.MIME_TYPE)); }
@Test public void parameterIsNotProvidedTest() { assertFalse(TaskTupleUtility.isProvidedAsParameter(stormTaskTuple, PluginParameterKeys.MIME_TYPE)); } |
### Question:
TaskTupleUtility { public static String getParameterFromTuple(StormTaskTuple stormTaskTuple, String parameter) { String outputValue = PluginParameterKeys.PLUGIN_PARAMETERS.get(parameter); if (isProvidedAsParameter(stormTaskTuple, parameter)) { outputValue = stormTaskTuple.getParameter(parameter); } return outputValue; } static String getParameterFromTuple(StormTaskTuple stormTaskTuple, String parameter); }### Answer:
@Test public void getDefaultValueTest() { assertEquals(TaskTupleUtility.getParameterFromTuple(stormTaskTuple, PluginParameterKeys.MIME_TYPE), PluginParameterKeys.PLUGIN_PARAMETERS.get(PluginParameterKeys.MIME_TYPE)); }
@Test public void getProvidedValueTest() { stormTaskTuple.addParameter(PluginParameterKeys.MIME_TYPE, MIME_TYPE); assertEquals(TaskTupleUtility.getParameterFromTuple(stormTaskTuple, PluginParameterKeys.MIME_TYPE), MIME_TYPE); } |
### Question:
FolderCompressor { public static void compress(String folderPath, String zipFolderPath) throws ZipException { File folder = new File(folderPath); ZipUtil.pack(folder, new File(zipFolderPath)); } static void compress(String folderPath, String zipFolderPath); }### Answer:
@Test(expected = ZipException.class) public void shouldThrowZipExceptionWhileCompressEmptyFolder() throws Exception { folderPath = FileUtil.createFolder(); File folder = new File(folderPath); assertTrue(folder.isDirectory()); zipFolderPath = FileUtil.createZipFolderPath(new Date()); FolderCompressor.compress(folderPath, zipFolderPath); System.out.println(folderPath); }
@Test public void shouldSuccessfullyCompressFolder() throws Exception { folderPath = FileUtil.createFolder(); File folder = new File(folderPath); assertTrue(folder.isDirectory()); InputStream inputStream = IOUtils.toInputStream("some test data for my input stream"); createFile(inputStream, folderPath + "fileName"); zipFolderPath = FileUtil.createZipFolderPath(new Date()); FolderCompressor.compress(folderPath, zipFolderPath); assertNotNull(zipFolderPath); } |
### Question:
Retriever { public static void retryOnError3Times(String errorMessage, Runnable runnable) { retryOnError3Times(errorMessage,()->{ runnable.run(); return null; }); } static void retryOnError3Times(String errorMessage, Runnable runnable); static V retryOnError3Times(String errorMessage, Callable<V> callable); static void waitForSpecificTime(int milliSecond); }### Answer:
@Test public void repeatOnError3Times_callNoThrowsExceptions_validResult() throws Exception { when(call.call()).thenReturn(RESULT); String result = Retriever.retryOnError3Times(ERROR_MESSAGE, call); assertEquals(RESULT, result); }
@Test public void repeatOnError3Times_callNoThrowsExceptions_callInvokedOnce() throws Exception { when(call.call()).thenReturn(RESULT); String result = Retriever.retryOnError3Times(ERROR_MESSAGE, call); verify(call).call(); }
@Test(expected = IOException.class) public void repeatOnError3Times_callAlwaysThrowsExceptions_catchedException() throws Exception { when(call.call()).thenThrow(IOException.class); Retriever.retryOnError3Times(ERROR_MESSAGE, call); }
@Test public void repeatOnError3Timescall_AlwaysThrowsExceptions_callInvoked3Times() throws Exception { when(call.call()).thenThrow(IOException.class); try { Retriever.<String,IOException>retryOnError3Times(ERROR_MESSAGE, call); } catch (IOException e) { e.printStackTrace(); } verify(call,times(4)).call(); } |
### Question:
TopologiesTopicsParser { public Map<String, List<String>> parse(String topicsList) { if (isInputValid(topicsList)) { List<String> topologies = extractTopologies(topicsList); return extractTopics(topologies); } else { throw new RuntimeException("Topics list is not valid"); } } Map<String, List<String>> parse(String topicsList); }### Answer:
@Test public void shouldSuccessfullyParseTopicsList() { TopologiesTopicsParser t = new TopologiesTopicsParser(); Map<String, List<String>> topologiesTopicsList = t.parse(VALID_INPUT); Assert.assertEquals(2, topologiesTopicsList.size()); Assert.assertNotNull(topologiesTopicsList.get("oai_topology")); Assert.assertNotNull(topologiesTopicsList.get("another_topology")); Assert.assertEquals(3, topologiesTopicsList.get("oai_topology").size()); Assert.assertEquals(2, topologiesTopicsList.get("another_topology").size()); }
@Test public void shouldSuccessfullyParseTopicsList_1() { TopologiesTopicsParser t = new TopologiesTopicsParser(); Map<String, List<String>> topologiesTopicsList = t.parse(VALID_INPUT_1); Assert.assertEquals(2, topologiesTopicsList.size()); Assert.assertNotNull(topologiesTopicsList.get("oai_topology")); Assert.assertNotNull(topologiesTopicsList.get("another_topology")); Assert.assertEquals(3, topologiesTopicsList.get("oai_topology").size()); Assert.assertEquals(0, topologiesTopicsList.get("another_topology").size()); }
@Test(expected = RuntimeException.class) public void shouldThrowExceptionForInvalidTopicsList_1() { TopologiesTopicsParser t = new TopologiesTopicsParser(); t.parse(INVALID_INPUT_1); } |
### Question:
ValidatorFactory { public static Validator getValidator(ValidatorType type) { if (type == ValidatorType.KEYSPACE) return new KeyspaceValidator(); if (type == ValidatorType.TABLE) return new TableValidator(); return null; } static Validator getValidator(ValidatorType type); }### Answer:
@Test public void TestValidator() { Validator validator = ValidatorFactory.getValidator(ValidatorType.KEYSPACE); assertTrue(validator instanceof KeyspaceValidator); validator = ValidatorFactory.getValidator(ValidatorType.TABLE); assertTrue(validator instanceof TableValidator); } |
### Question:
DepublicationFilesCounter extends FilesCounter { @Override public int getFilesCount(DpsTask task) throws TaskSubmissionException { if (task.getParameter(PluginParameterKeys.RECORD_IDS_TO_DEPUBLISH) != null) { return calculateRecordsNumber(task); } if (task.getParameter(PluginParameterKeys.METIS_DATASET_ID) != null) { return calculateDatasetSize(task); } throw new TaskSubmissionException("Can't evaluate task expected size! Needed parameters not found in the task"); } DepublicationFilesCounter(DatasetDepublisher depublisher); @Override int getFilesCount(DpsTask task); }### Answer:
@Test public void shouldCountRecords() throws Exception { int randomNum = ThreadLocalRandom.current().nextInt(1, DATASET_EXPECTED_SIZE); StringBuilder records = new StringBuilder("r1"); for(int index = 2; index <= randomNum; index++) { records.append(", r"); records.append(index); } DpsTask dpsTask = new DpsTask(); dpsTask.addParameter(METIS_DATASET_ID, ""); dpsTask.addParameter(RECORD_IDS_TO_DEPUBLISH, records.toString()); DepublicationFilesCounter depublicationFilesCounter = new DepublicationFilesCounter(datasetDepublisher); int count = depublicationFilesCounter.getFilesCount(dpsTask); assertEquals(randomNum, count); }
@Test public void shouldCountEntireDataset() throws Exception { DpsTask dpsTask = new DpsTask(); dpsTask.addParameter(METIS_DATASET_ID, ""); DepublicationFilesCounter depublicationFilesCounter = new DepublicationFilesCounter(datasetDepublisher); int count = depublicationFilesCounter.getFilesCount(dpsTask); assertEquals(DATASET_EXPECTED_SIZE, count); } |
### Question:
CassandraHelper { public static BoundStatement prepareBoundStatementForMatchingTargetTable(CassandraConnectionProvider cassandraConnectionProvider, String targetTableName, List<String> primaryKeys) { String matchCountStatementCQL = CQLBuilder.getMatchCountStatementFromTargetTable(targetTableName, primaryKeys); PreparedStatement matchCountStatementCQLStatement = cassandraConnectionProvider.getSession().prepare(matchCountStatementCQL); matchCountStatementCQLStatement.setConsistencyLevel(cassandraConnectionProvider.getConsistencyLevel()); return matchCountStatementCQLStatement.bind(); } static BoundStatement prepareBoundStatementForMatchingTargetTable(CassandraConnectionProvider cassandraConnectionProvider, String targetTableName, List<String> primaryKeys); static ResultSet getPrimaryKeysFromSourceTable(CassandraConnectionProvider cassandraConnectionProvider, String sourceTableName, List<String> primaryKeys); static List<String> getPrimaryKeysNames(CassandraConnectionProvider cassandraConnectionProvider, String tableName, String selectColumnNames); }### Answer:
@Test public void prepareBoundStatementForMatchingTargetTableTest() { assertThat(CassandraHelper.prepareBoundStatementForMatchingTargetTable(cassandraConnectionProvider, "table", primaryKeys), is(boundStatement)); } |
### Question:
CassandraHelper { public static ResultSet getPrimaryKeysFromSourceTable(CassandraConnectionProvider cassandraConnectionProvider, String sourceTableName, List<String> primaryKeys) { String selectPrimaryKeysFromSourceTable = CQLBuilder.constructSelectPrimaryKeysFromSourceTable(sourceTableName, primaryKeys); PreparedStatement sourceSelectStatement = cassandraConnectionProvider.getSession().prepare(selectPrimaryKeysFromSourceTable); sourceSelectStatement.setConsistencyLevel(cassandraConnectionProvider.getConsistencyLevel()); BoundStatement boundStatement = sourceSelectStatement.bind(); return cassandraConnectionProvider.getSession().execute(boundStatement); } static BoundStatement prepareBoundStatementForMatchingTargetTable(CassandraConnectionProvider cassandraConnectionProvider, String targetTableName, List<String> primaryKeys); static ResultSet getPrimaryKeysFromSourceTable(CassandraConnectionProvider cassandraConnectionProvider, String sourceTableName, List<String> primaryKeys); static List<String> getPrimaryKeysNames(CassandraConnectionProvider cassandraConnectionProvider, String tableName, String selectColumnNames); }### Answer:
@Test public void getPrimaryKeysFromSourceTableTest() { ResultSet resultSet = mock(ResultSet.class); when(session.execute(boundStatement)).thenReturn(resultSet); assertThat(CassandraHelper.getPrimaryKeysFromSourceTable(cassandraConnectionProvider, "table", primaryKeys), is(resultSet)); } |
### Question:
XmlXPath { String xpathToString(XPathExpression expr) throws HarvesterException { try { return evaluateExpression(expr); } catch (XPathExpressionException e) { throw new HarvesterException("Cannot xpath XML!", e); } } XmlXPath(String input); }### Answer:
@Test public void shouldReturnRecordIsDeleted() throws IOException, HarvesterException { final String fileContent = WiremockHelper.getFileContent("/deletedOaiRecord.xml"); final InputStream inputStream = IOUtils.toInputStream(fileContent, ENCODING); String content = IOUtils.toString(inputStream, ENCODING); assertEquals("deleted", new XmlXPath(content).xpathToString(isDeletedExpression)); }
@Test public void shouldReturnRecordIsNotDeleted() throws IOException, HarvesterException { final String fileContent = WiremockHelper.getFileContent("/sampleOaiRecord.xml"); final InputStream inputStream = IOUtils.toInputStream(fileContent, ENCODING); String content = IOUtils.toString(inputStream, ENCODING); assertFalse("deleted".equalsIgnoreCase(new XmlXPath(content).xpathToString(isDeletedExpression))); } |
### Question:
TopologyManager { public List<String> getNames() { return topologies; } TopologyManager(final String nameList); List<String> getNames(); boolean containsTopology(String topologyName); static final String separatorChar; static final Logger logger; }### Answer:
@Test public void should_successfully_getTopologyNames() { List<String> resultNameList = instance.getNames(); List<String> expectedNameList = convertStringToList(nameList); assertThat(resultNameList, is(equalTo(expectedNameList))); } |
### Question:
TopologyManager { public boolean containsTopology(String topologyName) { return topologies.contains(topologyName); } TopologyManager(final String nameList); List<String> getNames(); boolean containsTopology(String topologyName); static final String separatorChar; static final Logger logger; }### Answer:
@Test public void should_successfully_containsTopology1() { final String topologyName = "topologyA"; boolean result = instance.containsTopology(topologyName); assertThat(result, is(equalTo(true))); }
@Test public void should_successfully_containsTopology2() { final String topologyName = "topologyB"; boolean result = instance.containsTopology(topologyName); assertThat(result, is(equalTo(true))); }
@Test public void should_unsuccessfully_containsTopology() { final String topologyName = "topologyC"; boolean result = instance.containsTopology(topologyName); assertThat(result, is(equalTo(false))); } |
### Question:
CQLBuilder { public static String constructSelectPrimaryKeysFromSourceTable(String sourceTableName, List<String> primaryKeyNames) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("SELECT "); for (int i = 0; i < primaryKeyNames.size() - 1; i++) stringBuilder.append(primaryKeyNames.get(i)).append(" , "); stringBuilder.append(primaryKeyNames.get(primaryKeyNames.size() - 1)); stringBuilder.append(" from ").append(sourceTableName).append(";"); return stringBuilder.toString(); } static String getMatchCountStatementFromTargetTable(String targetTableName, List<String> names); static String constructSelectPrimaryKeysFromSourceTable(String sourceTableName, List<String> primaryKeyNames); }### Answer:
@Test public void shouldReturnTheExpectedPrimaryKeysSelectionCQL() { assertEquals(EXPECTED_PRIMARY_KEYS_SELECTION_STATEMENT, CQLBuilder.constructSelectPrimaryKeysFromSourceTable(SOURCE_TABLE, primaryKeys)); } |
### Question:
RepresentationVersionsResource { @GetMapping(produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE}) @ResponseBody public RepresentationsListWrapper listVersions( final HttpServletRequest request, @PathVariable String cloudId, @PathVariable String representationName) throws RepresentationNotExistsException { List<Representation> representationVersions = recordService.listRepresentationVersions(cloudId, representationName); for (Representation representationVersion : representationVersions) { EnrichUriUtil.enrich(request, representationVersion); } return new RepresentationsListWrapper(representationVersions); } RepresentationVersionsResource(RecordService recordService); @GetMapping(produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE}) @ResponseBody RepresentationsListWrapper listVersions(
final HttpServletRequest request,
@PathVariable String cloudId,
@PathVariable String representationName); static final Logger LOGGER; }### Answer:
@Test @Parameters(method = "mimeTypes") public void testListVersions(MediaType mediaType) throws Exception { List<Representation> expected = copy(REPRESENTATIONS); Representation expectedRepresentation = expected.get(0); URITools.enrich(expectedRepresentation, getBaseUri()); when(recordService.listRepresentationVersions(GLOBAL_ID, SCHEMA)).thenReturn(copy(REPRESENTATIONS)); ResultActions response = mockMvc.perform(get(LIST_VERSIONS_PATH).accept(mediaType)) .andExpect(status().isOk()) .andExpect(content().contentType(mediaType)); List<Representation> entity = responseContentAsRepresentationList(response, mediaType); assertThat(entity, is(expected)); verify(recordService, times(1)).listRepresentationVersions(GLOBAL_ID, SCHEMA); verifyNoMoreInteractions(recordService); } |
### Question:
CQLBuilder { public static String getMatchCountStatementFromTargetTable(String targetTableName, List<String> names) { String wherePart = getStringWherePart(names); StringBuilder selectStatementFromTargetTableBuilder = new StringBuilder(); selectStatementFromTargetTableBuilder.append("Select count(*) from ").append(targetTableName).append(" WHERE ").append(wherePart); return selectStatementFromTargetTableBuilder.toString(); } static String getMatchCountStatementFromTargetTable(String targetTableName, List<String> names); static String constructSelectPrimaryKeysFromSourceTable(String sourceTableName, List<String> primaryKeyNames); }### Answer:
@Test public void shouldReturnTheExpectedCountStatement() { assertEquals(EXPECTED_COUNT_STATEMENT, CQLBuilder.getMatchCountStatementFromTargetTable(SOURCE_TABLE, primaryKeys)); } |
### Question:
RecordsResource { @DeleteMapping @ResponseStatus(HttpStatus.NO_CONTENT) @PreAuthorize("hasRole('ROLE_ADMIN')") public void deleteRecord( @PathVariable String cloudId) throws RecordNotExistsException, RepresentationNotExistsException { recordService.deleteRecord(cloudId); } RecordsResource(RecordService recordService); @GetMapping(produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE}) @ResponseBody Record getRecord(
HttpServletRequest httpServletRequest,
@PathVariable String cloudId); @DeleteMapping @ResponseStatus(HttpStatus.NO_CONTENT) @PreAuthorize("hasRole('ROLE_ADMIN')") void deleteRecord(
@PathVariable String cloudId); }### Answer:
@Test public void deleteRecord() throws Exception { String globalId = "global1"; mockMvc.perform(delete("/records/" + globalId)) .andExpect(status().isNoContent()); verify(recordService, times(1)).deleteRecord(globalId); verifyNoMoreInteractions(recordService); }
@Test public void deleteRecordReturns404IfRecordDoesNotExists() throws Exception { String globalId = "global1"; Throwable exception = new RecordNotExistsException(); Mockito.doThrow(exception).when(recordService).deleteRecord(globalId); mockMvc.perform(delete("/records/" + globalId).contentType(MediaType.APPLICATION_XML)) .andExpect(status().isNotFound()); verify(recordService, times(1)).deleteRecord(globalId); verifyNoMoreInteractions(recordService); }
@Test public void deleteRecordReturns404IfRecordHasNoRepresentations() throws Exception { String globalId = "global1"; Throwable exception = new RepresentationNotExistsException(); Mockito.doThrow(exception).when(recordService).deleteRecord(globalId); mockMvc.perform(delete("/records/" + globalId).contentType(MediaType.APPLICATION_XML)) .andExpect(status().isNotFound()); verify(recordService, times(1)).deleteRecord(globalId); verifyNoMoreInteractions(recordService); } |
### Question:
DataSetsResource { @GetMapping(produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE}) @ResponseBody public ResultSlice<DataSet> getDataSets( @PathVariable String providerId, @RequestParam(required = false) String startFrom) { return dataSetService.getDataSets(providerId, startFrom, numberOfElementsOnPage); } DataSetsResource(DataSetService dataSetService, MutableAclService mutableAclService); @GetMapping(produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE}) @ResponseBody ResultSlice<DataSet> getDataSets(
@PathVariable String providerId,
@RequestParam(required = false) String startFrom); @PreAuthorize("isAuthenticated()") @PostMapping ResponseEntity<Void> createDataSet(
HttpServletRequest httpServletRequest,
@PathVariable String providerId,
@RequestParam String dataSetId,
@RequestParam(required = false) String description); }### Answer:
@Test public void shouldCreateDataset() throws Exception { Mockito.doReturn(new DataProvider()).when(uisHandler) .getProvider("provId"); String datasetId = "datasetId"; String description = "dataset description"; ResultActions createResponse = mockMvc.perform(post(dataSetsWebTarget, "provId").contentType(MediaType.APPLICATION_FORM_URLENCODED) .param(F_DATASET, datasetId).param(F_DESCRIPTION, description) ).andExpect(status().isCreated()); String uriFromResponse = createResponse.andReturn().getResponse().getHeader(HttpHeaders.LOCATION); assertEquals("http: List<DataSet> dataSetsForPrivider = dataSetService.getDataSets( "provId", null, 10000).getResults(); assertEquals("Expected single dataset in service", 1, dataSetsForPrivider.size()); DataSet ds = dataSetsForPrivider.get(0); assertEquals(datasetId, ds.getId()); assertEquals(description, ds.getDescription()); } |
### Question:
CSVReader implements RevisionsReader { @Override public List<RevisionInformation> getRevisionsInformation(String filePath) throws IOException { List<RevisionInformation> revisionInformationList = new ArrayList<>(); try (BufferedReader br = new BufferedReader(new FileReader(filePath))) { String line = ""; br.readLine(); while ((line = br.readLine()) != null) { String[] lines = line.split(LINE_SEPARATOR); RevisionInformation revisionInformation = new RevisionInformation(lines[0], lines[1], lines[2], lines[3], lines[4], lines[5]); revisionInformationList.add(revisionInformation); } } return revisionInformationList; } @Override List<RevisionInformation> getRevisionsInformation(String filePath); }### Answer:
@Test public void shouldReadAndReturnTaskIdsForCSVFile() throws IOException { List<RevisionInformation> taskIds = csvReader.getRevisionsInformation(Paths.get("src/test/resources/revisions.csv").toString()); assertNotNull(taskIds); assertEquals(8, taskIds.size()); } |
### Question:
RepresentationsResource { @GetMapping(produces = {MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) @ResponseBody public RepresentationsListWrapper getRepresentations( HttpServletRequest httpServletRequest, @PathVariable String cloudId) throws RecordNotExistsException { List<Representation> representationInfos = recordService.getRecord(cloudId).getRepresentations(); prepare(httpServletRequest, representationInfos); return new RepresentationsListWrapper(representationInfos); } RepresentationsResource(RecordService recordService); @GetMapping(produces = {MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) @ResponseBody RepresentationsListWrapper getRepresentations(
HttpServletRequest httpServletRequest,
@PathVariable String cloudId); }### Answer:
@Test @Parameters(method = "mimeTypes") public void getRepresentations(MediaType mediaType) throws Exception { Record expected = new Record(record); Representation expectedRepresentation = expected.getRepresentations().get(0); expectedRepresentation.setUri(URITools.getVersionUri(getBaseUri(), globalId, schema, version)); expectedRepresentation.setAllVersionsUri(URITools.getAllVersionsUri(getBaseUri(), globalId, schema)); expectedRepresentation.setFiles(new ArrayList<File>()); when(recordService.getRecord(globalId)).thenReturn(new Record(record)); ResultActions response = mockMvc.perform(get(URITools.getRepresentationsPath(globalId).toString()).accept(mediaType)) .andExpect(status().isOk()) .andExpect(content().contentType(mediaType)); List<Representation> entity = responseContentAsRepresentationList(response, mediaType); assertThat(entity, is(expected.getRepresentations())); verify(recordService, times(1)).getRecord(globalId); verifyNoMoreInteractions(recordService); } |
### Question:
ContentStreamDetector { public static MediaType detectMediaType(InputStream inputStream) throws IOException { if (!inputStream.markSupported()) { throw new UnsupportedOperationException("InputStream marking support is required!"); } return new AutoDetectParser().getDetector().detect(inputStream, new Metadata()); } private ContentStreamDetector(); static MediaType detectMediaType(InputStream inputStream); }### Answer:
@Test @Parameters({ "example_metadata.xml, application/xml", "example_jpg2000.jp2, image/jp2" }) public void shouldProperlyGuessMimeType_Xml(String fileName, String expectedMimeType) throws IOException { URL resource = Resources.getResource(fileName); byte[] expected = Resources.toByteArray(resource); BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream( resource.getFile())); String mimeType = detectMediaType(inputStream).toString(); assertThat(mimeType,is(expectedMimeType)); byte[] actual = readFully(inputStream, expected.length); assertThat(actual,is(expected)); } |
### Question:
StorageSelector { public Storage selectStorage() { return decide(assertUserMediaType(), getAvailable()); } StorageSelector(final PreBufferedInputStream inputStream, final String userMediaType); Storage selectStorage(); }### Answer:
@Test @Parameters({ "example_metadata.xml, DATA_BASE, application/xml", "example_jpg2000.jp2, OBJECT_STORAGE, image/jp2" }) public void shouldDetectStorage(String fileName, String expectedDecision, String mediaType) throws IOException { URL resource = Resources.getResource(fileName); byte[] expected = Resources.toByteArray(resource); PreBufferedInputStream inputStream = new PreBufferedInputStream( new FileInputStream(resource.getFile()), 512 * 1024); StorageSelector instance = new StorageSelector(inputStream, mediaType); Storage decision = instance.selectStorage(); assertThat(decision.toString(), is(expectedDecision)); byte[] actual = readFully(inputStream, expected.length); assertThat(actual, is(expected)); }
@Test(expected = BadRequestException.class) @Parameters({ "example_metadata.xml, image/jp2", "example_jpg2000.jp2, application/xml" }) public void shouldThrowBadRequestOnDifferentMimeTypeProvidedByUser(String fileName, String mediaType) throws IOException { URL resource = Resources.getResource(fileName); byte[] expected = Resources.toByteArray(resource); PreBufferedInputStream inputStream = new PreBufferedInputStream( new FileInputStream(resource.getFile()), 512 * 1024); StorageSelector instance = new StorageSelector(inputStream, mediaType); Storage decision = instance.selectStorage(); } |
### Question:
PreBufferedInputStream extends BufferedInputStream { @Override public synchronized int read() throws IOException { ensureIsNotClosed(); if (position < bufferFill) { return buffer[position++] & 0xff; } return super.read(); } PreBufferedInputStream(InputStream stream, int bufferSize); static PreBufferedInputStream wrap(final byte[] data,
final int preloadChunkSize); int getBufferSize(); @Override synchronized int read(); @Override synchronized int read(final byte[] b, final int offset, final int length); @Override synchronized int available(); @Override boolean markSupported(); @Override synchronized void mark(int readLimit); @Override synchronized void reset(); @Override synchronized void close(); @Override synchronized long skip(final long length); }### Answer:
@Test @Parameters({ "10, 20", "200, 10", "100, 10000", "100, 200", "200, 100" }) public void shouldReadStreamPerByte(int size, int bufferSize) throws IOException { byte[] randomByes = Helper.generateSeq(size); ByteArrayInputStream inputStream = new ByteArrayInputStream(randomByes); PreBufferedInputStream instance = new PreBufferedInputStream(inputStream, bufferSize); int[] actual = new int[randomByes.length]; for (int i = 0; i < actual.length; i++) { actual[i] = instance.read(); } int[] randomIntegers = new int[actual.length]; for (int i = 0; i < randomIntegers.length; i++) { randomIntegers[i] = randomByes[i] & 0xff; } assertThat(actual, is(randomIntegers)); } |
### Question:
PreBufferedInputStream extends BufferedInputStream { @Override public synchronized void close() throws IOException { if (in == null && buffer == null) { return; } buffer = null; in.close(); in = null; } PreBufferedInputStream(InputStream stream, int bufferSize); static PreBufferedInputStream wrap(final byte[] data,
final int preloadChunkSize); int getBufferSize(); @Override synchronized int read(); @Override synchronized int read(final byte[] b, final int offset, final int length); @Override synchronized int available(); @Override boolean markSupported(); @Override synchronized void mark(int readLimit); @Override synchronized void reset(); @Override synchronized void close(); @Override synchronized long skip(final long length); }### Answer:
@Test public void shouldCloseClosedStream() throws IOException { PreBufferedInputStream instance = new PreBufferedInputStream(new NullInputStream(1), 1); instance.close(); instance.close(); } |
### Question:
DynamicContentDAO { public void deleteContent(String fileName, Storage stored) throws FileNotExistsException { getContentDAO(stored).deleteContent(fileName); } @Autowired DynamicContentDAO(Map<Storage,ContentDAO> contentDAOs); void copyContent(String sourceObjectId, String trgObjectId, Storage stored); void deleteContent(String fileName, Storage stored); void getContent(String fileName, long start, long end, OutputStream os, Storage stored); PutResult putContent(String fileName, InputStream data, Storage stored); }### Answer:
@Test(expected = ContentDaoNotFoundException.class) public void shouldThrowExceptionOnNonExistingDAO() throws FileNotExistsException { final DynamicContentDAO instance = new DynamicContentDAO(prepareDAOMap( mock(SwiftContentDAO.class) )); instance.deleteContent("exampleFileName",Storage.DATA_BASE); }
@Test public void shouldProperlySelectDataBaseDeleteContent() throws FileNotExistsException { SwiftContentDAO daoMock = mock(SwiftContentDAO.class); final DynamicContentDAO instance = new DynamicContentDAO(prepareDAOMap(daoMock)); instance.deleteContent("exampleFileName",Storage.OBJECT_STORAGE); verify(daoMock).deleteContent(anyString()); } |
### Question:
CustomFileNameMigrator extends SwiftMigrator { @Override public String nameConversion(final String s) { return s.contains("|") ? s.replace("|", "_") : null; } @Override String nameConversion(final String s); }### Answer:
@Test public void shouldRetrunNullString() { final String fileName = ""; final String output = migrator.nameConversion(fileName); assertEquals(null, output); }
@Test public void shouldConvertFileProperly() { final String fileName = "test2|test1|tes2"; final String output = migrator.nameConversion(fileName); assertEquals("test2_test1_tes2", output); }
@Test public void shouldConvertFileProperly2() { final String fileName = "test2_test1|tes2"; final String output = migrator.nameConversion(fileName); assertEquals("test2_test1_tes2", output); } |
### Question:
CassandraAuthenticationService implements UserDetailsService, AuthenticationService { @Override public User getUser(String userName) throws DatabaseConnectionException, UserDoesNotExistException { return userDao.getUser(userName); } CassandraAuthenticationService(); CassandraAuthenticationService(CassandraUserDAO userDao); @Override UserDetails loadUserByUsername(final String userName); @Override User getUser(String userName); @Override void createUser(final User user); @Override void updateUser(final User user); @Override void deleteUser(final String userName); }### Answer:
@Test(expected = UserDoesNotExistException.class) public void testUserDoesNotExist() throws Exception { service.getUser("test2"); } |
### Question:
CassandraAuthenticationService implements UserDetailsService, AuthenticationService { @Override public void deleteUser(final String userName) throws DatabaseConnectionException, UserDoesNotExistException { userDao.deleteUser(userName); } CassandraAuthenticationService(); CassandraAuthenticationService(CassandraUserDAO userDao); @Override UserDetails loadUserByUsername(final String userName); @Override User getUser(String userName); @Override void createUser(final User user); @Override void updateUser(final User user); @Override void deleteUser(final String userName); }### Answer:
@Test(expected = UserDoesNotExistException.class) public void testDeleteUser() throws Exception { dao.createUser(new SpringUser("test3", "test3")); service.deleteUser("test3"); service.getUser("test3"); }
@Test(expected = UserDoesNotExistException.class) public void testDeleteUserException() throws Exception { service.deleteUser("test4"); } |
### Question:
RemoverImpl implements Remover { @Override public void removeNotifications(long taskId) { int retries = DEFAULT_RETRIES; while (true) { try { subTaskInfoDAO.removeNotifications(taskId); break; } catch (Exception e) { if (retries-- > 0) { LOGGER.warn("Error while removing the logs. Retries left: " + retries); waitForTheNextCall(); } else { LOGGER.error("Error while removing the logs."); throw e; } } } } RemoverImpl(String hosts, int port, String keyspaceName, String userName, String password); RemoverImpl(CassandraSubTaskInfoDAO subTaskInfoDAO, CassandraTaskErrorsDAO taskErrorDAO, CassandraNodeStatisticsDAO cassandraNodeStatisticsDAO); @Override void removeNotifications(long taskId); @Override void removeErrorReports(long taskId); @Override void removeStatistics(long taskId); }### Answer:
@Test public void shouldSuccessfullyRemoveNotifications() { doNothing().when(subTaskInfoDAO).removeNotifications(eq(TASK_ID)); removerImpl.removeNotifications(TASK_ID); verify(subTaskInfoDAO, times(1)).removeNotifications((eq(TASK_ID))); }
@Test(expected = Exception.class) public void shouldRetry5TimesBeforeFailing() { doThrow(Exception.class).when(subTaskInfoDAO).removeNotifications(eq(TASK_ID)); removerImpl.removeNotifications(TASK_ID); verify(subTaskInfoDAO, times(6)).removeNotifications((eq(TASK_ID))); } |
### Question:
CassandraAclService implements AclService { @Override public Acl readAclById(ObjectIdentity object) throws NotFoundException { return readAclById(object, null); } CassandraAclService(AclRepository aclRepository, AclCache aclCache, PermissionGrantingStrategy grantingStrategy,
AclAuthorizationStrategy aclAuthorizationStrategy, PermissionFactory permissionFactory); @Override List<ObjectIdentity> findChildren(ObjectIdentity parentIdentity); @Override Acl readAclById(ObjectIdentity object); @Override Acl readAclById(ObjectIdentity object, List<Sid> sids); @Override Map<ObjectIdentity, Acl> readAclsById(List<ObjectIdentity> objects); @Override Map<ObjectIdentity, Acl> readAclsById(List<ObjectIdentity> objects, List<Sid> sids); }### Answer:
@Test(expected = NotFoundException.class) public void testCreateAndRetrieve() throws Exception { TestingAuthenticationToken auth = new TestingAuthenticationToken(creator, creator); auth.setAuthenticated(true); SecurityContextHolder.getContext().setAuthentication(auth); ObjectIdentity obj = new ObjectIdentityImpl(testKey, testValue); MutableAcl acl = mutableAclService.createAcl(obj); acl.insertAce(0, BasePermission.READ, new PrincipalSid(creator), true); acl.insertAce(1, BasePermission.WRITE, new PrincipalSid(creator), true); acl.insertAce(2, BasePermission.DELETE, new PrincipalSid(creator), true); acl.insertAce(3, BasePermission.ADMINISTRATION, new PrincipalSid(creator), true); mutableAclService.updateAcl(acl); Acl readAcl = mutableAclService.readAclById(obj); Assert.assertTrue(acl.getEntries().size() == readAcl.getEntries().size()); mutableAclService.readAclById(new ObjectIdentityImpl(testKey, creator)); } |
### Question:
CassandraDataProviderService implements DataProviderService { @Override public DataProvider getProvider(String providerId) throws ProviderDoesNotExistException { LOGGER.info("getProvider() providerId='{}'", providerId); DataProvider dp = dataProviderDao.getProvider(providerId); if (dp == null) { LOGGER.warn("ProviderDoesNotExistException providerId='{}''", providerId); throw new ProviderDoesNotExistException(new IdentifierErrorInfo( IdentifierErrorTemplate.PROVIDER_DOES_NOT_EXIST.getHttpCode(), IdentifierErrorTemplate.PROVIDER_DOES_NOT_EXIST.getErrorInfo(providerId))); } else { return dp; } } CassandraDataProviderService(CassandraDataProviderDAO dataProviderDao); @Override ResultSlice<DataProvider> getProviders(String thresholdProviderId, int limit); @Override DataProvider getProvider(String providerId); @Override DataProvider createProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(DataProvider dataProvider); @Override void deleteProvider(String providerId); }### Answer:
@Test(expected = ProviderDoesNotExistException.class) public void shouldFailWhenFetchingNonExistingProvider() throws ProviderDoesNotExistException { cassandraDataProviderService.getProvider("provident"); } |
### Question:
CassandraDataProviderService implements DataProviderService { @Override public ResultSlice<DataProvider> getProviders(String thresholdProviderId, int limit) { LOGGER.info("getProviders() thresholdProviderId='{}', limit='{}'", thresholdProviderId, limit); String nextProvider = null; List<DataProvider> providers = dataProviderDao.getProviders(thresholdProviderId, limit + 1); final int providerSize = providers.size(); if (providerSize == limit + 1) { nextProvider = providers.get(limit).getId(); providers.remove(limit); } LOGGER.info("getProviders() returning providers={} and nextProvider={} for thresholdProviderId='{}', limit='{}'", providerSize, nextProvider, thresholdProviderId, limit); return new ResultSlice<DataProvider>(nextProvider, providers); } CassandraDataProviderService(CassandraDataProviderDAO dataProviderDao); @Override ResultSlice<DataProvider> getProviders(String thresholdProviderId, int limit); @Override DataProvider getProvider(String providerId); @Override DataProvider createProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(DataProvider dataProvider); @Override void deleteProvider(String providerId); }### Answer:
@Test public void shouldReturnEmptyArrayWhenNoProviderAdded() { assertTrue("Expecting no providers", cassandraDataProviderService.getProviders(null, 1).getResults().isEmpty()); } |
### Question:
CassandraDataProviderService implements DataProviderService { @Override public void deleteProvider(String providerId) throws ProviderDoesNotExistException { LOGGER.info("Deleting provider {}", providerId); DataProvider dp = dataProviderDao.getProvider(providerId); if (dp == null) { LOGGER.warn("ProviderDoesNotExistException providerId='{}'", providerId); throw new ProviderDoesNotExistException(new IdentifierErrorInfo( IdentifierErrorTemplate.PROVIDER_DOES_NOT_EXIST.getHttpCode(), IdentifierErrorTemplate.PROVIDER_DOES_NOT_EXIST.getErrorInfo(providerId))); } dataProviderDao.deleteProvider(providerId); } CassandraDataProviderService(CassandraDataProviderDAO dataProviderDao); @Override ResultSlice<DataProvider> getProviders(String thresholdProviderId, int limit); @Override DataProvider getProvider(String providerId); @Override DataProvider createProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(String providerId, DataProviderProperties properties); @Override DataProvider updateProvider(DataProvider dataProvider); @Override void deleteProvider(String providerId); }### Answer:
@Test(expected = ProviderDoesNotExistException.class) public void shouldThrowExceptionWhenDeletingNonExistingProvider() throws ProviderDoesNotExistException { cassandraDataProviderService.deleteProvider("not existing provident"); } |
### Question:
CassandraUniqueIdentifierService implements UniqueIdentifierService { @Override public CloudId getCloudId(String providerId, String recordId) throws DatabaseConnectionException, RecordDoesNotExistException { LOGGER.info("getCloudId() providerId='{}', recordId='{}'", providerId, recordId); List<CloudId> cloudIds = localIdDao.searchById(providerId, recordId); if (cloudIds.isEmpty()) { throw new RecordDoesNotExistException(new IdentifierErrorInfo( IdentifierErrorTemplate.RECORD_DOES_NOT_EXIST.getHttpCode(), IdentifierErrorTemplate.RECORD_DOES_NOT_EXIST.getErrorInfo(providerId, recordId))); } final CloudId cloudId = cloudIds.get(0); LOGGER.info("getCloudId() returning cloudId='{}'", cloudId); return cloudId; } CassandraUniqueIdentifierService(CassandraCloudIdDAO cloudIdDao, CassandraLocalIdDAO localIdDao,
CassandraDataProviderDAO dataProviderDao); @Override CloudId createCloudId(String... recordInfo); @Override CloudId getCloudId(String providerId, String recordId); @Override List<CloudId> getLocalIdsByCloudId(String cloudId); @Override List<CloudId> getLocalIdsByProvider(String providerId, String start, int end); @Override List<CloudId> getCloudIdsByProvider(String providerId, String startRecordId, int limit); @Override CloudId createIdMapping(String cloudId, String providerId, String recordId); @Override void removeIdMapping(String providerId, String recordId); @Override List<CloudId> deleteCloudId(String cloudId); @Override String getHostList(); @Override String getKeyspace(); @Override String getPort(); @Override CloudId createIdMapping(String cloudId, String providerId); }### Answer:
@Test(expected = RecordDoesNotExistException.class) public void testRecordDoesNotExist() throws Exception { service.getCloudId("test2", "test2"); } |
### Question:
StaticUrlProvider implements UrlProvider { public String getBaseUrl() { return baseUrl; } StaticUrlProvider(final String serviceUrl); String getBaseUrl(); }### Answer:
@Test @Parameters({"uis/,uis","uis,uis","uis public void shouldGetUrlWithoutSlashAtTheEnd(String inputSuffix, String expectedSuffix) { StaticUrlProvider provider = new StaticUrlProvider(URL_PREFIX + inputSuffix); String result = provider.getBaseUrl(); assertThat(result,is(URL_PREFIX + expectedSuffix)); } |
### Question:
DateAdapter extends XmlAdapter<String, Date> { @Override public Date unmarshal(String stringDate) throws ParseException { if (stringDate == null || stringDate.isEmpty()) { return null; } try { Date date = GregorianCalendar.getInstance().getTime(); if(date == null){ throw new ParseException("Cannot parse the date. The accepted date format is "+FORMAT, 0); } return date; } catch (ParseException e) { throw new ParseException(e.getMessage() + ". The accepted date format is "+FORMAT, e.getErrorOffset()); } } @Override String marshal(Date date); @Override Date unmarshal(String stringDate); }### Answer:
@Test public void shouldSerializeTheDateSuccessfully() throws ParseException { Date date = dateAdapter.unmarshal(DATE_STRING); assertEquals(cal.getTime(), date); }
@Test(expected = ParseException.class) public void shouldThrowParsingException() throws ParseException { String unParsedDateString = "2017-11-23"; dateAdapter.unmarshal(unParsedDateString); }
@Test public void shouldCreateNullDateInCaseEmptyOrNull() throws ParseException { assertNull(dateAdapter.unmarshal(null)); assertNull(dateAdapter.unmarshal("")); } |
### Question:
DateAdapter extends XmlAdapter<String, Date> { @Override public String marshal(Date date) { if (date == null) { throw new RuntimeException("The revision creation Date shouldn't be null"); } return FORMATTER.format(date); } @Override String marshal(Date date); @Override Date unmarshal(String stringDate); }### Answer:
@Test public void shouldDeSerializeTheDateSuccessfully() { assertEquals(dateAdapter.marshal(cal.getTime()), DATE_STRING); }
@Test(expected = RuntimeException.class) public void shouldThrowRunTimeException() { dateAdapter.marshal(null); } |
### Question:
BucketsHandler { public Bucket getCurrentBucket(String bucketsTableName, String objectId) { String query = "SELECT object_id, bucket_id, rows_count FROM " + bucketsTableName + " WHERE object_id = '" + objectId + "';"; ResultSet rs = session.execute(query); List<Row> rows = rs.all(); Row row = rows.isEmpty() ? null : rows.get(rows.size() - 1); if (row != null) { return new Bucket( row.getString(OBJECT_ID_COLUMN_NAME), row.getUUID(BUCKET_ID_COLUMN_NAME).toString(), row.getLong(ROWS_COUNT_COLUMN_NAME)); } return null; } BucketsHandler(Session session); Bucket getCurrentBucket(String bucketsTableName, String objectId); void increaseBucketCount(String bucketsTableName, Bucket bucket); void decreaseBucketCount(String bucketsTableName, Bucket bucket); List<Bucket> getAllBuckets(String bucketsTableName, String objectId); Bucket getBucket(String bucketsTableName, Bucket bucket); Bucket getNextBucket(String bucketsTableName, String objectId); Bucket getNextBucket(String bucketsTableName, String objectId, Bucket bucket); void removeBucket(String bucketsTableName, Bucket bucket); static final String OBJECT_ID_COLUMN_NAME; static final String BUCKET_ID_COLUMN_NAME; static final String ROWS_COUNT_COLUMN_NAME; }### Answer:
@Test public void currentBucketShouldBeNull() { Bucket bucket = bucketsHandler.getCurrentBucket(BUCKETS_TABLE_NAME, "sampleObject"); Assert.assertNull(bucket); } |
### Question:
RemoverImpl implements Remover { @Override public void removeErrorReports(long taskId) { int retries = DEFAULT_RETRIES; while (true) { try { taskErrorDAO.removeErrors(taskId); break; } catch (Exception e) { if (retries-- > 0) { LOGGER.warn("Error while removing the error reports. Retries left: " + retries); waitForTheNextCall(); } else { LOGGER.error("Error while removing the error reports."); throw e; } } } } RemoverImpl(String hosts, int port, String keyspaceName, String userName, String password); RemoverImpl(CassandraSubTaskInfoDAO subTaskInfoDAO, CassandraTaskErrorsDAO taskErrorDAO, CassandraNodeStatisticsDAO cassandraNodeStatisticsDAO); @Override void removeNotifications(long taskId); @Override void removeErrorReports(long taskId); @Override void removeStatistics(long taskId); }### Answer:
@Test public void shouldSuccessfullyRemoveErrors() { doNothing().when(taskErrorDAO).removeErrors(eq(TASK_ID)); removerImpl.removeErrorReports(TASK_ID); verify(taskErrorDAO, times(1)).removeErrors((eq(TASK_ID))); }
@Test(expected = Exception.class) public void shouldRetry5TimesBeforeFailingWhileRemovingErrorReports() { doThrow(Exception.class).when(taskErrorDAO).removeErrors(eq(TASK_ID)); removerImpl.removeErrorReports(TASK_ID); verify(taskErrorDAO, times(6)).removeErrors((eq(TASK_ID))); } |
### Question:
BucketsHandler { public void increaseBucketCount(String bucketsTableName, Bucket bucket) { String query = "UPDATE " + bucketsTableName + " SET rows_count = rows_count + 1 WHERE object_id = '" + bucket.getObjectId() + "' AND bucket_id = " + UUID.fromString(bucket.getBucketId()) + ";"; session.execute(query); } BucketsHandler(Session session); Bucket getCurrentBucket(String bucketsTableName, String objectId); void increaseBucketCount(String bucketsTableName, Bucket bucket); void decreaseBucketCount(String bucketsTableName, Bucket bucket); List<Bucket> getAllBuckets(String bucketsTableName, String objectId); Bucket getBucket(String bucketsTableName, Bucket bucket); Bucket getNextBucket(String bucketsTableName, String objectId); Bucket getNextBucket(String bucketsTableName, String objectId, Bucket bucket); void removeBucket(String bucketsTableName, Bucket bucket); static final String OBJECT_ID_COLUMN_NAME; static final String BUCKET_ID_COLUMN_NAME; static final String ROWS_COUNT_COLUMN_NAME; }### Answer:
@Test public void shouldCreateNewBucket() { Bucket bucket = new Bucket("sampleObjectId", new com.eaio.uuid.UUID().toString(), 0); bucketsHandler.increaseBucketCount(BUCKETS_TABLE_NAME, bucket); assertResults(bucket, 1); }
@Test public void shouldUpdateCounterForExistingBucket() { Bucket bucket = new Bucket("sampleObjectId", new com.eaio.uuid.UUID().toString(), 0); bucketsHandler.increaseBucketCount(BUCKETS_TABLE_NAME, bucket); bucketsHandler.increaseBucketCount(BUCKETS_TABLE_NAME, bucket); assertResults(bucket, 2); } |
### Question:
RecordStatisticsGenerator { public List<NodeStatistics> getStatistics() throws SAXException, IOException, ParserConfigurationException { Document doc = getParsedDocument(); doc.getDocumentElement().normalize(); Node root = doc.getDocumentElement(); addRootToNodeList(root); prepareNodeStatistics(root); return new ArrayList<>(nodeStatistics.values()); } RecordStatisticsGenerator(String fileContent); List<NodeStatistics> getStatistics(); }### Answer:
@Test public void nodeContentsSizeShouldBeSmallerThanMaximumSize() throws Exception { String fileContent = readFile("src/test/resources/BigContent.xml"); RecordStatisticsGenerator xmlParser = new RecordStatisticsGenerator(fileContent); List<NodeStatistics> nodeModelList = xmlParser.getStatistics(); for (NodeStatistics nodeModel : nodeModelList) { assertTrue(nodeModel.getValue().length() <= MAX_SIZE); } } |
### Question:
RemoverImpl implements Remover { @Override public void removeStatistics(long taskId) { int retries = DEFAULT_RETRIES; while (true) { try { cassandraNodeStatisticsDAO.removeStatistics(taskId); break; } catch (Exception e) { if (retries-- > 0) { LOGGER.warn("Error while removing the validation statistics. Retries left: " + retries); waitForTheNextCall(); } else { LOGGER.error("rror while removing the validation statistics."); throw e; } } } } RemoverImpl(String hosts, int port, String keyspaceName, String userName, String password); RemoverImpl(CassandraSubTaskInfoDAO subTaskInfoDAO, CassandraTaskErrorsDAO taskErrorDAO, CassandraNodeStatisticsDAO cassandraNodeStatisticsDAO); @Override void removeNotifications(long taskId); @Override void removeErrorReports(long taskId); @Override void removeStatistics(long taskId); }### Answer:
@Test public void shouldSuccessfullyRemoveStatistics() { doNothing().when(cassandraNodeStatisticsDAO).removeStatistics(eq(TASK_ID)); removerImpl.removeStatistics(TASK_ID); verify(cassandraNodeStatisticsDAO, times(1)).removeStatistics((eq(TASK_ID))); }
@Test(expected = Exception.class) public void shouldRetry5TimesBeforeFailingWhileRemovingStatistics() { doThrow(Exception.class).when(cassandraNodeStatisticsDAO).removeStatistics(eq(TASK_ID)); removerImpl.removeStatistics(TASK_ID); verify(cassandraNodeStatisticsDAO, times(6)).removeStatistics((eq(TASK_ID))); } |
### Question:
HttpKafkaSpout extends CustomKafkaSpout { @Override public void deactivate() { LOGGER.info("Deactivate method was executed"); deactivateWaitingTasks(); deactivateCurrentTask(); LOGGER.info("Deactivate method was finished"); } HttpKafkaSpout(KafkaSpoutConfig spoutConf); HttpKafkaSpout(KafkaSpoutConfig spoutConf, String hosts, int port, String keyspaceName,
String userName, String password); @Override void open(Map conf, TopologyContext context,
SpoutOutputCollector collector); @Override void nextTuple(); @Override void declareOutputFields(OutputFieldsDeclarer declarer); @Override void deactivate(); }### Answer:
@Test public void deactivateShouldClearTheTaskQueue() throws Exception { final int taskCount = 10; for (int i = 0; i < taskCount; i++) { httpKafkaSpout.taskDownloader.taskQueue.put(new DpsTask()); } assertTrue(!httpKafkaSpout.taskDownloader.taskQueue.isEmpty()); httpKafkaSpout.deactivate(); assertTrue(httpKafkaSpout.taskDownloader.taskQueue.isEmpty()); verify(cassandraTaskInfoDAO, atLeast(taskCount)).setTaskDropped(anyLong(), anyString()); } |
### Question:
UnpackingServiceFactory { public static FileUnpackingService createUnpackingService(String compressingExtension) throws CompressionExtensionNotRecognizedException { if (compressingExtension.equals(CompressionFileExtension.ZIP.getExtension())) return ZIP_UNPACKING_SERVICE; else if (compressingExtension.equals(CompressionFileExtension.GZIP.getExtension()) || compressingExtension.equals(CompressionFileExtension.TGZIP.getExtension())) return GZ_UNPACKING_SERVICE; else throw new CompressionExtensionNotRecognizedException("This compression extension is not recognized " + compressingExtension); } static FileUnpackingService createUnpackingService(String compressingExtension); }### Answer:
@Test public void shouldReturnZipService() throws CompressionExtensionNotRecognizedException { FileUnpackingService fileUnpackingService = UnpackingServiceFactory.createUnpackingService(ZIP_EXTENSION); assertTrue(fileUnpackingService instanceof ZipUnpackingService); }
@Test public void shouldReturnGZipService() throws CompressionExtensionNotRecognizedException { FileUnpackingService fileUnpackingService = UnpackingServiceFactory.createUnpackingService(GZIP_EXTENSION); assertTrue(fileUnpackingService instanceof GzUnpackingService); }
@Test public void shouldReturnGZipServiceFotTGZExtension() throws CompressionExtensionNotRecognizedException { FileUnpackingService fileUnpackingService = UnpackingServiceFactory.createUnpackingService(TGZIP_EXTENSION); assertTrue(fileUnpackingService instanceof GzUnpackingService); }
@Test(expected = CompressionExtensionNotRecognizedException.class) public void shouldThrowExceptionIfTheExTensionWasNotRecognized() throws CompressionExtensionNotRecognizedException { UnpackingServiceFactory.createUnpackingService(UNDEFINED_COMPRESSION_EXTENSION); } |
### Question:
KafkaBridge { public void importTopic(String topicToImport) throws Exception { List<String> topics = availableTopics; if (StringUtils.isNotEmpty(topicToImport)) { List<String> topics_subset = new ArrayList<>(); for(String topic : topics) { if (Pattern.compile(topicToImport).matcher(topic).matches()) { topics_subset.add(topic); } } topics = topics_subset; } if (CollectionUtils.isNotEmpty(topics)) { for(String topic : topics) { createOrUpdateTopic(topic); } } } KafkaBridge(Configuration atlasConf, AtlasClientV2 atlasClientV2); static void main(String[] args); void importTopic(String topicToImport); }### Answer:
@Test public void testImportTopic() throws Exception { List<String> topics = setupTopic(zkClient, TEST_TOPIC_NAME); AtlasEntity.AtlasEntityWithExtInfo atlasEntityWithExtInfo = new AtlasEntity.AtlasEntityWithExtInfo( getTopicEntityWithGuid("0dd466a4-3838-4537-8969-6abb8b9e9185")); KafkaBridge kafkaBridge = mock(KafkaBridge.class); when(kafkaBridge.createEntityInAtlas(atlasEntityWithExtInfo)).thenReturn(atlasEntityWithExtInfo); try { kafkaBridge.importTopic(TEST_TOPIC_NAME); } catch (Exception e) { Assert.fail("KafkaBridge import failed ", e); } } |
### Question:
AtlasMapType extends AtlasType { @Override public boolean isValidValue(Object obj) { if (obj != null) { if (obj instanceof Map) { Map<Object, Objects> map = (Map<Object, Objects>) obj; for (Map.Entry e : map.entrySet()) { if (!keyType.isValidValue(e.getKey()) || !valueType.isValidValue(e.getValue())) { return false; } } } else { return false; } } return true; } AtlasMapType(AtlasType keyType, AtlasType valueType); AtlasMapType(String keyTypeName, String valueTypeName, AtlasTypeRegistry typeRegistry); String getKeyTypeName(); String getValueTypeName(); AtlasType getKeyType(); AtlasType getValueType(); void setKeyType(AtlasType keyType); @Override Map<Object, Object> createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean areEqualValues(Object val1, Object val2, Map<String, String> guidAssignments); @Override boolean isValidValueForUpdate(Object obj); @Override Map<Object, Object> getNormalizedValue(Object obj); @Override Map<Object, Object> getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); @Override AtlasType getTypeForAttribute(); }### Answer:
@Test public void testMapTypeIsValidValue() { for (Object value : validValues) { assertTrue(intIntMapType.isValidValue(value), "value=" + value); } for (Object value : invalidValues) { assertFalse(intIntMapType.isValidValue(value), "value=" + value); } } |
### Question:
UserProfileService { public AtlasUserProfile saveUserProfile(AtlasUserProfile profile) throws AtlasBaseException { return dataAccess.save(profile); } @Inject UserProfileService(DataAccess dataAccess); AtlasUserProfile saveUserProfile(AtlasUserProfile profile); AtlasUserProfile getUserProfile(String userName); AtlasUserSavedSearch addSavedSearch(AtlasUserSavedSearch savedSearch); AtlasUserSavedSearch updateSavedSearch(AtlasUserSavedSearch savedSearch); List<AtlasUserSavedSearch> getSavedSearches(String userName); AtlasUserSavedSearch getSavedSearch(String userName, String searchName); AtlasUserSavedSearch getSavedSearch(String guid); void deleteUserProfile(String userName); void deleteSavedSearch(String guid); void deleteSearchBySearchName(String userName, String searchName); }### Answer:
@Test(dependsOnMethods = "filterInternalType") public void createsNewProfile() throws AtlasBaseException { for (int i = 0; i < NUM_USERS; i++) { AtlasUserProfile expected = getAtlasUserProfile(i); AtlasUserProfile actual = userProfileService.saveUserProfile(expected); assertNotNull(actual); assertEquals(expected.getName(), actual.getName()); assertEquals(expected.getFullName(), actual.getFullName()); assertNotNull(actual.getGuid()); } } |
### Question:
AtlasArrayType extends AtlasType { @Override public Collection<?> createDefaultValue() { Collection<Object> ret = new ArrayList<>(); ret.add(elementType.createDefaultValue()); if (minCount != COUNT_NOT_SET) { for (int i = 1; i < minCount; i++) { ret.add(elementType.createDefaultValue()); } } return ret; } AtlasArrayType(AtlasType elementType); AtlasArrayType(AtlasType elementType, int minCount, int maxCount, Cardinality cardinality); AtlasArrayType(String elementTypeName, AtlasTypeRegistry typeRegistry); AtlasArrayType(String elementTypeName, int minCount, int maxCount, Cardinality cardinality, AtlasTypeRegistry typeRegistry); String getElementTypeName(); void setMinCount(int minCount); int getMinCount(); void setMaxCount(int maxCount); int getMaxCount(); void setCardinality(Cardinality cardinality); Cardinality getCardinality(); AtlasType getElementType(); @Override Collection<?> createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean areEqualValues(Object val1, Object val2, Map<String, String> guidAssignments); @Override boolean isValidValueForUpdate(Object obj); @Override Collection<?> getNormalizedValue(Object obj); @Override Collection<?> getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); @Override AtlasType getTypeForAttribute(); }### Answer:
@Test public void testArrayTypeDefaultValue() { Collection defValue = intArrayType.createDefaultValue(); assertEquals(defValue.size(), 1); } |
### Question:
AtlasClassificationDefStoreV2 extends AtlasAbstractDefStoreV2<AtlasClassificationDef> { @Override public boolean isValidName(String typeName) { Matcher m = TRAIT_NAME_PATTERN.matcher(typeName); return m.matches(); } AtlasClassificationDefStoreV2(AtlasTypeDefGraphStoreV2 typeDefStore, AtlasTypeRegistry typeRegistry); @Override AtlasVertex preCreate(AtlasClassificationDef classificationDef); @Override AtlasClassificationDef create(AtlasClassificationDef classificationDef, AtlasVertex preCreateResult); @Override List<AtlasClassificationDef> getAll(); @Override AtlasClassificationDef getByName(String name); @Override AtlasClassificationDef getByGuid(String guid); @Override AtlasClassificationDef update(AtlasClassificationDef classifiDef); @Override AtlasClassificationDef updateByName(String name, AtlasClassificationDef classificationDef); @Override AtlasClassificationDef updateByGuid(String guid, AtlasClassificationDef classificationDef); @Override AtlasVertex preDeleteByName(String name); @Override AtlasVertex preDeleteByGuid(String guid); @Override boolean isValidName(String typeName); }### Answer:
@Test(dataProvider = "traitRegexString") public void testIsValidName(String data, boolean expected) { assertEquals(classificationDefStore.isValidName(data), expected); } |
### Question:
HdfsPathEntityCreator { public AtlasEntity.AtlasEntityWithExtInfo getCreateEntity(AtlasObjectId item) throws AtlasBaseException { if(item.getUniqueAttributes() == null || !item.getUniqueAttributes().containsKey(HDFS_PATH_ATTRIBUTE_NAME_PATH)) { return null; } return getCreateEntity((String) item.getUniqueAttributes().get(HDFS_PATH_ATTRIBUTE_NAME_PATH)); } @Inject HdfsPathEntityCreator(AtlasTypeRegistry typeRegistry, AtlasEntityStoreV2 entityStore); AtlasEntity.AtlasEntityWithExtInfo getCreateEntity(AtlasObjectId item); AtlasEntity.AtlasEntityWithExtInfo getCreateEntity(String path); AtlasEntity.AtlasEntityWithExtInfo getCreateEntity(String path, String clusterName); static String getQualifiedName(String path, String clusterName); static final String HDFS_PATH_TYPE; static final String HDFS_PATH_ATTRIBUTE_NAME_NAME; static final String HDFS_PATH_ATTRIBUTE_NAME_CLUSTER_NAME; static final String HDFS_PATH_ATTRIBUTE_NAME_PATH; static final String HDFS_PATH_ATTRIBUTE_QUALIFIED_NAME; }### Answer:
@Test(dependsOnMethods = "verifyCreate") public void verifyGet() throws AtlasBaseException { AtlasEntity.AtlasEntityWithExtInfo entityWithExtInfo = hdfsPathEntityCreator.getCreateEntity(expectedPath, expectedClusterName); assertNotNull(entityWithExtInfo); } |
### Question:
ExportService { @VisibleForTesting AtlasExportResult.OperationStatus getOverallOperationStatus(AtlasExportResult.OperationStatus... statuses) { AtlasExportResult.OperationStatus overall = (statuses.length == 0) ? AtlasExportResult.OperationStatus.FAIL : statuses[0]; for (AtlasExportResult.OperationStatus s : statuses) { if (overall != s) { overall = AtlasExportResult.OperationStatus.PARTIAL_SUCCESS; } } return overall; } @Inject ExportService(final AtlasTypeRegistry typeRegistry, AtlasGraph graph,
AuditsWriter auditsWriter, HdfsPathEntityCreator hdfsPathEntityCreator); AtlasExportResult run(ZipSink exportSink, AtlasExportRequest request, String userName, String hostName,
String requestingIP); void processEntity(AtlasEntityWithExtInfo entityWithExtInfo, ExportContext context); }### Answer:
@Test public void verifyOverallStatus() { assertEquals(AtlasExportResult.OperationStatus.FAIL, exportService.getOverallOperationStatus()); assertEquals(AtlasExportResult.OperationStatus.SUCCESS, exportService.getOverallOperationStatus(AtlasExportResult.OperationStatus.SUCCESS)); assertEquals(AtlasExportResult.OperationStatus.SUCCESS, exportService.getOverallOperationStatus( AtlasExportResult.OperationStatus.SUCCESS, AtlasExportResult.OperationStatus.SUCCESS, AtlasExportResult.OperationStatus.SUCCESS)); assertEquals(AtlasExportResult.OperationStatus.PARTIAL_SUCCESS, exportService.getOverallOperationStatus( AtlasExportResult.OperationStatus.FAIL, AtlasExportResult.OperationStatus.PARTIAL_SUCCESS, AtlasExportResult.OperationStatus.SUCCESS)); assertEquals(AtlasExportResult.OperationStatus.PARTIAL_SUCCESS, exportService.getOverallOperationStatus( AtlasExportResult.OperationStatus.FAIL, AtlasExportResult.OperationStatus.FAIL, AtlasExportResult.OperationStatus.PARTIAL_SUCCESS)); assertEquals(AtlasExportResult.OperationStatus.FAIL, exportService.getOverallOperationStatus( AtlasExportResult.OperationStatus.FAIL, AtlasExportResult.OperationStatus.FAIL, AtlasExportResult.OperationStatus.FAIL)); } |
### Question:
ExportImportAuditService { public ExportImportAuditEntry get(ExportImportAuditEntry entry) throws AtlasBaseException { if(entry.getGuid() == null) { throw new AtlasBaseException("entity does not have GUID set. load cannot proceed."); } return dataAccess.load(entry); } @Inject ExportImportAuditService(DataAccess dataAccess, AtlasDiscoveryService discoveryService); @GraphTransaction void save(ExportImportAuditEntry entry); ExportImportAuditEntry get(ExportImportAuditEntry entry); List<ExportImportAuditEntry> get(String userName, String operation, String cluster,
String startTime, String endTime,
int limit, int offset); void add(String userName, String sourceCluster, String targetCluster, String operation,
String result, long startTime, long endTime, boolean hasData); }### Answer:
@Test public void numberOfSavedEntries_Retrieved() throws AtlasBaseException, InterruptedException { final String source1 = "server1"; final String target1 = "cly"; int MAX_ENTRIES = 5; for (int i = 0; i < MAX_ENTRIES; i++) { saveAndGet(source1, ExportImportAuditEntry.OPERATION_EXPORT, target1); } pauseForIndexCreation(); List<ExportImportAuditEntry> results = auditService.get("", ExportImportAuditEntry.OPERATION_EXPORT, "", "", "", 10, 0); assertTrue(results.size() > 0); } |
### Question:
ZipSource implements EntityImportStream { @Override public List<String> getCreationOrder() { return this.creationOrder; } ZipSource(InputStream inputStream); ZipSource(InputStream inputStream, ImportTransforms importTransform); @Override ImportTransforms getImportTransform(); @Override void setImportTransform(ImportTransforms importTransform); @Override List<BaseEntityHandler> getEntityHandlers(); @Override void setEntityHandlers(List<BaseEntityHandler> entityHandlers); @Override AtlasTypesDef getTypesDef(); @Override AtlasExportResult getExportResult(); @Override List<String> getCreationOrder(); AtlasEntityWithExtInfo getEntityWithExtInfo(String guid); @Override void close(); @Override boolean hasNext(); @Override AtlasEntity next(); @Override AtlasEntityWithExtInfo getNextEntityWithExtInfo(); @Override void reset(); @Override AtlasEntity getByGuid(String guid); int size(); @Override void onImportComplete(String guid); @Override void setPosition(int index); @Override void setPositionUsingEntityGuid(String guid); @Override int getPosition(); }### Answer:
@Test(expectedExceptions = AtlasBaseException.class) public void improperInit_ReturnsNullCreationOrder() throws IOException, AtlasBaseException { byte bytes[] = new byte[10]; ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ZipSource zs = new ZipSource(bais); List<String> s = zs.getCreationOrder(); Assert.assertNull(s); } |
### Question:
ImportService { public AtlasImportResult run(InputStream inputStream, String userName, String hostName, String requestingIP) throws AtlasBaseException { return run(inputStream, null, userName, hostName, requestingIP); } @Inject ImportService(AtlasTypeDefStore typeDefStore, AtlasTypeRegistry typeRegistry, BulkImporter bulkImporter,
AuditsWriter auditsWriter, ImportTransformsShaper importTransformsShaper,
TableReplicationRequestProcessor tableReplicationRequestProcessor); AtlasImportResult run(InputStream inputStream, String userName,
String hostName, String requestingIP); AtlasImportResult run(InputStream inputStream, AtlasImportRequest request, String userName,
String hostName, String requestingIP); AtlasImportResult run(AtlasImportRequest request, String userName, String hostName, String requestingIP); }### Answer:
@Test public void importServiceProcessesIOException() { ImportService importService = new ImportService(typeDefStore, typeRegistry, null,null, null,null); AtlasImportRequest req = mock(AtlasImportRequest.class); Answer<Map> answer = invocationOnMock -> { throw new IOException("file is read only"); }; when(req.getFileName()).thenReturn("some-file.zip"); when(req.getOptions()).thenAnswer(answer); try { importService.run(req, "a", "b", "c"); } catch (AtlasBaseException ex) { assertEquals(ex.getAtlasErrorCode().getErrorCode(), AtlasErrorCode.INVALID_PARAMETERS.getErrorCode()); } } |
### Question:
StartEntityFetchByExportRequest { public List<AtlasObjectId> get(AtlasExportRequest exportRequest) { List<AtlasObjectId> list = new ArrayList<>(); for(AtlasObjectId objectId : exportRequest.getItemsToExport()) { List<String> guids = get(exportRequest, objectId); if (guids.isEmpty()) { continue; } objectId.setGuid(guids.get(0)); list.add(objectId); } return list; } StartEntityFetchByExportRequest(AtlasGraph atlasGraph, AtlasTypeRegistry typeRegistry, AtlasGremlinQueryProvider gremlinQueryProvider); List<AtlasObjectId> get(AtlasExportRequest exportRequest); List<String> get(AtlasExportRequest exportRequest, AtlasObjectId item); ScriptEngine getScriptEngine(); }### Answer:
@Test public void fetchTypeGuid() { String exportRequestJson = "{ \"itemsToExport\": [ { \"typeName\": \"hive_db\", \"guid\": \"111-222-333\" } ]}"; AtlasExportRequest exportRequest = AtlasType.fromJson(exportRequestJson, AtlasExportRequest.class); List<AtlasObjectId> objectGuidMap = startEntityFetchByExportRequestSpy.get(exportRequest); assertEquals(objectGuidMap.get(0).getGuid(), "111-222-333"); } |
### Question:
AtlasStructType extends AtlasType { @Override public AtlasStruct createDefaultValue() { AtlasStruct ret = new AtlasStruct(structDef.getName()); populateDefaultValues(ret); return ret; } AtlasStructType(AtlasStructDef structDef); AtlasStructType(AtlasStructDef structDef, AtlasTypeRegistry typeRegistry); AtlasStructDef getStructDef(); AtlasType getAttributeType(String attributeName); AtlasAttributeDef getAttributeDef(String attributeName); @Override AtlasStruct createDefaultValue(); @Override Object createDefaultValue(Object defaultValue); Map<String, AtlasAttribute> getAllAttributes(); Map<String, AtlasAttribute> getUniqAttributes(); AtlasAttribute getAttribute(String attributeName); AtlasAttribute getSystemAttribute(String attributeName); AtlasAttribute getBusinesAAttribute(String attributeName); @Override boolean isValidValue(Object obj); @Override boolean areEqualValues(Object val1, Object val2, Map<String, String> guidAssignments); @Override boolean isValidValueForUpdate(Object obj); @Override Object getNormalizedValue(Object obj); @Override Object getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); void normalizeAttributeValues(AtlasStruct obj); void normalizeAttributeValuesForUpdate(AtlasStruct obj); void normalizeAttributeValues(Map<String, Object> obj); void normalizeAttributeValuesForUpdate(Map<String, Object> obj); void populateDefaultValues(AtlasStruct obj); String getVertexPropertyName(String attrName); String getQualifiedAttributePropertyKey(String attrName); static final String UNIQUE_ATTRIBUTE_SHADE_PROPERTY_PREFIX; }### Answer:
@Test public void testStructTypeDefaultValue() { AtlasStruct defValue = structType.createDefaultValue(); assertNotNull(defValue); assertEquals(defValue.getTypeName(), structType.getTypeName()); } |
### Question:
AtlasAuditService { public AtlasAuditEntry get(AtlasAuditEntry entry) throws AtlasBaseException { if(entry.getGuid() == null) { throw new AtlasBaseException("Entity does not have GUID set. load cannot proceed."); } return dataAccess.load(entry); } @Inject AtlasAuditService(DataAccess dataAccess, AtlasDiscoveryService discoveryService); @GraphTransaction void save(AtlasAuditEntry entry); void add(String userName, AuditOperation operation, String clientId, Date startTime,
Date endTime, String params, String result, long resultCount); AtlasAuditEntry get(AtlasAuditEntry entry); List<AtlasAuditEntry> get(AuditSearchParameters auditSearchParameters); AtlasAuditEntry toAtlasAuditEntry(AtlasEntity.AtlasEntityWithExtInfo entityWithExtInfo); static final String ENTITY_TYPE_AUDIT_ENTRY; }### Answer:
@Test public void checkStoringMultipleAuditEntries() throws AtlasBaseException, InterruptedException { final String clientId = "client1"; final int MAX_ENTRIES = 5; final int LIMIT_PARAM = 3; for (int i = 0; i < MAX_ENTRIES; i++) { saveEntry(AuditOperation.PURGE, clientId); } waitForIndexCreation(); AuditSearchParameters auditSearchParameters = createAuditParameter("audit-search-parameter-purge"); auditSearchParameters.setLimit(LIMIT_PARAM); auditSearchParameters.setOffset(0); List<AtlasAuditEntry> resultLimitedByParam = auditService.get(auditSearchParameters); assertTrue(resultLimitedByParam.size() == LIMIT_PARAM); auditSearchParameters.setLimit(MAX_ENTRIES); auditSearchParameters.setOffset(LIMIT_PARAM); List<AtlasAuditEntry> results = auditService.get(auditSearchParameters); assertTrue(results.size() == (MAX_ENTRIES - LIMIT_PARAM)); } |
### Question:
AtlasJanusGraphIndexClient implements AtlasGraphIndexClient { @VisibleForTesting protected static String generateSuggestionsString(List<String> suggestionIndexFieldNames) { StringBuilder ret = new StringBuilder(); Iterator<String> iterator = suggestionIndexFieldNames.iterator(); while(iterator.hasNext()) { ret.append("'").append(iterator.next()).append("'"); if(iterator.hasNext()) { ret.append(", "); } } if (LOG.isDebugEnabled()) { LOG.debug("generateSuggestionsString(fieldsCount={}): ret={}", suggestionIndexFieldNames.size(), ret.toString()); } return ret.toString(); } AtlasJanusGraphIndexClient(Configuration configuration); @Override void applySearchWeight(String collectionName, Map<String, Integer> indexFieldName2SearchWeightMap); @Override Map<String, List<AtlasAggregationEntry>> getAggregatedMetrics(AggregationContext aggregationContext); @Override void applySuggestionFields(String collectionName, List<String> suggestionProperties); @Override List<String> getSuggestions(String prefixString, String indexFieldName); }### Answer:
@Test public void testGenerateSuggestionString() { List<String> fields = new ArrayList<>(); fields.add("one"); fields.add("two"); fields.add("three"); String generatedString = AtlasJanusGraphIndexClient.generateSuggestionsString(fields); Assert.assertEquals(generatedString, "'one', 'two', 'three'"); } |
### Question:
AtlasJanusGraphIndexClient implements AtlasGraphIndexClient { @VisibleForTesting protected static String generateSearchWeightString(Map<String, Integer> indexFieldName2SearchWeightMap) { StringBuilder searchWeightBuilder = new StringBuilder(); for (Map.Entry<String, Integer> entry : indexFieldName2SearchWeightMap.entrySet()) { searchWeightBuilder.append(" ") .append(entry.getKey()) .append("^") .append(entry.getValue().intValue()); } if (LOG.isDebugEnabled()) { LOG.debug("generateSearchWeightString(fieldsCount={}): ret={}", indexFieldName2SearchWeightMap.size(), searchWeightBuilder.toString()); } return searchWeightBuilder.toString(); } AtlasJanusGraphIndexClient(Configuration configuration); @Override void applySearchWeight(String collectionName, Map<String, Integer> indexFieldName2SearchWeightMap); @Override Map<String, List<AtlasAggregationEntry>> getAggregatedMetrics(AggregationContext aggregationContext); @Override void applySuggestionFields(String collectionName, List<String> suggestionProperties); @Override List<String> getSuggestions(String prefixString, String indexFieldName); }### Answer:
@Test public void testGenerateSearchWeightString() { Map<String, Integer> fields = new HashMap<>(); fields.put("one", 10); fields.put("two", 1); fields.put("three", 15); String generatedString = AtlasJanusGraphIndexClient.generateSearchWeightString(fields); Assert.assertEquals(generatedString, " one^10 two^1 three^15"); } |
### Question:
MappedElementCache { public Vertex getMappedVertex(Graph gr, Object key) { try { Vertex ret = lruVertexCache.get(key); if (ret == null) { synchronized (lruVertexCache) { ret = lruVertexCache.get(key); if(ret == null) { ret = fetchVertex(gr, key); lruVertexCache.put(key, ret); } } } return ret; } catch (Exception ex) { LOG.error("getMappedVertex: {}", key, ex); return null; } } Vertex getMappedVertex(Graph gr, Object key); void clearAll(); }### Answer:
@Test public void vertexFetch() { JsonNode node = getCol1(); MappedElementCache cache = new MappedElementCache(); TinkerGraph tg = TinkerGraph.open(); addVertex(tg, node); Vertex vx = cache.getMappedVertex(tg, 98336); assertNotNull(vx); assertEquals(cache.lruVertexCache.size(), 1); } |
### Question:
GraphSONUtility { static Object getTypedValueFromJsonNode(final JsonNode node) { Object theValue = null; if (node != null && !node.isNull()) { if (node.isBoolean()) { theValue = node.booleanValue(); } else if (node.isDouble()) { theValue = node.doubleValue(); } else if (node.isFloatingPointNumber()) { theValue = node.floatValue(); } else if (node.isInt()) { theValue = node.intValue(); } else if (node.isLong()) { theValue = node.longValue(); } else if (node.isTextual()) { theValue = node.textValue(); } else if (node.isBigDecimal()) { theValue = node.decimalValue(); } else if (node.isBigInteger()) { theValue = node.bigIntegerValue(); } else if (node.isArray()) { theValue = node; } else if (node.isObject()) { theValue = node; } else { theValue = node.textValue(); } } return theValue; } GraphSONUtility(final ElementProcessors elementProcessors); Map<String, Object> vertexFromJson(Graph g, final JsonNode json); Map<String, Object> edgeFromJson(Graph g, MappedElementCache cache, final JsonNode json); }### Answer:
@Test public void idFetch() { JsonNode node = getCol1(); final int EXPECTED_ID = 98336; Object o = GraphSONUtility.getTypedValueFromJsonNode(node.get(GraphSONTokensTP2._ID)); assertNotNull(o); assertEquals((int) o, EXPECTED_ID); } |
### Question:
GraphSONUtility { static Map<String, Object> readProperties(final JsonNode node) { final Map<String, Object> map = new HashMap<>(); final Iterator<Map.Entry<String, JsonNode>> iterator = node.fields(); while (iterator.hasNext()) { final Map.Entry<String, JsonNode> entry = iterator.next(); if (!isReservedKey(entry.getKey())) { final Object o = readProperty(entry.getValue()); if (o != null) { map.put(entry.getKey(), o); } } } return map; } GraphSONUtility(final ElementProcessors elementProcessors); Map<String, Object> vertexFromJson(Graph g, final JsonNode json); Map<String, Object> edgeFromJson(Graph g, MappedElementCache cache, final JsonNode json); }### Answer:
@Test public void verifyReadProperties() { JsonNode node = getCol1(); Map<String, Object> props = GraphSONUtility.readProperties(node); assertEquals(props.get("__superTypeNames").getClass(), ArrayList.class); assertEquals(props.get("Asset.name").getClass(), String.class); assertEquals(props.get("hive_column.position").getClass(), Integer.class); assertEquals(props.get("__timestamp").getClass(), Long.class); assertNotNull(props); } |
### Question:
FixedBufferList { public List<T> toList() { return this.buffer.subList(0, this.length); } FixedBufferList(Class<T> clazz); FixedBufferList(Class<T> clazz, int incrementCapacityBy); T next(); List<T> toList(); void reset(); }### Answer:
@Test public void createdBasedOnInitialSize() { Spying.resetCounters(); int incrementByFactor = 2; SpyingFixedBufferList fixedBufferList = new SpyingFixedBufferList(incrementByFactor); addElements(fixedBufferList, 0, 3); List<Spying> list = fixedBufferList.toList(); assertSpyingList(list, 3); assertEquals(Spying.callsToCtor.get(), incrementByFactor * 2); }
@Test public void retrieveEmptyList() { int size = 5; SpyingFixedBufferList fixedBufferList = new SpyingFixedBufferList(size); List<Spying> list = fixedBufferList.toList(); assertEquals(list.size(), 0); addElements(fixedBufferList, 0, 3); list = fixedBufferList.toList(); assertEquals(list.size(), 3); } |
### Question:
ActiveInstanceElectorService implements Service, LeaderLatchListener { @Override public void stop() { if (!HAConfiguration.isHAEnabled(configuration)) { LOG.info("HA is not enabled, no need to stop leader election service"); return; } try { leaderLatch.close(); curatorFactory.close(); } catch (IOException e) { LOG.error("Error closing leader latch", e); } } @Inject ActiveInstanceElectorService(Configuration configuration,
Set<ActiveStateChangeHandler> activeStateChangeHandlerProviders,
CuratorFactory curatorFactory, ActiveInstanceState activeInstanceState,
ServiceState serviceState, AtlasMetricsUtil metricsUtil); @Override void start(); @Override void stop(); @Override void isLeader(); @Override void notLeader(); }### Answer:
@Test public void testNoActionOnStopIfHAModeIsDisabled() { when(configuration.getBoolean(HAConfiguration.ATLAS_SERVER_HA_ENABLED_KEY, false)).thenReturn(false); ActiveInstanceElectorService activeInstanceElectorService = new ActiveInstanceElectorService(configuration, new HashSet<ActiveStateChangeHandler>(), curatorFactory, activeInstanceState, serviceState, metricsUtil); activeInstanceElectorService.stop(); verifyZeroInteractions(curatorFactory); } |
### Question:
ActiveInstanceElectorService implements Service, LeaderLatchListener { @Override public void isLeader() { LOG.warn("Server instance with server id {} is elected as leader", serverId); serviceState.becomingActive(); try { for (ActiveStateChangeHandler handler : activeStateChangeHandlers) { handler.instanceIsActive(); } activeInstanceState.update(serverId); serviceState.setActive(); metricsUtil.onServerActivation(); } catch (Exception e) { LOG.error("Got exception while activating", e); notLeader(); rejoinElection(); } } @Inject ActiveInstanceElectorService(Configuration configuration,
Set<ActiveStateChangeHandler> activeStateChangeHandlerProviders,
CuratorFactory curatorFactory, ActiveInstanceState activeInstanceState,
ServiceState serviceState, AtlasMetricsUtil metricsUtil); @Override void start(); @Override void stop(); @Override void isLeader(); @Override void notLeader(); }### Answer:
@Test public void testActiveStateSetOnBecomingLeader() { ActiveInstanceElectorService activeInstanceElectorService = new ActiveInstanceElectorService(configuration, new HashSet<ActiveStateChangeHandler>(), curatorFactory, activeInstanceState, serviceState, metricsUtil); activeInstanceElectorService.isLeader(); InOrder inOrder = inOrder(serviceState); inOrder.verify(serviceState).becomingActive(); inOrder.verify(serviceState).setActive(); } |
### Question:
ActiveInstanceElectorService implements Service, LeaderLatchListener { @Override public void notLeader() { LOG.warn("Server instance with server id {} is removed as leader", serverId); serviceState.becomingPassive(); for (int idx = activeStateChangeHandlers.size() - 1; idx >= 0; idx--) { try { activeStateChangeHandlers.get(idx).instanceIsPassive(); } catch (AtlasException e) { LOG.error("Error while reacting to passive state.", e); } } serviceState.setPassive(); } @Inject ActiveInstanceElectorService(Configuration configuration,
Set<ActiveStateChangeHandler> activeStateChangeHandlerProviders,
CuratorFactory curatorFactory, ActiveInstanceState activeInstanceState,
ServiceState serviceState, AtlasMetricsUtil metricsUtil); @Override void start(); @Override void stop(); @Override void isLeader(); @Override void notLeader(); }### Answer:
@Test public void testPassiveStateSetOnLoosingLeadership() { ActiveInstanceElectorService activeInstanceElectorService = new ActiveInstanceElectorService(configuration, new HashSet<ActiveStateChangeHandler>(), curatorFactory, activeInstanceState, serviceState, metricsUtil); activeInstanceElectorService.notLeader(); InOrder inOrder = inOrder(serviceState); inOrder.verify(serviceState).becomingPassive(); inOrder.verify(serviceState).setPassive(); } |
### Question:
ServiceState { public ServiceStateValue getState() { return state; } ServiceState(); ServiceState(Configuration configuration); ServiceStateValue getState(); void becomingActive(); void setActive(); void becomingPassive(); void setPassive(); boolean isInstanceInTransition(); void setMigration(); boolean isInstanceInMigration(); }### Answer:
@Test public void testShouldBeActiveIfHAIsDisabled() { when(configuration.getBoolean(HAConfiguration.ATLAS_SERVER_HA_ENABLED_KEY, false)).thenReturn(false); ServiceState serviceState = new ServiceState(configuration); assertEquals(ServiceState.ServiceStateValue.ACTIVE, serviceState.getState()); } |
### Question:
ServiceState { public void becomingPassive() { LOG.warn("Instance becoming passive from {}", state); setState(ServiceStateValue.BECOMING_PASSIVE); } ServiceState(); ServiceState(Configuration configuration); ServiceStateValue getState(); void becomingActive(); void setActive(); void becomingPassive(); void setPassive(); boolean isInstanceInTransition(); void setMigration(); boolean isInstanceInMigration(); }### Answer:
@Test(expectedExceptions = IllegalStateException.class) public void testShouldDisallowTransitionIfHAIsDisabled() { when(configuration.getBoolean(HAConfiguration.ATLAS_SERVER_HA_ENABLED_KEY, false)).thenReturn(false); ServiceState serviceState = new ServiceState(configuration); serviceState.becomingPassive(); fail("Should not allow transition"); } |
### Question:
AuditFilter implements Filter { boolean isOperationExcludedFromAudit(String requestHttpMethod, String requestOperation, Configuration config) { try { return AtlasRepositoryConfiguration.isExcludedFromAudit(config, requestHttpMethod, requestOperation); } catch (AtlasException e) { return false; } } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain); static void audit(AuditLog auditLog); @Override void destroy(); }### Answer:
@Test public void testVerifyExcludedOperations() { AtlasRepositoryConfiguration.resetExcludedOperations(); when(configuration.getStringArray(AtlasRepositoryConfiguration.AUDIT_EXCLUDED_OPERATIONS)).thenReturn(new String[]{"GET:Version", "GET:Ping"}); AuditFilter auditFilter = new AuditFilter(); assertTrue(auditFilter.isOperationExcludedFromAudit("GET", "Version", configuration)); assertTrue(auditFilter.isOperationExcludedFromAudit("get", "Version", configuration)); assertTrue(auditFilter.isOperationExcludedFromAudit("GET", "Ping", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Types", configuration)); }
@Test public void testVerifyNotExcludedOperations() { AtlasRepositoryConfiguration.resetExcludedOperations(); when(configuration.getStringArray(AtlasRepositoryConfiguration.AUDIT_EXCLUDED_OPERATIONS)).thenReturn(new String[]{"Version", "Ping"}); AuditFilter auditFilter = new AuditFilter(); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Version", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Ping", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Types", configuration)); }
@Test public void testNullConfig() { AtlasRepositoryConfiguration.resetExcludedOperations(); AuditFilter auditFilter = new AuditFilter(); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Version", null)); } |
### Question:
AuditFilter implements Filter { public static void audit(AuditLog auditLog) { if (AUDIT_LOG.isInfoEnabled() && auditLog != null) { AUDIT_LOG.info(auditLog.toString()); } } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain); static void audit(AuditLog auditLog); @Override void destroy(); }### Answer:
@Test public void testAudit() throws IOException, ServletException { AtlasRepositoryConfiguration.resetExcludedOperations(); when(servletRequest.getRequestURL()).thenReturn(new StringBuffer("api/atlas/types")); when(servletRequest.getMethod()).thenReturn("GET"); AuditFilter auditFilter = new AuditFilter(); auditFilter.doFilter(servletRequest, servletResponse, filterChain); verify(filterChain).doFilter(servletRequest, servletResponse); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Version", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Ping", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Types", configuration)); } |
### Question:
AtlasMapType extends AtlasType { @Override public Map<Object, Object> createDefaultValue() { Map<Object, Object> ret = new HashMap<>(); Object key = keyType.createDefaultValue(); if ( key != null) { ret.put(key, valueType.createDefaultValue()); } return ret; } AtlasMapType(AtlasType keyType, AtlasType valueType); AtlasMapType(String keyTypeName, String valueTypeName, AtlasTypeRegistry typeRegistry); String getKeyTypeName(); String getValueTypeName(); AtlasType getKeyType(); AtlasType getValueType(); void setKeyType(AtlasType keyType); @Override Map<Object, Object> createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean areEqualValues(Object val1, Object val2, Map<String, String> guidAssignments); @Override boolean isValidValueForUpdate(Object obj); @Override Map<Object, Object> getNormalizedValue(Object obj); @Override Map<Object, Object> getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); @Override AtlasType getTypeForAttribute(); }### Answer:
@Test public void testMapTypeDefaultValue() { Map<Object, Object> defValue = intIntMapType.createDefaultValue(); assertEquals(defValue.size(), 1); } |
### Question:
ReactiveBus implements Bus { public static ReactiveBus create() { return new ReactiveBus(); } static ReactiveBus create(); @Override void send(final Event object); @Override @SuppressWarnings("unchecked") Flowable<Event> receive(); }### Answer:
@Test public void shouldCreateBus() { Bus bus = ReactiveBus.create(); assertThat(bus).isNotNull(); } |
### Question:
Event { public static Event create() { return Event.builder().build(); } protected Event(String id, String name, Serializable data); protected Event(String id, String name); protected Event(Builder builder); protected Event(); static Event create(); static Builder id(final String id); String id(); static Builder name(final String name); String name(); static Builder data(final Serializable data); Serializable data(); boolean hasData(); @Override String toString(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void shouldCreateEvent() { Event event = Event.create(); assertThat(event).isNotNull(); } |
### Question:
ImmutableEdge implements Edge<V> { @Override public String toString() { return "ImmutableEdge [source=" + source + ", dest=" + dest + ", id=" + id + "]"; } ImmutableEdge(final V source, final V dest, final int id); static ImmutableEdge<V> construct(final V source, final V dest,
final int id); @Override final V getSource(); @Override final V getDest(); @Override final int getId(); @Override final Object clone(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(Edge<V> o); }### Answer:
@Test public void testToString() { assertEquals("ImmutableEdge [source=1, dest=2, id=1]", edge.toString()); } |
### Question:
MersenneTwister extends java.util.Random implements Serializable, Cloneable { public double nextDouble() { return (((long) next(26) << 27) + next(27)) / (double) (1L << 53); } MersenneTwister(); MersenneTwister(long seed); MersenneTwister(int[] array); @Override Object clone(); synchronized boolean stateEquals(MersenneTwister other); synchronized void readState(DataInputStream stream); synchronized void writeState(DataOutputStream stream); synchronized void setSeed(long seed); synchronized void setSeed(int[] array); boolean nextBoolean(); boolean nextBoolean(float probability); boolean nextBoolean(double probability); int nextInt(int n); long nextLong(long n); double nextDouble(); double nextDouble(boolean includeZero, boolean includeOne); float nextFloat(); float nextFloat(boolean includeZero, boolean includeOne); void nextBytes(byte[] bytes); char nextChar(); short nextShort(); byte nextByte(); synchronized void clearGaussian(); synchronized double nextGaussian(); static void main(String[] args); }### Answer:
@Test public void testRun() { List<Double> values = new ArrayList<>(); for (int i = 0; i < 10_000; ++i) { values.add(rng.nextDouble()); } Assert.assertEquals(0.5, values.stream().mapToDouble(x -> (double) x).average().orElse(-1.0), 0.01); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.