Develop Reference

Unable to write Mockito test case for my void method

I need to test this code with Mockito (JUnit):
public class Calculation {
public void logTimeTaken(String label, long estimatedTime, int size, boolean isDebug) {
String out = label + " took " + TimeUnit.MILLISECONDS.convert(estimatedTime, TimeUnit.NANOSECONDS) + " milliseconds for " + size + " events!";
if (isDebug) {
System.out.println(out);
} else {
System.out.println(out);
}
}
}
I search so many examples google but still not getting any idea.

You can configure System with an instance of PrintStream which you can then assert against after invoking Calculation.logTimeTaken.
Here's an example:
#Test
public void canLogTimeTaken() {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
PrintStream out = new PrintStream(bout);
System.setOut(out);
Calculation sut = new Calculation();
sut.logTimeTaken("label", 20 , 2, false);
assertEquals("if isDebug is false label took 0 milliseconds for 2 events!\n", bout.toString());
}
Note: there is no need for Mockito here, this is just vanilla JUnit, no mocking.
But, it might be a better design to refactor logTimeTaken into two distinct aspects:
Deriving the log message
Logging that message
For example:
public String createTimeTakenMessage(String label, long estimatedTime, int size, boolean isDebug) {
return label + " took " + TimeUnit.MILLISECONDS.convert(estimatedTime, TimeUnit.NANOSECONDS) + " milliseconds for " + size + " events!";
}
public void logTimeTaken(String message) {
System.out.println(message);
}
Then testing createTimeTakenMessage is trivial and you might even choose not to test logTimeTaken at all since all it does is invoke a System method. Or, perhaps you would hide the 'log action' behind an interface with an implementation using System.out now and perhaps, later, other implementations using a formal logging framework such as Logback.

JUnit Test with switch-case

I still new to Junit test. I have a switch-case as code below.
public void manageTrans(ISOMsgZxc isoMsgZxc) {
AbcEntry abcEntry = new AbcEntry();
abcEntry.setEntryMid(isoMsgZxc.getMid());
String mti = isoMsgZxc.getMti() + "." + isoMsgZxc.getProcessingCode().substring(0, 2);
String transType = "";
BigDecimal amt = new BigDecimal("00.000");
switch (mti) {
case "1234.14":
case "0212.02":
transType = "S";
amt = new BigDecimal(isoMsgZxc.getTransactionAmount()).negate();
break;
case "0400.20":
case "0200.22":
transType = "R";
amt = new BigDecimal(isoMsgZxc.getTransactionAmount());
break;
}
abcEntry.setEntryType(transType);
abcEntryRepository.saveAndFlush(abcEntry);
}
Here how I testing it by using #Test
#Test
public void manageTrans() throws Exception {
AbcEntry abcEntry = mock(abcEntry.class);
PowerMockito.whenNew(AbcEntry.class).withNoArguments()
.thenReturn(abcEntry);
ISOMsgZxc isoMsgZxc = new ISOMsgZxc();
isoMsgZxc.setMti("0100");
isoMsgZxc.setMid("0100");
isoMsgZxc.setProcessingCode("000012");
isoMsgZxc.setTransactionAmount("00.000");
txnService.manageTrans(isoMsgZxc);
verify(abcEntry).setEntryMid(isoMsgZxc.getMid());
String asd = "0400.20";
if(asd.equals("0400.20") || (mti.equals("0200.02")))
{
verify(abcEntry).setEntryType("R");
}
verify(abcEntryRepositoryMock).saveAndFlush(abcEntry);
}
So far the testing show pass. But are there any others method to test the switch-case ? What is the best way to test the switch case so all the possible value can be tested? Any help would be greatly appreciated.
Thanks in advance !

It seems like you're trying to test manageTrans, but in a strange fashion due to the structure of your code (mixing business and persistence logic).
You could have a generateEntry(ISOMsgZxc) which creates and returns the AbcEntry:
public AbcEntry generateEntry(ISOMsgZxc isoMsgZxc) {
AbcEntry abcEntry = new AbcEntry();
abcEntry.setEntryMid(isoMsgZxc.getMid());
String mti = isoMsgZxc.getMti() + "." + isoMsgZxc.getProcessingCode().substring(0, 2);
String transType = "";
BigDecimal amt = new BigDecimal("00.000");
switch (mti) {
case "1234.14":
case "0212.02":
transType = "S";
amt = new BigDecimal(isoMsgZxc.getTransactionAmount()).negate();
break;
case "0400.20":
case "0200.22":
transType = "R";
amt = new BigDecimal(isoMsgZxc.getTransactionAmount());
break;
}
abcEntry.setEntryType(transType);
return abcEntry;
}
This will allow you to test generateEntry to verify the entry after:
#Test
public void generateEntry() {
ISOMsgZxc isoMsgZxc = new ISOMsgZxc();
isoMsgZxc.setMti("0100");
isoMsgZxc.setMid("0100");
isoMsgZxc.setProcessingCode("000012");
isoMsgZxc.setTransactionAmount("00.000");
AbcEntry entry = txnService.generateEntry(isoMsgZxc);
//verfiy
verify(abcEntry).setEntryMid(isoMsgZxc.getMid());
Map<String, String> expectedValues = new HashMap<>();
expectedValues.put("0400.20", "R");
expectedValues.put("0200.02", "R");
//...
expectedValues.forEach((input, output) -> verify(input).setEntryType(output));
}
In your production code, simply call:
entryRepo.saveAndFlush(generateEntry())
Easier to maintain (room for validation), easier to test (concerns are separated).
Assuming you want to test the persistence part, you should create another test.
manageTrans would look like this:
public void manageTrans(ISOMsgZxc isoMsgZxc) {
AbcEntry entry = generateEntry();
entryRepo.saveAndFlush(entry);
}
And your test would simply check if the entry exists in the repo after calling manageTrans. Although chances are, saveAndFlush has already been tested, so the manageTrans really wouldn't need testing, as it's implementation consists of already-tested code, and there is no special integration required.

The test for the third test case could look like this.
#Test
public void manageTrans() throws Exception {
ISOMsgZxc isoMsgZxc = new ISOMsgZxc();
isoMsgZxc.setMti("0200");
isoMsgZxc.setMid("0100");
isoMsgZxc.setProcessingCode("220012");
isoMsgZxc.setTransactionAmount("00.000");
//mti should now be = 0200.00, the third case
txnService.manageTrans(isoMsgZxc);
assertThat(abcEntry.getEntryMid(), equalTo(isoMsgZxc.getMid()));
assertThat(abcEntry.getEntryType(), equalTo("R"));
verify(jcbEntryRepositoryMock).saveAndFlush(jcbEntry);
}
To cover the other test cases:
modify the two lines isoMsgZxc.setMti("0200"); and isoMsgZxc.setProcessingCode("220012"); such that they enter the correct case
you will need 5 tests for full coverage

how to minimize this switch case?

I am getting different provider through service call.
On that base my tab section will differ; and I want to minimize this code:
if(selectedProvider.equalsIgnoreCase("youtube")){
switch (tabName.toLowerCase()) {
case "songs":
sectionTab = "video";
break;
case "artists":
sectionTab="";
break;
case "albums":
sectionTab="channel";
break;
case "playlists":
sectionTab="playlist";
break;
}}
else if(selectedProvider.equalsIgnoreCase("soundcloud")){
switch (tabName.toLowerCase()) {
case "songs":
sectionTab = "track";
break;
case "artists":
sectionTab="artist";
break;
case "albums":
sectionTab="";
break;
case "playlists":
sectionTab="playlist";
break;
}}
else {
switch (tabName.toLowerCase()) {
case "songs":
sectionTab = "track";
break;
case "artists":
sectionTab = "artist";
break;
case "albums":
sectionTab = "album";
break;
case "playlists":
sectionTab = "playlist";
break;
}
}

One possible solution here: use a map that contains a map.
Like:
Map<String, String> soundCloudMappings = new HashMap<>();
soundCloudMappings.put("songs", "track");
...
Map<String, Map<String, String> providerMappings = ...
providerMappings.put("soundcloud", soundCloudMappings);
And then you can check if provider.toLowerCase() exists in your outer map; and then ask the inner map for the correct sectionTab entry.
But of course, this is a pretty "low level" solution. Depending on your context, you might rather look into turning these raw strings into Enums constants; and add nice mapping methods to that Enum. In other words: consider balancing flexibility (doing everything with strings) with increased compile-time safety.

I prefer to build structures to define the logic rather than coding it in situations like this.
// What tabs we have.
enum Tabs {
songs,
artists,
albums,
playlists;
// Build a lookup.
static Map<String, Tabs> lookup = Arrays.stream(Tabs.values()).collect(Collectors.toMap(e -> e.name(), e -> e));
static Tabs lookup(String s) {
return lookup.get(s);
}
}
// The providers.
enum Providers {
youtube("video","","channel","playlist"),
soundcloud("track","artist","","playlist"),
others("track","artist","album","playlist");
// Build a String lookup.
static Map<String, Providers> lookup = Arrays.stream(Providers.values()).collect(Collectors.toMap(e -> e.name(), e -> e));
Map<Tabs,String> tabs = new HashMap<>();
Providers(String track, String artist, String album, String playlists) {
tabs.put(Tabs.songs, track);
tabs.put(Tabs.artists, artist);
tabs.put(Tabs.albums, album);
tabs.put(Tabs.playlists, playlists);
}
static Providers lookup(String s) {
Providers p = lookup.get(s);
// Default to others.
return p == null ? others : p;
}
public static String getSectionTabName(String provider, String tabName) {
// Lookup the provider.
Providers p = lookup(provider);
Tabs t = Tabs.lookup(tabName);
return p.tabs.get(t);
}
}
public void test() {
String provider = "youtube";
String tabName = "albums";
String section = Providers.getSectionTabName(provider, tabName);
System.out.println(provider+"!"+tabName+" = "+section);
}
Benefits to doing it this way:
Adding new providers just requires adding new enums.
Adding new tabs is a little less trivial (add a new parameter to the Providers constructor) but still does not change the code significantly.

You can use a couple of Maps like this to do the translation
static final Map<String, String> SECTION_TAB2 = new LinkedHashMap<>();
static final Map<String, String> SECTION_TAB1 = new LinkedHashMap<>();
static {
// are there special two word outcomes
SECTION_TAB2.put("youtube songs", "artists");
SECTION_TAB2.put("youtube artists", "");
SECTION_TAB2.put("youtube albums", "channel");
SECTION_TAB2.put("soundcloud albums", "");
// if not, what are the default tab name outcomes.
SECTION_TAB1.put("songs", "track");
SECTION_TAB1.put("artists", "artist");
SECTION_TAB1.put("albums", "album");
SECTION_TAB1.put("playlists", "playlist");
}
public static String sectionTab(String selectedProvider, String tabName) {
return SECTION_TAB2.getOrDefault((selectedProvider + " " + tabName).toLowerCase(),
SECTION_TAB1.get(tabName.toLowerCase()));
}

i am unable to comment so i am commenting as answer for
public static void main(String[] args) throws IOException
{
Table<String,String,String> table= HashBasedTable.create();
table.put("youtube","songs","video");
table.put("youtube","artists","");
table.put("youtube","albums","channel");
table.put("youtube","playlists","playlist");
table.put("soundcloud","songs","track");
table.put("soundcloud","artists","artist");
table.put("soundcloud","albums","");
table.put("soundcloud","playlists","playlist");
table.put("default","songs","track");
table.put("default","artists","artist");
table.put("default","albums","albums");
table.put("default","playlists","playlist");
String sectionTab = table.get("soundcloud","artists"); // u will get artist
}
we can use guava table to avoid map of map and easy to maintain and redable
https://www.tutorialspoint.com/guava/guava_table.htm

Jersey - String not mapped to Json while using ObjectMappers function writeValueAsString succeeds

I have the following function :
protected final ResponseBuilderImpl RESPONSE_BUILDER_IMPL = new ResponseBuilderImpl(); // This is taken from jersey-core-1.11.jar
protected Response buildAcceptedResponse(Object entity) {
return buildResponse(entity, Response.Status.ACCEPTED);
}
protected Response buildResponse(Object entity, Response.Status status) {
return RESPONSE_BUILDER_IMPL.status(status).entity(entity).build();
}
I've tested several cases and noticed that only String is not working, and can't figure out why.
I'm using postman, sending some GET requests
switch (whatToTest){
case 1: //working
log.info("testing case of Interger!! ");
int x = 11;
return buildAcceptedResponse(x);
case 2: // getting as a response Unexpected 'e'
String t = "testing string";
log.info("testing case of String !!");
return buildAcceptedResponse(t);
case 3: //working
log.info("testing case of Boolean !! ");
boolean y = true;
return buildAcceptedResponse(y);
case 4: //not working
log.info("testing case of Object !! ");
Object yy = "test object";
return buildAcceptedResponse(yy);
case 5: //working
log.info("testing case of Object from type int !! ");
Object yyy = 1565746;
return buildAcceptedResponse(yyy);
case 6: //working
log.info("testing case of class with strings and ints!! ");
TestClass e = new TestClass(4,new Integer(7),"test1", false);
return buildAcceptedResponse(e);
/// Adding - when using this case - it works fine
case 7:
log.info("mapping to object");
ObjectMapper om = new ObjectMapper();
Object res = null;
String te = "test test";
try {
res = om.writeValueAsString(te);
} catch (IOException ex) {
ex.printStackTrace();
}
return buildAcceptedResponse(res);
I thought that I might have a problem with primitive types, but int and boolean are returning as they should. Also, a class containing a String inside - is also good.Can someone advise why only Strings are not working ?
Adding -
My function uses :
#GET
#Produces(MediaType.APPLICATION_JSON)
#Path("test/test")
public Response getTest(String someParam);
// Response is sr311-api\0.11\jsr311-api-0.11-sources.jar

GreenDao whereOr and conditions adding in a loop

I need to add some or clauses to query. I need to do it in a loop.
StringTokenizer st = new StringTokenizer(symptoms, ",");
while(st.hasMoreTokens()){
qb.whereOr(Properties.Symptom.like("%" + st.nextToken() + "%"));
}
How I can add those or conditions properly, because this above is not working as expected. I want to add or for every symptom.

If you look at the documentation, you'll see that whereOr() takes an unbounded number of conditions. What you want to do is add them all at once in an array:
StringTokenizer st = new StringTokenizer(symptoms, ",");
ArrayList<WhereCondition> whereConditions = new ArrayList<WhereCondition>();
while(st.hasMoreTokens()){
whereConditions.add(Properties.Symptom.like("%" + st.nextToken() + "%"));
}
// Give the ArrayList an already allocated array to place its contents in.
WhereCondition[] conditionsArray = new WhereCondition[whereConditions.size()];
conditionsArray = whereConditions.toArray(conditionsArray);
qb.whereOr(conditionsArray);
It looks like the method call in the documentation takes two non-array WhereConditions and then an ellipsized argument, which accepts an array or an additional comma-separated list of objects. So you might have to do something like this to get it to work properly:
qb.whereOr(conditionsArray[0], conditionsArray[1], Arrays.copyOfRange(conditionsArray, 2, conditionsArray.length));
ADDENDUM: It looks like you're using APIs that don't match the documentation, possibly an older version of greenDAO. I wrote this solution based off the current documentation. I can't guarantee that it will work for you. I recommend updating if possible.

Try this:
StringTokenizer st = new StringTokenizer(symptoms, ",");
WhereCondition where = null;
while(st.hasMoreTokens()){
if (where != null) {
where = qb.or(where, Properties.Symptom.like("%" + st.nextToken() + "%"));
} else {
where = Properties.Symptom.like("%" + st.nextToken() + "%");
}
}
qb.where(where).list();

I had the same problem so I added my own method in an Util class to perform the same behavior when I have one or several WhereCondition in an array.
Here is my gateway method :
public static QueryBuilder whereOr(QueryBuilder queryBuilder, WhereCondition[] whereConditions){
if(whereConditions == null) return queryBuilder.where(null);
else if(whereConditions.length == 1) return queryBuilder.where(whereConditions[0]);
else return queryBuilder.whereOr(whereConditions[0], whereConditions[1], Arrays.copyOfRange(whereConditions, 2, whereConditions.length));
}
Use : Util.whereOr(queryBuilder, whereConditionsArray);
Default : Can't use the Builder Pattern from the QueryBuilder with this approach
(More later) Here, I share you some code which could spare you time when developping DAO methods.
public class QueryBuilderUtil {
public static final String EQ = "=?";
public static final String NOTEQ = "<>?";
public static final String LIKE = " LIKE ?";
public static final String GE = ">=?";
public static final String LE = "<=?";
public static final String GT = ">?";
public static final String LT = "<?";
public static QueryBuilder whereOrOnSamePropertyWithDifferentValues(QueryBuilder queryBuilder, Property property, String operation, String values, String separator) {
return whereOrOnSamePropertyWithDifferentValues(queryBuilder, property, operation, values.split(separator));
}
public static QueryBuilder whereOrOnSamePropertyWithDifferentValues(QueryBuilder queryBuilder, Property property, String operation, String[] values) {
WhereCondition[] whereConditions = new WhereCondition[values.length];
int i = 0;
for (String value : values) {
whereConditions[i++] = new WhereCondition.PropertyCondition(property, operation, value);
}
return whereOr(queryBuilder, whereConditions);
}
public static QueryBuilder whereOr(QueryBuilder queryBuilder, WhereCondition[] whereConditions) {
if (whereConditions == null) return queryBuilder.where(null);
else if (whereConditions.length == 1) return queryBuilder.where(whereConditions[0]);
else return queryBuilder.whereOr(whereConditions[0], whereConditions[1], Arrays.copyOfRange(whereConditions, 2, whereConditions.length));
}
}
With this class, you can perform a whereOr with the same property on multiples "values string" in one line. It was necessary to clean my code :). However you can only do simple operations like variables declared in the class.
Example :
public List<Block> loadAllByModId(String mods_id) {
synchronized (this) {
QueryBuilder<Block> queryBuilder = queryBuilder();
QueryBuilderUtil.whereOrOnSamePropertyWithDifferentValues(queryBuilder, Properties.ModId, QueryBuilderUtil.EQ, mods_id, ";");
query_list = queryBuilder.build();
}
Query<Block> query = query_list.forCurrentThread();
return query.list();
}
Hope it helps