Have you ever wondered what the best way would be to test emails? Or how you would go about testing a messaging queue? Making sure your components are correctly interacting with each other is both a tester and developer’s concern. Join us to get a better understanding of what you should test and how, both manually and automated. This session is the first ever in which we will have two units working together to give you a nuanced insight on all aspects of integration testing. We’ll start off exploring the world of integration testing, defining the terminology, and creating a general understanding of what phases and kinds of testing exist. Later on we’ll delve into integration test automation, ranging from database integration testing to selenium UI testing and even as far as LDAP integration testing. We have a wide variety of demos prepared where we will show you how easy it is to test various components of your infrastructure. Some examples: - Database testing (JPA) - Arquillian, exploring container testing, EJB testing and more - Email testing - SOAP testing using SoapUI - LDAP testing - JMS testing

1. Integration Testing
Awesome subtitle

2. Integration Testing
Awesome subtitle

3. Integration Testing
Awesome subtitle

4. Integration Testing
Awesome subtitle

5. Testing
▪ Unit testing
▪ Integration testing
▪ System Integration testing
▪ Load testing
▪ Performance testing
▪ User acceptance testing

6. Overview
1. Testing Terminologies
2. Component Integration Testing
a. Persistence tests
b. Container tests
c. Other component integrations
3. System Integration Testing

7. Testing terminologies

8. Test levels/phases
Requirement Specification Acceptance Testing
Functional Analysis System Testing
Technical Design Integration Testing
Coding Component Testing
System Integration Testing
Component Integration Testing
BB
WB

9. Test characteristics
▪ Connectivity
▪ Continuity
▪ Data controllability
▪ Effectivity
▪ Efficiency
▪ Flexibility
▪ Functionality
▪ Suitability of infrastructure
▪ Maintainability
▪ Manageability
▪ Performance
▪ Portability
▪ Reusability
▪ Security
▪ Suitability
▪ Testability
▪ User-friendliness

10. Focus on terminology
▪ Dedicated test environments
▪ Sanity tests (smoke tests)
▪ Regression testing
▪ Combinations and boundaries
▪ Positive and negative
▪ Valid and invalid
▪ End 2 End testing (chain testing)
▪ Performance testing (load testing vs. stress testing)
▪ Manual testing vs. test automation

11. Component Integration Testing

12. Component Integration Testing
Demo:
▪ Service Layer going to Database Layer

13. PERSISTENCE TESTS

14. Persistence Tests
Using real databases for tests:
▪ slow
▪ harder than it should be
▪ separate schemas per user?
▪ network required
Using local database for tests:
▪ even slower
▪ requires (annoying) installation
▪ no network required

15. Persistence Tests
Using in-memory database for tests:
▪ super fast
▪ only lives during test
▪ allows for very specific test data
▪ can be upgraded/changed/...

16. Persistence Tests
Demo:
▪ JPA2 via Hibernate
▪ Spring Data
▪ SpringJUnit4ClassRunner
▪ DBUnit

17. Persistence Tests
Demo:
▪ JPA2 via Hibernate
▪ Spring Data
▪ SpringJUnit4ClassRunner
▪ DBUnit
▪ + Spring MVC (REST client)
▪ + Selenium (Chrome WebDriver)

18. CONTAINER TESTS

19. What is a container?

20. What is a container?
A Java ecosystem in which an application is managed
life-cycle
transactions
persistence
security
...

21. What is a container?
DI container (Dependency Injection)
EJB container (Enterprise Java Beans)
Web container
Application client container
Applet container

22. Most known providers today

23. Most known providers today
▪ Only provides a DI Container: IoC (inversion of control)
▪ Runs anywhere
▪ No application server needed

24. Most known providers today

25. Most known providers today
▪ Provides specifications for:
▪ DI container: CDI (Contexts and Dependency Injection)
▪ EJB container
▪ Web container
▪ Application client container
▪ Applet container
▪ It only runs on an application server implementing these specs.

26. What to test?
Dependency Injection (is everything wired correctly together?)
▪ Application Context
▪ CDI

27. What to test?
Persistence:
and : is JPA (Java Persistence API) mapping correct?

28. What to test?
Transaction Management:
▪ : Spring Transaction
▪ : JTA (Java Transaction API)

29. What to test?
Deployment:
▪ : no deployment needed (not to test)
▪ : will it deploy without exceptions in a real Java EE container?

30. How?
Container-tests

31. How?
out of the box
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes =
Application.class)
@Transactional
public class SpringIntegrationTest {
Really, that easy :-) !!

32. How?
not out of the box
Need for third-party frameworks

33. How?
OpenEJB: a lightweight embeddable EJB container
Can be used with JUnit

34. How?
A lot to write

35. How?
And more:

36. How?
Arquillian:
▪ Embeddable containers for JUnit-tests
▪ Run tests in real running containers
The real thing application servers:
Glassfish
Jboss
Weblogic
...

37. How?
All it takes in Arquillian
@RunWith(Arquillian.class)
public class ArquillianIntegrationTest {
@Deployment
public static Archive<?> createDeployment() {
return ShrinkWrap.create(WebArchive.class, "test.war")
.addPackage(MeetingRoom.class.getPackage())
.addPackage(MeetingOrganizer.class.getPackage())
.addPackage(MeetingRoomRepository.class.getPackage())
.addAsResource("persistence-test.xml", "META-
INF/persistence.xml")
.addAsWebInfResource("jbossas-ds.xml")
.addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");
}
Actually, together with xml config, but pretty straight-forward

38. Demo
Integration test
wiring
transactional test
Integration test
wiring
transactional test
web integration test with Graphene
https://github.com/brunobouko

39. OTHER COMPONENT INTEGRATIONS

40. File Permissions

41. How to test ?
● Via dedicated check
FilePermission fp = new FilePermission("file.txt", "read");
AccessController.checkPermission(fp);
● Via shell scripts
Check you have staff group and file is readable by staff
[~] % ls -l file.txt | awk '{ print $1" "$3" "$4;}' | egrep -e '....r..... .*
staff' >|/dev/null && echo 'ok' || echo 'ko'
ok
● Manually...

42. Results

43. Emails

44. How to test
● With developer controlled server
● With code
○ Spring Integration: https://github.com/spring-projects/spring-integration-samples/tree/master/basic/mail
● With dedicated tools
Eg: Sending emails could use FakeSMTP - http://nilhcem.github.io/FakeSMTP
● Running fake mail server during tests
○ GreenMail - http://www.icegreen.com/greenmail/
Roll the demo in: SendAMail project + GreenMail
https://github.com/pijalu/SendAMail.git

45. JMS

46. How to test ?
● Writing test code
○ ActiveMQ - http://activemq.apache.org/how-to-unit-test-jms-code.html
○ Spring Integration- https://github.com/spring-projects/spring-integration-
samples/tree/master/basic/jms
● Using tools
○ HermesJMS - http://www.hermesjms.com/confluence/display/HJMS/Home
■ Allows to post message on queues/topics
■ Observes topics !
● With containers test enabled test like Arquillian
Roll the demo in: EJBees project with Arquillian !
https://github.com/pijalu/ejbees.git

47. LDAP (and co)

48. How to test ?
● With tools
○ Spring security
■ It can run a “test” LDAP server based on a LDIF file
○ Apache Directory Studio
■ Allows to connect and browse to LDAP server (and AD is LDAP, but weird one...)
■ Allows to run your own LDAP server for integration
■ Allows to run your own LDAP server within JUnit tests
Roll the Demo in: LDAP Dance
https://github.com/pijalu/ldapdance

49. SOAP/REST/WS/...

50. How to test ?
● Writing your own integration tests
● Using tools
○ SoapUI
■ Can call the service
■ Perform tests
■ Can run with maven
Roll the demo in: SoapUI + SoapUI project !
https://github.com/pijalu/SoapUIDemo.git

51. Questions on other components tests ?

52. Environments

53. Environment - Disclaimer
● Commonly used
● Not exact
● Merged environments

54. Environment - Local
● typical laptop/desktop
● focus on work at hand
● not representative (resources, data volume)
● maybe even different application server
● mostly expecting unlimited resources
● limited constraints
● frequent deployments
● possibly different os
● possibly different settings (regional settings)
➔ goal: get your tasks completed
➔ target users: developer

55. Environment - Component Integration (DEV)
● more limited within company standards
● possibly increased complexity (authentication required)
● automated deployment?
● actual application server
● possible dummy systems
● mostly not load balanced
➔ goal: will it deploy on the actual infrastructure, sanity testing
➔ target users: developers
➔ challenge: bug free (and retard-proof)

56. Environment - System Integration (INT)
● representative systems
● possibly reduced data
● possibly load balanced
● whatsup
➔ goal: does it work well combined with other systems?
➔ target users: developers, testers

57. Environment - System Testing (TEST)
● representative systems
● possibly reduced data
● possibly load balanced
➔ goal: is it ready to present to business?
➔ target users: testers, functional analysts
➔ challenge: find the bugs!

58. Environment - User Acceptance Test (UAT)
● almost the real deal
● no impact on end users
● preferably identical setup compared to production
● loadbalanced
➔ goal: does it meet the business requirements we've specified? do we
need to rethink something? is this performant enough?
➔ target users: business users

59. Environment - Production
● the real deal
● impact on end users
➔ target users: end users

60. Environment - Disaster Recovery
● mirror
● offline
● alternate site
● pre go-live

61. System Integration Testing

62. System Integration Testing - What?
● web applications
● desktop applications
● mobile applications
● embedded applications
● headless applications
● others?

63. System Integration Testing - How?
● manual testing
● manual tools
○ soap ui
○ db tools
○ ldap browser
● automated tools
○ proprietary
○ selenium
○ custom made

64. System Integration Testing - Web application
● browser dependant
● device dependant
● subjective testing
● subject to change

65. System Integration Testing - Web application
● browser dependant
● device dependant
● subjective testing
● subject to change

66. System Integration Testing - Selenium
● target specific browser version
● browser bugs
● user simulation
● reusability
● screenshots
➔ record/replay
◆ limited usability
◆ parametrize!
➔ use static ids
➔ html only

67. System Integration Testing - Headless browser
● faster
● not 100% representative
● prepare test cases
● url check
● javascript check
● objective
➔ karma
➔ jasmine

68. System Integration Testing - When?
● funded by project
● sucky developers
● regression
● flow based applications

69. http://www.downvids.net/product-testing-institute-models-very-very-funny-
hq--38051.html