diff --git a/cobol-migration/.gitignore b/cobol-migration/.gitignore new file mode 100644 index 0000000..db37291 --- /dev/null +++ b/cobol-migration/.gitignore @@ -0,0 +1,16 @@ +target/ +!.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### IDE ### +.classpath +.project +.settings/ +.idea/ +*.iml +*.iws +*.ipr + +### OS ### +.DS_Store diff --git a/cobol-migration/README.md b/cobol-migration/README.md new file mode 100644 index 0000000..90c6da7 --- /dev/null +++ b/cobol-migration/README.md @@ -0,0 +1,151 @@ +# COBOL to Spring Boot Migration + +This Spring Boot 3.x application replaces the GnuCOBOL programs in the [COBOL-Examples](../) repository with modern Java 17+ equivalents. The original COBOL files are retained in their directories for reference. + +## Quick Start + +### Prerequisites +- Java 17+ +- Maven 3.8+ +- PostgreSQL 12+ (for database features) + +### Build & Test +```bash +cd cobol-migration +mvn clean install +``` + +### Run +```bash +mvn spring-boot:run +``` +The application starts on `http://localhost:8080`. + +### Database Setup +1. Create a PostgreSQL database named `cobol_db_example` +2. Flyway migrations run automatically on startup (creates the `accounts` table and seeds test data) +3. Configure connection in `src/main/resources/application.properties` if defaults differ + +## API Endpoints + +| Method | Endpoint | Replaces | Description | +|--------|----------|----------|-------------| +| GET | `/api/accounts` | sql_example.cbl menu option 1 | List all accounts | +| GET | `/api/accounts/disabled` | sql_example.cbl menu option 2 | List disabled accounts | +| GET | `/api/accounts/search?q={term}` | sql_example.cbl menu option 3 | Search accounts (LIKE wildcard) | +| GET | `/api/serialize/json` | json_generate.cbl | JSON serialization demo | +| GET | `/api/serialize/xml` | xml_generate.cbl | XML serialization demo | +| POST | `/api/customers/merge-sort` | merge_sort_test.cbl merge | Merge and sort two customer lists | +| GET | `/api/customers/demo` | merge_sort_test.cbl full flow | Run complete merge/sort demo | +| POST | `/api/reports/student` | report_test.cbl | Generate formatted student report | + +## Migration Mapping + +### COBOL File to Java Equivalent + +| COBOL Source | Java Equivalent | Notes | +|---|---|---| +| `sql/sql_example.cbl` | `AccountController`, `AccountService`, `AccountRepository` | Terminal menu replaced with REST API; embedded SQL replaced with Spring Data JPA | +| `sql/create_test_db.sql` | `V1__create_accounts.sql`, `V2__seed_data.sql` | Flyway migration files; `\c` command removed | +| `json_generate/json_generate.cbl` | `SerializationController.getJson()`, `SerializableRecord` | `JSON GENERATE` replaced with Jackson JSON | +| `xml_generate/xml_generate.cbl` | `SerializationController.getXml()`, `SerializableRecord` | `XML GENERATE` replaced with Jackson XML; attribute/suppress behavior preserved | +| `merge_sort/merge_sort_test.cbl` | `CustomerFileController`, `CustomerFileService`, `CustomerFileRecord` | File-based SORT/MERGE replaced with `Comparator` and in-memory lists | +| `report_writer/report_test.cbl` | `ReportController`, `ReportService`, `StudentRecord` | COBOL Report Writer replaced with formatted String output | +| `redifines/redefines.cbl` | `Customer` (abstract), `PersonCustomer`, `CorpCustomer` | `REDEFINES` pattern modeled with Java inheritance and polymorphism | +| `is_numeric/is_numeric.cbl` | `ValidationService.isNumeric()` | Three COBOL approaches (plain, zero-fill, trim) replicated | +| `numval_test/numval_test.cbl` | `ValidationService.parseNumericValue()` | `FUNCTION NUMVAL` replaced with `NumberUtils.isCreatable()` | +| `trim/trim.cbl` | `StringUtilService.trimVariants()` | `FUNCTION TRIM` (full/leading/trailing) mapped to `String.strip*()` | +| `unstring/unstring.cbl` | `StringUtilService.splitByDelimiter()`, `splitByMultipleDelimiters()`, `splitFormattedNumber()` | `UNSTRING` with `DELIMITER IN`, `COUNT IN`, `TALLYING IN` | +| `search/search.cbl` | `SearchDemoService` | `SEARCH ALL` (binary) -> `Collections.binarySearch()`; `SEARCH` (sequential) -> `Stream.filter()` | +| `sub_program/main_app.cbl`, `sub.cbl` | Service layer pattern (documented in `AppConfig.java`) | `CALL BY CONTENT` = immutable params; `CALL BY REFERENCE` = mutable objects | + +### Terminal UI Programs (Dropped or Replaced) + +| COBOL Source | Disposition | Notes | +|---|---|---| +| `accept/accept.cbl` | Replaced | Input validation concepts applied in controllers | +| `accept/accept_from.cbl` | Replaced | Environment vars -> `@Value`; dates -> `java.time`; args -> `ApplicationArguments` | +| `screen_size/get_screen_size.cbl` | Dropped | Terminal dimensions not applicable to web | +| `display_test/display-test.cbl` | Dropped | Positioned display with colors not applicable | +| `mouse/mouse_example.cbl` | Dropped | Mouse paint program not applicable | +| `display_timing/display_timing.cbl` | Dropped | Screen write benchmarking not applicable | +| `read_command_args/` | Replaced | Command-line args -> Spring Boot `ApplicationArguments` | +| `comp_test/comp_test.cbl` | Dropped | Java handles numeric types natively | + +## Behavioral Differences + +| Aspect | COBOL | Java (Spring Boot) | +|---|---|---| +| **String handling** | Fixed-width `PIC X(n)` fields padded with spaces | Dynamic-length `String`; no implicit padding | +| **Numeric types** | `PIC 9(n)`, `COMP-2`, `COMP-5` with explicit sizes | `int`, `long`, `double`; automatic type promotion | +| **Null handling** | No null concept; fields always have default values | Null is possible; use validation annotations | +| **Database access** | Embedded SQL with ODBC precompiler (esqlOC) | Spring Data JPA with HQL/JPQL queries | +| **File I/O** | `SELECT ... ASSIGN TO`, `READ`, `WRITE` with FD | In-memory lists; file I/O via `java.nio` if needed | +| **Memory layout** | `REDEFINES` shares memory between fields | Inheritance/polymorphism; no shared memory | +| **Search** | `SEARCH ALL` (binary) requires sorted indexed table | `Collections.binarySearch()` requires sorted list | +| **Sorting** | `SORT`/`MERGE` with sort work file (SD) | `List.sort()` with `Comparator` | +| **Report generation** | Report Writer (RD, PAGE LIMIT, GENERATE) | String formatting with pagination logic | +| **Subprograms** | `CALL BY CONTENT` / `CALL BY REFERENCE` | Method params (immutable vs mutable objects) | +| **Terminal I/O** | `ACCEPT`/`DISPLAY` with screen coordinates | REST API with JSON request/response | + +## Project Structure + +``` +cobol-migration/ + pom.xml + src/main/java/com/example/cobolmigration/ + CobolMigrationApplication.java + config/ + AppConfig.java + controller/ + AccountController.java + CustomerFileController.java + ReportController.java + SerializationController.java + model/ + Account.java (JPA entity) + Customer.java (abstract base - REDEFINES) + PersonCustomer.java (extends Customer) + CorpCustomer.java (extends Customer) + CustomerFileRecord.java (file-based model) + StudentRecord.java (report model) + SerializableRecord.java (JSON/XML model) + repository/ + AccountRepository.java + service/ + AccountService.java + CustomerFileService.java + ReportService.java + SearchDemoService.java + SerializationService.java + StringUtilService.java + ValidationService.java + src/main/resources/ + application.properties + db/migration/ + V1__create_accounts.sql + V2__seed_data.sql + src/test/java/com/example/cobolmigration/ + controller/ + AccountControllerTest.java + service/ + AccountServiceTest.java + CustomerFileServiceTest.java + ReportServiceTest.java + SearchDemoServiceTest.java + SerializationServiceTest.java + StringUtilServiceTest.java + ValidationServiceTest.java +``` + +## Technology Stack + +- **Java 17** — minimum version +- **Spring Boot 3.2** — web framework +- **Spring Data JPA** — database access (replaces embedded SQL/ODBC) +- **PostgreSQL** — database (same as COBOL original) +- **Flyway** — database migrations +- **Jackson** — JSON/XML serialization (replaces libjson-c and libxml2) +- **Apache Commons Lang** — utility functions +- **JUnit 5 + Mockito** — testing +- **Testcontainers** — PostgreSQL integration tests diff --git a/cobol-migration/pom.xml b/cobol-migration/pom.xml new file mode 100644 index 0000000..96480af --- /dev/null +++ b/cobol-migration/pom.xml @@ -0,0 +1,112 @@ + + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 3.2.5 + + + + com.example + cobol-migration + 1.0.0-SNAPSHOT + cobol-migration + Spring Boot application replacing COBOL programs from COBOL-Examples repository + + + 17 + + + + + + org.springframework.boot + spring-boot-starter-web + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + + org.springframework.boot + spring-boot-starter-validation + + + + + org.postgresql + postgresql + runtime + + + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + + + + + jakarta.xml.bind + jakarta.xml.bind-api + + + + + org.flywaydb + flyway-core + + + + + org.apache.commons + commons-lang3 + + + + + org.springframework.boot + spring-boot-starter-test + test + + + + + org.testcontainers + postgresql + 1.19.7 + test + + + org.testcontainers + junit-jupiter + 1.19.7 + test + + + + + com.h2database + h2 + test + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + + diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/CobolMigrationApplication.java b/cobol-migration/src/main/java/com/example/cobolmigration/CobolMigrationApplication.java new file mode 100644 index 0000000..ad68318 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/CobolMigrationApplication.java @@ -0,0 +1,12 @@ +package com.example.cobolmigration; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class CobolMigrationApplication { + + public static void main(String[] args) { + SpringApplication.run(CobolMigrationApplication.class, args); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/config/AppConfig.java b/cobol-migration/src/main/java/com/example/cobolmigration/config/AppConfig.java new file mode 100644 index 0000000..ab2ab72 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/config/AppConfig.java @@ -0,0 +1,63 @@ +package com.example.cobolmigration.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.http.MediaType; +import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +/** + * Application configuration. + * + * Subprogram Pattern (replaces sub_program/main_app.cbl and sub_program/sub.cbl): + * --------------------------------------------------------------------------------- + * The COBOL subprogram demonstrates call-by-content vs call-by-reference: + * + * CALL "sub-app" USING BY CONTENT ws-item-1 BY CONTENT ws-item-2 + * -> The sub-program receives copies of the values. Changes in the sub-program + * do NOT affect the caller's variables. + * + * CALL "sub-app" USING ws-item-1 ws-item-2 (default is BY REFERENCE) + * -> The sub-program can modify the caller's variables directly. + * + * In Java, this maps naturally to the service layer pattern: + * + * - Passing immutable objects (String, Integer, records) = by-content equivalent. + * The service receives a copy; the caller's value is unaffected. + * + * - Passing mutable objects (DTOs, lists) or returning modified values = by-reference equivalent. + * The service can modify the object's state, visible to the caller. + * + * - CANCEL "sub-app" (resetting WORKING-STORAGE) has no direct equivalent in Java; + * the closest pattern is creating a new service instance or resetting its state. + * With Spring's default singleton scope, services maintain state across calls + * (like WORKING-STORAGE), while method parameters behave like LOCAL-STORAGE + * (fresh on each invocation). + * + * Terminal UI Programs — Conversion Notes: + * ----------------------------------------- + * The following COBOL programs are terminal/screen-mode specific: + * - accept/accept.cbl: Screen mode input. Validation concepts (upper-case conversion) + * are implemented via request validation in controllers (e.g., @Valid, custom validators). + * - accept/accept_from.cbl: Environment variables and dates are accessed via Spring's + * @Value annotation, Environment bean, and java.time APIs. + * - screen_size/get_screen_size.cbl: Terminal dimensions — not applicable to web; dropped. + * - display_test/display-test.cbl: Positioned display with colors — not applicable; dropped. + * - mouse/mouse_example.cbl: Mouse paint program — not applicable; dropped. + * - display_timing/display_timing.cbl: Screen write benchmarking — not applicable; dropped. + * - read_command_args/: Command-line args — replaced by Spring Boot's ApplicationArguments. + * - comp_test/comp_test.cbl: COMP to display — Java handles numeric types natively. + */ +@Configuration +public class AppConfig implements WebMvcConfigurer { + + /** + * Configure content negotiation to default to JSON. + * Without this, jackson-dataformat-xml on the classpath causes Spring + * to prefer XML serialization for all endpoints. + */ + @Override + public void configureContentNegotiation(ContentNegotiationConfigurer configurer) { + configurer.defaultContentType(MediaType.APPLICATION_JSON); + } + +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/controller/AccountController.java b/cobol-migration/src/main/java/com/example/cobolmigration/controller/AccountController.java new file mode 100644 index 0000000..ed4ec4b --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/controller/AccountController.java @@ -0,0 +1,56 @@ +package com.example.cobolmigration.controller; + +import com.example.cobolmigration.model.Account; +import com.example.cobolmigration.service.AccountService; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * REST API replacing the terminal menu in sql/sql_example.cbl (lines 158-185). + * + * Menu options: + * 1) Display all accounts -> GET /api/accounts + * 2) Display disabled accounts -> GET /api/accounts/disabled + * 3) Query accounts -> GET /api/accounts/search?q={searchTerm} + */ +@RestController +@RequestMapping("/api/accounts") +public class AccountController { + + private final AccountService accountService; + + public AccountController(AccountService accountService) { + this.accountService = accountService; + } + + /** + * Replaces menu option 1 — "Display all accounts" (display-all-accounts paragraph). + */ + @GetMapping + public ResponseEntity> getAllAccounts() { + return ResponseEntity.ok(accountService.getAllAccounts()); + } + + /** + * Replaces menu option 2 — "Display disabled accounts" (display-disabled-accounts paragraph). + */ + @GetMapping("/disabled") + public ResponseEntity> getDisabledAccounts() { + return ResponseEntity.ok(accountService.getDisabledAccounts()); + } + + /** + * Replaces menu option 3 — "Query accounts" (query-accounts paragraph). + * The COBOL code wraps the search term with '%' wildcards and does LIKE matching + * across first_name, last_name, phone, address (sql/sql_example.cbl lines 334-336). + */ + @GetMapping("/search") + public ResponseEntity> searchAccounts(@RequestParam("q") String searchTerm) { + return ResponseEntity.ok(accountService.searchAccounts(searchTerm)); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/controller/CustomerFileController.java b/cobol-migration/src/main/java/com/example/cobolmigration/controller/CustomerFileController.java new file mode 100644 index 0000000..aec9e1f --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/controller/CustomerFileController.java @@ -0,0 +1,54 @@ +package com.example.cobolmigration.controller; + +import com.example.cobolmigration.model.CustomerFileRecord; +import com.example.cobolmigration.service.CustomerFileService; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; +import java.util.Map; + +/** + * REST endpoints replacing merge_sort/merge_sort_test.cbl. + */ +@RestController +@RequestMapping("/api/customers") +public class CustomerFileController { + + private final CustomerFileService customerFileService; + + public CustomerFileController(CustomerFileService customerFileService) { + this.customerFileService = customerFileService; + } + + /** + * Accepts two customer lists (east and west), returns merged+sorted result. + * Replaces the merge-and-display-files paragraph. + */ + @PostMapping("/merge-sort") + public ResponseEntity> mergeAndSort( + @RequestBody MergeSortRequest request) { + return ResponseEntity.ok( + customerFileService.mergeAndSort(request.eastCustomers(), request.westCustomers()) + ); + } + + /** + * Runs the full demo: create test data, merge, sort — returns results. + * Replaces the main-procedure flow (create-test-data, merge-and-display-files, + * sort-and-display-file). + */ + @GetMapping("/demo") + public ResponseEntity>> runDemo() { + return ResponseEntity.ok(customerFileService.runDemo()); + } + + public record MergeSortRequest( + List eastCustomers, + List westCustomers + ) {} +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/controller/ReportController.java b/cobol-migration/src/main/java/com/example/cobolmigration/controller/ReportController.java new file mode 100644 index 0000000..81ee19b --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/controller/ReportController.java @@ -0,0 +1,35 @@ +package com.example.cobolmigration.controller; + +import com.example.cobolmigration.model.StudentRecord; +import com.example.cobolmigration.service.ReportService; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * REST endpoint replacing report_writer/report_test.cbl. + */ +@RestController +@RequestMapping("/api/reports") +public class ReportController { + + private final ReportService reportService; + + public ReportController(ReportService reportService) { + this.reportService = reportService; + } + + /** + * Accepts student records and returns a formatted text report. + * Replaces the COBOL report writer flow. + */ + @PostMapping(value = "/student", produces = MediaType.TEXT_PLAIN_VALUE) + public ResponseEntity generateStudentReport(@RequestBody List records) { + return ResponseEntity.ok(reportService.generateReport(records)); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/controller/SerializationController.java b/cobol-migration/src/main/java/com/example/cobolmigration/controller/SerializationController.java new file mode 100644 index 0000000..3fd8b67 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/controller/SerializationController.java @@ -0,0 +1,53 @@ +package com.example.cobolmigration.controller; + +import com.example.cobolmigration.model.SerializableRecord; +import com.example.cobolmigration.service.SerializationService; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +/** + * REST endpoints replacing json_generate/json_generate.cbl and xml_generate/xml_generate.cbl. + */ +@RestController +@RequestMapping("/api/serialize") +public class SerializationController { + + private final SerializationService serializationService; + private final XmlMapper xmlMapper; + + public SerializationController(SerializationService serializationService) { + this.serializationService = serializationService; + this.xmlMapper = new XmlMapper(); + } + + /** + * Returns JSON — replaces json_generate.cbl. + * JSON GENERATE ws-json-output FROM ws-record. + */ + @GetMapping(value = "/json", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getJson() { + return ResponseEntity.ok(serializationService.getDefaultRecord()); + } + + /** + * Returns XML with declaration — replaces xml_generate.cbl. + * XML GENERATE ws-xml-output FROM ws-record WITH XML-DECLARATION. + * + * The COBOL XML output includes: + * - XML declaration (WITH XML-DECLARATION) + * - 'enabled' as an attribute (TYPE OF ws-record-flag IS ATTRIBUTE) + * - Blank fields suppressed (SUPPRESS WHEN SPACES) + */ + @GetMapping(value = "/xml", produces = MediaType.APPLICATION_XML_VALUE) + public ResponseEntity getXml() throws JsonProcessingException { + SerializableRecord record = serializationService.getDefaultRecord(); + String xmlContent = xmlMapper.writeValueAsString(record); + String xmlWithDeclaration = "" + xmlContent; + return ResponseEntity.ok(xmlWithDeclaration); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/Account.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/Account.java new file mode 100644 index 0000000..49a0ab0 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/Account.java @@ -0,0 +1,121 @@ +package com.example.cobolmigration.model; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import java.time.LocalDateTime; + +/** + * JPA entity mapping the {@code accounts} table from {@code sql/create_test_db.sql}. + * Replaces the COBOL ws-sql-account-record / ws-account-record structures + * defined in sql/sql_example.cbl (lines 44-89). + */ +@Entity +@Table(name = "accounts") +public class Account { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + @Column(name = "first_name", nullable = false) + private String firstName; + + @Column(name = "last_name", nullable = false) + private String lastName; + + @Column(nullable = false) + private String phone; + + @Column(nullable = false) + private String address; + + @Column(name = "is_enabled", nullable = false, length = 1) + private String isEnabled; + + @Column(name = "create_dt") + private LocalDateTime createDt; + + @Column(name = "mod_dt") + private LocalDateTime modDt; + + public Account() { + } + + public Account(String firstName, String lastName, String phone, String address, String isEnabled) { + this.firstName = firstName; + this.lastName = lastName; + this.phone = phone; + this.address = address; + this.isEnabled = isEnabled; + this.createDt = LocalDateTime.now(); + this.modDt = LocalDateTime.now(); + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getPhone() { + return phone; + } + + public void setPhone(String phone) { + this.phone = phone; + } + + public String getAddress() { + return address; + } + + public void setAddress(String address) { + this.address = address; + } + + public String getIsEnabled() { + return isEnabled; + } + + public void setIsEnabled(String isEnabled) { + this.isEnabled = isEnabled; + } + + public LocalDateTime getCreateDt() { + return createDt; + } + + public void setCreateDt(LocalDateTime createDt) { + this.createDt = createDt; + } + + public LocalDateTime getModDt() { + return modDt; + } + + public void setModDt(LocalDateTime modDt) { + this.modDt = modDt; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/CorpCustomer.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/CorpCustomer.java new file mode 100644 index 0000000..56ae976 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/CorpCustomer.java @@ -0,0 +1,28 @@ +package com.example.cobolmigration.model; + +/** + * Corporate customer — corresponds to the COBOL REDEFINES layout + * (redefines/redefines.cbl line 26) where ws-corp-name redefines ws-customer-name pic x(30). + * When ws-customer-type is 2 (CORP), the same memory is read as a single corp name. + */ +public class CorpCustomer extends Customer { + + private String corpName; + + public CorpCustomer() { + setCustomerType(CustomerType.CORP); + } + + public CorpCustomer(String corpName, String streetAddress, String state, String zipCode) { + super(CustomerType.CORP, streetAddress, state, zipCode); + this.corpName = corpName; + } + + public String getCorpName() { + return corpName; + } + + public void setCorpName(String corpName) { + this.corpName = corpName; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/Customer.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/Customer.java new file mode 100644 index 0000000..d61049f --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/Customer.java @@ -0,0 +1,71 @@ +package com.example.cobolmigration.model; + +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonTypeInfo; + +/** + * Abstract base class modeling the COBOL REDEFINES pattern from redefines/redefines.cbl (lines 17-31). + * + * In COBOL, a single memory layout (ws-customer) can be interpreted as either a person + * (first_name + last_name) or a corporation (corp_name) via the REDEFINES keyword. + * In Java, this is modeled with inheritance: PersonCustomer and CorpCustomer extend this base. + */ +@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "customerType") +@JsonSubTypes({ + @JsonSubTypes.Type(value = PersonCustomer.class, name = "PERSON"), + @JsonSubTypes.Type(value = CorpCustomer.class, name = "CORP") +}) +public abstract class Customer { + + public enum CustomerType { + PERSON, + CORP + } + + private CustomerType customerType; + private String streetAddress; + private String state; + private String zipCode; + + protected Customer() { + } + + protected Customer(CustomerType customerType, String streetAddress, String state, String zipCode) { + this.customerType = customerType; + this.streetAddress = streetAddress; + this.state = state; + this.zipCode = zipCode; + } + + public CustomerType getCustomerType() { + return customerType; + } + + public void setCustomerType(CustomerType customerType) { + this.customerType = customerType; + } + + public String getStreetAddress() { + return streetAddress; + } + + public void setStreetAddress(String streetAddress) { + this.streetAddress = streetAddress; + } + + public String getState() { + return state; + } + + public void setState(String state) { + this.state = state; + } + + public String getZipCode() { + return zipCode; + } + + public void setZipCode(String zipCode) { + this.zipCode = zipCode; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/CustomerFileRecord.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/CustomerFileRecord.java new file mode 100644 index 0000000..9b14cea --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/CustomerFileRecord.java @@ -0,0 +1,71 @@ +package com.example.cobolmigration.model; + +/** + * File-based customer model (not JPA) matching the COBOL record at + * merge_sort/merge_sort_test.cbl (lines 41-45): + * f-customer-id pic 9(5) + * f-customer-last-name pic x(50) + * f-customer-first-name pic x(50) + * f-customer-contract-id pic 9(5) + * f-customer-comment pic x(25) + */ +public class CustomerFileRecord { + + private int customerId; + private String lastName; + private String firstName; + private int contractId; + private String comment; + + public CustomerFileRecord() { + } + + public CustomerFileRecord(int customerId, String lastName, String firstName, + int contractId, String comment) { + this.customerId = customerId; + this.lastName = lastName; + this.firstName = firstName; + this.contractId = contractId; + this.comment = comment; + } + + public int getCustomerId() { + return customerId; + } + + public void setCustomerId(int customerId) { + this.customerId = customerId; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getContractId() { + return contractId; + } + + public void setContractId(int contractId) { + this.contractId = contractId; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/PersonCustomer.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/PersonCustomer.java new file mode 100644 index 0000000..3fee818 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/PersonCustomer.java @@ -0,0 +1,39 @@ +package com.example.cobolmigration.model; + +/** + * Person customer — corresponds to the COBOL ws-customer-name layout + * (redefines/redefines.cbl lines 23-25) when ws-customer-type is 1 (PERSON). + * Fields: ws-customer-first-name pic x(10), ws-customer-last-name pic x(20). + */ +public class PersonCustomer extends Customer { + + private String firstName; + private String lastName; + + public PersonCustomer() { + setCustomerType(CustomerType.PERSON); + } + + public PersonCustomer(String firstName, String lastName, + String streetAddress, String state, String zipCode) { + super(CustomerType.PERSON, streetAddress, state, zipCode); + this.firstName = firstName; + this.lastName = lastName; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/SerializableRecord.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/SerializableRecord.java new file mode 100644 index 0000000..c1045b1 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/SerializableRecord.java @@ -0,0 +1,69 @@ +package com.example.cobolmigration.model; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; + +/** + * POJO matching the COBOL ws-record structure from json_generate/json_generate.cbl (lines 27-33) + * and xml_generate/xml_generate.cbl (lines 26-32). + * + * COBOL fields: + * ws-record-name pic x(10) + * ws-record-value pic x(10) + * ws-record-blank pic x(10) — suppressed when spaces in XML (xml_generate.cbl line 50) + * ws-record-flag pic x(5) — "enabled" attribute in XML (xml_generate.cbl line 49) + * + * In XML output, 'enabled' is rendered as an attribute (type of ws-record-flag is attribute), + * and blank fields are suppressed (suppress when spaces). + */ +@JacksonXmlRootElement(localName = "ws-record") +@JsonInclude(JsonInclude.Include.NON_EMPTY) +public class SerializableRecord { + + @JsonProperty("name") + @JacksonXmlProperty(localName = "name") + private String name; + + @JsonProperty("value") + @JacksonXmlProperty(localName = "value") + private String value; + + @JsonProperty("enabled") + @JacksonXmlProperty(isAttribute = true, localName = "enabled") + private boolean enabled; + + public SerializableRecord() { + } + + public SerializableRecord(String name, String value, boolean enabled) { + this.name = name; + this.value = value; + this.enabled = enabled; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/model/StudentRecord.java b/cobol-migration/src/main/java/com/example/cobolmigration/model/StudentRecord.java new file mode 100644 index 0000000..797c891 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/model/StudentRecord.java @@ -0,0 +1,56 @@ +package com.example.cobolmigration.model; + +/** + * Corresponds to the COBOL report input record from report_writer/report_test.cbl (lines 24-28): + * f-test-student-id pic 9(6), f-test-student-name pic x(20), + * f-test-major pic xxx, f-test-num-courses pic 99. + */ +public class StudentRecord { + + private int studentId; + private String studentName; + private String major; + private int numCourses; + + public StudentRecord() { + } + + public StudentRecord(int studentId, String studentName, String major, int numCourses) { + this.studentId = studentId; + this.studentName = studentName; + this.major = major; + this.numCourses = numCourses; + } + + public int getStudentId() { + return studentId; + } + + public void setStudentId(int studentId) { + this.studentId = studentId; + } + + public String getStudentName() { + return studentName; + } + + public void setStudentName(String studentName) { + this.studentName = studentName; + } + + public String getMajor() { + return major; + } + + public void setMajor(String major) { + this.major = major; + } + + public int getNumCourses() { + return numCourses; + } + + public void setNumCourses(int numCourses) { + this.numCourses = numCourses; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/repository/AccountRepository.java b/cobol-migration/src/main/java/com/example/cobolmigration/repository/AccountRepository.java new file mode 100644 index 0000000..1405a9c --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/repository/AccountRepository.java @@ -0,0 +1,42 @@ +package com.example.cobolmigration.repository; + +import com.example.cobolmigration.model.Account; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import java.util.List; + +/** + * Spring Data JPA repository replacing the embedded SQL cursors from sql/sql_example.cbl. + */ +@Repository +public interface AccountRepository extends JpaRepository { + + /** + * Replaces ACCOUNT-ALL-CUR cursor (sql/sql_example.cbl lines 119-124): + * SELECT ID, FIRST_NAME, LAST_NAME, PHONE, ADDRESS, IS_ENABLED, CREATE_DT, MOD_DT + * FROM ACCOUNTS ORDER BY ID + */ + List findAllByOrderByIdAsc(); + + /** + * Replaces ACCOUNT-DISABLED-CUR cursor (sql/sql_example.cbl lines 130-137): + * SELECT ... FROM ACCOUNTS WHERE IS_ENABLED = 'N' ORDER BY ID + */ + List findByIsEnabledOrderByIdAsc(String isEnabled); + + /** + * Replaces ACCOUNT-QUERY-CUR cursor (sql/sql_example.cbl lines 141-153): + * SELECT ... FROM ACCOUNTS WHERE FIRST_NAME LIKE :search OR LAST_NAME LIKE :search + * OR PHONE LIKE :search OR ADDRESS LIKE :search ORDER BY ID + */ + @Query("SELECT a FROM Account a WHERE " + + "a.firstName LIKE :searchTerm OR " + + "a.lastName LIKE :searchTerm OR " + + "a.phone LIKE :searchTerm OR " + + "a.address LIKE :searchTerm " + + "ORDER BY a.id ASC") + List searchAccounts(@Param("searchTerm") String searchTerm); +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/AccountService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/AccountService.java new file mode 100644 index 0000000..862f501 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/AccountService.java @@ -0,0 +1,51 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.Account; +import com.example.cobolmigration.repository.AccountRepository; +import org.springframework.stereotype.Service; + +import java.util.List; + +/** + * Business logic layer for account operations. + * Replaces the terminal menu logic from sql/sql_example.cbl (lines 158-185). + */ +@Service +public class AccountService { + + private final AccountRepository accountRepository; + + public AccountService(AccountRepository accountRepository) { + this.accountRepository = accountRepository; + } + + /** + * Replaces menu option 1 — display-all-accounts paragraph (sql/sql_example.cbl lines 201-246). + * Uses ACCOUNT-ALL-CUR cursor to fetch all accounts ordered by ID. + */ + public List getAllAccounts() { + return accountRepository.findAllByOrderByIdAsc(); + } + + /** + * Replaces menu option 2 — display-disabled-accounts paragraph (sql/sql_example.cbl lines 258-295). + * Uses ACCOUNT-DISABLED-CUR cursor to fetch accounts where IS_ENABLED = 'N'. + */ + public List getDisabledAccounts() { + return accountRepository.findByIsEnabledOrderByIdAsc("N"); + } + + /** + * Replaces menu option 3 — query-accounts paragraph (sql/sql_example.cbl lines 318-394). + * The COBOL code trims the search term and wraps it with '%' wildcards (lines 333-343), + * then uses LIKE matching across first_name, last_name, phone, and address. + * + * @param searchTerm the raw search input from the user + * @return accounts matching the search across all text fields + */ + public List searchAccounts(String searchTerm) { + String trimmed = searchTerm != null ? searchTerm.trim() : ""; + String wildcardTerm = "%" + trimmed + "%"; + return accountRepository.searchAccounts(wildcardTerm); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/CustomerFileService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/CustomerFileService.java new file mode 100644 index 0000000..0f14836 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/CustomerFileService.java @@ -0,0 +1,83 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.CustomerFileRecord; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Map; + +/** + * Replaces merge_sort/merge_sort_test.cbl. + * Provides merge and sort operations on customer file records. + */ +@Service +public class CustomerFileService { + + /** + * Replaces merge-and-display-files paragraph (merge_sort_test.cbl lines 103-134). + * Merges two lists (east + west customers) and sorts ascending by customerId, + * matching: merge fd-sorting-file on ascending key f-customer-id. + */ + public List mergeAndSort(List eastCustomers, + List westCustomers) { + List merged = new ArrayList<>(); + merged.addAll(eastCustomers); + merged.addAll(westCustomers); + merged.sort(Comparator.comparingInt(CustomerFileRecord::getCustomerId)); + return merged; + } + + /** + * Replaces sort-and-display-file paragraph (merge_sort_test.cbl lines 138-169). + * Sorts descending by contractId, matching: + * sort fd-sorting-file on descending key f-customer-contract-id. + */ + public List sortByContractIdDescending(List customers) { + List sorted = new ArrayList<>(customers); + sorted.sort(Comparator.comparingInt(CustomerFileRecord::getContractId).reversed()); + return sorted; + } + + /** + * Generates the test data matching the create-test-data paragraph + * (merge_sort_test.cbl lines 173-338). + * + * East customers (test-file-1): IDs 1, 5, 10, 50, 25, 75 + * West customers (test-file-2): IDs 999, 3, 30, 85, 24 + */ + public Map> generateTestData() { + List east = new ArrayList<>(); + east.add(new CustomerFileRecord(1, "last-1", "first-1", 5423, "comment-1")); + east.add(new CustomerFileRecord(5, "last-5", "first-5", 12323, "comment-5")); + east.add(new CustomerFileRecord(10, "last-10", "first-10", 653, "comment-10")); + east.add(new CustomerFileRecord(50, "last-50", "first-50", 5050, "comment-50")); + east.add(new CustomerFileRecord(25, "last-25", "first-25", 7725, "comment-25")); + east.add(new CustomerFileRecord(75, "last-75", "first-75", 1175, "comment-75")); + + List west = new ArrayList<>(); + west.add(new CustomerFileRecord(999, "last-999", "first-999", 1610, "comment-99")); + west.add(new CustomerFileRecord(3, "last-03", "first-03", 3331, "comment-03")); + west.add(new CustomerFileRecord(30, "last-30", "first-30", 8765, "comment-30")); + west.add(new CustomerFileRecord(85, "last-85", "first-85", 4567, "comment-85")); + west.add(new CustomerFileRecord(24, "last-24", "first-24", 247, "comment-24")); + + return Map.of("east", east, "west", west); + } + + /** + * Runs the full demo: creates test data, merges, then sorts by contract ID descending. + * This replicates the main-procedure flow of merge_sort_test.cbl (lines 91-100). + */ + public Map> runDemo() { + Map> testData = generateTestData(); + List merged = mergeAndSort(testData.get("east"), testData.get("west")); + List sortedByContract = sortByContractIdDescending(merged); + + return Map.of( + "mergedByCustomerId", merged, + "sortedByContractIdDesc", sortedByContract + ); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/ReportService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/ReportService.java new file mode 100644 index 0000000..edfb3b3 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/ReportService.java @@ -0,0 +1,81 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.StudentRecord; +import org.springframework.stereotype.Service; + +import java.util.List; + +/** + * Replaces report_writer/report_test.cbl. + * Generates a formatted text report matching the COBOL report layout: + * - Header: "Customer Order Report" (line 50) + * - Page numbers (lines 53-57) + * - Detail lines with student data (lines 59-63) + * - Page limit of 66 lines, first detail at line 6, last detail at line 42 + */ +@Service +public class ReportService { + + private static final int PAGE_LIMIT = 66; + private static final int FIRST_DETAIL_LINE = 6; + private static final int LAST_DETAIL_LINE = 42; + private static final int DETAILS_PER_PAGE = LAST_DETAIL_LINE - FIRST_DETAIL_LINE + 1; + + /** + * Generates a formatted text report from student records. + * Matches the COBOL report writer output format from report_test.cbl. + */ + public String generateReport(List records) { + StringBuilder report = new StringBuilder(); + int pageNumber = 1; + int detailLineCount = 0; + + appendHeader(report, pageNumber); + + for (StudentRecord record : records) { + if (detailLineCount >= DETAILS_PER_PAGE) { + appendPageBreak(report); + pageNumber++; + detailLineCount = 0; + appendHeader(report, pageNumber); + } + + appendDetailLine(report, record); + detailLineCount++; + } + + return report.toString(); + } + + private void appendHeader(StringBuilder report, int pageNumber) { + // Header at line 1, column 44: "Customer Order Report" + report.append(String.format("%43s%-21s", "", "Customer Order Report")); + // Page number at column 100 + report.append(String.format("%35sPAGE %3d", "", pageNumber)); + report.append(System.lineSeparator()); + report.append(System.lineSeparator()); + // Blank lines until first detail line (lines 2-5) + report.append(String.format(" %-6s %-20s %-3s %-2s", + "ID", "Name", "Mjr", "NC")); + report.append(System.lineSeparator()); + report.append(" ------ -------------------- --- --"); + report.append(System.lineSeparator()); + } + + private void appendDetailLine(StringBuilder report, StudentRecord record) { + // Columns from COBOL: col 4=id(6), col 15=name(20), col 40=major(3), col 46=courses(2) + report.append(String.format(" %06d %-20s %-3s %02d", + record.getStudentId(), + record.getStudentName(), + record.getMajor(), + record.getNumCourses())); + report.append(System.lineSeparator()); + } + + private void appendPageBreak(StringBuilder report) { + report.append(System.lineSeparator()); + report.append("--- Page Break ---"); + report.append(System.lineSeparator()); + report.append(System.lineSeparator()); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/SearchDemoService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/SearchDemoService.java new file mode 100644 index 0000000..29b5e9b --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/SearchDemoService.java @@ -0,0 +1,117 @@ +package com.example.cobolmigration.service; + +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Replaces search/search.cbl — demonstrates binary search (SEARCH ALL) and + * sequential search (SEARCH) on in-memory tables. + * + * COBOL context: + * - SEARCH ALL (line 61): binary search on a sorted, keyed table (ascending ws-item-id-1) + * - SEARCH (line 100): sequential/linear search on an unkeyed table (ws-no-key-item-table) + * + * Java equivalents: + * - Collections.binarySearch() for the keyed table + * - Stream.filter() for the sequential search + */ +@Service +public class SearchDemoService { + + /** + * Represents a keyed item from the COBOL ws-item-table (search.cbl lines 17-32). + */ + public record KeyedItem(int id1, int id2, int id3, String name, String date) {} + + /** + * Represents an unkeyed item from the COBOL ws-no-key-item-table (search.cbl lines 37-39). + */ + public record UnkeyedItem(int id, String value) {} + + /** + * Sets up the test data matching search.cbl setup-test-data paragraph (lines 127-156). + */ + public Map getTestData() { + List keyedItems = new ArrayList<>(); + keyedItems.add(new KeyedItem(1, 101, 500, "test item 1", "2021/01/01")); + keyedItems.add(new KeyedItem(2, 102, 499, "test item 2", "2021/02/02")); + keyedItems.add(new KeyedItem(3, 103, 498, "test item 3", "2021/03/03")); + + List unkeyedItems = new ArrayList<>(); + unkeyedItems.add(new UnkeyedItem(2, "Value of id 2.")); + unkeyedItems.add(new UnkeyedItem(3, "Value of id 3.")); + unkeyedItems.add(new UnkeyedItem(1, "Value of id 1.")); + + Map data = new LinkedHashMap<>(); + data.put("keyedItems", keyedItems); + data.put("unkeyedItems", unkeyedItems); + return data; + } + + /** + * Binary search by id1 — replaces SEARCH ALL ws-item-table (search.cbl lines 61-66). + * The keyed table must be sorted ascending by id1 for binary search. + * + * Uses Collections.binarySearch() as the Java equivalent of COBOL's SEARCH ALL. + */ + @SuppressWarnings("unchecked") + public Map binarySearchById1(int searchId) { + Map testData = getTestData(); + List items = (List) testData.get("keyedItems"); + + // Items are already sorted by id1 (ascending) — required for binary search + int index = Collections.binarySearch( + items, + new KeyedItem(searchId, 0, 0, "", ""), + Comparator.comparingInt(KeyedItem::id1) + ); + + Map result = new LinkedHashMap<>(); + if (index >= 0) { + KeyedItem found = items.get(index); + result.put("found", true); + result.put("item", found); + result.put("searchMethod", "binary (SEARCH ALL equivalent)"); + } else { + result.put("found", false); + result.put("message", "Item not found."); + result.put("searchMethod", "binary (SEARCH ALL equivalent)"); + } + return result; + } + + /** + * Sequential search by id — replaces SEARCH ws-no-key-item-table (search.cbl lines 100-109). + * Sequential search does not require sorted data. + * + * Uses Stream.filter() as the Java equivalent of COBOL's SEARCH (sequential). + */ + @SuppressWarnings("unchecked") + public Map sequentialSearchById(int searchId) { + Map testData = getTestData(); + List items = (List) testData.get("unkeyedItems"); + + Optional found = items.stream() + .filter(item -> item.id() == searchId) + .findFirst(); + + Map result = new LinkedHashMap<>(); + if (found.isPresent()) { + result.put("found", true); + result.put("item", found.get()); + result.put("searchMethod", "sequential (SEARCH equivalent)"); + } else { + result.put("found", false); + result.put("message", "Item not found."); + result.put("searchMethod", "sequential (SEARCH equivalent)"); + } + return result; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/SerializationService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/SerializationService.java new file mode 100644 index 0000000..44e1844 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/SerializationService.java @@ -0,0 +1,25 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.SerializableRecord; +import org.springframework.stereotype.Service; + +/** + * Service for serialization operations. + * Replaces json_generate/json_generate.cbl and xml_generate/xml_generate.cbl. + * + * The COBOL programs create a ws-record with name="Test Name", value="Test Value", + * enabled=true (flag), and generate JSON/XML output from it. + */ +@Service +public class SerializationService { + + /** + * Creates the default record matching the COBOL test data: + * move "Test Name" to ws-record-name (json_generate.cbl line 38) + * move "Test Value" to ws-record-value (json_generate.cbl line 39) + * set ws-record-flag-enabled to true (json_generate.cbl line 40) + */ + public SerializableRecord getDefaultRecord() { + return new SerializableRecord("Test Name", "Test Value", true); + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/StringUtilService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/StringUtilService.java new file mode 100644 index 0000000..e711055 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/StringUtilService.java @@ -0,0 +1,147 @@ +package com.example.cobolmigration.service; + +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Replaces trim/trim.cbl and unstring/unstring.cbl. + * + * trim.cbl demonstrates FUNCTION TRIM with leading, trailing, and full trim. + * unstring.cbl demonstrates UNSTRING with various delimiter configurations. + */ +@Service +public class StringUtilService { + + /** + * Returns a map with "full", "leading", "trailing" trim results. + * Matches trim.cbl lines 22-25: + * FUNCTION TRIM(ws-test-string-1) — full trim + * FUNCTION TRIM(ws-test-string-1 LEADING) — trim leading spaces only + * FUNCTION TRIM(ws-test-string-1 TRAILING) — trim trailing spaces only + */ + public Map trimVariants(String input) { + Map results = new LinkedHashMap<>(); + if (input == null) { + results.put("full", null); + results.put("leading", null); + results.put("trailing", null); + return results; + } + results.put("full", input.strip()); + results.put("leading", input.stripLeading()); + results.put("trailing", input.stripTrailing()); + return results; + } + + /** + * Replaces basic UNSTRING (unstring.cbl Example 1, lines 58-61): + * UNSTRING ws-source-str DELIMITED BY SPACE INTO ws-part-1 ws-part-2 + */ + public List splitByDelimiter(String source, String delimiter) { + if (source == null || delimiter == null) { + return List.of(); + } + String[] parts = source.split(Pattern.quote(delimiter), -1); + List result = new ArrayList<>(); + for (String part : parts) { + result.add(part); + } + return result; + } + + /** + * Replaces the multi-delimiter UNSTRING examples (unstring.cbl Examples 4-5, lines 155-163). + * Returns split parts with delimiter info and character counts, matching the COBOL + * DELIMITER IN, COUNT IN, and TALLYING IN behavior. + * + * Each result entry contains: "value", "delimiter", "charCount". + */ + public Map splitByMultipleDelimiters(String source, List delimiters) { + List> parts = new ArrayList<>(); + + if (source == null || delimiters == null || delimiters.isEmpty()) { + Map result = new LinkedHashMap<>(); + result.put("parts", parts); + result.put("fieldsFilled", 0); + return result; + } + + // Build regex pattern that alternates between all delimiters + StringBuilder patternBuilder = new StringBuilder(); + for (int i = 0; i < delimiters.size(); i++) { + if (i > 0) { + patternBuilder.append("|"); + } + patternBuilder.append("(").append(Pattern.quote(delimiters.get(i))).append(")"); + } + + Pattern pattern = Pattern.compile(patternBuilder.toString()); + Matcher matcher = pattern.matcher(source); + + int lastEnd = 0; + while (matcher.find()) { + String value = source.substring(lastEnd, matcher.start()); + String delimiter = matcher.group(); + + Map partInfo = new LinkedHashMap<>(); + partInfo.put("value", value); + partInfo.put("delimiter", delimiter); + partInfo.put("charCount", value.length()); + parts.add(partInfo); + + lastEnd = matcher.end(); + } + + // Add the remaining part after the last delimiter + if (lastEnd <= source.length()) { + String remaining = source.substring(lastEnd); + Map partInfo = new LinkedHashMap<>(); + partInfo.put("value", remaining); + partInfo.put("delimiter", ""); + partInfo.put("charCount", remaining.length()); + parts.add(partInfo); + } + + Map result = new LinkedHashMap<>(); + result.put("parts", parts); + result.put("fieldsFilled", parts.size()); + return result; + } + + /** + * Replaces Example 6 of unstring.cbl (lines 240-252). + * Parses a formatted currency string like "$123,456.12" by unstringng on ',' and '.' + * (skipping the leading '$'). + * + * COBOL: + * move 123456.12 to ws-source-num — formatted as $123,456.12 + * unstring ws-source-num(2:) — start at 2 to skip '$' + * delimited by ',' or '.' + * into ws-dest-num(1) ws-dest-num(2) ws-dest-num(3) + */ + public List splitFormattedNumber(String formattedNumber) { + if (formattedNumber == null || formattedNumber.isEmpty()) { + return List.of(); + } + + // Skip leading '$' if present (matching COBOL's ws-source-num(2:)) + String source = formattedNumber; + if (source.startsWith("$")) { + source = source.substring(1); + } + + // Split by ',' or '.' + String[] parts = source.split("[,.]", -1); + List result = new ArrayList<>(); + for (String part : parts) { + result.add(part); + } + return result; + } +} diff --git a/cobol-migration/src/main/java/com/example/cobolmigration/service/ValidationService.java b/cobol-migration/src/main/java/com/example/cobolmigration/service/ValidationService.java new file mode 100644 index 0000000..397c3b7 --- /dev/null +++ b/cobol-migration/src/main/java/com/example/cobolmigration/service/ValidationService.java @@ -0,0 +1,75 @@ +package com.example.cobolmigration.service; + +import org.apache.commons.lang3.math.NumberUtils; +import org.springframework.stereotype.Service; + +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Replaces is_numeric/is_numeric.cbl and numval_test/numval_test.cbl. + * + * The COBOL is_numeric program demonstrates three approaches to checking if a string is numeric: + * 1. Plain check — if ws-user-input IS NUMERIC (fails with trailing spaces) + * 2. Right-justify + zero-fill — INSPECT ... REPLACING LEADING SPACES BY '0' then IS NUMERIC + * 3. Trim then check — if FUNCTION TRIM(ws-user-input) IS NUMERIC + * + * The COBOL NUMVAL function (numval_test.cbl line 28) converts a PIC X string to a numeric value. + */ +@Service +public class ValidationService { + + /** + * Checks if the input string is numeric using three approaches, + * mirroring the COBOL is_numeric.cbl behavior. + * + * @param input the string to validate + * @return a map with results for each approach: "plain", "zeroFill", "trimmed" + */ + public Map isNumeric(String input) { + Map results = new LinkedHashMap<>(); + + // Approach 1: Plain check (COBOL lines 25-38) + // In COBOL, trailing spaces cause IS NUMERIC to fail for alphanumeric fields. + // Java equivalent: check the full string including spaces. + results.put("plain", input != null && input.matches("^[0-9]+$")); + + // Approach 2: Right-justify + zero-fill (COBOL lines 42-60) + // COBOL: JUSTIFIED RIGHT + INSPECT REPLACING LEADING SPACES BY '0' + if (input != null) { + String rightJustified = String.format("%10s", input.trim()); + String zeroFilled = rightJustified.replace(' ', '0'); + results.put("zeroFill", zeroFilled.matches("^[0-9]+$")); + } else { + results.put("zeroFill", false); + } + + // Approach 3: Trim then check (COBOL lines 64-77) + // COBOL: FUNCTION TRIM(ws-user-input) IS NUMERIC + results.put("trimmed", input != null && input.trim().matches("^[0-9]+$")); + + return results; + } + + /** + * Parses a numeric value from a string, replacing the COBOL NUMVAL function + * (numval_test.cbl line 28: FUNCTION NUMVAL(ws-x-val)). + * + * NUMVAL converts a PIC X string to a numeric value, handling leading/trailing spaces + * and optional sign characters. + * + * @param input the string to parse + * @return the parsed numeric value + * @throws NumberFormatException if the input is not a valid number + */ + public double parseNumericValue(String input) { + if (input == null || input.trim().isEmpty()) { + throw new NumberFormatException("Input is null or empty"); + } + String trimmed = input.trim(); + if (NumberUtils.isCreatable(trimmed)) { + return NumberUtils.createDouble(trimmed); + } + throw new NumberFormatException("Cannot parse numeric value from: " + input); + } +} diff --git a/cobol-migration/src/main/resources/application.properties b/cobol-migration/src/main/resources/application.properties new file mode 100644 index 0000000..4999d1b --- /dev/null +++ b/cobol-migration/src/main/resources/application.properties @@ -0,0 +1,5 @@ +spring.datasource.url=${DB_URL} +spring.datasource.username=${DB_USERNAME} +spring.datasource.password=${DB_PASSWORD} +spring.jpa.hibernate.ddl-auto=validate +spring.flyway.enabled=true diff --git a/cobol-migration/src/main/resources/db/migration/V1__create_accounts.sql b/cobol-migration/src/main/resources/db/migration/V1__create_accounts.sql new file mode 100644 index 0000000..7707341 --- /dev/null +++ b/cobol-migration/src/main/resources/db/migration/V1__create_accounts.sql @@ -0,0 +1,16 @@ +-- Adapted from sql/create_test_db.sql for Flyway migration +-- Removed \c command (Flyway connects to the target database directly) + +DROP TABLE IF EXISTS accounts; + +CREATE TABLE accounts ( + id bigserial not null, + first_name varchar not null, + last_name varchar not null, + phone varchar not null, + address varchar not null, + is_enabled varchar(1) not null default 'N', + create_dt timestamp default now(), + mod_dt timestamp default now(), + primary key (id) +); diff --git a/cobol-migration/src/main/resources/db/migration/V2__seed_data.sql b/cobol-migration/src/main/resources/db/migration/V2__seed_data.sql new file mode 100644 index 0000000..a08a78e --- /dev/null +++ b/cobol-migration/src/main/resources/db/migration/V2__seed_data.sql @@ -0,0 +1,35 @@ +-- Seed data ported from sql/create_test_db.sql (lines 22-53) +-- 11 test account records (John Tester through Richard Tester10) + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('John', 'Tester', '15555550100', '123 Fake St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Mike', 'Tester1', '15555550121', '122 Real St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Mary', 'Tester2', '15555550132', '121 ABC St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Jack', 'Tester3', '15555550143', '120 Rock St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Bob', 'Tester4', '15555550154', '119 Truck St, Nowhere', 'N', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Paula', 'Tester5', '1555550165', '118 Car St, Nowhere', 'N', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('James', 'Tester6', '1555550176', '117 Land St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Jane', 'Tester7', '1555550187', '116 Sea St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Bill', 'Tester8', '1555550198', '115 Dock St, Nowhere', 'N', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Lucy', 'Tester9', '1555550209', '114 Beach St, Nowhere', 'Y', now(), now()); + +INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt) +VALUES ('Richard', 'Tester10', '1555550210', '113 Water St, Nowhere', 'Y', now(), now()); diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/controller/AccountControllerTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/controller/AccountControllerTest.java new file mode 100644 index 0000000..d0e3afc --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/controller/AccountControllerTest.java @@ -0,0 +1,67 @@ +package com.example.cobolmigration.controller; + +import com.example.cobolmigration.model.Account; +import com.example.cobolmigration.service.AccountService; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.test.web.servlet.MockMvc; + +import java.util.List; + +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@WebMvcTest(AccountController.class) +class AccountControllerTest { + + @Autowired + private MockMvc mockMvc; + + @MockBean + private AccountService accountService; + + @Test + void getAllAccounts_shouldReturnAllAccounts() throws Exception { + Account account = new Account("John", "Tester", "15555550100", "123 Fake St, Nowhere", "Y"); + when(accountService.getAllAccounts()).thenReturn(List.of(account)); + + mockMvc.perform(get("/api/accounts")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].firstName").value("John")) + .andExpect(jsonPath("$[0].lastName").value("Tester")); + } + + @Test + void getDisabledAccounts_shouldReturnDisabledOnly() throws Exception { + Account disabled = new Account("Bob", "Tester4", "15555550154", "119 Truck St, Nowhere", "N"); + when(accountService.getDisabledAccounts()).thenReturn(List.of(disabled)); + + mockMvc.perform(get("/api/accounts/disabled")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].firstName").value("Bob")) + .andExpect(jsonPath("$[0].isEnabled").value("N")); + } + + @Test + void searchAccounts_shouldPassSearchTermToService() throws Exception { + Account account = new Account("John", "Tester", "15555550100", "123 Fake St, Nowhere", "Y"); + when(accountService.searchAccounts("John")).thenReturn(List.of(account)); + + mockMvc.perform(get("/api/accounts/search").param("q", "John")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].firstName").value("John")); + } + + @Test + void searchAccounts_shouldReturnEmptyListForNoMatches() throws Exception { + when(accountService.searchAccounts("nonexistent")).thenReturn(List.of()); + + mockMvc.perform(get("/api/accounts/search").param("q", "nonexistent")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.length()").value(0)); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/AccountServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/AccountServiceTest.java new file mode 100644 index 0000000..5289978 --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/AccountServiceTest.java @@ -0,0 +1,79 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.Account; +import com.example.cobolmigration.repository.AccountRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class AccountServiceTest { + + @Mock + private AccountRepository accountRepository; + + @InjectMocks + private AccountService accountService; + + private Account testAccount; + + @BeforeEach + void setUp() { + testAccount = new Account("John", "Tester", "15555550100", "123 Fake St, Nowhere", "Y"); + } + + @Test + void getAllAccounts_shouldCallRepositoryAndReturnResults() { + when(accountRepository.findAllByOrderByIdAsc()).thenReturn(List.of(testAccount)); + List result = accountService.getAllAccounts(); + assertEquals(1, result.size()); + assertEquals("John", result.get(0).getFirstName()); + verify(accountRepository).findAllByOrderByIdAsc(); + } + + @Test + void getDisabledAccounts_shouldCallRepositoryWithN() { + Account disabled = new Account("Bob", "Tester4", "15555550154", "119 Truck St, Nowhere", "N"); + when(accountRepository.findByIsEnabledOrderByIdAsc("N")).thenReturn(List.of(disabled)); + List result = accountService.getDisabledAccounts(); + assertEquals(1, result.size()); + assertEquals("N", result.get(0).getIsEnabled()); + verify(accountRepository).findByIsEnabledOrderByIdAsc("N"); + } + + @Test + void searchAccounts_shouldTrimAndWrapWithWildcards() { + // Matching COBOL behavior: trim the input and wrap with '%' wildcards + // (sql/sql_example.cbl lines 333-343) + when(accountRepository.searchAccounts("%John%")).thenReturn(List.of(testAccount)); + List result = accountService.searchAccounts(" John "); + assertEquals(1, result.size()); + verify(accountRepository).searchAccounts("%John%"); + } + + @Test + void searchAccounts_shouldHandleNullInput() { + when(accountRepository.searchAccounts("%%")).thenReturn(List.of()); + List result = accountService.searchAccounts(null); + assertEquals(0, result.size()); + verify(accountRepository).searchAccounts("%%"); + } + + @Test + void searchAccounts_shouldHandleEmptyInput() { + when(accountRepository.searchAccounts("%%")).thenReturn(List.of()); + List result = accountService.searchAccounts(""); + assertEquals(0, result.size()); + verify(accountRepository).searchAccounts("%%"); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/CustomerFileServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/CustomerFileServiceTest.java new file mode 100644 index 0000000..66e0f6a --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/CustomerFileServiceTest.java @@ -0,0 +1,113 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.CustomerFileRecord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * Tests merge and sort with the same test data from merge_sort/merge_sort_test.cbl. + */ +class CustomerFileServiceTest { + + private CustomerFileService service; + + @BeforeEach + void setUp() { + service = new CustomerFileService(); + } + + @Test + void generateTestData_shouldCreateEastAndWestCustomerLists() { + Map> data = service.generateTestData(); + assertEquals(6, data.get("east").size()); + assertEquals(5, data.get("west").size()); + } + + @Test + void generateTestData_eastCustomersMatchCobolData() { + // From merge_sort_test.cbl create-test-data (lines 185-259) + Map> data = service.generateTestData(); + List east = data.get("east"); + + assertEquals(1, east.get(0).getCustomerId()); + assertEquals("last-1", east.get(0).getLastName()); + assertEquals("first-1", east.get(0).getFirstName()); + assertEquals(5423, east.get(0).getContractId()); + + assertEquals(75, east.get(5).getCustomerId()); + assertEquals(1175, east.get(5).getContractId()); + } + + @Test + void generateTestData_westCustomersMatchCobolData() { + // From merge_sort_test.cbl create-test-data (lines 272-333) + Map> data = service.generateTestData(); + List west = data.get("west"); + + assertEquals(999, west.get(0).getCustomerId()); + assertEquals(1610, west.get(0).getContractId()); + + assertEquals(24, west.get(4).getCustomerId()); + assertEquals(247, west.get(4).getContractId()); + } + + @Test + void mergeAndSort_shouldMergeAndSortAscendingByCustomerId() { + // Replaces merge-and-display-files: merge on ascending key f-customer-id + Map> data = service.generateTestData(); + List merged = service.mergeAndSort(data.get("east"), data.get("west")); + + assertEquals(11, merged.size()); + + // Verify ascending order by customerId + assertEquals(1, merged.get(0).getCustomerId()); + assertEquals(3, merged.get(1).getCustomerId()); + assertEquals(5, merged.get(2).getCustomerId()); + assertEquals(10, merged.get(3).getCustomerId()); + assertEquals(24, merged.get(4).getCustomerId()); + assertEquals(25, merged.get(5).getCustomerId()); + assertEquals(30, merged.get(6).getCustomerId()); + assertEquals(50, merged.get(7).getCustomerId()); + assertEquals(75, merged.get(8).getCustomerId()); + assertEquals(85, merged.get(9).getCustomerId()); + assertEquals(999, merged.get(10).getCustomerId()); + } + + @Test + void sortByContractIdDescending_shouldSortDescending() { + // Replaces sort-and-display-file: sort on descending key f-customer-contract-id + Map> data = service.generateTestData(); + List merged = service.mergeAndSort(data.get("east"), data.get("west")); + List sorted = service.sortByContractIdDescending(merged); + + assertEquals(11, sorted.size()); + + // Verify descending order by contractId + assertEquals(12323, sorted.get(0).getContractId()); + assertEquals(8765, sorted.get(1).getContractId()); + assertEquals(7725, sorted.get(2).getContractId()); + assertEquals(5423, sorted.get(3).getContractId()); + assertEquals(5050, sorted.get(4).getContractId()); + assertEquals(4567, sorted.get(5).getContractId()); + assertEquals(3331, sorted.get(6).getContractId()); + assertEquals(1610, sorted.get(7).getContractId()); + assertEquals(1175, sorted.get(8).getContractId()); + assertEquals(653, sorted.get(9).getContractId()); + assertEquals(247, sorted.get(10).getContractId()); + } + + @Test + void runDemo_shouldReturnBothMergedAndSortedResults() { + Map> result = service.runDemo(); + assertNotNull(result.get("mergedByCustomerId")); + assertNotNull(result.get("sortedByContractIdDesc")); + assertEquals(11, result.get("mergedByCustomerId").size()); + assertEquals(11, result.get("sortedByContractIdDesc").size()); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/ReportServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/ReportServiceTest.java new file mode 100644 index 0000000..8a074a2 --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/ReportServiceTest.java @@ -0,0 +1,61 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.StudentRecord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class ReportServiceTest { + + private ReportService service; + + @BeforeEach + void setUp() { + service = new ReportService(); + } + + @Test + void generateReport_shouldContainHeader() { + List records = List.of( + new StudentRecord(3345, "Test Name", "PHY", 12) + ); + String report = service.generateReport(records); + assertTrue(report.contains("Customer Order Report")); + assertTrue(report.contains("PAGE 1")); + } + + @Test + void generateReport_shouldContainStudentData() { + List records = List.of( + new StudentRecord(3345, "Test Name", "PHY", 12) + ); + String report = service.generateReport(records); + assertTrue(report.contains("003345")); + assertTrue(report.contains("Test Name")); + assertTrue(report.contains("PHY")); + assertTrue(report.contains("12")); + } + + @Test + void generateReport_shouldPaginateForManyRecords() { + // Page limit: 37 detail lines per page (lines 6-42) + List records = new java.util.ArrayList<>(); + for (int i = 0; i < 50; i++) { + records.add(new StudentRecord(i, "Student " + i, "CS", 5)); + } + String report = service.generateReport(records); + assertTrue(report.contains("PAGE 1")); + assertTrue(report.contains("PAGE 2")); + } + + @Test + void generateReport_emptyRecords_shouldStillContainHeader() { + String report = service.generateReport(List.of()); + assertTrue(report.contains("Customer Order Report")); + assertFalse(report.contains("--- Page Break ---")); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/SearchDemoServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/SearchDemoServiceTest.java new file mode 100644 index 0000000..4ed99be --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/SearchDemoServiceTest.java @@ -0,0 +1,56 @@ +package com.example.cobolmigration.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Tests for search operations matching search/search.cbl behavior. + */ +class SearchDemoServiceTest { + + private SearchDemoService service; + + @BeforeEach + void setUp() { + service = new SearchDemoService(); + } + + @Test + void binarySearchById1_found() { + // search.cbl: SEARCH ALL ws-item-table WHEN ws-item-id-1(idx) = 2 + Map result = service.binarySearchById1(2); + assertTrue((boolean) result.get("found")); + SearchDemoService.KeyedItem item = (SearchDemoService.KeyedItem) result.get("item"); + assertEquals(2, item.id1()); + assertEquals("test item 2", item.name()); + } + + @Test + void binarySearchById1_notFound() { + Map result = service.binarySearchById1(999); + assertFalse((boolean) result.get("found")); + assertEquals("Item not found.", result.get("message")); + } + + @Test + void sequentialSearchById_found() { + // search.cbl: SEARCH ws-no-key-item-table WHEN ws-no-key-id(idx-2) = 1 + Map result = service.sequentialSearchById(1); + assertTrue((boolean) result.get("found")); + SearchDemoService.UnkeyedItem item = (SearchDemoService.UnkeyedItem) result.get("item"); + assertEquals(1, item.id()); + assertEquals("Value of id 1.", item.value()); + } + + @Test + void sequentialSearchById_notFound() { + Map result = service.sequentialSearchById(999); + assertFalse((boolean) result.get("found")); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/SerializationServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/SerializationServiceTest.java new file mode 100644 index 0000000..d47896c --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/SerializationServiceTest.java @@ -0,0 +1,27 @@ +package com.example.cobolmigration.service; + +import com.example.cobolmigration.model.SerializableRecord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class SerializationServiceTest { + + private SerializationService service; + + @BeforeEach + void setUp() { + service = new SerializationService(); + } + + @Test + void getDefaultRecord_matchesCobolTestData() { + // json_generate.cbl lines 38-40 / xml_generate.cbl lines 37-39 + SerializableRecord record = service.getDefaultRecord(); + assertEquals("Test Name", record.getName()); + assertEquals("Test Value", record.getValue()); + assertTrue(record.isEnabled()); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/StringUtilServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/StringUtilServiceTest.java new file mode 100644 index 0000000..15f9804 --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/StringUtilServiceTest.java @@ -0,0 +1,156 @@ +package com.example.cobolmigration.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +/** + * Tests split/trim operations matching COBOL examples from trim.cbl and unstring.cbl. + */ +class StringUtilServiceTest { + + private StringUtilService service; + + @BeforeEach + void setUp() { + service = new StringUtilService(); + } + + // --- trimVariants tests (matching trim/trim.cbl) --- + + @Test + void trimVariants_matchesCobolTrimFunction() { + // From trim.cbl line 16: ws-test-string-1 = " hello world " + String input = " hello world "; + Map result = service.trimVariants(input); + + // FUNCTION TRIM(ws-test-string-1) -> "hello world" + assertEquals("hello world", result.get("full")); + // FUNCTION TRIM(ws-test-string-1 LEADING) -> "hello world " + assertEquals("hello world ", result.get("leading")); + // FUNCTION TRIM(ws-test-string-1 TRAILING) -> " hello world" + assertEquals(" hello world", result.get("trailing")); + } + + @Test + void trimVariants_nullInput() { + Map result = service.trimVariants(null); + assertNull(result.get("full")); + assertNull(result.get("leading")); + assertNull(result.get("trailing")); + } + + @Test + void trimVariants_stringLiteral() { + // From trim.cbl lines 50-57 + String input = " String literal "; + Map result = service.trimVariants(input); + assertEquals("String literal", result.get("full")); + assertEquals("String literal ", result.get("leading")); + assertEquals(" String literal", result.get("trailing")); + } + + // --- splitByDelimiter tests (matching unstring.cbl Example 1) --- + + @Test + void splitByDelimiter_simpleSpace() { + // unstring.cbl Example 1 (lines 58-61): + // UNSTRING "Hello World" DELIMITED BY SPACE INTO ws-part-1 ws-part-2 + List result = service.splitByDelimiter("Hello World", " "); + assertEquals(2, result.size()); + assertEquals("Hello", result.get(0)); + assertEquals("World", result.get(1)); + } + + @Test + void splitByDelimiter_pipeDelimiter() { + List result = service.splitByDelimiter("A|B|C", "|"); + assertEquals(3, result.size()); + assertEquals("A", result.get(0)); + assertEquals("B", result.get(1)); + assertEquals("C", result.get(2)); + } + + // --- splitByMultipleDelimiters tests (matching unstring.cbl Examples 4-5) --- + + @Test + @SuppressWarnings("unchecked") + void splitByMultipleDelimiters_matchesCobolExample4() { + // unstring.cbl Example 4 (lines 148, 155-163): + // Source: "AE%FG!HIJ|KL!MN>OP#QR!ST" + // Delimiters: "<", ">", "!", "|" + String source = "AE%FG!HIJ|KL!MN>OP#QR!ST"; + List delimiters = List.of("<", ">", "!", "|"); + + Map result = service.splitByMultipleDelimiters(source, delimiters); + List> parts = (List>) result.get("parts"); + + // First split: "A" delimited by "<" + assertEquals("A", parts.get(0).get("value")); + assertEquals("<", parts.get(0).get("delimiter")); + assertEquals(1, parts.get(0).get("charCount")); + + // Second split: "B" delimited by "<" + assertEquals("B", parts.get(1).get("value")); + assertEquals("<", parts.get(1).get("delimiter")); + } + + @Test + @SuppressWarnings("unchecked") + void splitByMultipleDelimiters_matchesCobolExample5() { + // unstring.cbl Example 5 (lines 183, 188-214): + // Source: "AEFG!HIJ|KLMN>O" + // Delimiters: "<", ">", "!", "|" + String source = "AEFG!HIJ|KLMN>O"; + List delimiters = List.of("<", ">", "!", "|"); + + Map result = service.splitByMultipleDelimiters(source, delimiters); + List> parts = (List>) result.get("parts"); + int fieldsFilled = (int) result.get("fieldsFilled"); + + // Java splits all segments including the trailing "O" after the last delimiter. + // In COBOL, only 6 INTO destinations were provided so "O" was dropped. + assertEquals(7, fieldsFilled); + assertEquals("A", parts.get(0).get("value")); + assertEquals("B", parts.get(1).get("value")); + assertEquals("CD", parts.get(2).get("value")); + assertEquals("EFG", parts.get(3).get("value")); + assertEquals("HIJ", parts.get(4).get("value")); + assertEquals("KLMN", parts.get(5).get("value")); + assertEquals("O", parts.get(6).get("value")); + } + + // --- splitFormattedNumber tests (matching unstring.cbl Example 6) --- + + @Test + void splitFormattedNumber_matchesCobolExample6() { + // unstring.cbl Example 6 (lines 240-252): + // Source: $123,456.12 -> after removing $ and splitting by ',' and '.' + // Parts: "123", "456", "12" + List result = service.splitFormattedNumber("$123,456.12"); + assertEquals(3, result.size()); + assertEquals("123", result.get(0)); + assertEquals("456", result.get(1)); + assertEquals("12", result.get(2)); + } + + @Test + void splitFormattedNumber_withoutDollarSign() { + List result = service.splitFormattedNumber("999,999.99"); + assertEquals(3, result.size()); + assertEquals("999", result.get(0)); + assertEquals("999", result.get(1)); + assertEquals("99", result.get(2)); + } + + @Test + void splitFormattedNumber_nullInput() { + List result = service.splitFormattedNumber(null); + assertEquals(0, result.size()); + } +} diff --git a/cobol-migration/src/test/java/com/example/cobolmigration/service/ValidationServiceTest.java b/cobol-migration/src/test/java/com/example/cobolmigration/service/ValidationServiceTest.java new file mode 100644 index 0000000..9ad031b --- /dev/null +++ b/cobol-migration/src/test/java/com/example/cobolmigration/service/ValidationServiceTest.java @@ -0,0 +1,105 @@ +package com.example.cobolmigration.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Tests numeric validation with the same inputs from is_numeric/is_numeric.cbl. + */ +class ValidationServiceTest { + + private ValidationService service; + + @BeforeEach + void setUp() { + service = new ValidationService(); + } + + @Test + void isNumeric_pureDigits_allApproachesReturnTrue() { + // Input "12345" — all digits, no spaces + Map result = service.isNumeric("12345"); + assertTrue(result.get("plain")); + assertTrue(result.get("zeroFill")); + assertTrue(result.get("trimmed")); + } + + @Test + void isNumeric_digitsWithTrailingSpaces_plainFails() { + // In COBOL, "123 " in a PIC X(10) field with trailing spaces fails IS NUMERIC + // for the plain approach (is_numeric.cbl lines 25-38) + Map result = service.isNumeric("123 "); + assertFalse(result.get("plain")); + // Zero-fill and trim approaches should succeed + assertTrue(result.get("zeroFill")); + assertTrue(result.get("trimmed")); + } + + @Test + void isNumeric_alphabeticInput_allFail() { + Map result = service.isNumeric("abc"); + assertFalse(result.get("plain")); + assertFalse(result.get("zeroFill")); + assertFalse(result.get("trimmed")); + } + + @Test + void isNumeric_mixedAlphaNumeric_allFail() { + Map result = service.isNumeric("12ab34"); + assertFalse(result.get("plain")); + assertFalse(result.get("zeroFill")); + assertFalse(result.get("trimmed")); + } + + @Test + void isNumeric_nullInput_allFail() { + Map result = service.isNumeric(null); + assertFalse(result.get("plain")); + assertFalse(result.get("zeroFill")); + assertFalse(result.get("trimmed")); + } + + @Test + void parseNumericValue_validInteger() { + // Replaces NUMVAL function (numval_test.cbl line 28) + assertEquals(42.0, service.parseNumericValue("42")); + } + + @Test + void parseNumericValue_validDecimal() { + assertEquals(3.14, service.parseNumericValue("3.14")); + } + + @Test + void parseNumericValue_withLeadingSpaces() { + // NUMVAL handles leading/trailing spaces + assertEquals(100.0, service.parseNumericValue(" 100 ")); + } + + @Test + void parseNumericValue_negativeNumber() { + assertEquals(-25.0, service.parseNumericValue("-25")); + } + + @Test + void parseNumericValue_invalidInput_throwsException() { + assertThrows(NumberFormatException.class, () -> service.parseNumericValue("abc")); + } + + @Test + void parseNumericValue_nullInput_throwsException() { + assertThrows(NumberFormatException.class, () -> service.parseNumericValue(null)); + } + + @Test + void parseNumericValue_emptyInput_throwsException() { + assertThrows(NumberFormatException.class, () -> service.parseNumericValue("")); + } +}