SE1EP3 - Build + Test Project

References

• Package Manager (opens new window)
• Maven Wrapper (opens new window)
• Getting Started With JUnit (opens new window)
• Jacoco Setup (opens new window)

Package Manager

- Mengenal Package Manager

Package Manager merupakan salah satu komponen penting pada pengembangan perangkat lunak. Package Manager menyediakan berbagai macam pustaka (Library) yang siap digunakan. Kebanyakan library dalam Package Manager disajikan oleh komunitas opensource dan terus dikembangkan.

Setiap project yang dibangun menggunakan Package Manager umumnya memiliki daftar pustaka (Library) yang dicatat dalam project tersebut, yang dikenal dengan istilah dependencies.

Selain menyediakan library, Package Manager juga dapat membantu mempercepat pembangunan perangkat lunak yaitu dengan berbagai fitur seperti:

• Initial Project / Skeleton
• Dependency management (add, update, remove library)
• Run tools
• Testing tools
• Build tools
• dll

- Apache Maven

Maven atau Apache Maven adalah salah satu Package Manager untuk Java yang populer dan masih banyak digunakan hingga saat ini. Kamu bisa menginstall Maven dengan dua cara yaitu:

• Install binary
• Download wrapper

Install Binary Maven dapat dilakukan dengan mengunjungi link berikut:

maven.apache.org/install.html

Download wrapper tersedia pada repository github.com/takari/maven-wrapper dan dapat dilakukan dengan terminal:

mkdir -p example/.mvn/wrapper

cd example

curl -LO https://github.com/takari/maven-wrapper/raw/master/mvnw

# Windows Only
curl -LO https://github.com/takari/maven-wrapper/raw/master/mvnw.cmd

curl -L -o .mvn/wrapper/maven-wrapper.properties https://github.com/takari/maven-wrapper/raw/master/.mvn/wrapper/maven-wrapper.properties

chmod +x mvnw

./mvnw --version

Membuat Project baru dengan Maven:

./mvnw -DoutputDirectory=.. archetype:generate

# Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 2096: (enter)

# Choose org.apache.maven.archetypes:maven-archetype-quickstart version: 
# 1: 1.0-alpha-1
# 2: 1.0-alpha-2
# 3: 1.0-alpha-3
# 4: 1.0-alpha-4
# 5: 1.0
# 6: 1.1
# 7: 1.3
# 8: 1.4
# Choose a number: 8: (enter)

# Define value for property 'groupId': com.example (enter)

# Define value for property 'artifactId': example (enter)

# Define value for property 'version' 1.0-SNAPSHOT: : (enter)

# Define value for property 'package' com.example: : (enter)

# Confirm properties configuration:
# groupId: com.example
# artifactId: example
# version: 1.0-SNAPSHOT
# package: com.example
#  Y: : Y (enter)

Setelah inisialisasi project berhasil makan maven akan membuat satu folder baru yaitu src dengan susunan seperti berikut:

.
├── .mvn
│   └── wrapper
│       ├── maven-wrapper.jar
│       └── maven-wrapper.properties
├── src
│   ├── main
│   │   └── java
│   │       └── com
│   │           └── example
│   │               └── App.java
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── AppTest.java
├── mvnw
├── mvnw.cmd
└── pom.xml

Untuk menjalankan project dengan maven, kamu perlu menambahkan kode berikut pada file pom.xml dalam susunan project>build.

<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.example.App</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <configuration>
      <mainClass>com.example.App</mainClass>
    </configuration>
  </plugin>
</plugins>

Kemudian jalankan perintah berikut:

./mvnw exec:java

Membuat jar dengan maven:

./mvnw package
# output jar: target/example-1.0-SNAPSHOT.jar

- Gradle

Untuk menginstall Gradle kamu bisa mengikuti langkah-langkah pada link berikut:

docs.gradle.org/current/userguide/installation.html

Download wrapper tersedia pada repository github.com/gradle/gradle dan dapat dilakukan dengan terminal:

mkdir -p example/gradle/wrapper

cd example

curl -LO https://github.com/gradle/gradle/raw/master/gradlew

# Windows Only
curl -LO https://github.com/gradle/gradle/raw/master/gradlew.bat

curl -L -o gradle/wrapper/gradle-wrapper.properties https://github.com/gradle/gradle/raw/master/gradle/wrapper/gradle-wrapper.properties

curl -L -o gradle/wrapper/gradle-wrapper.jar https://github.com/gradle/gradle/raw/master/gradle/wrapper/gradle-wrapper.jar

chmod +x gradlew

./gradlew --version

Membuat project baru dengan Gradle:

./gradlew init
# Select type of project to generate:
#   1: basic
#   2: application
#   3: library
#   4: Gradle plugin
# Enter selection (default: basic) [1..4] 2 (enter)

# Select implementation language:
#   1: C++
#   2: Groovy
#   3: Java
#   4: Kotlin
#   5: Scala
#   6: Swift
# Enter selection (default: Java) [1..6] (enter)

# Generate multiple subprojects for application? (default: no) [yes, no] (enter)

# Select build script DSL:
#   1: Kotlin
#   2: Groovy
# Enter selection (default: Kotlin) [1..2] 2 (enter)

# Select test framework:
#   1: JUnit 4
#   2: TestNG
#   3: Spock
#   4: JUnit Jupiter
# Enter selection (default: JUnit Jupiter) [1..4] 1 (enter)

# Project name (default: example): example (enter)

# Enter target version of Java (min. 7) (default: 21): (enter)

# Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] (enter)

Setelah proses inisialisasi diatas, makan gradle akan membuatkan project baru pada folder app dengan susunan direktori seperti berikut:

.
├── app
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   │   └── org
│   │   │   │       └── example
│   │   │   │           └── App.java
│   │   │   └── resources
│   │   └── test
│   │       ├── java
│   │       │   └── org
│   │       │       └── example
│   │       │           └── AppTest.java
│   │       └── resources
│   └── build.gradle
├── gradle
│   ├── wrapper
│   │   ├── gradle-wrapper.jar
│   │   └── gradle-wrapper.properties
│   └── libs.versions.toml
├── gradlew
├── gradlew.bat
└── settings.gradle

Tambahkan informasi main class pada file app/gradle.properties:

jar {
  manifest {
    attributes(
      'Main-Class': 'org.example.App'
    )
  }
}

Untuk menjalankan gradle project gunakan perintah berikut:

./gradlew run -q

Untuk membuat jar dengan gradle:

./gradlew build
# output jar: app/build/libs/app.jar

Nah sekarang kamu sudah paham kan bagaimana penggunakan package manager pada java!

Pastikan kamu memilih salah satu package manager (Maven/Gradle) dan tidak menggunakan beberapa package manager secara bersamaan.

Unit Testing

Unit testing pada Java dapat dilakukan dengan 2 cara yaitu cara manual dan menggunakan Project Manager.

Ada banyak library yang bisa digunakan untuk menjalankan unit test pada project java, salah satunya yang populer adalah JUnit.

Berikut ini situs resmi JUnit:

junit.org

Secara default baik Maven maupun Gradle, masing-masing sudah menyematkan JUnit didalam projectnya.

Ada beberapa konfigurasi yang harus disesuaikan pada file pom.xml di project maven, yaitu pada susunan project>build>plugins:

<project>
  ...
  <build>
    ...
    <plugins>
      ...
      <plugin>
        <groupId>org.jacoco</groupId>
        <artifactId>jacoco-maven-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>prepare-agent</goal>
            </goals>
          </execution>
          <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
              <goal>report</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
</project>

Setelah konfigurasi jacoco ditambahkan, jalankan perintah berikut:

./mvnw test

Untuk melihat code coverage pada project maven kamu bisa membuka file target/sites/jacoco/index.html di web browser.

Untuk menjalankan unit test pada project gradle, kamu perlu menambahkan beberapa konfigurasi untuk mendapatkan code coverage pada file app/build.gradle:

plugins {
  ...
  id 'jacoco'
}

...

test.finalizedBy jacocoTestReport

Setelah konfigurasi gradle disesuaikan, jalankan perintah berikut:

./gradlew test

Untuk melihat code coverage pada project gradle kamu bisa membuka file app/build/reports/jacoco/test/html/index.html di web browser.

- Studi Kasus

Sebelumnya kamu sudah paham cara menjalankan unit test pada project java, selanjutnya adalah membuat unit test pada program java.

Jika kamu memiliki class Calculator, maka kamu perlu membuat unit test nya dengan nama CalculatorTest (Penambahan kata Test dibelakang). Contoh:

src/main/java/com/example/Calculator.java
# berpasangan dengan
src/main/test/com/example/CalculatorTest.java

contoh class Calculator beserta unit test CalculatorTest:

package com.example;

class Calculator {

    public static int sum(int[] numbers) {

        int result = 0;

        for (int i: numbers) {
            result += i;
        }

        return result;
    }
}

package org.example;

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {

    @Test
    public void sumTest() {

        assertEquals(0, Calculator.sum(new int[]{}));
    }
}

Contoh hasil coverage dari Jacoco:

Mengenal IDE

IDE atau Integrated Development Environment adalah salah satu tools yang utama bagi seorang programmer. Fungsi IDE difokuskan pada fitur-fitur untuk mempermudah penulisan kode program. IDE yang baik biasanya memiliki kriteria sebagai berikut:

1. Mendukung bahasa program sesuai dengan kebutuhan developer
2. Independen atau Portable dan Cross-Platform
3. Memiliki fitur autocomplete yang memadai
4. Memiliki kapabilitas untuk membantu menelusuri kesalahan pada kode (bugs)
5. Memiliki banyak extensi dari komunitas
6. Opensource
7. Dokumentasi dan dukungan yang lengkap
8. Popularitas

Untuk materi kali ini, kita akan menggunakan IDE dari Jetbrains untuk membuat project dengan Java, yaitu Intellij Idea.

Cara membuka project Java di Intellij IDEA:

1. Buka Intellij Idea yang sudah di install, kemudian klik Open.
2. Pilih folder project yang akan dibuka dengan Intellij Idea lalu klik OK. Jika ditemukan peringatan seperti ini, klik Trust Project.
3. Jika berhasil maka project sudah siap dikerjakan.
4. Untuk menjalankan project pada Intellij Idea, ada beberapa cara, pertama buka file java yang memiliki entrypoint atau method main. lalu klik tombol play. cara kedua yaitu dengan membuat custom configuration.

Untuk menjalankan project java dari custom configuration yaitu dengan memilih tombol edit configuration pada navbar kanan atas, kemudian pilih edit configuration.

Setelah itu klik tombol + (plus), lalu pilih konfigurasi Java Scratch.

Lalu isi dengan konfigurasi berikut:

Atau jika kamu memilih konfigurasi Shell Script.

Atau jika kamu memilih konfigurasi Application.

dan masih banyak lagi konfigurasi yang dapat kamu tambahkan. Setelah konfigurasi ditambahkan, maka akan muncul daftar konfigurasi yang sudah kamu tambahkan.