What is Pure Functional Programming, and how it can improve our application testing?

WHAT IS PURE FUNCTIONAL PROGRAMMING, AND HOW IT

CAN IMPROVE OUR APPLICATION TESTING?

Voxxed Days Zürich 2016-03-03

Voxxed Days Zürich 2016-03-03 1

About me

Luca Molteni

@volothamp

BitGold (h+ps://bitgold.com)


Pure Func)onal Programming is fun


Tes$ng is also fun


Code quality


Table of Content• What is Pure Func0onal Programming?

• Tes0ng

• Type Systems

• Conclusions

• Q & A


What is Func,onal Programming?• Func&ons are first-class, that is, func&ons are values which can

be used in exactly the same ways as any other sort of value.

• FP languages are focused around evalua&ng expressions rather than execu&ng instruc&ons.


What is "Pure Func0onal Programming?"


What is Referen-al Transparency?

“An expression is said to be referen1ally transparent if it can be replaced with its value without changing the behavior of a program (in other words, yielding a program that has the same effects and

output on the same input).”


Referen&al Transparency in Haskell

sum :: Int -> Int -> Intsum a b = a + b

sum 2 3 == 5sum 3 3 == 6


Referen&al Transparency in Javapublic int sum(int a, int b) { int anotherB = // If the DB is empty, use b as default persistence.readFromSumTableWithDefault(b);

int sum = a + anotherB;

updateSumTable(sum);

return sum;}

sum(2, 3) == 5sum(2, 3) == 7 // ?!


An Impure language can write a pure func2on

/* This is the same method as before */public int sum(int a, int b) { return a + b;}

sum(2, 3) == 5sum(2, 3) == 5


This is not a pure func0on

public int sum(int a, int b) { writeLastExecutedFile(a, b); return a + b;}


What are the "Pure" Func.onal programming languages?

• Haskell

• Clean

• Excel

• Scala?

• Java?


Tes$ng pure code


• By Paul Chiusano and Rúnar Bjarnason (Manning)Voxxed Days Zürich 2016-03-03 16

Untestable Cafeclass CreditCard() { def charge(price: BigDecimal): Unit = if (Random.nextInt(4) == 1) println("I'm calling a webservice") else throw new RuntimeException("crashing")}

case class Coffee(price: BigDecimal = 1)

class UntestableCafe { def buyCoffee(cc: CreditCard): Coffee = {

val cup = new Coffee() cc.charge(cup.price) // Side effect cup }}


Untestable Cafe Test

class UntestableCafeTest extends Specification { "Cafe should be able to charge an amount" >> {

val cafe = new UntestableCafe()

val coffee = cafe.buyCoffee(new CreditCard())

success("hopefully charged") }}


Testable Cafecase class CreditCard()case class Coffee(price: BigDecimal = 1)

trait Payments { def charge(cc: CreditCard, amount: BigDecimal) }

class TestableCafe { def buyCoffee(cc: CreditCard, p: Payments): Coffee = {

val cup = new Coffee()

p.charge(cc, cup.price) cup }}


Testable Cafe Testclass TestableCafeTest extends Specification with Mockito { "Cafe should be able to charge an amount" >> {

val cafe = new TestableCafe()

val mockedPayment = mock[Payments] val cc = new CreditCard()

val coffee = cafe.buyCoffee(cc, mockedPayment)

there was one(mockedPayment).charge(cc, 1) }}


Pure Cafecase class CreditCard()

case class Coffee(price: BigDecimal = 1)

case class Charge(cc: CreditCard, amount: BigDecimal)

class PureCafe { def buyCoffee(cc: CreditCard): (Coffee, Charge) = {

val cup = new Coffee()

(cup, Charge(cc, cup.price)) }}


Pure Cafe Test

class PureCafeTest extends Specification with Mockito { "Cafe should be able to charge an amount" >> {

val cafe = new PureCafe()

val result = cafe.buyCoffee(new CreditCard())

result._2.amount === 1 }}


Pure FP Helps Unit Tes0ng


Do we have something be0er than unit tes3ng?


Increase the entropy of the inputs"insert element in database" in { val username = randomString

val numberOfRowInserted = database.insert(1, username).futureAwait

val usernameFromDB = database.findById(1)

numberOfRowInserted === 1 usernameFromDB === username}


Beware of pseudo-random tests!


Property based tes-ng

val modelGenerator = for { tag <- arbitrary[String] elem <- arbitrary[String] } yield Model(tag, elem)

property("String is always 891 characters") = forAll(modelGenerator) { record => processString(record).length == 891}


Proper&es instead of Asser&ons


How can Pure FP helps Property based tes5ng?


Beware of readability 1

take5 :: [Char] -> [Char]take5 = take 5 . filter (`elem` ['a'..'e'])

quickCheck ((\s -> (reverse.reverse) s == s) :: [Char] -> Bool)

quickCheck (\s -> all (`elem` ['a'..'e']) (take5 s))

1 h$ps://wiki.haskell.org/Introduc9ontoQuickCheck1


TDD by Kent Beck and property base tes3ng 2

2 h$p://natpryce.com/ar2cles/000807.html


Side Effects and Mocks


Code Example with a lot of mocking public void mocking() { final File dir = Mockito.mock(File.class); BDDMockito.given(dir.getAbsolutePath()).willReturn("/some/otherdir/" + FILE); Mockito.doReturn(dir).when(extensionAccessor).getExtensionDir(FILE);

final String remotePath = "/some/dir/" + NAME; Mockito.doReturn(remotePath).when(request).getRequestURI();

Mockito.doReturn(remotePath).when(filter).getFullPathNameFromRequest(request); Mockito.doReturn("/some/dir/" + NAME).when(filter).getFullPathNameFromRequest(request);

filter.doFilter(request, response, filterChain);

Mockito.verify(filter).copyFileInternalIfNeeded("/some/dir/" + NAME); }


Mockable classtrait DbThing { def getDbStuff(params): Future[DbStuff] }

trait HttpThing { def getHttpStuff(params): Future[HttpStuff] }

class BizThingImpl(db: DbThing, http: HttpThing) { def doComplicatedStuff(params): () = db.getDbStuff(params).zip(http.getHttpStuff(params)).map { case (dbStuff, httpStuff) => if(dbStuff.value > 0) doSomething else doSomethingElse case _ => throw new Exception("something went wrong") }}


Can we avoid stubbing?def bizThingImpl(getDBStuff: Param => Future[DBStuff]) (httpStuff: Param => Future[HTTPStuff]): () = {

getDbStuff.zip(httpStuff(params)).map { case (dbStuff, httpStuff) => if(dbStuff.value > 0) doSomething else doSomethingElse case _ => throw new Exception("something went wrong") }}


How can we avoid mocking?def bizThingImpl(getDBStuff: Param => Future[DBStuff]) (httpStuff: Param => Future[HTTPStuff]): Future[Result] = {

getDbStuff.zip(httpStuff(params)).map { case (dbStuff, httpStuff) => if(dbStuff.value > 0) Ok(httpValue.result) else NotFound case _ => InternalServerError }}


Separate the pure from the impure part


Applica'on with li.le logicpublic void complexInteraction(User user) {

httpClient.call(user.firstName , user.lastName, user.address, user.capCode, user.phoneNumber)

db.insertUser(user.firstName , user.lastName, user.address, user.capCode, user.phoneNumber)}


Tes$ng applica$on with li1le logicpublic void testComplexInteraction(User user) {

User user = aUser("firstName", "lastName", "address", "capCode", "phoneNumber")

service.complexInteraction(user)

verify(httpClient) .call(user.firstName, user.lastName, user.address , user.capCode, user.phoneNumber) verify(db) .insertUser(user.firstName , user.lastName, user.address , user.capCode, user.phoneNumber)

}


What should we test?


It is hard to write tests.


Tests vs Type Systems


Referen&al Transparency again 3

function sum(a, b) = { ??? }

num = sum(2,3)

test.assert(typeof num === 'number');

3 h$p://unitjs.com/


Same test using Javapublic String sayHello(String name) { return "Hello " + name + "!";}

public void testGreetingIsString() { assertEquals(String.class, sayHello("luca").getClass());}


Excep&ons break referen&al transparency


Feedback


Compile )me vs Execu)on )me

• Type System ⟶ Compile /me

• Tests ⟶ Run Time


Reading asser+on vs reading type errors


Compiler error messages shouldn't be hard (Elm) 4

4 h$p://elm-lang.org/blog/compiler-errors-for-humans


"The problem with the type checker is that it should never be smarter

than the developer"— Unknown


Readability• Use unit tes*ng to give example of your API

• Use property based tes*ng when you want to verify proper*es

• Use Type Systems when having li?le logic


Be careful using type inference


BONUS


Dependent Types


Test the concatena+ons of two lists

def testConcatenationOfList() { List(1, 2) ++ List(3,4) === List(1,2,3,4)}

def testConcatenationOfListWithSize() { val sum = List(1, 2) ++ List(3,4)

sum.length === 4}


Concatena(on using dependent types 5

concatenate : Vect n a -> Vect m a -> Vect (n + m) aconcatenate Nil ys = ysconcatenate (x :: xs) ys = x :: app xs ys

5 h$ps://eb.host.cs.st-andrews.ac.uk/wri8ngs/idris-tutorial.pdf


Idris error messages

Can’t unify

Vect (n + n) awith

Vect (plus n m) aSpecifically:

Can’t unify plus n n with plus n m


Conclusion• Pure Func*onal Programming leads to a more testable code

• If you're going to use pure FP, use a strong type system too (but don't forget tests)

• Modern type systems help us finding bugs in a more efficient way while designing our applica*on.

• If the logic is limited, rely on the Type System


Q&A


Thank you for your ,meFeedback please!

@volothamp

mailto:[email protected]


BONUS 2


Stability Problem• h#ps://github.com/mikeizbicki/HerbiePlugin


The problem with the IO Type / Monad in Haskell


Software

What is Pure Functional Programming, and how it can improve our application testing?