embedded-postgres

Java embedded PostgreSQL component for testing (by zonkyio)

Embedded-postgres Alternatives

Similar projects and alternatives to embedded-postgres

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better embedded-postgres alternative or higher similarity.

embedded-postgres reviews and mentions

Posts with mentions or reviews of embedded-postgres. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-02-27.
  • Testcontainers
    16 projects | news.ycombinator.com | 27 Feb 2024
  • Why you should probably be using SQLite
    8 projects | news.ycombinator.com | 27 Oct 2023
    Little use if you’re not on the JVM but I’ve had great success with Embedded Postgres:

    https://github.com/zonkyio/embedded-postgres

    Each test just copies a template database so it’s ultra fast and avoids the need for complicated reset logic.

  • Ask HN: What's your favorite software testing framework and why?
    15 projects | news.ycombinator.com | 21 May 2023
    Outside of differences between assertion-based unit tests and property-based tests (both of which are worth doing), I don't think framework makes much difference. But your approach to testing definitely does.

    I think every language having its own testing framework is good, even for things like functional tests which can often be externalised. Tests are an essential part of every project and should be well integrated with the rest of the codebase and the team creating it. Often, the tests are the only good place to go and see what an app actually _does_ and so they form an essential part of the documentation.

    In my experience it's very rare that you can effectively create and maintain something like Cucumber tests owned by anyone but the team implementing the code so there's little benefit to translating from a text DSL like that. But the language used is definitely useful, so what I like to see is code in the implementation language that matches the Given/When/Then structure of those tests, but instead of reusable text steps you just have reusable functions which take parameters. This means you can easily refactor, and use the full functionality of your IDE to suggest and go to definitions etc. No matter what, you should treat your test code the same way you do everything else - abstractions matter, so functional tests at the top level should rarely just be about clicking on things and asserting other things, they should be in the language of the domain.

    Functional tests are worth much more than unit tests. No only do they test the only things of actual business value, they are also more robust in the face of implementation refactorings and so require less rework (unless you're being overly specific with CSS selectors etc). Unit tests are often highly coupled to specific implementations and can be a poor investment, especially early in a project. I believe a good balance is functional and integration tests that explore the various paths through your app and prove everything's hooked up, coupled with property based unit tests for gnarly or repetitive logic that isn't worth endlessly iterating via the UI. All other unit tests are optional and at the discretion of the implementer.

    You should be able to mock out every major articulation point in your code, but it's generally preferable if you can mock _real_ dependencies. That is, instead of mocking out a 'repository' abstraction that looks stuff up and returns canned data, have a real test database against which you look up real data (created by steps in your functional tests). This reduces risk and cognitive overhead (you're not having to encode too many assumptions in your test suite) and doesn't have to be as slow as people like to make out - Embedded Postgres is quite fast, for example:

    https://github.com/zonkyio/embedded-postgres

    Same with network services - it's not slow to chat to localhost and you'll find more issues testing proper round-trips. I have not found "assert that you called X" style testing with mocks useful - you care about outcomes, not implementation details.

    Beyond all that, as long as you can make assertions that generate clear error messages, you're fine.

  • Hctree is an experimental high-concurrency database back end for SQLite
    5 projects | news.ycombinator.com | 18 Jan 2023
    I use an embedded postgres testing library for the JVM that does something along those lines.

    Well no actually it just unpacks the tar file in a temp dir and runs the full postgres, but it mostly feels like what you describe (minus the single file part) and starts surprisingly fast. That would totally work for a little proof of concept (https://github.com/zonkyio/embedded-postgres)

  • Thoughts on Micronaut vs. Quarkus?
    2 projects | /r/java | 21 Aug 2022
  • A note from our sponsor - SaaSHub
    www.saashub.com | 1 May 2024
    SaaSHub helps you find the best software and product alternatives Learn more →

Stats

Basic embedded-postgres repo stats
5
324
6.4
22 days ago

Sponsored
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com