Project 2: Move the Expense Tracker to PostgreSQL with JDBC

   command line        |        v   +---------+      +----------------+      +--------------------+   |   Cli   | ---> | ExpenseService | ---> |  ExpenseRepository |  (interface, one new method)   +---------+      +----------------+      +--------------------+   +import           +importAll              ^         ^          ^                                              |         |          |                              CsvExpenseRepository  InMemory...  JdbcExpenseRepository  <- NEW                                                                    |                                                         DataSource (HikariCP) -> PostgreSQL   Main chooses the repository from the environment

--- a/pom.xml+++ b/pom.xml@@ -7,5 +7,5 @@   <groupId>com.example</groupId>   <artifactId>expense-tracker</artifactId>-  <version>1.0.0</version>+  <version>2.0.0</version>   <packaging>jar</packaging> @@ -14,11 +14,49 @@     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>     <junit.version>6.1.3</junit.version>+    <postgres.binaries.version>18.6.0</postgres.binaries.version>   </properties> +  <dependencyManagement>+    <dependencies>+      <!-- Makes the embedded test database a PostgreSQL 18 server -->+      <dependency>+        <groupId>io.zonky.test.postgres</groupId>+        <artifactId>embedded-postgres-binaries-bom</artifactId>+        <version>${postgres.binaries.version}</version>+        <type>pom</type>+        <scope>import</scope>+      </dependency>+    </dependencies>+  </dependencyManagement>+   <dependencies>+    <dependency>+      <groupId>org.postgresql</groupId>+      <artifactId>postgresql</artifactId>+      <version>42.7.13</version>+      <scope>runtime</scope>+    </dependency>+    <dependency>+      <groupId>com.zaxxer</groupId>+      <artifactId>HikariCP</artifactId>+      <version>7.1.0</version>+    </dependency>+    <dependency>+      <groupId>org.slf4j</groupId>+      <artifactId>slf4j-simple</artifactId>+      <version>2.0.18</version>+      <scope>runtime</scope>+    </dependency>+     <dependency>       <groupId>org.junit.jupiter</groupId>       <artifactId>junit-jupiter</artifactId>       <version>${junit.version}</version>+      <scope>test</scope>+    </dependency>+    <dependency>+      <groupId>io.zonky.test</groupId>+      <artifactId>embedded-postgres</artifactId>+      <version>2.2.2</version>       <scope>test</scope>     </dependency>@@ -34,13 +72,35 @@       <plugin>         <groupId>org.apache.maven.plugins</groupId>-        <artifactId>maven-jar-plugin</artifactId>-        <version>3.4.2</version>-        <configuration>-          <archive>-            <manifest>-              <mainClass>com.example.expenses.Main</mainClass>-            </manifest>-          </archive>-        </configuration>+        <artifactId>maven-shade-plugin</artifactId>+        <version>3.6.0</version>+        <executions>+          <execution>+            <phase>package</phase>+            <goals>+              <goal>shade</goal>+            </goals>+            <configuration>+              <createDependencyReducedPom>false</createDependencyReducedPom>+              <transformers>+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">+                  <mainClass>com.example.expenses.Main</mainClass>+                </transformer>+                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>+              </transformers>+              <filters>+                <filter>+                  <artifact>*:*</artifact>+                  <excludes>+                    <exclude>META-INF/*.SF</exclude>+                    <exclude>META-INF/*.DSA</exclude>+                    <exclude>META-INF/*.RSA</exclude>+                    <exclude>module-info.class</exclude>+                    <exclude>META-INF/versions/*/module-info.class</exclude>+                  </excludes>+                </filter>+              </filters>+            </configuration>+          </execution>+        </executions>       </plugin>     </plugins>

CREATE TABLE IF NOT EXISTS categories (    id   integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,    name text NOT NULL UNIQUE);CREATE TABLE IF NOT EXISTS expenses (    id           bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,    spent_on     date    NOT NULL,    amount_cents bigint  NOT NULL CHECK (amount_cents > 0),    category_id  integer NOT NULL REFERENCES categories (id),    description  text    NOT NULL DEFAULT '');CREATE INDEX IF NOT EXISTS idx_expenses_spent_on ON expenses (spent_on);

org.slf4j.simpleLogger.defaultLogLevel=warn

// File: src/main/java/com/example/expenses/ExpenseRepository.javapackage com.example.expenses;import java.time.LocalDate;import java.util.List;/** Where expenses are stored. The rest of the program depends only on this interface. */public interface ExpenseRepository {    Expense add(LocalDate date, long amountCents, Category category, String description);    /**     * Stores copies of the given expenses, assigning new ids (the ids passed in are ignored).     * It is all or nothing: if any expense cannot be stored, none is, and an exception is thrown.     *     * @return the number of expenses stored     */    int addAll(List<Expense> expenses);    /** Returns every expense in id order. */    List<Expense> findAll();    boolean deleteById(long id);}

--- a/src/main/java/com/example/expenses/InMemoryExpenseRepository.java+++ b/src/main/java/com/example/expenses/InMemoryExpenseRepository.java@@ -18,4 +18,12 @@      @Override+    public int addAll(List<Expense> expenses) {+        for (Expense e : expenses) {+            add(e.date(), e.amountCents(), e.category(), e.description());+        }+        return expenses.size();+    }++    @Override     public List<Expense> findAll() {         return new ArrayList<>(byId.values());

--- a/src/main/java/com/example/expenses/CsvExpenseRepository.java+++ b/src/main/java/com/example/expenses/CsvExpenseRepository.java@@ -29,4 +29,15 @@         store(all);         return expense;+    }++    @Override+    public int addAll(List<Expense> expenses) {+        List<Expense> all = load();+        long nextId = all.stream().mapToLong(Expense::id).max().orElse(0) + 1;+        for (Expense e : expenses) {+            all.add(new Expense(nextId++, e.date(), e.amountCents(), e.category(), e.description()));+        }+        store(all);                                  // one write: the file changes completely or not at all+        return expenses.size();     } 

// File: src/main/java/com/example/expenses/StorageException.javapackage com.example.expenses;/** A storage problem that is not the user's fault: the database is unreachable, the schema is wrong, and so on. */public class StorageException extends RuntimeException {    public StorageException(String message, Throwable cause) {        super(message, cause);    }}

// File: src/main/java/com/example/expenses/JdbcExpenseRepository.javapackage com.example.expenses;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.time.LocalDate;import java.util.ArrayList;import java.util.List;import javax.sql.DataSource;/** Stores expenses in PostgreSQL. All SQL and all JDBC types stay inside this class. */public class JdbcExpenseRepository implements ExpenseRepository {    private static final String INSERT = """            INSERT INTO expenses (spent_on, amount_cents, category_id, description)            VALUES (?, ?, (SELECT id FROM categories WHERE name = ?), ?)            """;    private final DataSource dataSource;    public JdbcExpenseRepository(DataSource dataSource) {        this.dataSource = dataSource;    }    @Override    public Expense add(LocalDate date, long amountCents, Category category, String description) {        try (Connection connection = dataSource.getConnection();             PreparedStatement statement = connection.prepareStatement(INSERT + "RETURNING id")) {            bind(statement, date, amountCents, category, description);            try (ResultSet rs = statement.executeQuery()) {                rs.next();                return new Expense(rs.getLong(1), date, amountCents, category, description);            }        } catch (SQLException e) {            throw new StorageException("could not save the expense", e);        }    }    @Override    public int addAll(List<Expense> expenses) {        try (Connection connection = dataSource.getConnection()) {            boolean originalAutoCommit = connection.getAutoCommit();            connection.setAutoCommit(false);                       // one transaction for the whole list            try (PreparedStatement statement = connection.prepareStatement(INSERT)) {                for (Expense e : expenses) {                    bind(statement, e.date(), e.amountCents(), e.category(), e.description());                    statement.addBatch();                }                statement.executeBatch();                connection.commit();                return expenses.size();            } catch (SQLException e) {                connection.rollback();                             // nothing from this list is kept                throw e;            } finally {                connection.setAutoCommit(originalAutoCommit);            }        } catch (SQLException e) {            throw new StorageException("could not save the expenses, none were stored", e);        }    }    @Override    public List<Expense> findAll() {        String sql = """                SELECT e.id, e.spent_on, e.amount_cents, c.name, e.description                FROM expenses e                JOIN categories c ON c.id = e.category_id                ORDER BY e.id                """;        try (Connection connection = dataSource.getConnection();             PreparedStatement statement = connection.prepareStatement(sql);             ResultSet rs = statement.executeQuery()) {            List<Expense> result = new ArrayList<>();            while (rs.next()) {                result.add(new Expense(                        rs.getLong("id"),                        rs.getObject("spent_on", LocalDate.class),                        rs.getLong("amount_cents"),                        toCategory(rs.getString("name")),                        rs.getString("description")));            }            return result;        } catch (SQLException e) {            throw new StorageException("could not read the expenses", e);        }    }    @Override    public boolean deleteById(long id) {        try (Connection connection = dataSource.getConnection();             PreparedStatement statement = connection.prepareStatement("DELETE FROM expenses WHERE id = ?")) {            statement.setLong(1, id);            return statement.executeUpdate() > 0;        } catch (SQLException e) {            throw new StorageException("could not delete the expense", e);        }    }    private static Category toCategory(String name) {        try {            return Category.valueOf(name);        } catch (IllegalArgumentException e) {            throw new StorageException("the database contains a category this version does not know: " + name, e);        }    }    private static void bind(PreparedStatement statement, LocalDate date, long amountCents,                             Category category, String description) throws SQLException {        statement.setObject(1, date);        statement.setLong(2, amountCents);        statement.setString(3, category.name());        statement.setString(4, description);    }}

// File: src/main/java/com/example/expenses/Schema.javapackage com.example.expenses;import java.io.IOException;import java.io.InputStream;import java.io.UncheckedIOException;import java.nio.charset.StandardCharsets;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;import java.sql.Statement;import javax.sql.DataSource;/** Creates the tables if they are missing and makes sure every Category has a row. Safe to run repeatedly. */public final class Schema {    private Schema() {    }    public static void apply(DataSource dataSource) {        String script = readScript();        try (Connection connection = dataSource.getConnection()) {            boolean originalAutoCommit = connection.getAutoCommit();            connection.setAutoCommit(false);            try {                try (Statement statement = connection.createStatement()) {                    for (String sql : script.split(";")) {                        if (!sql.isBlank()) {                            statement.execute(sql);                        }                    }                }                try (PreparedStatement insert = connection.prepareStatement(                        "INSERT INTO categories (name) VALUES (?) ON CONFLICT (name) DO NOTHING")) {                    for (Category category : Category.values()) {                        insert.setString(1, category.name());                        insert.addBatch();                    }                    insert.executeBatch();                }                connection.commit();            } catch (SQLException e) {                connection.rollback();                throw e;            } finally {                connection.setAutoCommit(originalAutoCommit);            }        } catch (SQLException e) {            throw new StorageException("could not prepare the database schema", e);        }    }    private static String readScript() {        try (InputStream in = Schema.class.getResourceAsStream("/schema.sql")) {            if (in == null) {                throw new IllegalStateException("schema.sql is missing from the application");            }            return new String(in.readAllBytes(), StandardCharsets.UTF_8);        } catch (IOException e) {            throw new UncheckedIOException(e);        }    }}

// File: src/test/java/com/example/expenses/ExpenseRepositoryContract.javapackage com.example.expenses;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertTrue;import java.time.LocalDate;import java.util.List;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;/** * The behaviour every ExpenseRepository must have. Each implementation's test class extends this one, * so all implementations are held to the same rules. */abstract class ExpenseRepositoryContract {    protected ExpenseRepository repository;    /** Returns a new, empty repository. */    protected abstract ExpenseRepository newRepository();    @BeforeEach    void createRepository() {        repository = newRepository();    }    @Test    void aNewRepositoryIsEmpty() {        assertTrue(repository.findAll().isEmpty());    }    @Test    void addReturnsTheStoredExpenseWithAnId() {        Expense saved = repository.add(LocalDate.of(2026, 3, 1), 1250, Category.FOOD, "lunch");        assertTrue(saved.id() > 0);        assertEquals(LocalDate.of(2026, 3, 1), saved.date());        assertEquals(1250, saved.amountCents());        assertEquals(Category.FOOD, saved.category());        assertEquals("lunch", saved.description());    }    @Test    void idsIncreaseAndFindAllReturnsExpensesInIdOrder() {        Expense first = repository.add(LocalDate.of(2026, 3, 5), 100, Category.FOOD, "first");        Expense second = repository.add(LocalDate.of(2026, 3, 1), 200, Category.HOUSING, "second");        assertTrue(second.id() > first.id());        assertEquals(List.of(first, second), repository.findAll());    }    @Test    void textSurvivesAStoreAndReload() {        String tricky = "café, \"quoted\" and 100% fine";        repository.add(LocalDate.of(2026, 3, 1), 100, Category.OTHER, tricky);        assertEquals(tricky, repository.findAll().get(0).description());    }    @Test    void deleteRemovesOnlyTheNamedExpense() {        Expense first = repository.add(LocalDate.of(2026, 3, 1), 100, Category.FOOD, "a");        Expense second = repository.add(LocalDate.of(2026, 3, 2), 200, Category.FOOD, "b");        assertTrue(repository.deleteById(first.id()));        assertEquals(List.of(second), repository.findAll());    }    @Test    void deletingAnUnknownIdReturnsFalse() {        assertFalse(repository.deleteById(12345));    }    @Test    void addAllStoresCopiesWithNewIds() {        List<Expense> source = List.of(                new Expense(900, LocalDate.of(2026, 1, 1), 100, Category.FOOD, "x"),                new Expense(901, LocalDate.of(2026, 1, 2), 200, Category.HEALTH, "y"));        int stored = repository.addAll(source);        List<Expense> all = repository.findAll();        assertEquals(2, stored);        assertEquals(List.of("x", "y"), all.stream().map(Expense::description).toList());        assertEquals(List.of(Category.FOOD, Category.HEALTH), all.stream().map(Expense::category).toList());        assertTrue(all.stream().noneMatch(e -> e.id() >= 900), "the ids passed in must be ignored");    }}

// File: src/test/java/com/example/expenses/InMemoryExpenseRepositoryTest.javapackage com.example.expenses;class InMemoryExpenseRepositoryTest extends ExpenseRepositoryContract {    @Override    protected ExpenseRepository newRepository() {        return new InMemoryExpenseRepository();    }}

// File: src/test/java/com/example/expenses/CsvExpenseRepositoryTest.javapackage com.example.expenses;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.time.LocalDate;import java.util.List;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;class CsvExpenseRepositoryTest extends ExpenseRepositoryContract {    @TempDir    Path directory;    @Override    protected ExpenseRepository newRepository() {        return new CsvExpenseRepository(directory.resolve("expenses.csv"));    }    @Test    void dataSurvivesANewRepositoryInstance() {        Path file = directory.resolve("survive.csv");        new CsvExpenseRepository(file).add(LocalDate.of(2026, 3, 1), 1250, Category.FOOD, "lunch");        List<Expense> loaded = new CsvExpenseRepository(file).findAll();        assertEquals(List.of(new Expense(1, LocalDate.of(2026, 3, 1), 1250, Category.FOOD, "lunch")), loaded);    }    @Test    void missingFileMeansNoExpensesAndTheFileAndFolderAreCreatedOnFirstAdd() {        Path file = directory.resolve("nested").resolve("expenses.csv");        CsvExpenseRepository repository = new CsvExpenseRepository(file);        assertTrue(repository.findAll().isEmpty());        repository.add(LocalDate.of(2026, 3, 1), 100, Category.OTHER, "");        assertTrue(Files.exists(file));    }    @Test    void aDamagedFileIsReportedWithItsLineNumber() throws IOException {        Path file = directory.resolve("damaged.csv");        Files.writeString(file, CsvExpenseRepository.HEADER + "\n1,2026-03-01,not-a-number,FOOD,lunch\n");        IllegalStateException e = assertThrows(IllegalStateException.class,                () -> new CsvExpenseRepository(file).findAll());        assertTrue(e.getMessage().contains("damaged at line 2"), e.getMessage());    }    @Test    void splitsQuotedFieldsCorrectly() {        assertEquals(List.of("1", "a,b", "say \"hi\"", ""),                CsvExpenseRepository.splitCsv("1,\"a,b\",\"say \"\"hi\"\"\","));    }}

// File: src/test/java/com/example/expenses/JdbcExpenseRepositoryTest.javapackage com.example.expenses;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import io.zonky.test.db.postgres.embedded.EmbeddedPostgres;import java.io.IOException;import java.sql.Connection;import java.sql.SQLException;import java.sql.Statement;import java.time.LocalDate;import java.util.List;import javax.sql.DataSource;import org.junit.jupiter.api.AfterAll;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;/** Runs the repository contract against a real PostgreSQL server started for the duration of the test class. */class JdbcExpenseRepositoryTest extends ExpenseRepositoryContract {    private static EmbeddedPostgres postgres;    private static DataSource dataSource;    @BeforeAll    static void startDatabase() throws IOException {        postgres = EmbeddedPostgres.start();        dataSource = postgres.getPostgresDatabase();        Schema.apply(dataSource);    }    @AfterAll    static void stopDatabase() throws IOException {        postgres.close();    }    @Override    protected ExpenseRepository newRepository() {        execute("TRUNCATE expenses RESTART IDENTITY");        execute("INSERT INTO categories (name) SELECT 'OTHER' WHERE NOT EXISTS "                + "(SELECT 1 FROM categories WHERE name = 'OTHER')");        return new JdbcExpenseRepository(dataSource);    }    private static void execute(String sql) {        try (Connection connection = dataSource.getConnection(); Statement statement = connection.createStatement()) {            statement.execute(sql);        } catch (SQLException e) {            throw new IllegalStateException(e);        }    }    @Test    void applyingTheSchemaTwiceChangesNothing() {        Schema.apply(dataSource);        Schema.apply(dataSource);        repository.add(LocalDate.of(2026, 3, 1), 100, Category.FOOD, "still works");        assertEquals(1, repository.findAll().size());    }    @Test    void addAllStoresNothingWhenOneRowFails() {        execute("DELETE FROM categories WHERE name = 'OTHER'");     // reference data is missing        List<Expense> source = List.of(                new Expense(1, LocalDate.of(2026, 1, 1), 100, Category.FOOD, "fine"),                new Expense(2, LocalDate.of(2026, 1, 2), 200, Category.OTHER, "cannot be stored"));        StorageException e = assertThrows(StorageException.class, () -> repository.addAll(source));        assertTrue(e.getCause() instanceof SQLException, "the cause should be the SQLException");        assertTrue(repository.findAll().isEmpty(), "the valid row must have been rolled back too");    }    @Test    void aCategoryTheCodeDoesNotKnowIsReportedNotCrashed() {        execute("INSERT INTO categories (name) VALUES ('LEGACY')");        execute("INSERT INTO expenses (spent_on, amount_cents, category_id, description) "                + "SELECT DATE '2026-03-01', 100, id, 'old' FROM categories WHERE name = 'LEGACY'");        StorageException e = assertThrows(StorageException.class, () -> repository.findAll());        assertTrue(e.getMessage().contains("LEGACY"), e.getMessage());    }    @Test    void aDatabaseProblemBecomesAStorageException() {        execute("ALTER TABLE expenses RENAME TO expenses_old");        try {            assertThrows(StorageException.class, () -> repository.findAll());        } finally {            execute("ALTER TABLE expenses_old RENAME TO expenses");        }    }}

--- a/src/main/java/com/example/expenses/ExpenseService.java+++ b/src/main/java/com/example/expenses/ExpenseService.java@@ -31,4 +31,15 @@     } +    /** Copies expenses (for example from another store) into this one, all or nothing. */+    public int importAll(List<Expense> expenses) {+        LocalDate today = LocalDate.now(clock);+        for (Expense e : expenses) {+            if (e.date().isAfter(today)) {+                throw new InvalidInputException("expense #" + e.id() + " has a date in the future: " + e.date());+            }+        }+        return repository.addAll(expenses);+    }+     /** Lists expenses oldest first. A null month means all months. */     public List<Expense> list(YearMonth month) {

--- a/src/main/java/com/example/expenses/Cli.java+++ b/src/main/java/com/example/expenses/Cli.java@@ -3,4 +3,6 @@ import java.io.PrintStream; import java.io.UncheckedIOException;+import java.nio.file.Files;+import java.nio.file.Path; import java.time.LocalDate; import java.time.YearMonth;@@ -20,4 +22,5 @@               expenses delete <id>               expenses categories+              expenses import <csv-file>             """; @@ -46,4 +49,5 @@                 case "delete" -> delete(rest);                 case "categories" -> categories(rest);+                case "import" -> importCsv(rest);                 default -> {                     err.println("error: unknown command '" + args[0] + "'");@@ -56,5 +60,5 @@             err.println("error: " + e.getMessage());             return 1;-        } catch (UncheckedIOException | IllegalStateException e) {+        } catch (UncheckedIOException | IllegalStateException | StorageException e) {             err.println("error: " + e.getMessage());             return 2;@@ -128,4 +132,17 @@     } +    private void importCsv(List<String> args) {+        if (args.size() != 1) {+            throw new InvalidInputException("import needs exactly one <csv-file>");+        }+        Path file = Path.of(args.get(0));+        if (!Files.isRegularFile(file)) {+            throw new InvalidInputException("no such file: " + file);+        }+        List<Expense> source = new CsvExpenseRepository(file).findAll();+        int count = service.importAll(source);+        out.println("Imported " + count + " expense(s) from " + file);+    }+     /** Removes "--name value" from the arguments and returns the value, or null if absent. */     private static String takeOption(List<String> args, String name) {

--- a/src/test/java/com/example/expenses/ExpenseServiceTest.java+++ b/src/test/java/com/example/expenses/ExpenseServiceTest.java@@ -77,4 +77,27 @@      @Test+    void importCopiesEveryExpenseAndAssignsNewIds() {+        List<Expense> source = List.of(+                new Expense(40, LocalDate.of(2026, 1, 5), 100, Category.FOOD, "a"),+                new Expense(41, LocalDate.of(2026, 1, 6), 200, Category.HEALTH, "b"));++        int imported = service.importAll(source);++        assertEquals(2, imported);+        assertEquals(List.of(1L, 2L), service.list(null).stream().map(Expense::id).toList());+    }++    @Test+    void importStoresNothingIfAnyExpenseIsDatedInTheFuture() {+        List<Expense> source = List.of(+                new Expense(1, LocalDate.of(2026, 1, 5), 100, Category.FOOD, "fine"),+                new Expense(2, LocalDate.of(2026, 3, 16), 200, Category.FOOD, "tomorrow"));++        assertThrows(InvalidInputException.class, () -> service.importAll(source));++        assertTrue(service.list(null).isEmpty());+    }++    @Test     void deleteReportsWhetherAnythingWasRemoved() {         Expense saved = service.add(450, Category.FOOD, "", null);

--- a/src/test/java/com/example/expenses/CliTest.java+++ b/src/test/java/com/example/expenses/CliTest.java@@ -110,4 +110,24 @@      @Test+    void importCopiesExpensesFromAnotherCsvFile() {+        Path other = directory.resolve("other.csv");+        new CsvExpenseRepository(other).add(java.time.LocalDate.of(2026, 2, 1), 5000, Category.HOUSING, "deposit");+        new CsvExpenseRepository(other).add(java.time.LocalDate.of(2026, 2, 2), 250, Category.FOOD, "bread");++        assertEquals(0, run("import", other.toString()));+        assertEquals("Imported 2 expense(s) from " + other, out().get(0));++        outBytes.reset();+        run("summary");+        assertEquals("  TOTAL              52.50", out().get(out().size() - 1));+    }++    @Test+    void importOfAMissingFileFails() {+        assertEquals(1, run("import", directory.resolve("nope.csv").toString()));+        assertTrue(err().get(0).startsWith("error: no such file: "), err().toString());+    }++    @Test     void noArgumentsPrintsTheUsage() {         assertEquals(1, run());

// File: src/main/java/com/example/expenses/Main.javapackage com.example.expenses;import com.zaxxer.hikari.HikariConfig;import com.zaxxer.hikari.HikariDataSource;import com.zaxxer.hikari.pool.HikariPool;import java.nio.file.Path;import java.time.Clock;/** * Chooses the store from the environment: PostgreSQL when DB_URL is set (with DB_USER and DB_PASSWORD), * otherwise the CSV file from version 1. */public class Main {    public static void main(String[] args) {        String dbUrl = System.getenv("DB_URL");        int exitCode;        if (dbUrl == null || dbUrl.isBlank()) {            Path file = dataFile(System.getenv("EXPENSE_TRACKER_FILE"), System.getProperty("user.home"));            exitCode = run(new CsvExpenseRepository(file), args);        } else {            try (HikariDataSource pool = new HikariDataSource(poolConfig(dbUrl))) {                Schema.apply(pool);                exitCode = run(new JdbcExpenseRepository(pool), args);            } catch (StorageException | HikariPool.PoolInitializationException e) {                System.err.println("error: cannot use the database: " + rootMessage(e));                exitCode = 2;            }        }        System.exit(exitCode);    }    private static int run(ExpenseRepository repository, String[] args) {        ExpenseService service = new ExpenseService(repository, Clock.systemDefaultZone());        return new Cli(service, System.out, System.err).run(args);    }    private static HikariConfig poolConfig(String url) {        HikariConfig config = new HikariConfig();        config.setJdbcUrl(url);        config.setUsername(System.getenv("DB_USER"));        config.setPassword(System.getenv("DB_PASSWORD"));        config.setMaximumPoolSize(4);        config.setConnectionTimeout(5000);        config.setPoolName("expenses-pool");        return config;    }    private static String rootMessage(Throwable e) {        Throwable root = e;        while (root.getCause() != null) {            root = root.getCause();        }        return root.getMessage();    }    /** The file named by EXPENSE_TRACKER_FILE, or ~/.expense-tracker/expenses.csv. */    static Path dataFile(String override, String home) {        if (override != null && !override.isBlank()) {            return Path.of(override);        }        return Path.of(home, ".expense-tracker", "expenses.csv");    }}

export DB_URL=jdbc:postgresql://localhost:5432/expensesexport DB_USER=expensesexport DB_PASSWORD='the-password-you-chose'alias expenses='java -jar target/expense-tracker-2.0.0.jar'

# Version 1 still works with a file$ expenses add 12.50 food "lunch with Sam" --date 2026-09-03Added #1: 2026-09-03 12.50 FOOD$ expenses add 1200 housing "rent" --date 2026-09-01Added #2: 2026-09-01 1200.00 HOUSING$ expenses add 3.20 food "coffee, and a muffin" --date 2026-10-02Added #3: 2026-10-02 3.20 FOOD# Version 2 with PostgreSQL$ expenses listNo expenses found.$ expenses import old-expenses.csvImported 3 expense(s) from old-expenses.csv$ expenses add 45 transport "monthly metro pass" --date 2026-09-05Added #4: 2026-09-05 45.00 TRANSPORT$ expenses list  ID  DATE            AMOUNT  CATEGORY       DESCRIPTION   2  2026-09-01     1200.00  HOUSING        rent   1  2026-09-03       12.50  FOOD           lunch with Sam   4  2026-09-05       45.00  TRANSPORT      monthly metro pass   3  2026-10-02        3.20  FOOD           coffee, and a muffin4 expense(s), total 1260.70$ expenses summary --month 2026-09Summary for 2026-09  FOOD               12.50  TRANSPORT          45.00  HOUSING          1200.00  TOTAL            1257.50$ expenses delete 1Deleted #1$ expenses delete 1error: no expense with id 1(exit code 1)$ expenses add 5 snackserror: unknown category 'snacks', choose one of [FOOD, TRANSPORT, HOUSING, UTILITIES, HEALTH, ENTERTAINMENT, OTHER](exit code 1)$ expenses import missing.csverror: no such file: missing.csv(exit code 1)# Running it again changes nothing in the schema$ expenses list --month 2026-10  ID  DATE            AMOUNT  CATEGORY       DESCRIPTION   3  2026-10-02        3.20  FOOD           coffee, and a muffin1 expense(s), total 3.20# The database holds a category this version does not know(another program adds a category called LEGACY, and an expense that uses it)$ expenses listerror: the database contains a category this version does not know: LEGACY(exit code 2)# The database cannot be reached$ DB_URL=jdbc:postgresql://localhost:1/postgres expenses listerror: cannot use the database: Connection refused: no further information(exit code 2)