{"id":1293,"date":"2015-06-23T11:47:09","date_gmt":"2015-06-23T15:47:09","guid":{"rendered":"http:\/\/springframework.guru\/?p=1293"},"modified":"2019-06-24T21:14:30","modified_gmt":"2019-06-25T01:14:30","slug":"unit-testing-junit-part-1","status":"publish","type":"post","link":"https:\/\/springframework.guru\/unit-testing-junit-part-1\/","title":{"rendered":"Unit Testing with JUnit – Part 1"},"content":{"rendered":"

Unit testing is the first level of testing software<\/a> where you write test code that executes a specific functionality in the code to be tested. In most cases, you as a programmer are responsible to deliver unit tested code. The objective is to check if the unit of the software, for example a public method of a class under test, behaves as expected and\/or returns the expected data. Unit tests are not<\/em> done on the production system but as isolated units. If the unit under test have external dependencies, such as an external data source or a Web service, the dependencies are replaced with a test implementation or a mock object created using a test framework. Unit testing is not the only type and it alone cannot handle all testing aspects. Other types of testing, such as integration and functional testing have their own roles in testing software.<\/p>\n

In this series of posts we will focus on unit testing with JUnit – one of the most popular framework to test Java code. In this post, we will start by creating and executing a basic unit test, and then in further posts move to specific unit testing aspects.<\/p>\n

The core JUnit framework comes in a single JAR file, which you can download, point the classpath to it, and then create and run tests. But in this post, we will learn how to perform unit testing in the real programmer\u2019s way. We will start with Maven, and then move to IntelliJ.<\/p>\n

Unit Testing with Maven<\/h2>\n

You’ve likely heard Maven being referred as a build tool. But, in addition to its capability to build deployable artifacts from source code, Maven provides a number of features for managing the software development life cycle. Unit testing is one such feature, which is incorporated as a test phase in the Maven build lifecycle<\/a>.<\/p>\n

Without going into Maven in depth, let\u2019s start our first JUnit test with Maven.<\/p>\n

    \n
  1. \n
      \n
    1. Download and install Maven<\/a>\u00a0if you haven’t done yet.<\/li>\n
    2. Open up a command prompt (Windows) or a terminal (*uix or Mac), browse to a working directory to setup the project, and execute the following command.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
      mvn archetype:generate -DgroupId=guru.springframework.unittest.quickstart -DartifactId=unittest -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false<\/pre>\n
      The preceding archetype:generate<\/code> command uses the maven-archetype-quickstart<\/code> template to create a basic Maven project containing a pom.xml<\/code> file, a App.java<\/code> class, and a AppTest.java<\/code> test class in the following directory structure.<\/p>\n
      \u2514\u2500\u2500\u2500pom.xml      \r\n\u2514\u2500\u2500\u2500src\r\n    \u251c\u2500\u2500\u2500main\r\n    \u2502   \u2514\u2500\u2500\u2500java\r\n    \u2502       \u2514\u2500\u2500\u2500guru\r\n    \u2502           \u2514\u2500\u2500\u2500springframework\r\n    \u2502               \u2514\u2500\u2500\u2500unittest\r\n    \u2502                   \u2514\u2500\u2500\u2500quickstart\r\n    \u2502                           App.java\r\n    \u2502                           \r\n    \u2514\u2500\u2500\u2500test\r\n        \u2514\u2500\u2500\u2500java\r\n            \u2514\u2500\u2500\u2500guru\r\n                \u2514\u2500\u2500\u2500springframework\r\n                    \u2514\u2500\u2500\u2500unittest\r\n                        \u2514\u2500\u2500\u2500quickstart\r\n                                AppTest.java\r\n<\/pre>\n
      In the directory structure above, the pom.xml<\/code> file, also known as the Maven configuration file is the heart of a Maven project. It is where you define your project configurations – specifically the dependencies of your project. For example, as our project depends on JUnit, we need to declare it as a dependency in the pom.xml<\/code> file. Although a JUnit dependency will already be present by default, we will update it to point to the latest JUnit version. This is how our final pom.xml<\/code> file will look like.<\/p>\n
      pom.xml<\/h4>\n
        4.0.0\r\n  guru.springframework.unittest.quickstart\r\n  unittest\r\n  jar\r\n  1.0-SNAPSHOT\r\n  unittest\r\n  http:\/\/maven.apache.org\r\n  \r\n    \r\n     junit\r\n     junit\r\n     4.12\r\n     test\r\n    \r\n      \r\n          org.hamcrest\r\n          hamcrest-library\r\n          1.3\r\n          test\r\n      \r\n      \r\n          org.mockito\r\n          mockito-all\r\n          1.9.5\r\n      \r\n  \r\n\r\n<\/pre>\n
      Now that we have set up a basic Java class, a test class, and the pom.xml<\/code> configuration, we can run a unit test.<\/p>\n
        \n
      1. \n
          \n
        1. Execute the mvn test<\/code> command from the working directory.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
          This command will run the default AppTest<\/code> class that Maven generated for us with the following output.<\/p>\n
          -------------------------------------------------------\r\n T E S T S\r\n-------------------------------------------------------\r\nRunning guru.springframework.unittest.quickstart.AppTest\r\nTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.043 sec\r\n\r\nResults :\r\n\r\nTests run: 1, Failures: 0, Errors: 0, Skipped: 0\r\n\r\n[INFO] ------------------------------------------------------------------------\r\n[INFO] BUILD SUCCESS\r\n[INFO] ------------------------------------------------------------------------\r\n[INFO] Total time: 8.691 s\r\n[INFO] Finished at: 2015-06-18T20:16:34+05:30\r\n[INFO] Final Memory: 14M\/136M\r\n[INFO] ------------------------------------------------------------------------ \r\n<\/pre>\n
          We have executed a JUnit test using Maven. This test passed, but hardly provides any value yet. We will next move to using the IntelliJ IDE to write and execute a more comprehensive test.<\/p>\n
          Unit Testing in IntelliJ<\/h2>\n
          Using IntelliJ, you can easily create, run, and debug unit tests. Among several other unit testing frameworks, IntelliJ provides built-in support for JUnit. In IntelliJ, you can create a JUnit test class with a click and navigate quickly between test classes and their corresponding target classes to debug test errors. A very useful unit testing feature in IntelliJ is code coverage. With this feature, you can view the exact percentage of methods and even lines of code covered by unit tests in your project.<\/p>\n
          Let\u2019s import our existing Maven project to IntelliJ and do some unit testing.<\/p>\n
          Import Maven Project to IntelliJ<\/h3>\n
          If you don’t have IntelliJ installed, download and install the free Community Edition or the 30-day trial of Ultimate Edition from the official website<\/a>. Once you are done, perform the following steps:<\/p>\n
            \n
          1. \n
              \n
            1. Open IntelliJ.<\/li>\n
            2. On the Welcome to IntelliJ IDEA<\/strong> window, click Import Project<\/strong>.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
              \"Click<\/a><\/p>\n
                \n
              1. \n
                  \n
                1. In the Select File or Directory to Import<\/strong> dialog box, browse to the working directory of the Maven project and select the pom.xml<\/code> file.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                  \"Select<\/a><\/p>\n
                    \n
                  1. \n
                      \n
                    1. Click the OK <\/strong>button.<\/li>\n
                    2. In the Import Project from Maven<\/strong> dialog box that appears, select the Import Maven projects automatically<\/strong> checkbox to synchronize changes between the Maven and InteliiJ projects each time the pom.xml<\/code> file changes.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                      \"Select<\/a><\/p>\n
                        \n
                      1. \n
                          \n
                        1. Click the Next <\/strong>button through a few more dialog boxes, accepting the default settings, and finally click Finish<\/strong>. The Project <\/strong>window of IntelliJ displays the project structure.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                          \"Thct<\/a><\/p>\n
                            \n
                          1. Double click App<\/strong> in the Project<\/strong> window to open it in the code editor.<\/li>\n
                          2. Replace the default code of the App<\/code> class with this code.<\/li>\n<\/ol>\n
                            App.java<\/h4>\n
                            package guru.springframework.unittest.quickstart;\r\n\r\n\r\npublic class App\r\n{\r\n    public String concatAndConvertString(String str1, String str2){\r\n        String concatedString=str1.concat(str2);\r\n        return concatedString.toUpperCase();\r\n    }\r\n    }\r\n<\/pre>\n
                            In the code above we wrote a concatAndConvertString()<\/code> method in the App<\/code> class that accepts two String<\/code> parameters. The method first concatenates the strings and converts the result to uppercase before returning it.<\/p>\n
                            We will next add a test class to test the concatAndConvertString()<\/code> method.<\/p>\n
                            Add a Test Class<\/h3>\n
                            Let\u2019s go through the steps to add a test class in IntelliJ from scratch.<\/p>\n
                              \n
                            1. \n
                                \n
                              1. Delete the default AppTest<\/strong> class from the\u00a0Project<\/b>\u00a0window.<\/li>\n
                              2. In the Project<\/strong> window create a directory with the name test<\/strong> under main<\/strong>, We will use the test<\/strong> directory to keep the test code separated from the application code.<\/li>\n
                              3. Right-click test<\/strong> and select Mark Directory As\u2192Test Sources Root<\/strong>.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                                \"select<\/a><\/p>\n
                                  \n
                                1. \n
                                    \n
                                  1. In the code editor where the App<\/strong> class is open, press Shift+F10<\/code> and select Create New Test<\/strong>.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                                    \"Select<\/a><\/p>\n
                                      \n
                                    1. \n
                                        \n
                                      1. In the Create Test<\/strong> dialog box that appears, select the jUnit4<\/strong> radio button and the check box corresponding to the concatAndConvertString()<\/code> method that we will test.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                                        \"Select<\/a><\/p>\n
                                          \n
                                        1. Click the OK<\/strong> button. JUnit creates the AppTest<\/strong> class with a testConcatAndConvertString()<\/code> method decorated with the @Test<\/code> annotation. This annotation tells JUnit to run the method as a test case. In the test method, we will write the code to test the concatAndConvertString()<\/code> method of App<\/strong>.<\/li>\n<\/ol>\n
                                          AppTest.java<\/h4>\n
                                          package guru.springframework.unittest.quickstart;\r\nimport org.junit.Test;\r\nimport static org.junit.Assert.*;\r\n\r\npublic class AppTest {\r\n\r\n   @Test\r\n    public void testConcatAndConvertString() throws Exception {\r\n       String expectedValue=\"HELLOWORLD\";\r\n       App app=new App();\r\n       String actualValue=app.concatAndConvertString(\"Hello\", \"World\");\r\n       assertEquals(expectedValue, actualValue);\r\n    }\r\n}\r\n\r\n\r\n\r\n<\/pre>\n
                                          In Line 12 of the example above, we called the assertEquals()<\/code> method, which is one of the several JUnit assertion methods. This overloaded method checks whether two String<\/code> objects are equal. If they are not, the method throws an AssertionError<\/code>. In our example, we called the assertEquals()<\/code> method by passing the expected string value (HELLOWORLD<\/code>) as the first parameter and the actual value that the concatAndConvertString()<\/code> method returns as the second parameter.<\/p>\n
                                          Run the Unit Test<\/h3>\n
                                          To run the test, select Run AppTest<\/strong> from the Run menu of IntelliJ or press Shift+F10<\/strong>. The Run<\/strong> window displays the test result. A green highlight box indicates that the test completed without any failure.<\/p>\n
                                          \"Green<\/a><\/p>\n
                                          To know how test failures are reported, change the value of the expectedValue <\/code>variable to HelloWorld<\/code> and press Shift+F10<\/strong>. The Run<\/strong> dialog box displays a red progress bar to indicate the test failure along with a comparison failure message.<\/p>\n
                                          \"Red<\/a><\/p>\n
                                          Revert the the expectedValue<\/code> variable to its original value before you close IntelliJ.<\/p>\n
                                          Summary<\/h2>\n
                                          At this point, if you are thinking Why not just use System.out.println() for unit testing?<\/em>\u00a0Then you are thinking wrong. Inserting System.out.println()<\/code> for debugging into code is undesirable because it requires manually scanning the output, every time the program is run, to ensure that the code is doing what’s expected. Imagine doing this in an enterprise application having hundreds and thousands of lines of code. On the other hand, unit tests examine the code’s behavior on runtime from the client’s point of view. This provides better insight on what might happen when the software is released.<\/p>\n
                                          Whenever you are writing code, you should be writing unit tests too. Writing unit tests will catch programming errors and improve the quality of your code. Many professional developers advocate doing Test Driven Development (TDD), where you write your unit tests before you write the application code.<\/p>\n
                                          Either way if you write your unit tests before or after you write the application code, the unit tests become a valuable asset for instrumenting your code. As the code base grows, you can refactor things as needed, and have more confidence that your changes will not have unintended consequences (ie where you change one thing, and accidently break something else).<\/p>\n
                                          In part 2 of my tutorial series on unit testing with JUnit<\/a> I’ll take a deeper look at JUnit Assertions, JUnit Annotations, and JUnit Test Suites.<\/p>\n
                                          Unit Testing with\u00a0the Spring Framework<\/h3>\n
                                          Testing is an integral part of Enterprise Application Development<\/a>\u00a0process with the Spring Framework. The architecture of the Spring Framework lends itself to modular code and easier unit testing. \u00a0Spring provides testing support through the TestContext Framework that abstracts the underlying testing framework, such as JUnit and TestNG. You can use it by setting SpringJUnit4ClassRunner.class<\/code> as the value for the @RunWith<\/code> annotation. This tells Spring to use the test runner of TestContext instead of JUnit\u2019s built in test runner.\u00a0I’ve written a more in depth post about testing Spring applications with JUnit here<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                          Unit testing is the first level of testing software where you write test code that executes a specific functionality in the code to be tested. In most cases, you as a programmer are responsible to deliver unit tested code. The objective is to check if the unit of the software, for example a public method […]Continue reading<\/a><\/p>\n","protected":false},"author":1,"featured_media":4591,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"Unit Testing with JUnit - Part 1 https:\/\/wp.me\/p5BZrZ-kR #junit #java","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[20,33,85],"tags":[43,27,60,28,113],"class_list":["post-1293","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","category-junit","category-testing","tag-intellij","tag-java","tag-junit","tag-maven","tag-unit-test"],"jetpack_publicize_connections":[],"aioseo_notices":[],"modified_by":"Simanta","jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/springframework.guru\/wp-content\/uploads\/2015\/03\/Banner560x292_06web.jpg","jetpack_shortlink":"https:\/\/wp.me\/p5BZrZ-kR","_links":{"self":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/1293"}],"collection":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/comments?post=1293"}],"version-history":[{"count":10,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/1293\/revisions"}],"predecessor-version":[{"id":5727,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/1293\/revisions\/5727"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media\/4591"}],"wp:attachment":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media?parent=1293"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/categories?post=1293"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/tags?post=1293"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}