public class OrderProcessor { // 注文を処理して割引を適用する public double calculateFinalPrice(Order order) { double price = order.getBasePrice(); // 5000円以上で5%割引 if (price >= 5000) { price = price * 0.95; } // プレミアム会員はさらに10%割引 if (order.getCustomer().isPremium()) { price = price * 0.9; } // 送料追加（北海道・沖縄は追加送料） String prefecture = order.getShippingAddress().getPrefecture(); if ("北海道".equals(prefecture) || "沖縄県".equals(prefecture)) { price += 500; } else { price += 300; } return price; } } 

import org.junit.jupiter.api.Test; import org.junit.jupiter.api.BeforeEach; import static org.junit.jupiter.api.Assertions.*; public class OrderProcessorTest { private OrderProcessor processor; private Customer regularCustomer; private Customer premiumCustomer; private Address tokyoAddress; private Address hokkaidoAddress; @BeforeEach void setUp() { // テストごとに新しいインスタンスを準備 processor = new OrderProcessor(); regularCustomer = new Customer("田中太郎", false); // 一般会員 premiumCustomer = new Customer("佐藤花子", true); // プレミアム会員 tokyoAddress = new Address("東京都", "新宿区", "1-1-1"); hokkaidoAddress = new Address("北海道", "札幌市", "2-2-2"); } @Test void testRegularCustomerWithSmallOrderInTokyo() { // 通常顧客が東京で3000円の注文を行うケース Order order = new Order(3000, regularCustomer, tokyoAddress); double finalPrice = processor.calculateFinalPrice(order); // 3000円 + 送料300円 = 3300円になるはず assertEquals(3300, finalPrice, "通常顧客の小額注文（東京）の計算が正しくありません"); } @Test void testPremiumCustomerWithLargeOrderInHokkaido() { // プレミアム顧客が北海道で10000円の注文を行うケース Order order = new Order(10000, premiumCustomer, hokkaidoAddress); double finalPrice = processor.calculateFinalPrice(order); // 10000円 - 5%割引 = 9500円 // 9500円 - 10%割引 = 8550円 // 8550円 + 送料500円 = 9050円になるはず assertEquals(9050, finalPrice, "プレミアム顧客の大口注文（北海道）の計算が正しくありません"); } } 

import org.junit.jupiter.api.*; public class LifecycleDemoTest { @BeforeAll static void setUpAll() { // テストクラス全体の前に1回だけ実行 System.out.println("BeforeAll"); } @BeforeEach void setUp() { // 各テストメソッドの前に実行 System.out.println("BeforeEach"); } @Test void testMethod1() { System.out.println("Test method 1"); } @Test void testMethod2() { System.out.println("Test method 2"); } @AfterEach void tearDown() { // 各テストメソッドの後に実行 System.out.println("AfterEach"); } @AfterAll static void tearDownAll() { // テストクラス全体の後に1回だけ実行 System.out.println("AfterAll"); } } 

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class AssertionsDemoTest { @Test void standardAssertions() { assertEquals(2, 1 + 1); // 値の比較 assertTrue(1 < 2); // 条件が真かどうか assertFalse(1 > 2); // 条件が偽かどうか } @Test void groupedAssertions() { // グループ化されたアサーション（すべて実行され、すべての失敗がレポートされる） assertAll("person", () -> assertEquals("John", person.getFirstName()), () -> assertEquals("Doe", person.getLastName()) ); } @Test void exceptionTesting() { // 例外発生の検証 Exception exception = assertThrows(ArithmeticException.class, () -> { int result = 1 / 0; }); assertEquals("/ by zero", exception.getMessage()); } @Test void timeoutNotExceeded() { // タイムアウトの検証 assertTimeout(Duration.ofMillis(100), () -> { // 100ミリ秒以内に完了する処理 }); } } 

import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import org.junit.jupiter.params.provider.ValueSource; class ParameterizedTestsDemo { @ParameterizedTest @ValueSource(ints = {1, 2, 3}) void testWithValueSource(int argument) { assertTrue(argument > 0); } @ParameterizedTest @CsvSource({"1, 1, 2", "2, 3, 5", "5, 8, 13"}) void testAdd(int a, int b, int expected) { Calculator calculator = new Calculator(); assertEquals(expected, calculator.add(a, b)); } } 

public class PaymentService { private PaymentGateway paymentGateway; // 外部の決済API public PaymentService(PaymentGateway paymentGateway) { this.paymentGateway = paymentGateway; } // 注文の支払い処理を行う public PaymentResult processPayment(Order order, CreditCard card) { // 不正なカード番号をはじく if (!isValidCardNumber(card.getNumber())) { return new PaymentResult(false, "不正なカード番号です"); } // 決済金額を計算 double amount = order.getFinalPrice(); try { // 外部APIを呼び出して実際に決済処理 TransactionResult transaction = paymentGateway.charge(card, amount); if (transaction.isSuccessful()) { // 成功時：注文ステータスを「支払い完了」に更新 order.setStatus(OrderStatus.PAID); return new PaymentResult(true, "支払いが完了しました"); } else { // 失敗時：エラーメッセージを返す return new PaymentResult(false, transaction.getErrorMessage()); } } catch (PaymentException e) { // 例外発生時：システムエラーとして処理 return new PaymentResult(false, "システムエラーが発生しました: " + e.getMessage()); } } private boolean isValidCardNumber(String cardNumber) { // カード番号の検証ロジック（省略） return cardNumber != null && cardNumber.length() >= 14 && cardNumber.length() <= 16; } } 

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.Mockito.*; class PaymentServiceTest { private PaymentService paymentService; private PaymentGateway mockGateway; private Order testOrder; private CreditCard validCard; private CreditCard invalidCard; @BeforeEach void setUp() { // モックの作成 mockGateway = mock(PaymentGateway.class); // テスト対象クラスにモックを注入 paymentService = new PaymentService(mockGateway); // テスト用のデータ準備 testOrder = new Order(); testOrder.setFinalPrice(5000); validCard = new CreditCard("1234567890123456", "12/25", "123"); invalidCard = new CreditCard("123", "12/25", "123"); // 短すぎる番号 } @Test void testSuccessfulPayment() { // モックの振る舞いを設定：決済成功のケース TransactionResult successResult = new TransactionResult(true, "承認番号: 123456"); when(mockGateway.charge(validCard, 5000)).thenReturn(successResult); // テスト実行 PaymentResult result = paymentService.processPayment(testOrder, validCard); // 検証 assertTrue(result.isSuccess()); assertEquals("支払いが完了しました", result.getMessage()); assertEquals(OrderStatus.PAID, testOrder.getStatus()); // モックメソッドが呼ばれたことを検証 verify(mockGateway).charge(validCard, 5000); } @Test void testFailedPayment() { // モックの振る舞いを設定：決済失敗のケース TransactionResult failureResult = new TransactionResult(false, "残高不足です"); when(mockGateway.charge(validCard, 5000)).thenReturn(failureResult); // テスト実行 PaymentResult result = paymentService.processPayment(testOrder, validCard); // 検証 assertFalse(result.isSuccess()); assertEquals("残高不足です", result.getMessage()); assertNotEquals(OrderStatus.PAID, testOrder.getStatus()); // モックメソッドが呼ばれたことを検証 verify(mockGateway).charge(validCard, 5000); } @Test void testInvalidCardNumber() { // テスト実行 PaymentResult result = paymentService.processPayment(testOrder, invalidCard); // 検証 assertFalse(result.isSuccess()); assertEquals("不正なカード番号です", result.getMessage()); // 外部APIは呼ばれないことを検証 verify(mockGateway, never()).charge(any(), anyDouble()); } @Test void testExceptionInPaymentGateway() { // モックの振る舞いを設定：例外をスローするケース when(mockGateway.charge(validCard, 5000)).thenThrow(new PaymentException("ネットワークエラー")); // テスト実行 PaymentResult result = paymentService.processPayment(testOrder, validCard); // 検証 assertFalse(result.isSuccess()); assertTrue(result.getMessage().contains("システムエラー")); assertTrue(result.getMessage().contains("ネットワークエラー")); // モックメソッドが呼ばれたことを検証 verify(mockGateway).charge(validCard, 5000); } } 

import org.junit.platform.suite.api.SelectPackages; import org.junit.platform.suite.api.Suite; @Suite @SelectPackages({"com.example.module1", "com.example.module2"}) public class AllTests { // この中身は空でOK } 

@ParameterizedTest @CsvSource({ "apple, 1", "banana, 2", "orange, 3" }) void testWithCsvSource(String fruit, int rank) { assertNotNull(fruit); assertTrue(rank > 0); } 

@Test @EnabledOnOs(OS.LINUX) void testOnlyOnLinux() { // Linuxでのみ実行されるテスト } 

@DisplayName("計算機テスト") class CalculatorTest { Calculator calculator = new Calculator(); @Nested @DisplayName("加算テスト") class AdditionTests { @Test @DisplayName("正の数の加算") void testAddPositiveNumbers() { assertEquals(5, calculator.add(2, 3)); } @Test @DisplayName("負の数の加算") void testAddNegativeNumbers() { assertEquals(-5, calculator.add(-2, -3)); } } @Nested @DisplayName("除算テスト") class DivisionTests { @Test @DisplayName("正常な除算") void testDivision() { assertEquals(2, calculator.divide(4, 2)); } @Test @DisplayName("ゼロ除算例外") void testDivisionByZero() { assertThrows(ArithmeticException.class, () -> calculator.divide(1, 0)); } } } 

@TestFactory Collection<DynamicTest> dynamicTests() { return Arrays.asList( dynamicTest("1番目の動的テスト", () -> assertTrue(true)), dynamicTest("2番目の動的テスト", () -> assertEquals(4, 2 * 2)) ); } 

// JUnit 5とMockitoを統合するための拡張機能 @ExtendWith(MockitoExtension.class) class UserServiceTest { // モックを自動生成 @Mock private UserRepository userRepository; // テスト対象クラスに@Mockでモック化したオブジェクトを自動注入 @InjectMocks private UserService userService; @Test void testGetUserById() { // モックの振る舞いを設定 User mockUser = new User("1", "John Doe"); when(userRepository.findById("1")).thenReturn(mockUser); // テスト実行 User result = userService.getUserById("1"); // 検証 assertEquals("John Doe", result.getName()); verify(userRepository).findById("1"); } } 

@SpringBootTest class UserControllerIntegrationTest { @Autowired private MockMvc mockMvc; @MockBean private UserService userService; @Test void testGetUserById() throws Exception { // モックの振る舞いを設定 User mockUser = new User("1", "John Doe"); when(userService.getUserById("1")).thenReturn(mockUser); // APIリクエストをモック mockMvc.perform(get("/api/users/1")) .andExpect(status().isOk()) .andExpect(jsonPath("$.id").value("1")) .andExpect(jsonPath("$.name").value("John Doe")); } } 

@ExtendWith(MockitoExtension.class) class AdvancedMockingTest { @Mock private UserRepository userRepository; @InjectMocks private UserService userService; @Captor private ArgumentCaptor<User> userCaptor; @Test void argumentCaptorExample() { // サービスメソッド呼び出し userService.registerUser("テスト太郎", "test@example.com"); // 引数キャプチャ verify(userRepository).save(userCaptor.capture()); // キャプチャした引数を検証 User capturedUser = userCaptor.getValue(); assertThat(capturedUser.getName()).isEqualTo("テスト太郎"); assertThat(capturedUser.getEmail()).isEqualTo("test@example.com"); } @Test void mockingConsecutiveCalls() { // 連続呼び出しで異なる戻り値を設定 when(userRepository.findById(1L)) .thenReturn(Optional.of(new User(1L, "初回ユーザー"))) .thenReturn(Optional.of(new User(1L, "2回目ユーザー"))) .thenThrow(new RuntimeException("3回目エラー")); // 1回目の呼び出し Optional<User> firstCall = userRepository.findById(1L); assertThat(firstCall).isPresent(); assertThat(firstCall.get().getName()).isEqualTo("初回ユーザー"); // 2回目の呼び出し Optional<User> secondCall = userRepository.findById(1L); assertThat(secondCall).isPresent(); assertThat(secondCall.get().getName()).isEqualTo("2回目ユーザー"); // 3回目の呼び出し（例外がスローされる） assertThrows(RuntimeException.class, () -> userRepository.findById(1L)); } @Test void answerExample() { // 引数に基づいて動的に戻り値を計算 when(userRepository.findById(anyLong())).thenAnswer(invocation -> { Long id = invocation.getArgument(0); if (id < 0) { return Optional.empty(); } return Optional.of(new User(id, "ユーザー" + id)); }); // 異なるIDで検証 assertThat(userRepository.findById(1L)).isPresent(); assertThat(userRepository.findById(1L).get().getName()).isEqualTo("ユーザー1"); assertThat(userRepository.findById(42L).get().getName()).isEqualTo("ユーザー42"); assertThat(userRepository.findById(-1L)).isEmpty(); } } 

// 基本的な統合テスト実装 @SpringBootTest class UserServiceIntegrationTest { @Autowired private UserService userService; @Test void registerUserSuccessfully() { // テスト実装 UserDto dto = new UserDto("テスト太郎", "test@example.com"); User savedUser = userService.registerUser(dto); assertThat(savedUser.getId()).isNotNull(); assertThat(savedUser.getName()).isEqualTo("テスト太郎"); } } // WebEnvironment設定オプション例 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) class WebIntegrationTest { @Autowired private TestRestTemplate restTemplate; @Test void apiEndpointTest() { // 実際にHTTPリクエストを送信するテスト ResponseEntity<UserDto> response = restTemplate.getForEntity("/api/users/1", UserDto.class); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); assertThat(response.getBody().getName()).isEqualTo("テスト太郎"); } } 

@WebMvcTest(UserController.class) class UserControllerTest { @Autowired private MockMvc mockMvc; @MockBean private UserService userService; @Test void getUserById() throws Exception { // モックサービスの振る舞いを設定 User mockUser = new User(1L, "テスト太郎", "test@example.com"); when(userService.findById(1L)).thenReturn(mockUser); // コントローラーエンドポイントへのリクエストをテスト mockMvc.perform(get("/api/users/1") .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(jsonPath("$.id").value(1)) .andExpect(jsonPath("$.name").value("テスト太郎")) .andExpect(jsonPath("$.email").value("test@example.com")); } @Test void createUserSuccessfully() throws Exception { // リクエストボディの作成 UserDto dto = new UserDto("新規ユーザー", "new@example.com"); User createdUser = new User(1L, "新規ユーザー", "new@example.com"); when(userService.createUser(any(UserDto.class))).thenReturn(createdUser); // POSTリクエストのテスト mockMvc.perform(post("/api/users") .contentType(MediaType.APPLICATION_JSON) .content(new ObjectMapper().writeValueAsString(dto))) .andExpect(status().isCreated()) .andExpect(header().string("Location", containsString("/api/users/1"))); } } 

@DataJpaTest class UserRepositoryTest { @Autowired private UserRepository userRepository; @Autowired private TestEntityManager entityManager; @Test void findByEmailReturnsCorrectUser() { // テストデータのセットアップ User user = new User(null, "テスト太郎", "test@example.com"); entityManager.persist(user); entityManager.flush(); // リポジトリメソッドのテスト Optional<User> found = userRepository.findByEmail("test@example.com"); assertThat(found).isPresent(); assertThat(found.get().getName()).isEqualTo("テスト太郎"); } @Test void findActiveUsersByRoleReturnsCorrectList() { // 複数のテストデータをセットアップ Role adminRole = entityManager.persist(new Role("ADMIN")); Role userRole = entityManager.persist(new Role("USER")); User user1 = new User(null, "管理者A", "admin1@example.com"); user1.setActive(true); user1.setRole(adminRole); entityManager.persist(user1); User user2 = new User(null, "管理者B", "admin2@example.com"); user2.setActive(false); // 非アクティブ user2.setRole(adminRole); entityManager.persist(user2); User user3 = new User(null, "一般ユーザー", "user@example.com"); user3.setActive(true); user3.setRole(userRole); entityManager.persist(user3); entityManager.flush(); // カスタムクエリメソッドのテスト List<User> activeAdmins = userRepository.findActiveUsersByRole("ADMIN"); assertThat(activeAdmins).hasSize(1); assertThat(activeAdmins.get(0).getName()).isEqualTo("管理者A"); } } 

# application-test.yml spring: datasource: url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1 username: sa password: driver-class-name: org.h2.Driver jpa: database-platform: org.hibernate.dialect.H2Dialect hibernate: ddl-auto: create-drop properties: hibernate: format_sql: true show-sql: true 

@SpringBootTest @ActiveProfiles("test") // application-test.ymlを使用 class UserServiceIntegrationTest { // テスト実装 } 

@SpringBootTest @Testcontainers class DatabaseIntegrationTest { @Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:14") .withDatabaseName("testdb") .withUsername("test") .withPassword("test"); @DynamicPropertySource static void dbProperties(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", postgres::getJdbcUrl); registry.add("spring.datasource.username", postgres::getUsername); registry.add("spring.datasource.password", postgres::getPassword); } @Autowired private UserRepository userRepository; @Test void testWithRealPostgreSQL() { // 実DBを使ったテスト User user = new User(null, "コンテナテストユーザー", "container@example.com"); User saved = userRepository.save(user); Optional<User> found = userRepository.findById(saved.getId()); assertThat(found).isPresent(); assertThat(found.get().getName()).isEqualTo("コンテナテストユーザー"); } } 

@SpringBootTest class OrderServiceTest { @Autowired private OrderService orderService; @Test @Sql("/sql/create-test-users.sql") @Sql(scripts = "/sql/create-test-products.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) @Sql(scripts = "/sql/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD) void processOrderSuccessfully() { // テストデータがセットアップされた状態でテスト実行 Order order = orderService.createOrder(1L, Arrays.asList(1L, 2L)); assertThat(order).isNotNull(); assertThat(order.getItems()).hasSize(2); assertThat(order.getStatus()).isEqualTo(OrderStatus.CREATED); } } 

INSERT INTO users (id, name, email, active) VALUES (1, 'テストユーザー', 'test@example.com', true); INSERT INTO users (id, name, email, active) VALUES (2, '管理者ユーザー', 'admin@example.com', true); 

@DataJpaTest class ProductRepositoryTest { @Autowired private TestEntityManager entityManager; @Autowired private ProductRepository productRepository; @BeforeEach void setup() { // テストデータ準備 Category category = new Category("電子機器"); entityManager.persist(category); Product product1 = new Product("スマートフォン", 50000, category); entityManager.persist(product1); Product product2 = new Product("タブレット", 40000, category); entityManager.persist(product2); entityManager.flush(); } @Test void findByCategoryName() { List<Product> products = productRepository.findByCategoryName("電子機器"); assertThat(products).hasSize(2); assertThat(products).extracting("name") .containsExactlyInAnyOrder("スマートフォン", "タブレット"); } } 

@SpringBootTest @Transactional class UserServiceTransactionalTest { @Autowired private UserService userService; @Autowired private UserRepository userRepository; @Test void registerUserRollsBackAfterTest() { // このテスト内でのデータ変更は、テスト完了後にロールバックされる User user = userService.registerUser(new UserDto("一時ユーザー", "temp@example.com")); assertThat(user.getId()).isNotNull(); // テスト内ではデータが存在することを確認 assertThat(userRepository.findById(user.getId())).isPresent(); // テスト終了後、このデータはロールバックされる } } 

@SpringBootTest // クラスレベルの@Transactionalは付けない class BankTransferServiceTest { @Autowired private BankTransferService transferService; @Autowired private AccountRepository accountRepository; @Test void transferFailsAndRollsBackWhenInsufficientFunds() { // 事前データ設定 Account sourceAccount = accountRepository.save(new Account("送金元", 1000)); Account targetAccount = accountRepository.save(new Account("送金先", 0)); // 残高不足での送金テスト assertThrows(InsufficientFundsException.class, () -> { transferService.transfer(sourceAccount.getId(), targetAccount.getId(), 2000); }); // トランザクションがロールバックされていることを確認 Account updatedSource = accountRepository.findById(sourceAccount.getId()).orElseThrow(); Account updatedTarget = accountRepository.findById(targetAccount.getId()).orElseThrow(); assertThat(updatedSource.getBalance()).isEqualTo(1000); // 変更なし assertThat(updatedTarget.getBalance()).isEqualTo(0); // 変更なし } } 

@SpringBootTest class DataCleanupTest { @Autowired private UserRepository userRepository; @BeforeEach void setup() { // テスト前にデータをクリーンアップ userRepository.deleteAll(); } @Test void testUserCreation() { // テストの実装 } @AfterEach void cleanup() { // テスト後にデータをクリーンアップ（必要に応じて） userRepository.deleteAll(); } } 

@ParameterizedTest @CsvSource({ "10, 'A'", // 0-20のクラスからの代表値 "35, 'B'", // 21-50のクラスからの代表値 "75, 'C'" // 51-100のクラスからの代表値 }) void gradeCalculationByEquivalencePartitioning(int score, char expectedGrade) { assertEquals(expectedGrade, gradeService.calculateGrade(score)); } 

@ParameterizedTest @CsvSource({ "0, 'A'", // 下限境界値 "20, 'A'", // 上限境界値 "21, 'B'", // 下限境界値+1 "50, 'B'", // 上限境界値 "51, 'C'", // 下限境界値+1 "100, 'C'" // 上限境界値 }) void gradeCalculationByBoundaryValueAnalysis(int score, char expectedGrade) { assertEquals(expectedGrade, gradeService.calculateGrade(score)); } 

// ビルダークラス定義 public class UserTestBuilder { private Long id = 1L; private String name = "テストユーザー"; private String email = "test@example.com"; private List<Role> roles = new ArrayList<>(); private boolean active = true; public static UserTestBuilder aUser() { return new UserTestBuilder(); } public UserTestBuilder withId(Long id) { this.id = id; return this; } public UserTestBuilder withName(String name) { this.name = name; return this; } public UserTestBuilder withEmail(String email) { this.email = email; return this; } public UserTestBuilder withRole(Role role) { this.roles.add(role); return this; } public UserTestBuilder inactive() { this.active = false; return this; } public User build() { User user = new User(); user.setId(id); user.setName(name); user.setEmail(email); user.setRoles(roles); user.setActive(active); return user; } } // 使用例 @Test void testWithBuilder() { User testUser = UserTestBuilder.aUser() .withName("テスト太郎") .withEmail("taro@example.com") .withRole(new Role("ADMIN")) .build(); // テスト実装 userService.sendWelcomeEmail(testUser); verify(emailService).sendEmail(eq(testUser.getEmail()), any(), any()); } 

public class TestDataFactory { // 標準的なユーザーセット public static List<User> createSampleUsers() { List<User> users = new ArrayList<>(); users.add(new User(1L, "一般ユーザー", "user@example.com")); users.add(new User(2L, "管理者", "admin@example.com")); users.add(new User(3L, "非アクティブユーザー", "inactive@example.com", false)); return users; } // 標準的な商品セット public static List<Product> createSampleProducts() { Category electronics = new Category(1L, "電化製品"); Category food = new Category(2L, "食品"); List<Product> products = new ArrayList<>(); products.add(new Product(1L, "スマートフォン", 50000, electronics)); products.add(new Product(2L, "タブレット", 40000, electronics)); products.add(new Product(3L, "お菓子セット", 1000, food)); return products; } // 特定のテストケース用のデータセット public static Order createOrderWithItems() { Order order = new Order(1L, createSampleUsers().get(0)); List<OrderItem> items = new ArrayList<>(); items.add(new OrderItem(1L, createSampleProducts().get(0), 1)); items.add(new OrderItem(2L, createSampleProducts().get(2), 3)); order.setItems(items); return order; } } // 使用例 @Test void calculateOrderTotalCorrectly() { Order testOrder = TestDataFactory.createOrderWithItems(); double total = orderService.calculateTotal(testOrder); // スマートフォン1台(50000) + お菓子セット3個(3000) = 53000 assertEquals(53000, total); } 

pipeline { agent any stages { stage('Checkout') { steps { checkout scm } } stage('Build') { steps { sh 'mvn clean compile' } } stage('Test') { steps { sh 'mvn test' } post { always { junit 'target/surefire-reports/*.xml' jacoco execPattern: 'target/jacoco.exec' } } } stage('Package') { steps { sh 'mvn package -DskipTests' } } } post { success { echo 'Build succeeded!' } failure { echo 'Build failed!' } always { // 常に実行するクリーンアップステップ } } } 

pipeline { agent any stages { stage('Build') { steps { echo 'Building..' } } stage('Test') { steps { echo 'Testing..' } } stage('Deploy') { steps { echo 'Deploying....' } } } } 

pipeline { agent any stages { stage('Build') { steps { echo 'Building..' } } stage('Deploy to Production') { when { branch 'master' } steps { echo 'Deploying to production...' } } } } 

pipeline { agent any stages { stage('Tests') { parallel { stage('Unit Tests') { steps { echo 'Running unit tests...' } } stage('Integration Tests') { steps { echo 'Running integration tests...' } } } } } } 

pipeline { agent any environment { MAVEN_HOME = '/usr/share/maven' } stages { stage('Build') { environment { DEBUG_FLAG = 'true' } steps { sh 'echo $MAVEN_HOME' sh 'echo $DEBUG_FLAG' } } } } 

pipeline { agent any stages { stage('Test') { steps { sh 'mvn test' } post { always { junit 'target/surefire-reports/*.xml' } } } } } 

pipeline { agent any stages { stage('Test') { steps { sh 'mvn test' } post { success { jacoco( execPattern: 'target/jacoco.exec', classPattern: 'target/classes', sourcePattern: 'src/main/java', exclusionPattern: 'src/test*' ) } } } } } 

name: Java CI on: [push, pull_request] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up JDK 11 uses: actions/setup-java@v2 with: java-version: '11' distribution: 'adopt' - name: Build with Maven run: mvn -B package --file pom.xml - name: Test run: mvn test - name: Publish Test Report uses: mikepenz/action-junit-report@v2 if: always() # テストが失敗しても常に実行 with: report_paths: '**/target/surefire-reports/TEST-*.xml' - name: JaCoCo Code Coverage Report uses: codecov/codecov-action@v1 with: file: ./target/site/jacoco/jacoco.xml fail_ci_if_error: true 

image: maven:3.8.1-openjdk-11 stages: - build - test - deploy variables: MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository" cache: paths: - .m2/repository build: stage: build script: - mvn compile test: stage: test script: - mvn test artifacts: reports: junit: - target/surefire-reports/TEST-*.xml paths: - target/site/jacoco/jacoco.xml code_quality: stage: test script: - mvn verify -DskipTests artifacts: paths: - target/site/ deploy: stage: deploy script: - mvn package -DskipTests only: - master artifacts: paths: - target/*.jar 

version: 2.1 jobs: build-and-test: docker: - image: cimg/openjdk:11.0 steps: - checkout - restore_cache: key: maven-{{ checksum "pom.xml" }} - run: name: Build command: mvn -B -DskipTests clean package - run: name: Test command: mvn test - save_cache: paths: - ~/.m2 key: maven-{{ checksum "pom.xml" }} - store_test_results: path: target/surefire-reports - store_artifacts: path: target/site/jacoco/jacoco.xml destination: jacoco/jacoco.xml workflows: version: 2 build-test-deploy: jobs: - build-and-test 

AWSTemplateFormatVersion: '2010-09-09' Resources: CodeBuildServiceRole: Type: 'AWS::IAM::Role' Properties: AssumeRolePolicyDocument: Version: '2012-10-17' Statement: - Effect: Allow Principal: Service: codebuild.amazonaws.com Action: 'sts:AssumeRole' ManagedPolicyArns: - 'arn:aws:iam::aws:policy/AmazonS3FullAccess' - 'arn:aws:iam::aws:policy/AmazonECR-FullAccess' CodePipelineServiceRole: Type: 'AWS::IAM::Role' Properties: AssumeRolePolicyDocument: Version: '2012-10-17' Statement: - Effect: Allow Principal: Service: codepipeline.amazonaws.com Action: 'sts:AssumeRole' ManagedPolicyArns: - 'arn:aws:iam::aws:policy/AWSCodeBuildAdminAccess' - 'arn:aws:iam::aws:policy/AmazonS3FullAccess' CodeBuildProject: Type: 'AWS::CodeBuild::Project' Properties: Artifacts: Type: CODEPIPELINE Environment: Type: LINUX_CONTAINER ComputeType: BUILD_GENERAL1_SMALL Image: aws/codebuild/amazonlinux2-x86_64-standard:3.0 ServiceRole: !GetAtt CodeBuildServiceRole.Arn Source: Type: CODEPIPELINE BuildSpec: | version: 0.2 phases: install: runtime-versions: java: corretto11 build: commands: - mvn compile test: commands: - mvn test reports: junit: files: - 'target/surefire-reports/TEST-*.xml' artifacts: files: - target/*.jar - appspec.yml discard-paths: no ArtifactBucket: Type: 'AWS::S3::Bucket' Properties: VersioningConfiguration: Status: Enabled Pipeline: Type: 'AWS::CodePipeline::Pipeline' Properties: RoleArn: !GetAtt CodePipelineServiceRole.Arn ArtifactStore: Type: S3 Location: !Ref ArtifactBucket Stages: - Name: Source Actions: - Name: Source ActionTypeId: Category: Source Owner: AWS Provider: CodeStarSourceConnection Version: '1' Configuration: ConnectionArn: !Ref CodeStarConnection FullRepositoryId: your-repo-owner/your-repo-name BranchName: main OutputArtifacts: - Name: SourceCode - Name: Build Actions: - Name: BuildAndTest ActionTypeId: Category: Build Owner: AWS Provider: CodeBuild Version: '1' Configuration: ProjectName: !Ref CodeBuildProject InputArtifacts: - Name: SourceCode OutputArtifacts: - Name: BuildOutput 

// 元のレガシーコード（テスト困難） public class LegacyPaymentProcessor { public boolean processPayment(double amount) { // 直接データベースへアクセス Connection conn = DatabaseSingleton.getConnection(); // 直接外部APIを呼び出し String apiKey = Configuration.getApiKey(); PaymentGateway gateway = new PaymentGateway(apiKey); try { TransactionResult result = gateway.charge(amount); if (result.isSuccessful()) { saveToDatabase(conn, result); return true; } return false; } catch (Exception e) { return false; } } private void saveToDatabase(Connection conn, TransactionResult result) { // データベース処理 } } // リファクタリング後（テスト可能） public class ModernPaymentProcessor { private PaymentGatewayInterface gateway; private TransactionRepository repository; // 依存性注入によるテスト容易性の向上 public ModernPaymentProcessor(PaymentGatewayInterface gateway, TransactionRepository repository) { this.gateway = gateway; this.repository = repository; } public boolean processPayment(double amount) { try { TransactionResult result = gateway.charge(amount); if (result.isSuccessful()) { repository.save(result); return true; } return false; } catch (Exception e) { return false; } } } // テストコード @Test void testSuccessfulPaymentProcessing() { // モックの準備 PaymentGatewayInterface mockGateway = mock(PaymentGatewayInterface.class); TransactionRepository mockRepo = mock(TransactionRepository.class); TransactionResult successResult = new TransactionResult(true, "12345"); when(mockGateway.charge(100.0)).thenReturn(successResult); // テスト対象クラスの作成 ModernPaymentProcessor processor = new ModernPaymentProcessor(mockGateway, mockRepo); // テスト実行 boolean result = processor.processPayment(100.0); // 検証 assertTrue(result); verify(mockRepo).save(successResult); } 

@Test void characterizeExistingBehavior() { // 既存クラスの現在の動作を記録 LegacyCalculator calculator = new LegacyCalculator(); // さまざまな入力に対する既存の出力を記録 assertEquals(42, calculator.complexCalculation(10, 20)); assertEquals(65, calculator.complexCalculation(15, 25)); assertEquals(-3, calculator.complexCalculation(-5, 2)); // 例外ケースの振る舞いも記録 assertThrows(ArithmeticException.class, () -> calculator.complexCalculation(999, 0)); } 

// テスト困難なオリジナルクラス public class LegacyService { protected Database getDatabase() { return DatabaseSingleton.getInstance(); } public List<Customer> getActiveCustomers() { Database db = getDatabase(); return db.executeQuery("SELECT * FROM customers WHERE active = 1"); } } // テスト用サブクラス class TestableService extends LegacyService { private Database mockDatabase; public TestableService(Database mockDatabase) { this.mockDatabase = mockDatabase; } @Override protected Database getDatabase() { return mockDatabase; } } // テストコード @Test void testGetActiveCustomers() { // モックデータベースの準備 Database mockDb = mock(Database.class); List<Customer> expectedCustomers = Arrays.asList( new Customer(1, "Alice"), new Customer(2, "Bob") ); when(mockDb.executeQuery(anyString())).thenReturn(expectedCustomers); // テスト用サブクラスを使用 TestableService service = new TestableService(mockDb); // テスト実行 List<Customer> result = service.getActiveCustomers(); // 検証 assertEquals(2, result.size()); assertEquals("Alice", result.get(0).getName()); assertEquals("Bob", result.get(1).getName()); } 

@Test void goldenMasterTest() throws IOException { // 広範囲のテストデータを準備 List<TestInput> testInputs = generateTestInputs(); // 元のアルゴリズムの出力を記録 Map<TestInput, Result> originalResults = new HashMap<>(); LegacyAlgorithm legacy = new LegacyAlgorithm(); for (TestInput input : testInputs) { originalResults.put(input, legacy.process(input)); } // 新しいアルゴリズムの出力を比較 RefactoredAlgorithm refactored = new RefactoredAlgorithm(); for (TestInput input : testInputs) { Result originalResult = originalResults.get(input); Result newResult = refactored.process(input); assertEquals(originalResult, newResult, "Input: " + input + " produced different results"); } } 

<plugin> <groupId>org.sonarsource.scanner.maven</groupId> <artifactId>sonar-maven-plugin</artifactId> <version>3.9.1.2184</version> </plugin> 

stage('SonarQube Analysis') { steps { withSonarQubeEnv('SonarQube Server') { sh 'mvn sonar:sonar -Dsonar.projectKey=my-project -Dsonar.projectName="My Project"' } } } 

# docker-compose.yml version: '3' services: prometheus: image: prom/prometheus volumes: - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml ports: - "9090:9090" grafana: image: grafana/grafana depends_on: - prometheus ports: - "3000:3000" volumes: - grafana-storage:/var/lib/grafana environment: - GF_SECURITY_ADMIN_PASSWORD=admin - GF_USERS_ALLOW_SIGN_UP=false volumes: grafana-storage: