Test training for Acme

$ mvn clean validate

$ mvn clean package

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  
<?xml version="1.0" encoding="UTF-8"?>
<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.2</version>
  <executions>
    <execution>
      <goals>
        <goal>prepare-agent</goal>
      </goals>
    </execution>
    <execution>
      <id>report</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>report</goal>
      </goals>
    </execution>
  </executions>
</plugin>

$ mvn clean test

$ mvn jacoco:report

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

  
<?xml version="1.0" encoding="UTF-8"?>
<execution>
  <id>jacoco-check</id>
  <goals>
    <goal>check</goal>
  </goals>
  <configuration>
    <rules>
      <rule>
        <!-- element can also be PACKAGE or LINES -->
        <element>BUNDLE</element>
        <limits>
          <limit>
            <counter>LINE</counter>
            <value>COVEREDRATIO</value>
            <minimum>0.50</minimum>
          </limit>
        </limits>
      </rule>
    </rules>
  </configuration>
</execution>

$ mvn clean verify  # the verify phase is the Maven phase in which the jacoco:check goal is run

<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>test</scope>
</dependency>

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

  
package nl.ing.testing.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class BankAccount {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    private String bankAccountNumber;
    private double saldo;
    private boolean savingsAccount;

    public boolean isSavingsAccount() {
        return savingsAccount;
    }

    public void setSavingsAccount(boolean savingsAccount) {
        this.savingsAccount = savingsAccount;
    }

    public long getId() {
        return id;
    }

    public String getBankAccountNumber() {
        return bankAccountNumber;
    }

    public double getSaldo() {
        return saldo;
    }

    public void setBankAccountNumber(String bankAccountNumber) {
        this.bankAccountNumber = bankAccountNumber;
    }

    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

  
package nl.ing.testing.service;

import nl.ing.testing.model.BankAccount;
import nl.ing.testing.persistence.BankAccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.Optional;

@Service
@Transactional
public class BankAccountService {

    @Autowired
    private BankAccountRepository repository;

    public BankAccount insert(BankAccount newBankAccount) {
        return this.repository.save(newBankAccount);
    }

    public Optional<BankAccount> findById(long id) {
        return this.repository.findById(id);
    }

    public BankAccount update(long id, BankAccount data) {
        BankAccount target = this.repository.findById(id).get();
        target.setBankAccountNumber(data.getBankAccountNumber());
        target.setSaldo(data.getSaldo());

        return this.repository.save(target);
    }

    public boolean deleteById(long id){
        if(this.repository.findById(id).isPresent()) {
            this.repository.deleteById(id);

            return true;
        }
        else {
            return false;
        }
    }

    public long count() {

        return this.repository.count();
    }

    public void setAllBankAccountsToZeroes() {

        this.repository.setAllBankAccountsToZeroes();
    }

    public Iterable<BankAccount> findAll() {

        return this.repository.findAll();
    }

    public void setAllBankAccountsToSavingsAccount() {
        this.repository.setAllBankAccountsToSavingsAccount();
    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  
package nl.ing.testing.persistence;

import nl.ing.testing.model.BankAccount;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BankAccountRepository  extends CrudRepository <BankAccount, Long> {

    @Query("update BankAccount set saldo='0'")
    @Modifying
    public void setAllBankAccountsToZeroes();

    @Query("update BankAccount set savingsAccount=true")
    @Modifying
    public void setAllBankAccountsToSavingsAccount();
}

  
1
2
3
4

  
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
#nog niet nodig spring.datasource.password=
spring.datasource.driverClassName=org.h2.Driver

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

  
package nl.ing.testing.service;

import nl.ing.testing.Application;
import nl.ing.testing.model.BankAccount;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.context.ActiveProfiles;

@ActiveProfiles("integrationtest")
@SpringBootTest(classes = Application.class, webEnvironment = WebEnvironment.RANDOM_PORT)
public class BankAccountServiceIT {

   @Autowired
   private BankAccountService bankAccountService;

   @Test
   public void testCrud() {

      BankAccount nieuwe = new BankAccount();
      nieuwe.setSavingsAccount(true);
      nieuwe.setBankAccountNumber("Schaken");

      BankAccount bankAccountCreated = this.bankAccountService.insert(nieuwe);

      Assertions.assertTrue(bankAccountCreated.getId() != 0);

      long id = bankAccountCreated.getId();

      BankAccount opgehaald = this.bankAccountService.findById(id).get();  // rloman refactor

      Assertions.assertEquals(nieuwe.getBankAccountNumber(), opgehaald.getBankAccountNumber());

      opgehaald.setBankAccountNumber("10.21.33.44.555");

      BankAccount opgehaaldNaSaven = this.bankAccountService.update(id, opgehaald);

      Assertions.assertEquals("10.21.33.44.555", opgehaaldNaSaven.getBankAccountNumber());

      this.bankAccountService.deleteById(id);

      Assertions.assertFalse(this.bankAccountService.findById(id).isPresent());
   }

   @Test
   public void testDeletingNonExisting() {

      BankAccount nieuwe = new BankAccount();
      nieuwe.setSavingsAccount(true);
      nieuwe.setBankAccountNumber("Schaken");

      BankAccount bankAccountCreated = this.bankAccountService.insert(nieuwe);

      Assertions.assertTrue(bankAccountCreated.getId() != 0);

      long id = bankAccountCreated.getId();

      BankAccount opgehaald = this.bankAccountService.findById(id).get(); // rloman refactor

      Assertions.assertEquals(nieuwe.getBankAccountNumber(), opgehaald.getBankAccountNumber());

      opgehaald.setBankAccountNumber("Schaken en Dammen");

      BankAccount opgehaaldNaSaven = this.bankAccountService.update(id, opgehaald);

      Assertions.assertEquals("Schaken en Dammen", opgehaaldNaSaven.getBankAccountNumber());

      Assertions.assertTrue(this.bankAccountService.deleteById(id));

      Assertions.assertFalse(this.bankAccountService.deleteById(id));

   }

   @Test
   public void testSetAllBankAccountsToZero() {

     long init = this.bankAccountService.count();

      for (int i = 0; i < 3; i++) {
         BankAccount nieuwe = new BankAccount();
         nieuwe.setSavingsAccount(false);
         nieuwe.setBankAccountNumber(String.valueOf(Math.random()* 100_000_000));

         this.bankAccountService.insert(nieuwe);
      }

     Assertions.assertEquals(init+3, this.bankAccountService.count());

     this.bankAccountService.setAllBankAccountsToZeroes();

     this.bankAccountService.findAll().forEach(s -> {
        Assertions.assertEquals(0, s.getSaldo(), 0.01);
     });

     Assertions.assertEquals(3, this.bankAccountService.count());
   }

   @Test
   public void testSetAllBankAccountsToSavingsAccount() {

      long init = this.bankAccountService.count();

      for (int i = 0; i < 3; i++) {
         BankAccount nieuwe = new BankAccount();
         nieuwe.setSavingsAccount(false);

         this.bankAccountService.insert(nieuwe);
      }

      this.bankAccountService.setAllBankAccountsToSavingsAccount();

      this.bankAccountService.findAll().forEach(s -> {
         Assertions.assertTrue(s.isSavingsAccount());
      });

      Assertions.assertEquals(init+3, this.bankAccountService.count());
   }
}