Mock Utility Class

Doing some exploration, I created the following Mock class with a mix of methods for filtering using different methods. The client simply invokes the method in a static way.


public final class Mock {
private static String mockFileBaseLocation = System.getProperty("user.dir");
private static String mockFileResourcesLocation = "src\\test\\resources";

public Mock() {
}

public static Map<String, Object> getEachXmlFileAsString(Map<String, Object> data) {
return iterateAndConvert(data).get();
}

public static String getXmlAsString(final String whichFileFromTheMockDatabase) {
return readContentsOfFileIntoString(
Mock.buildFullPathToXmlTestFile(whichFileFromTheMockDatabase));
}

public static Observable<Map<String, Object>> map(Map<String, Object> data) {
return Observable.from(data).map(Mock::transformMap);
}

public static Observable<Map<String, Object>> filter(Map<String, Object> data, String removeKey) {
return Observable.from(data).filter((entry) -> isItemInDataThenRemove(entry, removeKey));
}

public static Observable<Map<String, Object>> preserve(Map<String, Object> data, String preserveKey) {
return Observable.from(data).filter((entry) -> isItemInDataThenPreserveAndRemoveEverythingElse(data, preserveKey));
}

private static Map<String, Object> iterateAndConvertValueXmlToString(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
for (Map.Entry<String,Object> entry : data.entrySet()) {
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue()));
}
return returnMap;
}

private static boolean isItemInDataThenRemove(Map<String, Object> data, String removeKey) {
data.entrySet().stream().filter(entry ->
entry.getKey().equalsIgnoreCase(removeKey)).forEach(entry -> {
data.remove(entry.getKey());
});
return true;
}

private static boolean isItemInDataThenPreserveAndRemoveEverythingElse(Map<String, Object> data, String preserveKey) {
data.entrySet().stream().filter(entry -> !entry.getKey().equalsIgnoreCase(preserveKey)).forEach(entry -> {
System.out.printf("Found element that is not to be preserved %s, removing. %n", entry.getKey());
data.remove(entry.getKey());
});

return data.get(preserveKey) != null;
}

private static Supplier<Map<String, Object>> iterateAndConvert(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
data.entrySet().forEach((entry) ->
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue())));
return () -> returnMap;
}

private static Map<String, Object> transformMap(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
data.entrySet().forEach((entry) ->
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue())));
return returnMap;
}

private static String buildFullPathToXmlTestFile(final String xmlFileName) {
return String.format("%s\\%s\\%s",
Mock.getMockFileBaseLocation(), Mock.getMockFileResourcesLocation(),
xmlFileName);
}

private static String getMockFileBaseLocation() {
return mockFileBaseLocation;
}

private static String getMockFileResourcesLocation() {
return mockFileResourcesLocation;
}

private static String readContentsOfFileIntoString(final String whichFileFromTheMockDatabase) {
String contentToReturn = "";

try (Scanner scanner = new Scanner(new File(whichFileFromTheMockDatabase))) {
scanner.useDelimiter("\\A");
contentToReturn = scanner.next();
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}

return contentToReturn;
}

private static InputStream openXmlFile(String fileClassPath) {
File temp = new File(fileClassPath);

try (InputStream inputStream = new FileInputStream(temp)) {
System.out.printf("Returning openXmlFile: %s%n", temp.getAbsolutePath());
return inputStream;
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}

return null;
}

private static File createFileFromInputStream(String fileNameAndPath, InputStream inputStream) {
File outFile = new File(fileNameAndPath);

try (OutputStream outputStream = new FileOutputStream(outFile)) {
int readBytes = 0;
byte[] byteBuffer = new byte[2048];
while ((readBytes = inputStream.read(byteBuffer)) != -1) {
outputStream.write(byteBuffer, 0, readBytes);
}
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
} finally {
if (inputStream != null) {
try { inputStream.close(); } catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}
}
}

return outFile;
}
}

Create Nested Directories From List


import org.junit.Before;
import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertNotNull;

/**
* Created by dking on 7/18/2014.
*/
public class NioStructureTest {
final String FILE_PREFIX = "file://";
final String DIRECTORY_FILE_PREFIX = "file:///";
final List<URI> dirsList = new ArrayList<>();
final List<String> dirNamesList = new ArrayList<>();

@Test
public void initializeFrontEndStructure() throws IOException {
//URI rootPathStr = URI.create(String.format("%s%s", DIRECTORY_FILE_PREFIX, "Temp//niostructuretest"));
//boolean yesOverwriteExistingDirectory = true;
//createDirectory(rootPathStr.getPath(), yesOverwriteExistingDirectory);
}

private void createDirectory(String rootPathStr, boolean overwrite, boolean isNested) throws IOException {
if (!FileSystems.getDefault().getPath(rootPathStr).toFile().exists()) {
doCreateDirectory(rootPathStr, isNested);
} else if (FileSystems.getDefault().getPath(rootPathStr).toFile().exists() && overwrite) {
doDeleteDirectory(rootPathStr);
doCreateDirectory(rootPathStr, isNested);
} else
System.out.println("RootPath already exists.");
}

private void doDeleteDirectory(String rootPathStr) throws IOException {
System.out.printf("doDeleteDirectory with arg: %s%n", rootPathStr);
Files.delete(Paths.get(URI.create(String.format("%s%s", FILE_PREFIX, rootPathStr))));
}

private void doCreateDirectory(String rootPathStr, boolean isNested) throws IOException {
System.out.printf("doCreateDirectory with arg: %s%n", rootPathStr);
if (isNested) {
File file = new File(rootPathStr);
boolean wasDirsCreated = file.mkdirs();
if (wasDirsCreated) {
System.out.printf("Directories were created: %s%n", file.getAbsolutePath());
} else {
System.out.printf("Directores were NOT created: %s%n", file.getAbsolutePath());
}
} else {
Path rootPath = Files.createDirectory(Paths.get(URI.create(String.format("%s%s", FILE_PREFIX, rootPathStr))));
assertNotNull("RootPath was null", rootPath);
System.out.printf("Path created: %s%n", rootPath.toString());
}
}

@Before
public void setUp() throws IOException {
dirNamesList.add("Temp//niostructuretest");
dirNamesList.add("Temp//niostructuretest//src//main//java");
dirNamesList.add("Temp//niostructuretest//src//main//resources");
dirNamesList.add("Temp//niostructuretest//src//main//webapp");
dirNamesList.add("Temp//niostructuretest//src//main//webapp//WEB-INF");

System.out.println("Building directory structure in memory.");
for (String directoryName : dirNamesList) {
if (null != directoryName) {
dirsList.add(URI.create(String.format("%s%s", DIRECTORY_FILE_PREFIX, directoryName)));
}
}
System.out.println("In memory structure is: " + dirsList);

//createDirectory(dirsList.get(4).getPath(), true, false);

System.out.println("Creating the directories from the stored structures.");
for (URI uriPath : dirsList) {
if (null != uriPath) {
try {
createDirectory(uriPath.getPath(), false, true);
} catch (IOException e) {
e.printStackTrace();
}
}
}

System.out.println("Done with directories setup.");
}
}

&nbsp;

What The Error?

A public place where developers, architects and designers can post error conditions and exceptions with explanations interpretations of the opaque error displayed and possible solutions for the error / exception.

For example,

Error/Exception:
java.lang.NullPointerException

Explanation(s):
The variable or statement in question does not point to
an instance of anything.

Resolution:
Ensure variable or statement is pointing to an actual value.