PAN-52 Added findByName and findByBranch methods to the repository, and created first couple of methods and corresponding tests in the ProofController

persistence/scripts/mysql/local_development.sql

@@ -36,6 +36,7 @@ version int default 1
 CREATE TABLE proofs
 (
   id                       INT NOT NULL AUTO_INCREMENT,
+  name                     VARCHAR(512) NOT NULL,
   branch                   VARCHAR(512) NOT NULL,
   referenced_definitions   JSON,
   referenced_theorems      JSON,

persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java

@@ -1,11 +1,69 @@
 package edu.msudenver.tsp.persistence.controller;
 
+import edu.msudenver.tsp.persistence.dto.ProofDto;
 import edu.msudenver.tsp.persistence.repository.ProofRepository;
 import lombok.AllArgsConstructor;
-import org.springframework.stereotype.Component;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.util.StopWatch;
+import org.springframework.web.bind.annotation.*;
 
-@Component
+import java.util.List;
+
+@Slf4j
+@RestController
 @AllArgsConstructor
+@RequestMapping("/proofs")
 public class ProofController {
     private final ProofRepository proofRepository;
+
+    @GetMapping("/")
+    public @ResponseBody
+    ResponseEntity<Iterable<ProofDto>> getAllProofs() {
+        LOG.info("Received request to list all theorems");
+
+        LOG.debug("Querying for list of all theorems");
+        final StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+
+        final List<ProofDto> listOfProofs = proofRepository.findAll();
+
+        stopWatch.stop();
+
+        LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete");
+        LOG.info("Returning list of all theorems with size " + listOfProofs.size());
+
+        return new ResponseEntity<>(listOfProofs, HttpStatus.OK);
+    }
+
+    @GetMapping("/{branch}")
+    public @ResponseBody
+    ResponseEntity<List<ProofDto>> getAllProofsByBranch(@PathVariable("branch") final String branch) {
+        LOG.info("Received request to query for proofs related to the " + branch + " branch of mathematics");
+        if (branch == null) {
+            LOG.error("ERROR: branch was null");
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+        }
+
+        LOG.debug("Querying for proofs with branch " + branch);
+
+        final StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+
+        final List<ProofDto> listOfProofs = proofRepository.findByBranch(branch);
+
+        stopWatch.stop();
+
+        LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete");
+        LOG.info("Returning list of all proofs with size " + listOfProofs.size());
+
+        if (listOfProofs.isEmpty()) {
+            LOG.warn("No proofs were found for branch {}", branch);
+            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+        }
+
+        LOG.info("Returning list of proofs with branch {}", branch);
+        return new ResponseEntity<>(listOfProofs, HttpStatus.OK);
+    }
 }

persistence/src/main/java/edu/msudenver/tsp/persistence/dto/ProofDto.java

@@ -11,38 +11,42 @@ import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.Size;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.List;
 
 @Entity(name = "proofs")
 @EntityListeners(AuditingEntityListener.class)
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class ProofDto extends BaseDto implements Serializable {
+    @NotBlank(groups = Insert.class)
+    @Size(min = 1, max = 512, message = "The name must be at least 1 character and at most 512 characters")
+    private String name;
     @NotBlank(groups = Insert.class)
     @Size(min = 1, max = 512, message = "The branch must be at least 1 character and at most 512 characters")
     private String branch;
-    @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private String referencedDefinitions;
+    @Type(type = "json") @Column(name = "referenced_definitions", columnDefinition = "jsonb") private List<String> referencedDefinitions;
-    @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private String referencedTheorems;
+    @Type(type = "json") @Column(name = "referenced_theorems", columnDefinition = "jsonb") private List<String> referencedTheorems;
     @Temporal(TemporalType.DATE) @Column(name = "date_created") private Date dateCreated;
     @Temporal(TemporalType.DATE) @Column(name = "last_updated") private Date lastUpdated;
 
 
     @JsonProperty("referenced_definitions")
-    public String getReferencedDefinitions() {
+    public List<String> getReferencedDefinitions() {
         return referencedDefinitions;
     }
 
     @JsonProperty("referenced_definitions")
-    public void setReferencedDefinitions(final String referencedDefinitions) {
+    public void setReferencedDefinitions(final List<String> referencedDefinitions) {
         this.referencedDefinitions = referencedDefinitions;
     }
 
     @JsonProperty("referenced_theorems")
-    public String getReferencedTheorems() {
+    public List<String> getReferencedTheorems() {
         return referencedTheorems;
     }
 
     @JsonProperty("referenced_theorems")
-    public void setReferencedTheorems(final String referencedTheorems) {
+    public void setReferencedTheorems(final List<String> referencedTheorems) {
         this.referencedTheorems = referencedTheorems;
     }
 

persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java

@@ -1,7 +1,13 @@
 package edu.msudenver.tsp.persistence.repository;
 
-import edu.msudenver.tsp.persistence.dto.BaseDto;
+import edu.msudenver.tsp.persistence.dto.ProofDto;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface ProofRepository extends JpaRepository<BaseDto, Integer> {
+import java.util.List;
+
+public interface ProofRepository extends JpaRepository<ProofDto, Integer> {
+
+    List<ProofDto> findByBranch(String branch);
+
+    List<ProofDto> findByName(String name);
 }

persistence/src/test/java/edu/msudenver/tsp/persistence/controller/ProofControllerTest.java

@@ -0,0 +1,108 @@
+package edu.msudenver.tsp.persistence.controller;
+
+import edu.msudenver.tsp.persistence.dto.ProofDto;
+import edu.msudenver.tsp.persistence.repository.ProofRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.BindingResult;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProofControllerTest {
+    @Mock private ProofRepository proofRepository;
+    @InjectMocks private ProofController proofController;
+    @Mock private BindingResult bindingResult;
+
+    @Test
+    public void testGetAllTheorems() {
+        final ProofDto proofDto = createProof();
+        final List<ProofDto> listOfProofs = new ArrayList<>();
+        listOfProofs.add(proofDto);
+        listOfProofs.add(proofDto);
+
+        when(proofRepository.findAll()).thenReturn(listOfProofs);
+
+        final ResponseEntity<Iterable<ProofDto>> responseEntity = proofController.getAllProofs();
+
+        assertNotNull(responseEntity);
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+        assertTrue(responseEntity.hasBody());
+        assertNotNull(responseEntity.getBody());
+
+        responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof));
+    }
+
+    @Test
+    public void testGetAllProofsByBranch() {
+        final ProofDto proofDto = createProof();
+        final List<ProofDto> listOfProofs = new ArrayList<>();
+        listOfProofs.add(proofDto);
+        listOfProofs.add(proofDto);
+
+        when(proofRepository.findByBranch(anyString())).thenReturn(listOfProofs);
+
+        final ResponseEntity<List<ProofDto>> responseEntity = proofController.getAllProofsByBranch("test");
+
+        assertNotNull(responseEntity);
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+        assertTrue(responseEntity.hasBody());
+        assertNotNull(responseEntity.getBody());
+
+        responseEntity.getBody().forEach(proof -> assertEquals(proofDto, proof));
+    }
+
+    @Test
+    public void testGetAllProfsByBranch_nullBranch() {
+        final ResponseEntity<List<ProofDto>> responseEntity = proofController.getAllProofsByBranch(null);
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
+        verifyZeroInteractions(proofRepository);
+    }
+
+    @Test
+    public void testGetAllProofsByBranch_noProofsFound() {
+        when(proofRepository.findByBranch(anyString())).thenReturn(Collections.emptyList());
+
+        final ResponseEntity<List<ProofDto>> responseEntity = proofController.getAllProofsByBranch("test nonexistent branch");
+
+        assertNotNull(responseEntity);
+        assertFalse(responseEntity.hasBody());
+        assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode());
+    }
+
+    private ProofDto createProof() {
+        final List<String> referencedTheoremsList = new ArrayList<>();
+        referencedTheoremsList.add("test theorem 1");
+        referencedTheoremsList.add("test theorem 2");
+
+        final List<String> referencedDefinitionsList = new ArrayList<>();
+        referencedDefinitionsList.add("test definition 1");
+        referencedDefinitionsList.add("test definition 2");
+
+        final ProofDto proofDto = new ProofDto();
+        proofDto.setName("Test proof");
+        proofDto.setBranch("Test branch");
+        proofDto.setDateCreated(new Date());
+        proofDto.setReferencedTheorems(referencedTheoremsList);
+        proofDto.setReferencedDefinitions(referencedDefinitionsList);
+
+        return proofDto;
+    }
+}