Skip to main content
unit-test-utility-methods Provides patterns for testing utility classes, static methods, and helper functions. Validates pure functions, null handling, edge cases, and boundary conditions. Generates AssertJ assertions and @ParameterizedTest for string utils, math utils, validators, and collection helpers. Use when testing utils, test helpers, helper functions, static methods, or verifying utility code correctness.
설치로 이동 Skills Marketplace 커뮤니티가 만든 AI 스킬을 발견하고 탐색하세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill unit-test-utility-methods명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Zip 다운로드 다운로드 중... 이 저장소의 다른 Skills Posts review findings from a JSON file as inline comments on a GitHub Pull Request, attaching each comment to its file and line. Use when you have a list/JSON of review findings (each with a file path, line number, and a message such as summary/failure_scenario) and want them published on a PR as inline review comments. Triggers include "post these review comments on the PR", "associate comments to files in the PR", "publish review findings to PR
typescript-security-review Provides security review capability for TypeScript/Node.js applications, validates code against XSS, injection, CSRF, JWT/OAuth2 flaws, dependency CVEs, and secrets exposure. Use when performing security audits, before deployment, reviewing authentication/authorization implementations, or ensuring OWASP compliance for Express, NestJS, and Next.js. Triggers on "security review", "check for security issues", "TypeScript security audit".
Initialize Spec-Driven Development context — detects tech stack, conventions, architecture patterns, and bootstraps persistence backends. Triggers on 'sdd-init', 'init sdd', 'setup sdd', 'initialize sdd', 'setup project', 'initialize project context'. Creates/updates docs/specs/architecture.md & ontology.md (Constitution), and populates knowledge-graph.json.
giuseppe-trisciuoglio
giuseppe-trisciuoglio/developer-kit
GitHub 저장소 열기 name unit-test-utility-methods description Provides patterns for testing utility classes, static methods, and helper functions. Validates pure functions, null handling, edge cases, and boundary conditions. Generates AssertJ assertions and @ParameterizedTest for string utils, math utils, validators, and collection helpers. Use when testing utils, test helpers, helper functions, static methods, or verifying utility code correctness. allowed-tools Read, Write, Bash, Glob, Grep
Unit Testing Utility Classes and Static Methods
Overview
This skill generates tests for utility classes with static helper methods and pure functions. It provides patterns for testing null handling, edge cases, boundary conditions, and common utilities like string manipulation, calculations, data validation, and collections. Pure functions require no mocking.
When to Use
Use this skill when:
Writing tests for utility/helper classes with static methods
Testing pure functions with no state or side effects
Testing string manipulation, formatting, or transformation utilities
Testing calculation, conversion, or math helper functions
Testing data validation and formatter utilities
Verifying null/empty input handling in utility code
Testing collections or array helper methods
Instructions
Create test class : Name it after the utility (e.g., StringUtilsTest)Test happy path : Valid inputs with expected outputsTest edge cases : null, empty, whitespace, single elementsTest boundary conditions : max/min values, large numbers, precision
Use descriptive names : shouldCapitalizeFirstLetter instead of test1
Use AssertJ : For readable, chainable assertions
Use @ParameterizedTest : For multiple similar inputs (see references/parameterized-tests.md)
Avoid mocking : Pure utilities need no mocks
Examples
Basic Static Utility Test import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.*;
class StringUtilsTest {
@Test
void shouldCapitalizeFirstLetter () {
assertThat(StringUtils.capitalize("hello" )).isEqualTo("Hello" );
}
@Test
void shouldReturnNullForNullInput () {
assertThat(StringUtils.capitalize(null )).isNull();
}
@Test
void shouldHandleEmptyString () {
assertThat(StringUtils.capitalize("" )).isEmpty();
}
@Test
void shouldHandleSingleCharacter () {
assertThat(StringUtils.capitalize("a" )).isEqualTo("A" );
}
}
Comprehensive Example: isEmpty Implementation
class StringUtilsTest {
@Test
void shouldReturnTrueForNullString () {
assertThat(StringUtils.isEmpty(null )).isTrue();
}
@Test
void shouldReturnTrueForEmptyString () {
assertThat(StringUtils.isEmpty("" )).isTrue();
}
@Test
void shouldReturnTrueForWhitespaceOnly () {
assertThat(StringUtils.isEmpty(" " )).isTrue();
}
@Test
void shouldReturnFalseForNonEmptyString () {
assertThat(StringUtils.isEmpty("hello" )).isFalse();
}
}
Null-Safe Utility class NullSafeUtilsTest {
@Test
void shouldReturnDefaultWhenNull () {
assertThat(NullSafeUtils.getOrDefault(null , "default" )).isEqualTo("default" );
}
@Test
void shouldReturnValueWhenNotNull () {
assertThat(NullSafeUtils.getOrDefault("value" , "default" )).isEqualTo("value" );
}
@Test
void shouldReturnFalseWhenBlank () {
assertThat(NullSafeUtils.isNotBlank(null )).isFalse();
assertThat(NullSafeUtils.isNotBlank(" " )).isFalse();
}
}
Math/Calculation Utility class MathUtilsTest {
@Test
void shouldCalculatePercentage () {
assertThat(MathUtils.percentage(25 , 100 )).isEqualTo(25.0 );
}
@Test
void shouldHandleZeroDivisor () {
assertThat(MathUtils.percentage(50 , 0 )).isZero();
}
@Test
void shouldRoundToDecimalPlaces () {
assertThat(MathUtils.round(3.14159 , 2 )).isEqualTo(3.14 );
}
@Test
void shouldHandleFloatingPointWithTolerance () {
assertThat(MathUtils.multiply(0.1 , 0.2 ))
.isCloseTo(0.02 , within(0.0001 ));
}
}
Collection Utility class CollectionUtilsTest {
@Test
void shouldFilterList () {
List<Integer> result = CollectionUtils.filter(List.of(1 , 2 , 3 , 4 ), n -> n % 2 == 0 );
assertThat(result).containsExactly(2 , 4 );
}
@Test
void shouldHandleNullList () {
assertThat(CollectionUtils.filter(null , n -> true )).isEmpty();
}
@Test
void shouldJoinWithSeparator () {
assertThat(CollectionUtils.join(List.of("a" , "b" , "c" ), "-" )).isEqualTo("a-b-c" );
}
@Test
void shouldDeduplicateList () {
assertThat(CollectionUtils.deduplicate(List.of("a" , "b" , "a" )))
.containsExactlyInAnyOrder("a" , "b" );
}
}
Data Validation Utility class ValidatorUtilsTest {
@Test
void shouldValidateEmailFormat () {
assertThat(ValidatorUtils.isValidEmail("user@example.com" )).isTrue();
assertThat(ValidatorUtils.isValidEmail("invalid" )).isFalse();
}
@Test
void shouldValidateUrlFormat () {
assertThat(ValidatorUtils.isValidUrl("https://example.com" )).isTrue();
assertThat(ValidatorUtils.isValidUrl("not a url" )).isFalse();
}
@Test
void shouldValidateCreditCard () {
assertThat(ValidatorUtils.isValidCreditCard("4532015112830366" )).isTrue();
assertThat(ValidatorUtils.isValidCreditCard("1234567890123456" )).isFalse();
}
}
Utility with Clock Dependency (Rare) @ExtendWith(MockitoExtension.class)
class DateUtilsTest {
@Mock
private Clock clock;
@Test
void shouldGetDateFromClock () {
when (clock.instant()).thenReturn(Instant.parse("2024-01-15T10:00:00Z" ));
assertThat(DateUtils.today(clock)).isEqualTo(LocalDate.of(2024 , 1 , 15 ));
}
}
Best Practices
Test pure functions exclusively - no side effects or state dependencyCover happy path and edge cases - null, empty, whitespace, extreme valuesUse descriptive test names - shouldReturnNullWhenInputIsNullUse @ParameterizedTest for multiple similar inputs (see references/parameterized-tests.md)Test boundary conditions - min/max values, overflow, precisionAvoid mocking pure functions - only mock external dependencies like ClockKeep tests independent - no order dependency between tests
Constraints and Warnings
No mocking static methods : Use reflection utilities only when absolutely necessaryPure function requirement : Stateful utilities are harder to test; prefer immutabilityFloating point precision : Never use exact equality; use isCloseTo(delta)Null handling consistency : Decide whether utility returns null or throws; test accordinglyThread safety : Static utilities must be thread-safe; verify concurrent behavior separatelyImmutable inputs : Document whether utilities modify input parametersEdge cases reference : See references/edge-cases.md for boundary testing patterns 