diff --git a/.travis.yml b/.travis.yml index 933d299..8faab01 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,7 +19,7 @@ before_install: before_script: - mysql_upgrade --force -uroot - mysql -u root -e 'CREATE DATABASE IF NOT EXISTS pandamonium;' - - mysql -u root -e "CREATE USER 'panda'@'localhost';" + - mysql -u root -e "CREATE USER 'panda'@'localhost' IDENTIFIED BY 'secret';" - mysql -u root -e "GRANT ALL PRIVILEGES ON *.* to 'panda'@'localhost';" - mysql -u root pandamonium < persistence/scripts/mysql/local_development.sql diff --git a/pandamonium-theorem-prover/build.gradle b/pandamonium-theorem-prover/build.gradle index f93378a..a89060e 100644 --- a/pandamonium-theorem-prover/build.gradle +++ b/pandamonium-theorem-prover/build.gradle @@ -55,12 +55,13 @@ subprojects { compile 'org.slf4j:slf4j-api:1.7.21' compile "joda-time:joda-time:2.2" compile('org.springframework:spring-context:5.0.9.RELEASE') - + + compileOnly 'org.projectlombok:lombok:1.18.4' + testCompile group: 'junit', name: 'junit', version: '4.11' testCompile group: 'junit', name: 'junit', version: '4.12' testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} - compileOnly 'org.projectlombok:lombok:1.18.4' } test { @@ -94,11 +95,10 @@ dependencies { compile 'org.codehaus.groovy:groovy-all:2.3.11' compile 'org.apache.commons:commons-lang3:3.5' // The production code uses the SLF4J logging API at compile time - compile 'org.slf4j:slf4j-api:1.7.21' + compile 'org.slf4j:slf4j-api:1.7.22' compile "joda-time:joda-time:2.2" - compile("org.springframework.boot:spring-boot-starter-web") - - testCompile group: 'junit', name: 'junit', version: '4.11' + compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + testCompile group: 'junit', name: 'junit', version: '4.12' testCompile "org.springframework:spring-test:5.0.9.RELEASE" testCompile('org.mockito:mockito-core:1.10.19') {exclude(group: 'org.hamcrest')} @@ -129,6 +129,6 @@ compileTestKotlin { } wrapper { - gradleVersion = '4.10.2' + gradleVersion = '5.2.1' distributionType = Wrapper.DistributionType.ALL } \ No newline at end of file diff --git a/pandamonium-theorem-prover/lib/javax.ejb.jar b/pandamonium-theorem-prover/lib/javax.ejb.jar new file mode 100644 index 0000000..4ebf5ec Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.ejb.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.jms.jar b/pandamonium-theorem-prover/lib/javax.jms.jar new file mode 100644 index 0000000..d31451a Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.jms.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.persistence.jar b/pandamonium-theorem-prover/lib/javax.persistence.jar new file mode 100644 index 0000000..21d80e0 Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.persistence.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.resource.jar b/pandamonium-theorem-prover/lib/javax.resource.jar new file mode 100644 index 0000000..696a234 Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.resource.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.servlet.jsp.jar b/pandamonium-theorem-prover/lib/javax.servlet.jsp.jar new file mode 100644 index 0000000..9c0631c Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.servlet.jsp.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.servlet.jsp.jstl.jar b/pandamonium-theorem-prover/lib/javax.servlet.jsp.jstl.jar new file mode 100644 index 0000000..7be17cc Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.servlet.jsp.jstl.jar differ diff --git a/pandamonium-theorem-prover/lib/javax.transaction.jar b/pandamonium-theorem-prover/lib/javax.transaction.jar new file mode 100644 index 0000000..729c695 Binary files /dev/null and b/pandamonium-theorem-prover/lib/javax.transaction.jar differ diff --git a/pandamonium-theorem-prover/persistence/build.gradle b/pandamonium-theorem-prover/persistence/build.gradle index a7b5ca9..b832e7e 100644 --- a/pandamonium-theorem-prover/persistence/build.gradle +++ b/pandamonium-theorem-prover/persistence/build.gradle @@ -1,5 +1,4 @@ -import org.gradle.internal.os.OperatingSystem; - +import org.gradle.internal.os.OperatingSystem plugins { id 'java' } @@ -10,23 +9,36 @@ version '1.0' sourceCompatibility = 1.8 +sonarqube { + properties { + property "sonar.projectName", 'Pandamonium Persistence Tier' + } +} + repositories { mavenCentral() } dependencies { - testCompile group: 'junit', name: 'junit', version: '4.12' + compile group: 'org.springframework.data', name: 'spring-data-jpa', version: '2.0.5.RELEASE' + compile group: 'org.apache.tomcat', name: 'tomcat-jdbc', version: '9.0.16' + compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '2.0.5.RELEASE' + compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.5.RELEASE' + compile group: 'org.springframework', name: 'spring-aspects', version: '5.1.5.RELEASE' + compile group: 'org.hibernate', name: 'hibernate-core', version: '5.4.1.Final' + compile group: 'com.vladmihalcea', name: 'hibernate-types-52', version: '2.4.1' + compile fileTree(dir: 'lib', include: '**/*.jar') - - compile 'com.mchange:c3p0:0.9.5.2' - compile 'mysql:mysql-connector-java:5.1.35' - compile 'org.hibernate:hibernate-validator:5.3.4.Final' - compile 'javax.validation:validation-api:1.1.0.Final' + + compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.15' compile('com.googlecode.log4jdbc:log4jdbc:1.2') { exclude(group: 'org.slf4j') } + testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.1.2.RELEASE' + testCompile group: 'junit', name: 'junit', version: '4.12' testCompile 'javax.el:javax.el-api:3.0.0' + } task loadDb(type: Exec, group: 'Verification', description: 'Reloads the local database.') { @@ -35,6 +47,6 @@ task loadDb(type: Exec, group: 'Verification', description: 'Reloads the local d commandLine './loaddb.sh' } else { workingDir "./scripts/mysql" - commandLine 'loaddb.bat' + commandLine=['cmd','/c','loaddb.bat'] } } diff --git a/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.bat b/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.bat index 37c4da6..6a923cb 100644 --- a/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.bat +++ b/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.bat @@ -1,5 +1,5 @@ -SET MYSQL_PWD=secret -FOR /R %%s IN (.\*.sql) do ( +set mysql_pwd = secret +FOR /R %%s IN (*.sql) do ( echo **** %%s **** - echo mysql --batch --quick --raw --line-numbers --force --user=panda < %%s + mysql -u panda -psecret < %%s ) diff --git a/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.sh b/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.sh index 974a80b..b169b0a 100755 --- a/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.sh +++ b/pandamonium-theorem-prover/persistence/scripts/mysql/loaddb.sh @@ -1,8 +1,7 @@ #!/usr/bin/env bash -export MYSQL_PWD=secret for sqlScript in $( find . -name "*.sql" -print | sort); do echo "**** $sqlScript ****" - mysql --batch --quick --raw --line-numbers --force --user=panda < $sqlScript + mysql -u panda -psecret < $sqlScript done \ No newline at end of file diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java new file mode 100644 index 0000000..824d5a8 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/DefinitionsIntegrationTest.java @@ -0,0 +1,74 @@ +package edu.msudenver.tsp.persistence; + +import edu.msudenver.tsp.persistence.dto.Definition; +import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Notation; +import edu.msudenver.tsp.persistence.repository.DefinitionRepository; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = PersistenceTestConfig.class) +public class DefinitionsIntegrationTest { + @Autowired private DefinitionRepository definitionRepository; + + @Test + public void testCRUDFunctionality() { + // Create a new definition + final DefinitionDto definitionDto = createDefinition(); + final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); + + assertNotNull(savedDefinition); + assertEquals(Integer.valueOf(0), savedDefinition.getVersion()); + + final int id = savedDefinition.getId(); + + assertEquals("Test Name", savedDefinition.getName()); + assertNotNull(savedDefinition.getDefinition()); + assertNotNull(savedDefinition.getNotation()); + + final List definitionsList = savedDefinition.getDefinition().getDefinitions(); + final List notationList = savedDefinition.getNotation().getNotations(); + + assertEquals(2, definitionsList.size()); + assertEquals(1, notationList.size()); + assertEquals("Test definition 1", definitionsList.get(0)); + assertEquals("Test definition 2", definitionsList.get(1)); + assertEquals("\\testLaTeX", notationList.get(0)); + + definitionRepository.delete(savedDefinition); + final Optional deletedDefinition = definitionRepository.findById(id); + assertFalse(deletedDefinition.isPresent()); + } + + private DefinitionDto createDefinition() { + final List definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + definitionList.add("Test definition 2"); + + final Definition definition = new Definition(); + definition.setDefinitions(definitionList); + + final List notationList = new ArrayList<>(); + notationList.add("\\testLaTeX"); + + final Notation notation = new Notation(); + notation.setNotations(notationList); + + final DefinitionDto definitionDto = new DefinitionDto(); + definitionDto.setName("Test Name"); + definitionDto.setDefinition(definition); + definitionDto.setNotation(notation); + + return definitionDto; + } +} diff --git a/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java new file mode 100644 index 0000000..7427fa2 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/integrationTest/java/edu/msudenver/tsp/persistence/PersistenceTestConfig.java @@ -0,0 +1,93 @@ +package edu.msudenver.tsp.persistence; + +import org.hibernate.SessionFactory; +import org.hibernate.jpa.HibernatePersistenceProvider; +import org.springframework.boot.autoconfigure.domain.EntityScan; +import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import org.springframework.data.jpa.repository.config.EnableJpaAuditing; +import org.springframework.data.jpa.repository.config.EnableJpaRepositories; +import org.springframework.jdbc.datasource.init.DataSourceInitializer; +import org.springframework.orm.hibernate5.HibernateTransactionManager; +import org.springframework.orm.hibernate5.LocalSessionFactoryBuilder; +import org.springframework.orm.jpa.JpaTransactionManager; +import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; +import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter; + +import javax.sql.DataSource; +import java.util.Properties; + +@Configuration +@EnableJpaRepositories +@EnableJpaAuditing +@EntityScan(basePackages = "edu.msudenver.tsp.persistence") +public class PersistenceTestConfig { + @Bean + @Primary + public LocalContainerEntityManagerFactoryBean entityManagerFactory() { + final LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean(); + entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter()); + entityManagerFactoryBean.setDataSource(getDataSource()); + entityManagerFactoryBean.setPersistenceProviderClass(HibernatePersistenceProvider.class); + entityManagerFactoryBean.setPackagesToScan("edu.msudenver.tsp.persistence"); + entityManagerFactoryBean.setJpaProperties(additionalProperties()); + + return entityManagerFactoryBean; + } + + @Bean + public JpaTransactionManager jpaTransactionManager() { + final JpaTransactionManager jpaTransactionManager = new JpaTransactionManager(); + jpaTransactionManager.setEntityManagerFactory(entityManagerFactory().getObject()); + return jpaTransactionManager; + } + + private HibernateJpaVendorAdapter vendorAdapter() { + final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); + vendorAdapter.setShowSql(true); + return vendorAdapter; + } + + @Bean(name = "dataSource") + public DataSource getDataSource(){ + return DataSourceBuilder + .create() + .username("panda") + .password("secret") + .url("jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false") + .driverClassName("com.mysql.cj.jdbc.Driver") + .build(); + } + + @Bean(name = "sessionFactory") + public SessionFactory getSessionFactory(final DataSource dataSource) { + final LocalSessionFactoryBuilder sessionFactoryBuilder = new LocalSessionFactoryBuilder(dataSource); + sessionFactoryBuilder.scanPackages("edu.msudenver.tsp.persistence.dto"); + return sessionFactoryBuilder.buildSessionFactory(); + } + + @Bean(name = "transactionManager") + public HibernateTransactionManager getTransactionManager(final SessionFactory sessionFactory) { + return new HibernateTransactionManager(sessionFactory); + } + + @Bean + public DataSourceInitializer dataSourceInitializer(final DataSource dataSource) { + final DataSourceInitializer initializer = new DataSourceInitializer(); + initializer.setDataSource(dataSource); + return initializer; + } + + private Properties additionalProperties() { + final Properties properties = new Properties(); + properties.setProperty("hibernate.hbm2ddl.auto", "update"); + properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect"); + properties.setProperty("spring.jpa.show-sql", "true"); + properties.setProperty("spring.datasource.tomcat.max-active", "1"); + properties.setProperty("hibernate.id.new_generator_mappings","false"); + + return properties; + } +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java new file mode 100644 index 0000000..39a3f11 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceApi.java @@ -0,0 +1,109 @@ +package edu.msudenver.tsp.persistence; + +import org.hibernate.SessionFactory; +import org.hibernate.jpa.HibernatePersistenceProvider; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.domain.EntityScan; +import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Primary; +import org.springframework.data.jpa.repository.config.EnableJpaAuditing; +import org.springframework.data.jpa.repository.config.EnableJpaRepositories; +import org.springframework.jdbc.datasource.init.DataSourceInitializer; +import org.springframework.orm.hibernate5.HibernateTransactionManager; +import org.springframework.orm.hibernate5.LocalSessionFactoryBuilder; +import org.springframework.orm.jpa.JpaTransactionManager; +import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; +import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter; + +import javax.sql.DataSource; +import java.util.Properties; + +@SpringBootApplication +@EnableJpaRepositories +@EnableJpaAuditing +@EntityScan +public class PersistenceApi { + + @Value("${spring.datasource.username}") private String username; + @Value("${spring.datasource.password}") private String password; + @Value("${spring.jpa.hibernate.ddl-auto}") private String hibernateTablePolicy; + @Value("${spring.datasource.url}") private String databaseUrl; + @Value("${spring.jpa.properties.hibernate.dialect}") private String hibernateDialect; + @Value("${spring.jpa.show-sql}") private String showSql; + @Value("${spring.datasource.driver-class-name}") private String driverClassName; + @Value("${spring.datasource.tomcat.max-active}") private String tomcatPoolMaxActive; + + public static void main(final String[] args) { + SpringApplication.run(PersistenceApi.class, args); + } + + @Bean + @Primary + public LocalContainerEntityManagerFactoryBean entityManagerFactory() { + final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); + em.setJpaVendorAdapter(vendorAdapter()); + em.setDataSource(getDataSource()); + em.setPersistenceProviderClass(HibernatePersistenceProvider.class); + em.setPackagesToScan("edu.msudenver.tsp.persistence"); + em.setJpaProperties(additionalProperties()); + + return em; + } + + @Bean + public JpaTransactionManager jpaTransactionManager() { + final JpaTransactionManager jpaTransactionManager = new JpaTransactionManager(); + jpaTransactionManager.setEntityManagerFactory(entityManagerFactory().getObject()); + return jpaTransactionManager; + } + + private HibernateJpaVendorAdapter vendorAdapter() { + final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); + vendorAdapter.setShowSql(true); + return vendorAdapter; + } + + @Bean(name = "dataSource") + public DataSource getDataSource(){ + return DataSourceBuilder + .create() + .username(username) + .password(password) + .url(databaseUrl) + .driverClassName(driverClassName) + .build(); + } + + @Bean(name = "sessionFactory") + public SessionFactory getSessionFactory(final DataSource dataSource) { + final LocalSessionFactoryBuilder sessionFactoryBuilder = new LocalSessionFactoryBuilder(dataSource); + sessionFactoryBuilder.scanPackages("edu.msudenver.tsp.persistence.dto"); + return sessionFactoryBuilder.buildSessionFactory(); + } + + @Bean(name = "transactionManager") + public HibernateTransactionManager getTransactionManager(final SessionFactory sessionFactory) { + return new HibernateTransactionManager(sessionFactory); + } + + @Bean + public DataSourceInitializer dataSourceInitializer(final DataSource dataSource) { + final DataSourceInitializer initializer = new DataSourceInitializer(); + initializer.setDataSource(dataSource); + return initializer; + } + + Properties additionalProperties() { + final Properties properties = new Properties(); + properties.setProperty("hibernate.hbm2ddl.auto", "update"); + properties.setProperty("hibernate.dialect", hibernateDialect); + properties.setProperty("spring.jpa.show-sql", showSql); + properties.setProperty("spring.datasource.tomcat.max-active", tomcatPoolMaxActive); + properties.setProperty("hibernate.id.new_generator_mappings","false"); + + return properties; + } +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceConfig.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceConfig.java deleted file mode 100644 index 34a2b13..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/PersistenceConfig.java +++ /dev/null @@ -1,10 +0,0 @@ -package edu.msudenver.tsp.persistence; - -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ComponentScan -public class PersistenceConfig { - -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java new file mode 100644 index 0000000..8404acb --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/AccountController.java @@ -0,0 +1,26 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.AccountsDto; +import edu.msudenver.tsp.persistence.repository.AccountsRepository; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.*; + +import java.util.Optional; + +@RestController +@AllArgsConstructor +@RequestMapping("/accounts") +public class AccountController { + private final AccountsRepository accountsRepository; + + @GetMapping("/") + public @ResponseBody Iterable getListOfAccounts() { + return accountsRepository.findAll(); + } + + @GetMapping("/{id}") + public @ResponseBody + Optional getAccountById(@PathVariable("id") final Integer id) { + return accountsRepository.findById(id); + } +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java new file mode 100644 index 0000000..cb74331 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/DefinitionController.java @@ -0,0 +1,126 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.repository.DefinitionRepository; +import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.util.StopWatch; +import org.springframework.validation.BindingResult; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import javax.validation.Valid; +import javax.validation.groups.Default; +import java.util.List; +import java.util.Optional; + +@Slf4j +@RestController +@AllArgsConstructor +@RequestMapping(path = "/definitions/") +public class DefinitionController { + private final DefinitionRepository definitionRepository; + + @GetMapping("/") + public @ResponseBody + ResponseEntity> getAllDefinitions() { + LOG.info("Received request to list all definitions"); + + LOG.debug("Querying for list of all definitions"); + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final List listOfDefinitions = definitionRepository.findAll(); + + stopWatch.stop(); + + LOG.debug("Successfully completed query. Query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + LOG.info("Returning list of all definition with size " + listOfDefinitions.size()); + + return new ResponseEntity<>(listOfDefinitions, HttpStatus.OK); + } + + @GetMapping("/{id}") + public @ResponseBody + ResponseEntity getDefinitionById(@PathVariable("id") final Integer id) { + LOG.info("Received request to query for definition with id " + id); + if (id == null) { + LOG.error("ERROR: ID was null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Querying for definition with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final Optional definition = definitionRepository.findById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + return definition.map(definitionDto -> { + LOG.info("Returning definition with id " + id); + return new ResponseEntity<>(definitionDto, HttpStatus.OK); + }).orElseGet( + () -> { + LOG.warn("No definition was found with id " + id); + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + }); + + } + + @PostMapping("/") + @Validated({DefinitionDto.Insert.class, Default.class}) + public @ResponseBody ResponseEntity insertDefinition( + @Valid @RequestBody final DefinitionDto definitionDto, + final BindingResult bindingResult) { + LOG.info("Received request to insert a new definition"); + if (bindingResult.hasErrors()) { + LOG.error("Binding result is unprocessable"); + return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY); + } + + if (definitionDto == null) { + LOG.error("Passed entity is unprocessable"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Saving new definition"); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + final DefinitionDto savedDefinition = definitionRepository.save(definitionDto); + + stopWatch.stop(); + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + LOG.info("Returning the newly created definition with id " + savedDefinition.getId()); + return new ResponseEntity<>(savedDefinition, HttpStatus.CREATED); + } + + @DeleteMapping("/{id}") + public @ResponseBody ResponseEntity deleteDefinitionById(@PathVariable("id") final Integer id) { + LOG.info("Received request to delete definition with id " + id); + if (id == null) { + LOG.error("Specified id is null"); + return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + } + + LOG.debug("Deleting definition with id " + id); + + final StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + definitionRepository.deleteById(id); + + stopWatch.stop(); + + LOG.debug("Received response from server: query took " + stopWatch.getTotalTimeMillis() + "ms to complete"); + + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java new file mode 100644 index 0000000..35b8a86 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/NotationController.java @@ -0,0 +1,11 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.repository.NotationRepository; +import lombok.AllArgsConstructor; +import org.springframework.stereotype.Component; + +@Component +@AllArgsConstructor +public class NotationController { + final private NotationRepository notationRepository; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java new file mode 100644 index 0000000..51e5d25 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/ProofController.java @@ -0,0 +1,11 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.repository.ProofRepository; +import lombok.AllArgsConstructor; +import org.springframework.stereotype.Component; + +@Component +@AllArgsConstructor +public class ProofController { + final private ProofRepository proofRepository; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java new file mode 100644 index 0000000..080ed54 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/controller/TheoremController.java @@ -0,0 +1,11 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.repository.TheoremRepository; +import lombok.AllArgsConstructor; +import org.springframework.stereotype.Component; + +@Component +@AllArgsConstructor +public class TheoremController { + final private TheoremRepository theoremRepository; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/BaseDao.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/BaseDao.java deleted file mode 100644 index 7a9d832..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/BaseDao.java +++ /dev/null @@ -1,28 +0,0 @@ -package edu.msudenver.tsp.persistence.dao; - -class BaseDao { - -// T findById(final int id) { -// //TODO insert DB calls for finding objects by their ID's -// } - -// List queryForList(final String query) { -// //TODO insert DB calls for querying for lists based on the specified query -// } - -// T save(final T t) { -// //TODO insert DB calls here for insert and update -// } - - void delete(final T t) { - //TODO insert DB calls here to delete - } - -// private T insert(final T object) { -// // TODO insert DB calls to insert records -// } -// -// private T update(final T object) { -// //TODO insert DB calls to update records -// } -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/DefinitionDao.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/DefinitionDao.java deleted file mode 100644 index f54d733..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/DefinitionDao.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dao; - -public class DefinitionDao extends BaseDao { -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/NotationDao.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/NotationDao.java deleted file mode 100644 index 52bfa9e..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/NotationDao.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dao; - -public class NotationDao extends BaseDao { -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/ProofDao.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/ProofDao.java deleted file mode 100644 index 61120b8..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/ProofDao.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dao; - -public class ProofDao extends BaseDao { -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/TheoremDao.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/TheoremDao.java deleted file mode 100644 index 6c27914..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dao/TheoremDao.java +++ /dev/null @@ -1,4 +0,0 @@ -package edu.msudenver.tsp.persistence.dao; - -public class TheoremDao extends BaseDao { -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java new file mode 100644 index 0000000..6d689a5 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/AccountsDto.java @@ -0,0 +1,28 @@ +package edu.msudenver.tsp.persistence.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.springframework.data.jpa.domain.support.AuditingEntityListener; + +import javax.persistence.Entity; +import javax.persistence.EntityListeners; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.Date; + +@Entity(name = "accounts") +@EntityListeners(AuditingEntityListener.class) +@Data +@EqualsAndHashCode(callSuper = true) +public class AccountsDto extends BaseDto implements Serializable { + @Size(max = 50) private String username; + @Size(max = 256) private String password; + @NotNull @JsonProperty("administrator_status") private boolean administratorStatus; + @Temporal(TemporalType.DATE) @JsonProperty("last_login") private Date lastLogin; + + public static final long serialVersionUID = 7095627971593953734L; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java index 811ac68..b718619 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/BaseDto.java @@ -1,9 +1,40 @@ package edu.msudenver.tsp.persistence.dto; +import com.vladmihalcea.hibernate.type.array.IntArrayType; +import com.vladmihalcea.hibernate.type.array.StringArrayType; +import com.vladmihalcea.hibernate.type.json.JsonBinaryType; +import com.vladmihalcea.hibernate.type.json.JsonNodeBinaryType; +import com.vladmihalcea.hibernate.type.json.JsonNodeStringType; +import com.vladmihalcea.hibernate.type.json.JsonStringType; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.TypeDef; +import org.hibernate.annotations.TypeDefs; + +import javax.persistence.*; +import java.io.Serializable; + @Data -class BaseDto { - private String id; - private int version; +@AllArgsConstructor +@NoArgsConstructor(access = AccessLevel.PROTECTED) +@MappedSuperclass +@TypeDefs({ + @TypeDef(name = "string-array", typeClass = StringArrayType.class), + @TypeDef(name = "int-array", typeClass = IntArrayType.class), + @TypeDef(name = "json", typeClass = JsonStringType.class), + @TypeDef(name = "jsonb", typeClass = JsonBinaryType.class), + @TypeDef(name = "jsonb-node", typeClass = JsonNodeBinaryType.class), + @TypeDef(name = "json-node", typeClass = JsonNodeStringType.class), +}) +public class BaseDto implements Serializable { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private int id; + @Version + private Integer version; + + public static final long serialVersionUID = -1686252381978213945L; } diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java new file mode 100644 index 0000000..e346772 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Definition.java @@ -0,0 +1,17 @@ +package edu.msudenver.tsp.persistence.dto; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +import java.io.Serializable; +import java.util.List; + +@Getter +@Setter +@ToString +public class Definition implements Serializable { + private List definitions; + + public static final long serialVersionUID = -2208496232532214840L; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java index 04f3dcd..806e84c 100644 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/DefinitionDto.java @@ -1,4 +1,34 @@ package edu.msudenver.tsp.persistence.dto; -public class DefinitionDto extends BaseDto { +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.hibernate.annotations.Type; +import org.springframework.data.jpa.domain.support.AuditingEntityListener; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.EntityListeners; +import javax.persistence.Table; +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.Size; +import java.io.Serializable; + +@Entity(name = "definitions") +@Table(name = "definitions") +@EntityListeners(AuditingEntityListener.class) +@Data +@EqualsAndHashCode(callSuper = true) +public class DefinitionDto extends BaseDto implements Serializable { + @NotBlank(groups = Insert.class, message = "A name must be specified") + @Size(min = 1, max = 200, message = "Must be between 1 and 200 characters") + private String name; + + @NotBlank(groups = Insert.class, message = "At least one (1) definition must be specified") + @Type(type = "json") @Column(columnDefinition = "jsonb") private Definition definition; + + @Type(type = "json") @Column(columnDefinition = "jsonb") private Notation notation; + + public static final long serialVersionUID = -5314619286352932857L; + + public interface Insert {} } diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java new file mode 100644 index 0000000..0545f3c --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/dto/Notation.java @@ -0,0 +1,16 @@ +package edu.msudenver.tsp.persistence.dto; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +import java.io.Serializable; +import java.util.List; + +@Getter +@Setter +@ToString +public class Notation implements Serializable { + private List notations; + public static final long serialVersionUID = 2301438318932336121L; +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/DefinitionManager.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/DefinitionManager.java deleted file mode 100644 index ed0052b..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/DefinitionManager.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.manager; - -import edu.msudenver.tsp.persistence.dao.DefinitionDao; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class DefinitionManager { - final private DefinitionDao definitionDao; -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ManagerConfig.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ManagerConfig.java deleted file mode 100644 index 93c0dc7..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ManagerConfig.java +++ /dev/null @@ -1,10 +0,0 @@ -package edu.msudenver.tsp.persistence.manager; - -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ComponentScan -public class ManagerConfig { - -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/NotationManager.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/NotationManager.java deleted file mode 100644 index f298199..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/NotationManager.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.manager; - -import edu.msudenver.tsp.persistence.dao.NotationDao; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class NotationManager { - final private NotationDao notationDao; -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ProofManager.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ProofManager.java deleted file mode 100644 index a248b8b..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/ProofManager.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.manager; - -import edu.msudenver.tsp.persistence.dao.ProofDao; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class ProofManager { - final private ProofDao proofDao; -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/TheoremManager.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/TheoremManager.java deleted file mode 100644 index 1d8dc2c..0000000 --- a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/manager/TheoremManager.java +++ /dev/null @@ -1,11 +0,0 @@ -package edu.msudenver.tsp.persistence.manager; - -import edu.msudenver.tsp.persistence.dao.TheoremDao; -import lombok.AllArgsConstructor; -import org.springframework.stereotype.Component; - -@Component -@AllArgsConstructor -public class TheoremManager { - final private TheoremDao theoremDao; -} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java new file mode 100644 index 0000000..a2d0704 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/AccountsRepository.java @@ -0,0 +1,9 @@ +package edu.msudenver.tsp.persistence.repository; + +import edu.msudenver.tsp.persistence.dto.AccountsDto; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface AccountsRepository extends JpaRepository { +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java new file mode 100644 index 0000000..1cda40a --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/DefinitionRepository.java @@ -0,0 +1,11 @@ +package edu.msudenver.tsp.persistence.repository; + + +import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface DefinitionRepository extends JpaRepository { + +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java new file mode 100644 index 0000000..47f0904 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/NotationRepository.java @@ -0,0 +1,7 @@ +package edu.msudenver.tsp.persistence.repository; + +import edu.msudenver.tsp.persistence.dto.BaseDto; +import org.springframework.data.repository.CrudRepository; + +public interface NotationRepository extends CrudRepository { +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java new file mode 100644 index 0000000..8466bbb --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/ProofRepository.java @@ -0,0 +1,7 @@ +package edu.msudenver.tsp.persistence.repository; + +import edu.msudenver.tsp.persistence.dto.BaseDto; +import org.springframework.data.repository.CrudRepository; + +public interface ProofRepository extends CrudRepository { +} diff --git a/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java new file mode 100644 index 0000000..c4237ce --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/java/edu/msudenver/tsp/persistence/repository/TheoremRepository.java @@ -0,0 +1,7 @@ +package edu.msudenver.tsp.persistence.repository; + +import edu.msudenver.tsp.persistence.dto.BaseDto; +import org.springframework.data.repository.CrudRepository; + +public interface TheoremRepository extends CrudRepository { +} diff --git a/pandamonium-theorem-prover/persistence/src/main/resources/application.properties b/pandamonium-theorem-prover/persistence/src/main/resources/application.properties new file mode 100644 index 0000000..0068dff --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/main/resources/application.properties @@ -0,0 +1,13 @@ +spring.jpa.hibernate.ddl-auto = none +spring.jpa.database=mysql +spring.datasource.url=jdbc:mysql://127.0.0.1:3306/pandamonium?autoReconnect=true&useSSL=false +spring.datasource.username=panda +spring.datasource.password=secret +spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver +spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL8Dialect +spring.jpa.show-sql = true +spring.datasource.tomcat.test-while-idle=true +spring.datasource.tomcat.validation-query=SELECT 1 +logging.level.org.springframework.web=DEBUG +spring.datasource.tomcat.max-active=5 +server.port=8090 \ No newline at end of file diff --git a/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java new file mode 100644 index 0000000..df20891 --- /dev/null +++ b/pandamonium-theorem-prover/persistence/src/test/java/edu/msudenver/tsp/persistence/controller/DefinitionControllerTest.java @@ -0,0 +1,169 @@ +package edu.msudenver.tsp.persistence.controller; + +import edu.msudenver.tsp.persistence.dto.Definition; +import edu.msudenver.tsp.persistence.dto.DefinitionDto; +import edu.msudenver.tsp.persistence.dto.Notation; +import edu.msudenver.tsp.persistence.repository.DefinitionRepository; +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.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.BindingResult; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.*; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.*; + +@RunWith(MockitoJUnitRunner.class) +@WebMvcTest(controllers = DefinitionController.class) +public class DefinitionControllerTest { + @Mock private DefinitionRepository definitionRepository; + @InjectMocks private DefinitionController definitionController; + @Mock private BindingResult bindingResult; + + @Test + public void testGetAllDefinitions() { + final DefinitionDto definitionDto = createDefinition(); + final List definitionDtoList = new ArrayList<>(); + definitionDtoList.add(definitionDto); + definitionDtoList.add(definitionDto); + + when(definitionRepository.findAll()).thenReturn(definitionDtoList); + + final ResponseEntity> responseEntity = definitionController.getAllDefinitions(); + + assertNotNull(responseEntity); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + + responseEntity.getBody().forEach(definition -> assertEquals(definition, definitionDto)); + } + + @Test + public void testGetDefinitionsById() { + final DefinitionDto definitionDto = createDefinition(); + when(definitionRepository.findById(anyInt())).thenReturn(Optional.ofNullable(definitionDto)); + + final ResponseEntity responseEntity = definitionController.getDefinitionById(1); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.OK, responseEntity.getStatusCode()); + assertEquals(definitionDto, responseEntity.getBody()); + verify(definitionRepository).findById(anyInt()); + } + + @Test + public void testGetDefinitionById_nullId() { + final ResponseEntity responseEntity = definitionController.getDefinitionById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testGetDefinitionById_noDefinitionFound() { + when(definitionRepository.findById(anyInt())).thenReturn(Optional.empty()); + + final ResponseEntity responseEntity = definitionController.getDefinitionById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode()); + verify(definitionRepository).findById(anyInt()); + } + + @Test + public void testInsertDefinition() { + final DefinitionDto definitionDto = createDefinition(); + when(definitionRepository.save(any(DefinitionDto.class))).thenReturn(definitionDto); + + final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult); + + assertNotNull(responseEntity); + assertTrue(responseEntity.hasBody()); + assertNotNull(responseEntity.getBody()); + assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode()); + assertEquals(definitionDto, responseEntity.getBody()); + verify(definitionRepository).save(any(DefinitionDto.class)); + } + + @Test + public void testInsertDefinition_definitionDtoIsNull() { + final ResponseEntity responseEntity = definitionController.insertDefinition(null, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testInsertDefinition_bindingResultHasErrors() { + final DefinitionDto definitionDto = createDefinition(); + when(bindingResult.hasErrors()).thenReturn(true); + + final ResponseEntity responseEntity = definitionController.insertDefinition(definitionDto, bindingResult); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + @Test + public void testDeleteDefinitionById() { + doNothing().when(definitionRepository).deleteById(anyInt()); + + final ResponseEntity responseEntity = definitionController.deleteDefinitionById(1); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode()); + verify(definitionRepository).deleteById(anyInt()); + } + + @Test + public void testDeleteDefinitionById_nullId() { + final ResponseEntity responseEntity = definitionController.deleteDefinitionById(null); + + assertNotNull(responseEntity); + assertFalse(responseEntity.hasBody()); + assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode()); + verifyZeroInteractions(definitionRepository); + } + + private DefinitionDto createDefinition() { + final List definitionList = new ArrayList<>(); + definitionList.add("Test definition 1"); + + final Definition definition = new Definition(); + definition.setDefinitions(definitionList); + + final List notationList = new ArrayList<>(); + notationList.add("\\testLaTeX"); + + final Notation notation = new Notation(); + notation.setNotations(notationList); + + final DefinitionDto definitionDto = new DefinitionDto(); + definitionDto.setName("Test Name"); + definitionDto.setDefinition(definition); + definitionDto.setNotation(notation); + + return definitionDto; + } +} \ No newline at end of file diff --git a/pandamonium-theorem-prover/services/build.gradle b/pandamonium-theorem-prover/services/build.gradle index efcc2d3..a53319f 100644 --- a/pandamonium-theorem-prover/services/build.gradle +++ b/pandamonium-theorem-prover/services/build.gradle @@ -7,6 +7,12 @@ version '1.0' sourceCompatibility = 1.8 +sonarqube { + properties { + property "sonar.projectName", 'Theorem Prover Services' + } +} + repositories { mavenCentral() } diff --git a/pandamonium-theorem-prover/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java b/pandamonium-theorem-prover/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java index 8c71f25..747521d 100644 --- a/pandamonium-theorem-prover/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java +++ b/pandamonium-theorem-prover/services/src/main/java/edu/msudenver/tsp/services/parser/ParserService.java @@ -1,26 +1,26 @@ package edu.msudenver.tsp.services.parser; -import edu.msudenver.tsp.persistence.manager.DefinitionManager; -import edu.msudenver.tsp.persistence.manager.NotationManager; -import edu.msudenver.tsp.persistence.manager.ProofManager; -import edu.msudenver.tsp.persistence.manager.TheoremManager; +import edu.msudenver.tsp.persistence.controller.DefinitionController; +import edu.msudenver.tsp.persistence.controller.NotationController; +import edu.msudenver.tsp.persistence.controller.ProofController; +import edu.msudenver.tsp.persistence.controller.TheoremController; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service class ParserService { - private final DefinitionManager definitionManager; - private final TheoremManager theoremManager; - private final NotationManager notationManager; - private final ProofManager proofManager; + private final DefinitionController definitionController; + private final TheoremController theoremController; + private final NotationController notationController; + private final ProofController proofController; @Autowired - public ParserService(final DefinitionManager definitionManager, final TheoremManager theoremManager, - final NotationManager notationManager, final ProofManager proofManager) { - this.definitionManager = definitionManager; - this.theoremManager = theoremManager; - this.notationManager = notationManager; - this.proofManager = proofManager; + public ParserService(final DefinitionController definitionController, final TheoremController theoremController, + final NotationController notationController, final ProofController proofController) { + this.definitionController = definitionController; + this.theoremController = theoremController; + this.notationController = notationController; + this.proofController = proofController; } } diff --git a/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/HelloController.java b/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/HelloController.java deleted file mode 100644 index 0e6a635..0000000 --- a/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/HelloController.java +++ /dev/null @@ -1,13 +0,0 @@ -package edu.msudenver.tsp.website; - -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; - -@RestController -public class HelloController { - - @RequestMapping("/") - public String index() { - return "Welcome to Project Pandamonium!"; - } -} diff --git a/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/WebsiteConfig.java b/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/WebsiteConfig.java deleted file mode 100644 index 92cb387..0000000 --- a/pandamonium-theorem-prover/src/main/java/edu/msudenver/tsp/website/WebsiteConfig.java +++ /dev/null @@ -1,12 +0,0 @@ -package edu.msudenver.tsp.website; - -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ComponentScan -//@PropertySource("classpath:development.properties") -public class WebsiteConfig { - - -} diff --git a/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/HelloControllerTest.java b/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/HelloControllerTest.java deleted file mode 100644 index ba94e3f..0000000 --- a/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/HelloControllerTest.java +++ /dev/null @@ -1,13 +0,0 @@ -package edu.msudenver.tsp.website; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -public class HelloControllerTest { - - @Test - public void test() { - assertEquals(3, 3); - } -} diff --git a/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/integrationTest/HelloControllerIntegrationTest.java b/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/integrationTest/HelloControllerIntegrationTest.java deleted file mode 100644 index 00f8fd7..0000000 --- a/pandamonium-theorem-prover/src/test/java/edu/msudenver/tsp/website/integrationTest/HelloControllerIntegrationTest.java +++ /dev/null @@ -1,15 +0,0 @@ -package edu.msudenver.tsp.website.integrationTest; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import static org.junit.Assert.assertEquals; - -@RunWith(SpringJUnit4ClassRunner.class) -public class HelloControllerIntegrationTest { - @Test - public void test() { - assertEquals(3,3); - } -} diff --git a/pandamonium-theorem-prover/utilities/build.gradle b/pandamonium-theorem-prover/utilities/build.gradle index b8e0e3f..007e3e1 100644 --- a/pandamonium-theorem-prover/utilities/build.gradle +++ b/pandamonium-theorem-prover/utilities/build.gradle @@ -7,6 +7,12 @@ version '1.0' sourceCompatibility = 1.8 +sonarqube { + properties { + property "sonar.projectName", 'Parsing and Proofs Utilities' + } +} + repositories { mavenCentral() }