How to mock method inside method in scala object? - scala

Question

I would like to use a simple example for my problem.
I have a below trait:
trait ReaderTrait {
def readTable(tableName:String, closingDate: String)(implicit sparkSession: SparkSession): DataFrame = {
sparkSession.read.table(
tableName
).filter(col("closingDate") === closingDate)
}
def read(fullTable:String, closingDate: String)(implicit sparkSession: SparkSession): DataFrame
}
I have below Object:
object Reader extends ReaderTrait
{
override final def read(fullTable: String, closingDate: String)(implicit sparkSession: SparkSession): DataFrame =
{
readTable(fullTable: String, closingDate: String)
//.filter..
//I have business logic here which I want to test, I want to mock only readTable
}
}
Now I want to mock only the readTable method in Object.
I have a Test class:
class ReaderTest extends FeatureSpec with MockitoSugar {
scenario("first") {
//sample dataframe1 created ......
val mockTrait = mock[Reader.type ]
when(mockTrait.readTable("abc", "sss")(spark)) thenReturn (dataframe1)
val result = mockTrait.read("abc", "sss")(spark)
result.show()
}
}
After running the above test class, it's giving me the below error:
java.lang.NullPointerException was thrown.
Please help me to resolve this situation; I have to mock the readTable method in read method in object without making any changes to existing code.

Answer 1

Many problems here:
You cannot mock objects.
mock[Reader.type] does not make sense. You could mock the trait with mock[ReaderTrait] though.
Mock doesn't work the way you seem to think.
If you have class A { def foo = ""; def bar = foo }, and then you do
val m = mock[A]
when(m.foo).thenReturn("baz")
val result = m.bar
the value of result will not be "baz" it will be null. Why? Because m is a mock – a dummy object, with all of the methods stubbed out. m.bar does not call foo, because it is a stub, it just returns null.
There is a way to stub only some methods of a class, and have others keep original behavior. If you'd like to learn more about it, look up the concept of a spy (you would do spy(new A) instead of mock[A]). I will not get into this here, because it is not a good practice to use spies. Which brings me to my third point ...
You should not stub methods of the class you are testing. When you need to, it is a symptom of your class design violating the single responsibility principle, which is not a good thing.
The proper way of writing your test in this case would be isolate the readTable "provider" class from the functionality you are testing.
For example:
trait TableReader {
def readTable(table:String, date: String)(implicit s: SparkSession) =
s.read.table(table).filter(col("closingDate") === date)
}
object TableReader extends TableReader
class Reader(val tr: TableReader) {
def read(table: String, date: String)(implicit s: SparkSession) =
tr.readTable(table, date)
}
object Reader extends Reader(TableReader)
Now you can test your Reader class with something like:
val tr = mock[TableReader]
wen(tr.readTable(any, any)(any)).thenReturn(dataframe1)
val reader = new Reader(tr)
reader.read("foo", "bar")(spark) shouldBe dataframe1
verify(tr).readTable("foo", "bar")(spark)
This will work, but kinda unclear what it is you are trying to test here.
You are not testing readTable because you stubbed it out. And there is no logic in read, so nothing to test there.
I would suggest to move the filtering logic out from TableReader into Reader, that would make for a cleaner separation of responsibilities between the two classes: one is responsible for fetching data from the table, and the other applies filtering and other business logic:
trait TableReader {
def readTable(t: String)(implicit s: SparkSession) = s.read.table(t)
}
class Reader(tr: TableReader) {
def read(table: String, date: String)(implicit s: SparkSession) =
tr.readTable(table).filter(col("closingDate") === date)
}
This gives you an ability to write meaningful tests, like:
reader.read("foo", "bar")(spark)
.select("closingDate")
.as[String]
.collect
.toList shouldBe List("bar", "bar", "bar")
(basically, checking that the filter for closingDate === "bar" was properly applied to the dataframe)
The idea here is that you do not need to test TableReader, as there is no any business logic there, it is only a simple wrapper around spark, so you can stub it out easily.
And the Reader class is only concerned about business logic that you do want to test, and does not know anything about where the actual data comes from, so you don't need to stub any of its methods, just supply a mock provider of the data (mock[TableReader]).