make Hibernate sequence start above 1,000,000 to spare ids for sample data

src/main/resources/config/liquibase/changelog/00000000000000_initial_schema.xml

@@ -7,7 +7,7 @@
                         http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
 
     <changeSet id="00000000000000" author="jhipster">
-        <createSequence sequenceName="hibernate_sequence" startValue="1000" incrementBy="50"/>
+        <createSequence sequenceName="hibernate_sequence" startValue="1000051" incrementBy="50"/>
     </changeSet>
 
     <!--

src/test/java/org/hostsharing/hsadminng/repository/AssetRepositoryIntTest.java

@@ -0,0 +1,76 @@
+// Licensed under Apache-2.0
+package org.hostsharing.hsadminng.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hostsharing.hsadminng.HsadminNgApp;
+import org.hostsharing.hsadminng.domain.Asset;
+import org.hostsharing.hsadminng.domain.Customer;
+import org.hostsharing.hsadminng.domain.Membership;
+import org.hostsharing.hsadminng.domain.enumeration.AssetAction;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = HsadminNgApp.class)
+@Transactional
+public class AssetRepositoryIntTest {
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    @Autowired
+    private MembershipRepository membershipRepository;
+
+    @Autowired
+    private AssetRepository assetRepository;
+
+    @Test
+    public void sequenceStartsAbove1000000ToSpareIdsForSampleData() {
+        // given
+        final Asset givenAsset = createArbitraryAsset();
+
+        // when
+        assetRepository.save(givenAsset);
+
+        // then
+        assertThat(givenAsset.getId()).isGreaterThan(1000000);
+    }
+
+    // --- only test fixture below ---
+
+    private Customer createPersistentCustomer() {
+        return customerRepository.save(CustomerRepositoryIntTest.createCustomer());
+    }
+
+    private Membership createPersistentMembership() {
+        return membershipRepository
+                .save(MembershipRepositoryIntTest.createMembership(createPersistentCustomer(), "2019-01-08", null));
+    }
+
+    static Asset createAsset(
+            final Membership membership,
+            final AssetAction action,
+            final String amount,
+            final String documentDate) {
+        final Asset asset = new Asset();
+        asset.setMembership(membership);
+        asset.setAction(action);
+        asset.setAmount(new BigDecimal(amount));
+        asset.setDocumentDate(LocalDate.parse(documentDate));
+        asset.setValueDate(LocalDate.parse(documentDate).plusDays(1));
+        return asset;
+    }
+
+    private Asset createArbitraryAsset() {
+        return createAsset(createPersistentMembership(), AssetAction.PAYMENT, "160.00", "2019-01-08");
+    }
+}

src/test/java/org/hostsharing/hsadminng/repository/CustomerRepositoryIntTest.java

@@ -0,0 +1,52 @@
+// Licensed under Apache-2.0
+package org.hostsharing.hsadminng.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hostsharing.hsadminng.HsadminNgApp;
+import org.hostsharing.hsadminng.domain.Customer;
+import org.hostsharing.hsadminng.domain.enumeration.CustomerKind;
+import org.hostsharing.hsadminng.domain.enumeration.VatRegion;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.apache.commons.lang3.RandomUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = HsadminNgApp.class)
+@Transactional
+public class CustomerRepositoryIntTest {
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    @Test
+    public void sequenceStartsAbove1000000ToSpareIdsForSampleData() {
+        // given
+        final Customer givenCustomer = createCustomer();
+
+        // when
+        customerRepository.save(givenCustomer);
+
+        // then
+        assertThat(givenCustomer.getId()).isGreaterThan(1000000);
+    }
+
+    // --- only test fixture below ---
+
+    static Customer createCustomer() {
+        final Customer customer = new Customer();
+        customer.setPrefix(RandomStringUtils.randomAlphabetic(3).toLowerCase());
+        customer.setReference(RandomUtils.nextInt(10001, 19999));
+        customer.setName(RandomStringUtils.randomAlphabetic(10));
+        customer.setContractualAddress(RandomStringUtils.randomAlphabetic(10));
+        customer.setKind(CustomerKind.NATURAL);
+        customer.setVatRegion(VatRegion.DOMESTIC);
+        return customer;
+    }
+}

src/test/java/org/hostsharing/hsadminng/repository/MembershipRepositoryIntTest.java

@@ -6,11 +6,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import org.hostsharing.hsadminng.HsadminNgApp;
 import org.hostsharing.hsadminng.domain.Customer;
 import org.hostsharing.hsadminng.domain.Membership;
-import org.hostsharing.hsadminng.domain.enumeration.CustomerKind;
-import org.hostsharing.hsadminng.domain.enumeration.VatRegion;
 
-import org.apache.commons.lang3.RandomStringUtils;
-import org.apache.commons.lang3.RandomUtils;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -31,10 +27,22 @@ public class MembershipRepositoryIntTest {
     @Autowired
     private MembershipRepository membershipRepository;
 
+    @Test
+    public void sequenceStartsAbove1000000ToSpareIdsForSampleData() {
+        // given
+        final Membership givenMembership = createMembership(createPersistentCustomer(), "2019-01-01", null);
+
+        // when
+        membershipRepository.save(givenMembership);
+
+        // then
+        assertThat(givenMembership.getId()).isGreaterThan(1000000);
+    }
+
     @Test
     public void hasUncancelledMembershipForCustomerIsTrueForCustomerWithUncancelledMembership() {
         // given
-        final Customer givenCustomerWithUncancelledMembership = createCustomerWithMembership("2011-08-18", null);
+        final Customer givenCustomerWithUncancelledMembership = createPersistentCustomerWithMembership("2011-08-18", null);
 
         // when
         boolean actual = membershipRepository
@@ -47,7 +55,7 @@ public class MembershipRepositoryIntTest {
     @Test
     public void hasUncancelledMembershipForCustomerIsFalseForCustomerWithoutMembership() {
         // given
-        final Customer givenCustomerWithoutMembership = createCustomer();
+        final Customer givenCustomerWithoutMembership = createPersistentCustomer();
 
         // when
         boolean actual = membershipRepository.hasUncancelledMembershipForCustomer(givenCustomerWithoutMembership.getId());
@@ -59,7 +67,9 @@ public class MembershipRepositoryIntTest {
     @Test
     public void hasUncancelledMembershipForCustomerIsFalseForCustomerWithCancelledMembership() {
         // given
-        final Customer givenCustomerWithCancelledMembership = createCustomerWithMembership("2011-08-18", "2017-12-31");
+        final Customer givenCustomerWithCancelledMembership = createPersistentCustomerWithMembership(
+                "2011-08-18",
+                "2017-12-31");
 
         // when
         boolean actual = membershipRepository.hasUncancelledMembershipForCustomer(givenCustomerWithCancelledMembership.getId());
@@ -70,20 +80,18 @@ public class MembershipRepositoryIntTest {
 
     // --- only test fixture below ---
 
-    private Customer createCustomer() {
+    private Customer createPersistentCustomer() {
-        final Customer customer = new Customer();
+        return customerRepository.save(CustomerRepositoryIntTest.createCustomer());
-        customer.setPrefix(RandomStringUtils.randomAlphabetic(3).toLowerCase());
+    }
-        customer.setReference(RandomUtils.nextInt(10001, 19999));
+
-        customer.setName(RandomStringUtils.randomAlphabetic(10));
+    private Customer createPersistentCustomerWithMembership(final String from, final String to) {
-        customer.setContractualAddress(RandomStringUtils.randomAlphabetic(10));
+        final Customer customer = createPersistentCustomer();
-        customer.setKind(CustomerKind.NATURAL);
+        final Membership membership = createMembership(customer, from, to);
-        customer.setVatRegion(VatRegion.DOMESTIC);
+        membershipRepository.save(membership);
-        customerRepository.save(customer);
         return customer;
     }
 
-    private Customer createCustomerWithMembership(final String from, final String to) {
+    static Membership createMembership(final Customer customer, final String from, final String to) {
-        final Customer customer = createCustomer();
         final Membership membership = new Membership();
         membership.setCustomer(customer);
         membership.setMemberFromDate(LocalDate.parse(from));
@@ -91,7 +99,6 @@ public class MembershipRepositoryIntTest {
             membership.setMemberUntilDate(LocalDate.parse(to));
         }
         membership.setAdmissionDocumentDate(membership.getMemberFromDate().minusDays(7));
-        membershipRepository.save(membership);
+        return membership;
-        return customer;
     }
 }

src/test/java/org/hostsharing/hsadminng/repository/SepaMandateRepositoryIntTest.java

@@ -0,0 +1,62 @@
+// Licensed under Apache-2.0
+package org.hostsharing.hsadminng.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hostsharing.hsadminng.HsadminNgApp;
+import org.hostsharing.hsadminng.domain.Customer;
+import org.hostsharing.hsadminng.domain.SepaMandate;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = HsadminNgApp.class)
+@Transactional
+public class SepaMandateRepositoryIntTest {
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    @Autowired
+    private SepaMandateRepository sepaMandateRepository;
+
+    @Test
+    public void sequenceStartsAbove1000000ToSpareIdsForSampleData() {
+        // given
+        final SepaMandate givenSepaMandate = createSepaMandate(createPersistentCustomer(), "DUMMY_REF", "2019-01-08", null);
+
+        // when
+        sepaMandateRepository.save(givenSepaMandate);
+
+        // then
+        assertThat(givenSepaMandate.getId()).isGreaterThan(1000000);
+    }
+
+    // --- only test fixture below ---
+
+    private Customer createPersistentCustomer() {
+        return customerRepository.save(CustomerRepositoryIntTest.createCustomer());
+    }
+
+    static SepaMandate createSepaMandate(final Customer customer, final String reference, final String from, final String to) {
+        final SepaMandate sepaMandate = new SepaMandate();
+        sepaMandate.setCustomer(customer);
+        sepaMandate.setReference(reference);
+        sepaMandate.setIban("NL57ABNA2228161411");
+        sepaMandate.setBic("ABNANL2A");
+        sepaMandate.setGrantingDocumentDate(LocalDate.parse(from));
+        sepaMandate.setValidFromDate(LocalDate.parse(from).plusDays(1));
+        if (to != null) {
+            sepaMandate.setRevokationDocumentDate(LocalDate.parse(to));
+            sepaMandate.setValidUntilDate(LocalDate.parse(to).plusDays(7));
+        }
+        return sepaMandate;
+    }
+}

src/test/java/org/hostsharing/hsadminng/repository/ShareRepositoryIntTest.java

@@ -0,0 +1,75 @@
+// Licensed under Apache-2.0
+package org.hostsharing.hsadminng.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hostsharing.hsadminng.HsadminNgApp;
+import org.hostsharing.hsadminng.domain.Customer;
+import org.hostsharing.hsadminng.domain.Membership;
+import org.hostsharing.hsadminng.domain.Share;
+import org.hostsharing.hsadminng.domain.enumeration.ShareAction;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = HsadminNgApp.class)
+@Transactional
+public class ShareRepositoryIntTest {
+
+    @Autowired
+    private CustomerRepository customerRepository;
+
+    @Autowired
+    private MembershipRepository membershipRepository;
+
+    @Autowired
+    private ShareRepository shareRepository;
+
+    @Test
+    public void sequenceStartsAbove1000000ToSpareIdsForSampleData() {
+        // given
+        final Share givenShare = createArbitraryShare();
+
+        // when
+        shareRepository.save(givenShare);
+
+        // then
+        assertThat(givenShare.getId()).isGreaterThan(1000000);
+    }
+
+    // --- only test fixture below ---
+
+    private Customer createPersistentCustomer() {
+        return customerRepository.save(CustomerRepositoryIntTest.createCustomer());
+    }
+
+    private Membership createPersistentMembership() {
+        return membershipRepository
+                .save(MembershipRepositoryIntTest.createMembership(createPersistentCustomer(), "2019-01-08", null));
+    }
+
+    static Share createShare(
+            final Membership membership,
+            final ShareAction action,
+            final int quantity,
+            final String documentDate) {
+        final Share share = new Share();
+        share.setMembership(membership);
+        share.setAction(action);
+        share.setQuantity(quantity);
+        share.setDocumentDate(LocalDate.parse(documentDate));
+        share.setValueDate(LocalDate.parse(documentDate).plusDays(1));
+        return share;
+    }
+
+    private Share createArbitraryShare() {
+        return createShare(createPersistentMembership(), ShareAction.SUBSCRIPTION, 1, "2019-01-08");
+    }
+}