diff --git a/.gitignore b/.gitignore index 0c9d47c18..e4ca049ca 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,6 @@ build .gradle .idea *.iml +ci/variables.yml +.DS_Store +out diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 000000000..71a6de46d --- /dev/null +++ b/.travis.yml @@ -0,0 +1,54 @@ +dist: trusty +sudo: false +notifications: + email: false +env: + - RELEASE_TAG="release-$TRAVIS_BUILD_NUMBER" +if: tag IS blank + +jobs: + include: + - stage: build and publish + language: java + jdk: oraclejdk8 + addons: + mariadb: '10.2' + install: skip + before_script: + - mysql -uroot < databases/tracker/create_databases.sql + - curl https://repo1.maven.org/maven2/org/flywaydb/flyway-commandline/5.1.1/flyway-commandline-5.1.1-linux-x64.tar.gz | tar xvz + - flyway-*/flyway -url="jdbc:mysql://localhost:3306/tracker_test" -locations=filesystem:databases/tracker -user=tracker -password= clean migrate + script: ./gradlew clean build + before_deploy: + - git config --local user.name "Travis CI" + - git config --local user.email "travis@example.com" + - git tag -f $RELEASE_TAG + deploy: + provider: releases + api_key: $GITHUB_OAUTH_TOKEN + file: "build/libs/pal-tracker-0.0.1-SNAPSHOT.jar" + skip_cleanup: true + - stage: deploy to review + language: java + before_install: + - wget -q -O - https://packages.cloudfoundry.org/debian/cli.cloudfoundry.org.key | sudo apt-key add - + - echo "deb https://packages.cloudfoundry.org/debian stable main" | sudo tee /etc/apt/sources.list.d/cloudfoundry-cli.list + - sudo apt-get update + - sudo apt-get install cf-cli + - sudo apt-get -y install jq + - curl https://repo1.maven.org/maven2/org/flywaydb/flyway-commandline/5.1.1/flyway-commandline-5.1.1-linux-x64.tar.gz | tar xvz + script: + - echo "Downloading $RELEASE_TAG" + - wget -P build/libs https://github.com/$GITHUB_USERNAME/pal-tracker/releases/download/$RELEASE_TAG/pal-tracker-0.0.1-SNAPSHOT.jar + before_deploy: + - echo "Deploying $RELEASE_TAG to review" + after_success: + - cf login -a $CF_API_URL -u $CF_USERNAME -p $CF_PASSWORD -o $CF_ORG -s review + - scripts/migrate-databases.sh pal-tracker . + deploy: + provider: cloudfoundry + api: $CF_API_URL + username: $CF_USERNAME + password: $CF_PASSWORD + organization: $CF_ORG + space: review diff --git a/build.gradle b/build.gradle new file mode 100644 index 000000000..90f288ac0 --- /dev/null +++ b/build.gradle @@ -0,0 +1,91 @@ +import org.flywaydb.gradle.task.FlywayMigrateTask + +buildscript { + ext { + kotlinVersion = '1.2.41' + springBootVersion = '1.5.14.RELEASE' + } + repositories { + mavenCentral() + maven { + url "https://plugins.gradle.org/m2/" + } + } + dependencies { + classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") + classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}") + classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}") + classpath("gradle.plugin.com.boxfuse.client:gradle-plugin-publishing:5.1.4") + } +} + +apply plugin: 'kotlin' +apply plugin: 'kotlin-spring' +apply plugin: 'eclipse' +apply plugin: 'org.springframework.boot' +apply plugin: 'org.flywaydb.flyway' + +group = 'io.pivotal' +version = '0.0.1-SNAPSHOT' +sourceCompatibility = 1.8 +compileKotlin { + kotlinOptions { + freeCompilerArgs = ["-Xjsr305=strict"] + jvmTarget = "1.8" + } +} +compileTestKotlin { + kotlinOptions { + freeCompilerArgs = ["-Xjsr305=strict"] + jvmTarget = "1.8" + } +} + +repositories { + mavenCentral() +} + + +dependencies { + compile('org.springframework.boot:spring-boot-starter-web') + compile("org.springframework.boot:spring-boot-starter-actuator") + compile("org.springframework.boot:spring-boot-starter-jdbc") + compile("org.springframework.boot:spring-boot-starter-security") + compile("mysql:mysql-connector-java:8.0.11") + compile("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}") + compile("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}") + compile("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.1") + compile('com.fasterxml.jackson.module:jackson-module-kotlin') + testCompile('org.springframework.boot:spring-boot-starter-test') +} + +def developmentDbUrl = "jdbc:mysql://localhost:3306/tracker_dev?user=tracker&useSSL=false&useTimezone=true&serverTimezone=UTC&useLegacyDatetimeCode=false" +bootRun.environment([ + "WELCOME_MESSAGE": "hello", + "SPRING_DATASOURCE_URL": developmentDbUrl, + "MANAGEMENT_SECURITY_ENABLED": false, + "HTTPS_DISABLED": true +]) + +def testDbUrl = "jdbc:mysql://localhost:3306/tracker_test?user=tracker&useSSL=false&useTimezone=true&serverTimezone=UTC&useLegacyDatetimeCode=false" +test.environment([ + "WELCOME_MESSAGE": "Hello from test", + "SPRING_DATASOURCE_URL": testDbUrl, + "MANAGEMENT_SECURITY_ENABLED": false, + "HTTPS_DISABLED": true +]) + +flyway { + url = developmentDbUrl + user = "tracker" + password = "" + locations = ["filesystem:databases/tracker/migrations"] +} + +task testMigrate(type: FlywayMigrateTask) { + url = testDbUrl +} + +springBoot { + buildInfo() +} \ No newline at end of file diff --git a/databases/tracker/create_databases.sql b/databases/tracker/create_databases.sql new file mode 100644 index 000000000..6f1e86abf --- /dev/null +++ b/databases/tracker/create_databases.sql @@ -0,0 +1,10 @@ +DROP DATABASE IF EXISTS tracker_dev; +DROP DATABASE IF EXISTS tracker_test; + +CREATE DATABASE tracker_dev; +CREATE DATABASE tracker_test; + +CREATE USER IF NOT EXISTS 'tracker'@'localhost' + IDENTIFIED BY ''; +GRANT ALL PRIVILEGES ON tracker_dev.* TO 'tracker' @'localhost'; +GRANT ALL PRIVILEGES ON tracker_test.* TO 'tracker' @'localhost'; \ No newline at end of file diff --git a/databases/tracker/migrations/V1__intitial_schema.sql b/databases/tracker/migrations/V1__intitial_schema.sql new file mode 100644 index 000000000..daca8c4e3 --- /dev/null +++ b/databases/tracker/migrations/V1__intitial_schema.sql @@ -0,0 +1,11 @@ +CREATE TABLE time_entries ( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + project_id BIGINT(20), + user_id BIGINT(20), + date DATE, + hours INT, + + PRIMARY KEY (id) +) + ENGINE = innodb + DEFAULT CHARSET = utf8; \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000..1a958be64 Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000..90a06cec7 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-3.5.1-bin.zip diff --git a/gradlew b/gradlew new file mode 100755 index 000000000..4453ccea3 --- /dev/null +++ b/gradlew @@ -0,0 +1,172 @@ +#!/usr/bin/env sh + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS="" + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn ( ) { + echo "$*" +} + +die ( ) { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save ( ) { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 000000000..e95643d6a --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,84 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/manifest.yml b/manifest.yml new file mode 100644 index 000000000..d26815dde --- /dev/null +++ b/manifest.yml @@ -0,0 +1,8 @@ +--- +applications: +- name: pal-tracker + path: build/libs/pal-tracker-0.0.1-SNAPSHOT.jar + routes: + - route: cm-pal-tracker-review.cfapps.io + env: + WELCOME_MESSAGE: Hello from the review environment diff --git a/pal-tracker-codebase.txt b/pal-tracker-codebase.txt deleted file mode 100644 index 0943c3cd3..000000000 --- a/pal-tracker-codebase.txt +++ /dev/null @@ -1 +0,0 @@ -pal-tracker codebase diff --git a/scripts/migrate-databases.sh b/scripts/migrate-databases.sh new file mode 100755 index 000000000..dcd50fae0 --- /dev/null +++ b/scripts/migrate-databases.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash +set -e + + +app_guid=`cf app $1 --guid` +credentials=`cf curl /v2/apps/$app_guid/env | jq '.system_env_json.VCAP_SERVICES' | jq '.["cleardb"][0].credentials'` + +ip_address=`echo $credentials | jq -r '.hostname'` +db_name=`echo $credentials | jq -r '.name'` +db_username=`echo $credentials | jq -r '.username'` +db_password=`echo $credentials | jq -r '.password'` + +echo "Opening ssh tunnel to $ip_address" +cf ssh -N -L 63306:$ip_address:3306 pal-tracker & +cf_ssh_pid=$! + +echo "Waiting for tunnel" +sleep 5 + +flyway-*/flyway -url="jdbc:mysql://127.0.0.1:63306/$db_name" -locations=filesystem:$2/databases/tracker -user=$db_username -password=$db_password migrate + +kill -STOP $cf_ssh_pid diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 000000000..e31056948 --- /dev/null +++ b/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'pal-tracker' diff --git a/src/main/kotlin/io/pivotal/pal/tracker/PalTrackerApplication.kt b/src/main/kotlin/io/pivotal/pal/tracker/PalTrackerApplication.kt new file mode 100644 index 000000000..47761f176 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/PalTrackerApplication.kt @@ -0,0 +1,33 @@ +package io.pivotal.pal.tracker + +import com.fasterxml.jackson.annotation.JsonInclude +import com.fasterxml.jackson.databind.ObjectMapper +import com.fasterxml.jackson.databind.SerializationFeature +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule +import com.fasterxml.jackson.module.kotlin.KotlinModule +import io.pivotal.pal.tracker.repositories.JdbcTimeEntryRepository +import org.springframework.boot.SpringApplication +import org.springframework.boot.autoconfigure.SpringBootApplication +import org.springframework.context.annotation.Bean +import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder +import javax.sql.DataSource + + +@SpringBootApplication +class PalTrackerApplication { + @Bean + fun timeEntryRepository(dataSource: DataSource) = JdbcTimeEntryRepository(dataSource) + + @Bean + fun jsonObjectMapper(): ObjectMapper { + return Jackson2ObjectMapperBuilder.json() + .serializationInclusion(JsonInclude.Include.NON_NULL) // Don’t include null values + .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS) //ISODate + .modules(listOf(JavaTimeModule(), KotlinModule())) + .build() + } +} + +fun main(args: Array) { + SpringApplication.run(PalTrackerApplication::class.java, *args) +} diff --git a/src/main/kotlin/io/pivotal/pal/tracker/SecurityConfiguration.kt b/src/main/kotlin/io/pivotal/pal/tracker/SecurityConfiguration.kt new file mode 100644 index 000000000..38c6decd8 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/SecurityConfiguration.kt @@ -0,0 +1,27 @@ +package io.pivotal.pal.tracker + +import org.springframework.beans.factory.annotation.Value +import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder +import org.springframework.security.config.annotation.web.builders.HttpSecurity +import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity +import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter + +@EnableWebSecurity +class SecurityConfiguration( + @Value("\${HTTPS_DISABLED:false}") var httpsDisabled: Boolean) : WebSecurityConfigurerAdapter() { + + override fun configure(http: HttpSecurity) { + + if (!httpsDisabled) { + http.requiresChannel().anyRequest().requiresSecure(); + } + + http.authorizeRequests().antMatchers("/**").hasRole("USER").and().httpBasic() + http.csrf().disable() + } + + override fun configure(auth: AuthenticationManagerBuilder) { + auth.inMemoryAuthentication().withUser("user").password("password").roles("USER") + } + +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/TimeEntryHealthIndicator.kt b/src/main/kotlin/io/pivotal/pal/tracker/TimeEntryHealthIndicator.kt new file mode 100644 index 000000000..d33b7d3ee --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/TimeEntryHealthIndicator.kt @@ -0,0 +1,19 @@ +package io.pivotal.pal.tracker + +import io.pivotal.pal.tracker.repositories.TimeEntryRepository +import org.springframework.boot.actuate.health.Health +import org.springframework.boot.actuate.health.HealthIndicator +import org.springframework.stereotype.Component + +@Component +class TimeEntryHealthIndicator(val timeEntryRepository: TimeEntryRepository): HealthIndicator { + override fun health(): Health { + val count = timeEntryRepository.list().size + return if (count < 5) { + Health.Builder().up().build() + } + else { + Health.Builder().down().build() + } + } +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/controllers/EnvController.kt b/src/main/kotlin/io/pivotal/pal/tracker/controllers/EnvController.kt new file mode 100644 index 000000000..74807e8d1 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/controllers/EnvController.kt @@ -0,0 +1,23 @@ +package io.pivotal.pal.tracker.controllers + +import org.springframework.beans.factory.annotation.Value +import org.springframework.web.bind.annotation.GetMapping +import org.springframework.web.bind.annotation.RestController + +@RestController +class EnvController( + @Value("\${PORT:NOT SET}") var port: String, + @Value("\${MEMORY_LIMIT:NOT SET}") var memoryLimit: String, + @Value("\${CF_INSTANCE_INDEX:NOT SET}") var cfInstanceIndex: String, + @Value("\${CF_INSTANCE_ADDR:NOT SET}") var cfInstanceAddr: String +) { + + @GetMapping("/env") + fun getEnv(): Map = + hashMapOf( + "PORT" to port, + "MEMORY_LIMIT" to memoryLimit, + "CF_INSTANCE_INDEX" to cfInstanceIndex, + "CF_INSTANCE_ADDR" to cfInstanceAddr + ) +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/controllers/TimeEntryController.kt b/src/main/kotlin/io/pivotal/pal/tracker/controllers/TimeEntryController.kt new file mode 100644 index 000000000..df76791d5 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/controllers/TimeEntryController.kt @@ -0,0 +1,62 @@ +package io.pivotal.pal.tracker.controllers + +import io.pivotal.pal.tracker.domain.TimeEntry +import io.pivotal.pal.tracker.repositories.TimeEntryRepository +import org.springframework.http.HttpStatus +import org.springframework.http.ResponseEntity +import org.springframework.web.bind.annotation.* +import org.springframework.boot.actuate.metrics.CounterService +import org.springframework.boot.actuate.metrics.GaugeService + +@RestController +@RequestMapping("/time-entries") +class TimeEntryController( + val timeEntryRepository: TimeEntryRepository, + val counter: CounterService, + val gauge: GaugeService + ) { + + @PostMapping + fun create(@RequestBody timeEntry: TimeEntry): ResponseEntity { + val returnedTimeEntry = timeEntryRepository.create(timeEntry) + counter.increment("TimeEntry.created") + gauge.submit("timeEntries.count", timeEntryRepository.list().size.toDouble()) + return ResponseEntity(returnedTimeEntry, HttpStatus.CREATED) + } + + @GetMapping("/{id}") + // TODO: Use when for refactor + fun read(@PathVariable id: Long): ResponseEntity { + val returnedTimeEntry = timeEntryRepository.find(id) + return if (returnedTimeEntry != null) { + counter.increment("TimeEntry.read") + ResponseEntity(returnedTimeEntry, HttpStatus.OK) + } + else {ResponseEntity(HttpStatus.NOT_FOUND)} + } + + @GetMapping + fun list(): ResponseEntity> { + val returnedTimeEntryList = timeEntryRepository.list() + counter.increment("TimeEntry.listed") + return ResponseEntity(returnedTimeEntryList, HttpStatus.OK) + } + + @PutMapping("/{id}") + fun update(@PathVariable id: Long, @RequestBody timeEntry: TimeEntry): ResponseEntity { + val returnedTimeEntry = timeEntryRepository.update(id, timeEntry) + return if (returnedTimeEntry != null) { + counter.increment("TimeEntry.updated") + ResponseEntity(returnedTimeEntry, HttpStatus.OK) + } + else {ResponseEntity(HttpStatus.NOT_FOUND)} + } + + @DeleteMapping("/{id}") + fun delete(@PathVariable id: Long) : ResponseEntity { + timeEntryRepository.delete(id) + counter.increment("TimeEntry.deleted") + gauge.submit("timeEntries.count", timeEntryRepository.list().size.toDouble()) + return ResponseEntity(HttpStatus.NO_CONTENT) + } +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/controllers/WelcomeController.kt b/src/main/kotlin/io/pivotal/pal/tracker/controllers/WelcomeController.kt new file mode 100644 index 000000000..66f551436 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/controllers/WelcomeController.kt @@ -0,0 +1,18 @@ +package io.pivotal.pal.tracker.controllers + +import org.springframework.beans.factory.annotation.Value +import org.springframework.boot.actuate.metrics.CounterService +import org.springframework.web.bind.annotation.GetMapping +import org.springframework.web.bind.annotation.RestController + +@RestController +class WelcomeController( + @Value("\${WELCOME_MESSAGE}") var message: String, + val counter: CounterService + ) { + @GetMapping("/") + fun sayHello(): String { + counter.increment("Welcome.shown") + return message + } +} diff --git a/src/main/kotlin/io/pivotal/pal/tracker/domain/TimeEntry.kt b/src/main/kotlin/io/pivotal/pal/tracker/domain/TimeEntry.kt new file mode 100644 index 000000000..375166298 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/domain/TimeEntry.kt @@ -0,0 +1,14 @@ +package io.pivotal.pal.tracker.domain + +import java.time.LocalDate + +data class TimeEntry( + val id: Long?, + val projectId: Long, + val userId: Long, + val date: LocalDate, + val hours: Int +) { + constructor(projectId: Long, userId: Long, date: LocalDate, hours: Int) : + this(null, projectId, userId, date, hours) +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/repositories/InMemoryTimeEntryRepository.kt b/src/main/kotlin/io/pivotal/pal/tracker/repositories/InMemoryTimeEntryRepository.kt new file mode 100644 index 000000000..c57e5c03b --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/repositories/InMemoryTimeEntryRepository.kt @@ -0,0 +1,32 @@ +package io.pivotal.pal.tracker.repositories + +import io.pivotal.pal.tracker.domain.TimeEntry + +class InMemoryTimeEntryRepository : TimeEntryRepository { + private var timeEntries: MutableMap = mutableMapOf() + private var nextId: Long = 1L + + override fun create(timeEntry: TimeEntry): TimeEntry { + val createdTimeEntry = timeEntry.copy(id=nextId++) + timeEntries[createdTimeEntry.id!!] = createdTimeEntry + return createdTimeEntry + } + + override fun find(id: Long): TimeEntry? { + return timeEntries[id] + } + + override fun list(): List { + return timeEntries.values.toList() + } + + override fun update(id: Long, timeEntry: TimeEntry): TimeEntry { + val updatedTimeEntry = timeEntry.copy(id=id) + timeEntries[id] = updatedTimeEntry + return updatedTimeEntry + } + + override fun delete(id: Long) { + timeEntries.remove(id) + } +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/repositories/JdbcTimeEntryRepository.kt b/src/main/kotlin/io/pivotal/pal/tracker/repositories/JdbcTimeEntryRepository.kt new file mode 100644 index 000000000..dd0f58b0d --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/repositories/JdbcTimeEntryRepository.kt @@ -0,0 +1,95 @@ +package io.pivotal.pal.tracker.repositories + +import io.pivotal.pal.tracker.domain.TimeEntry +import org.springframework.jdbc.core.JdbcTemplate +import org.springframework.jdbc.core.RowMapper +import org.springframework.jdbc.support.GeneratedKeyHolder +import java.sql.Date +import java.sql.ResultSet +import java.sql.Statement +import javax.sql.DataSource + +class JdbcTimeEntryRepository(dataSource: DataSource): TimeEntryRepository { + private val jdbcTemplate = JdbcTemplate(dataSource) + private val timeEntryRowMapper = RowMapper({ rs, _ -> + TimeEntry( + rs.getLong("id"), + rs.getLong("project_id"), + rs.getLong("user_id"), + rs.getDate("date").toLocalDate(), + rs.getInt("hours") + ) + }) + + override fun create(timeEntry: TimeEntry): TimeEntry? { + val sql = "INSERT INTO time_entries (project_id, user_id, date, hours) VALUES (?, ?, ?, ?)" + val generatedKeyHolder = GeneratedKeyHolder() + + jdbcTemplate.update({ + val query = it.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS) + query.setLong(1, timeEntry.projectId) + query.setLong(2, timeEntry.userId) + query.setDate(3, Date.valueOf(timeEntry.date)) + query.setInt(4, timeEntry.hours) + + query + }, generatedKeyHolder) + + return find(generatedKeyHolder.key.toLong()) + } + + override fun find(id: Long): TimeEntry? { + val sql = "SELECT id, project_id, user_id, date, hours FROM time_entries WHERE id = ?" + var fetchedTimeEntry: TimeEntry? = null + + jdbcTemplate.query({ + val query = it.prepareStatement(sql) + query.setLong(1, id) + + query + }, { + fetchedTimeEntry = timeEntryRowMapper.mapRow(it, 0) + }) + + return fetchedTimeEntry + } + + override fun list(): List { + val sql = "SELECT id, project_id, user_id, date, hours FROM time_entries" + val fetchedTimeEntries: MutableList = mutableListOf() + + jdbcTemplate.query(sql, { + fetchedTimeEntries.add(timeEntryRowMapper.mapRow(it, 0)) + }) + + return fetchedTimeEntries + } + + override fun update(id: Long, timeEntry: TimeEntry): TimeEntry? { + val sql = "UPDATE time_entries SET project_id = ?, user_id = ?, date = ?, hours = ? WHERE id = ?" + + jdbcTemplate.update({ + val query = it.prepareStatement(sql) + query.setLong(1, timeEntry.projectId) + query.setLong(2, timeEntry.userId) + query.setDate(3, Date.valueOf(timeEntry.date)) + query.setInt(4, timeEntry.hours) + query.setLong(5, id) + + query + }) + + return find(id) + } + + override fun delete(id: Long) { + val sql = "DELETE FROM time_entries WHERE id = ?" + + jdbcTemplate.update({ + val query = it.prepareStatement(sql) + query.setLong(1, id) + + query + }) + } +} \ No newline at end of file diff --git a/src/main/kotlin/io/pivotal/pal/tracker/repositories/TimeEntryRepository.kt b/src/main/kotlin/io/pivotal/pal/tracker/repositories/TimeEntryRepository.kt new file mode 100644 index 000000000..e21a6bc13 --- /dev/null +++ b/src/main/kotlin/io/pivotal/pal/tracker/repositories/TimeEntryRepository.kt @@ -0,0 +1,15 @@ +package io.pivotal.pal.tracker.repositories + +import io.pivotal.pal.tracker.domain.TimeEntry + +interface TimeEntryRepository { + fun create(timeEntry: TimeEntry): TimeEntry? + + fun find(id: Long): TimeEntry? + + fun list(): List + + fun update(id: Long, timeEntry: TimeEntry): TimeEntry? + + fun delete(id: Long) +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 000000000..a2c51fcb6 --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1 @@ +#https.disabled=false \ No newline at end of file diff --git a/src/test/java/test/pivotal/pal/tracker/EnvControllerTest.java b/src/test/java/test/pivotal/pal/tracker/EnvControllerTest.java new file mode 100644 index 000000000..f12cb4207 --- /dev/null +++ b/src/test/java/test/pivotal/pal/tracker/EnvControllerTest.java @@ -0,0 +1,28 @@ +package test.pivotal.pal.tracker; + +import org.junit.Test; + +import java.util.Map; +import io.pivotal.pal.tracker.controllers.EnvController; + +import static org.assertj.core.api.Assertions.assertThat; + +public class EnvControllerTest { + @Test + public void getEnv() throws Exception { + EnvController controller = new EnvController( + "8675", + "12G", + "34", + "123.sesame.street" + ); + + Map env = controller.getEnv(); + + assertThat(env.get("PORT")).isEqualTo("8675"); + assertThat(env.get("MEMORY_LIMIT")).isEqualTo("12G"); + assertThat(env.get("CF_INSTANCE_INDEX")).isEqualTo("34"); + assertThat(env.get("CF_INSTANCE_ADDR")).isEqualTo("123.sesame.street"); + } + +} diff --git a/src/test/java/test/pivotal/pal/tracker/InMemoryTimeEntryRepositoryTest.java b/src/test/java/test/pivotal/pal/tracker/InMemoryTimeEntryRepositoryTest.java new file mode 100644 index 000000000..098f2e35a --- /dev/null +++ b/src/test/java/test/pivotal/pal/tracker/InMemoryTimeEntryRepositoryTest.java @@ -0,0 +1,71 @@ +package test.pivotal.pal.tracker; + +import io.pivotal.pal.tracker.repositories.InMemoryTimeEntryRepository; +import io.pivotal.pal.tracker.domain.TimeEntry; +import org.junit.Test; + +import java.time.LocalDate; +import java.util.List; + +import static java.util.Arrays.asList; +import static org.assertj.core.api.Assertions.assertThat; + +public class InMemoryTimeEntryRepositoryTest { + @Test + public void create() throws Exception { + InMemoryTimeEntryRepository repo = new InMemoryTimeEntryRepository(); + TimeEntry createdTimeEntry = repo.create(new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8)); + + TimeEntry expected = new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8); + assertThat(createdTimeEntry).isEqualTo(expected); + + TimeEntry readEntry = repo.find(createdTimeEntry.getId()); + assertThat(readEntry).isEqualTo(expected); + } + + @Test + public void find() throws Exception { + InMemoryTimeEntryRepository repo = new InMemoryTimeEntryRepository(); + repo.create(new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8)); + + TimeEntry expected = new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8); + TimeEntry readEntry = repo.find(1L); + assertThat(readEntry).isEqualTo(expected); + } + + @Test + public void list() throws Exception { + InMemoryTimeEntryRepository repo = new InMemoryTimeEntryRepository(); + repo.create(new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8)); + repo.create(new TimeEntry(789L, 654L, LocalDate.parse("2017-01-07"), 4)); + + List expected = asList( + new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8), + new TimeEntry(2L, 789L, 654L, LocalDate.parse("2017-01-07"), 4) + ); + assertThat(repo.list()).isEqualTo(expected); + } + + @Test + public void update() throws Exception { + InMemoryTimeEntryRepository repo = new InMemoryTimeEntryRepository(); + TimeEntry created = repo.create(new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8)); + + TimeEntry updatedEntry = repo.update( + created.getId(), + new TimeEntry(321L, 654L, LocalDate.parse("2017-01-09"), 5)); + + TimeEntry expected = new TimeEntry(created.getId(), 321L, 654L, LocalDate.parse("2017-01-09"), 5); + assertThat(updatedEntry).isEqualTo(expected); + assertThat(repo.find(created.getId())).isEqualTo(expected); + } + + @Test + public void delete() throws Exception { + InMemoryTimeEntryRepository repo = new InMemoryTimeEntryRepository(); + TimeEntry created = repo.create(new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8)); + + repo.delete(created.getId()); + assertThat(repo.list()).isEmpty(); + } +} diff --git a/src/test/java/test/pivotal/pal/tracker/JdbcTimeEntryRepositoryTest.java b/src/test/java/test/pivotal/pal/tracker/JdbcTimeEntryRepositoryTest.java new file mode 100644 index 000000000..8331d7234 --- /dev/null +++ b/src/test/java/test/pivotal/pal/tracker/JdbcTimeEntryRepositoryTest.java @@ -0,0 +1,159 @@ +package test.pivotal.pal.tracker; + + +import com.mysql.cj.jdbc.MysqlDataSource; +import io.pivotal.pal.tracker.repositories.JdbcTimeEntryRepository; +import io.pivotal.pal.tracker.domain.TimeEntry; +import io.pivotal.pal.tracker.repositories.TimeEntryRepository; +import org.junit.Before; +import org.junit.Test; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.sql.Date; +import java.time.LocalDate; +import java.util.List; +import java.util.Map; +import java.util.TimeZone; + +import static org.assertj.core.api.Assertions.assertThat; + +public class JdbcTimeEntryRepositoryTest { + private TimeEntryRepository subject; + private JdbcTemplate jdbcTemplate; + + @Before + public void setUp() throws Exception { + MysqlDataSource dataSource = new MysqlDataSource(); + dataSource.setUrl(System.getenv("SPRING_DATASOURCE_URL")); + + subject = new JdbcTimeEntryRepository(dataSource); + + jdbcTemplate = new JdbcTemplate(dataSource); + jdbcTemplate.execute("DELETE FROM time_entries"); + + TimeZone.setDefault(TimeZone.getTimeZone("UTC")); + } + + @Test + public void createInsertsATimeEntryRecord() throws Exception { + TimeEntry newTimeEntry = new TimeEntry(123, 321, LocalDate.parse("2017-01-09"), 8); + TimeEntry entry = subject.create(newTimeEntry); + + Map foundEntry = jdbcTemplate.queryForMap("Select * from time_entries where id = ?", entry.getId()); + + assertThat(foundEntry.get("id")).isEqualTo(entry.getId()); + assertThat(foundEntry.get("project_id")).isEqualTo(123L); + assertThat(foundEntry.get("user_id")).isEqualTo(321L); + assertThat(((Date)foundEntry.get("date")).toLocalDate()).isEqualTo(LocalDate.parse("2017-01-09")); + assertThat(foundEntry.get("hours")).isEqualTo(8); + } + + @Test + public void createReturnsTheCreatedTimeEntry() throws Exception { + TimeEntry newTimeEntry = new TimeEntry(123, 321, LocalDate.parse("2017-01-09"), 8); + TimeEntry entry = subject.create(newTimeEntry); + + assertThat(entry.getId()).isNotNull(); + assertThat(entry.getProjectId()).isEqualTo(123); + assertThat(entry.getUserId()).isEqualTo(321); + assertThat(entry.getDate()).isEqualTo(LocalDate.parse("2017-01-09")); + assertThat(entry.getHours()).isEqualTo(8); + } + + @Test + public void findFindsATimeEntry() throws Exception { + jdbcTemplate.execute( + "INSERT INTO time_entries (id, project_id, user_id, date, hours) " + + "VALUES (999, 123, 321, '2017-01-09', 8)" + ); + + TimeEntry timeEntry = subject.find(999L); + + assertThat(timeEntry.getId()).isEqualTo(999L); + assertThat(timeEntry.getProjectId()).isEqualTo(123L); + assertThat(timeEntry.getUserId()).isEqualTo(321L); + assertThat(timeEntry.getDate()).isEqualTo(LocalDate.parse("2017-01-09")); + assertThat(timeEntry.getHours()).isEqualTo(8); + } + + @Test + public void findReturnsNullWhenNotFound() throws Exception { + TimeEntry timeEntry = subject.find(999L); + + assertThat(timeEntry).isNull(); + } + + @Test + public void listFindsAllTimeEntries() throws Exception { + jdbcTemplate.execute( + "INSERT INTO time_entries (id, project_id, user_id, date, hours) " + + "VALUES (999, 123, 321, '2017-01-09', 8), (888, 456, 678, '2017-01-08', 9)" + ); + + List timeEntries = subject.list(); + assertThat(timeEntries.size()).isEqualTo(2); + + TimeEntry timeEntry = timeEntries.get(0); + assertThat(timeEntry.getId()).isEqualTo(888L); + assertThat(timeEntry.getProjectId()).isEqualTo(456L); + assertThat(timeEntry.getUserId()).isEqualTo(678L); + assertThat(timeEntry.getDate()).isEqualTo(LocalDate.parse("2017-01-08")); + assertThat(timeEntry.getHours()).isEqualTo(9); + + timeEntry = timeEntries.get(1); + assertThat(timeEntry.getId()).isEqualTo(999L); + assertThat(timeEntry.getProjectId()).isEqualTo(123L); + assertThat(timeEntry.getUserId()).isEqualTo(321L); + assertThat(timeEntry.getDate()).isEqualTo(LocalDate.parse("2017-01-09")); + assertThat(timeEntry.getHours()).isEqualTo(8); + } + + @Test + public void updateReturnsTheUpdatedRecord() throws Exception { + jdbcTemplate.execute( + "INSERT INTO time_entries (id, project_id, user_id, date, hours) " + + "VALUES (1000, 123, 321, '2017-01-09', 8)"); + + TimeEntry timeEntryUpdates = new TimeEntry(456, 987, LocalDate.parse("2017-01-10"), 10); + + TimeEntry updatedTimeEntry = subject.update(1000L, timeEntryUpdates); + + assertThat(updatedTimeEntry.getId()).isEqualTo(1000L); + assertThat(updatedTimeEntry.getProjectId()).isEqualTo(456L); + assertThat(updatedTimeEntry.getUserId()).isEqualTo(987L); + assertThat(updatedTimeEntry.getDate()).isEqualTo(LocalDate.parse("2017-01-10")); + assertThat(updatedTimeEntry.getHours()).isEqualTo(10); + } + + @Test + public void updateUpdatesTheRecord() throws Exception { + jdbcTemplate.execute( + "INSERT INTO time_entries (id, project_id, user_id, date, hours) " + + "VALUES (1000, 123, 321, '2017-01-09', 8)"); + + TimeEntry updatedTimeEntry = new TimeEntry(456, 322, LocalDate.parse("2017-01-10"), 10); + + TimeEntry timeEntry = subject.update(1000L, updatedTimeEntry); + + Map foundEntry = jdbcTemplate.queryForMap("Select * from time_entries where id = ?", timeEntry.getId()); + + assertThat(foundEntry.get("id")).isEqualTo(timeEntry.getId()); + assertThat(foundEntry.get("project_id")).isEqualTo(456L); + assertThat(foundEntry.get("user_id")).isEqualTo(322L); + assertThat(((Date)foundEntry.get("date")).toLocalDate()).isEqualTo(LocalDate.parse("2017-01-10")); + assertThat(foundEntry.get("hours")).isEqualTo(10); + } + + @Test + public void deleteRemovesTheRecord() throws Exception { + jdbcTemplate.execute( + "INSERT INTO time_entries (id, project_id, user_id, date, hours) " + + "VALUES (999, 123, 321, '2017-01-09', 8)" + ); + + subject.delete(999L); + + Map foundEntry = jdbcTemplate.queryForMap("Select count(*) count from time_entries where id = ?", 999); + assertThat(foundEntry.get("count")).isEqualTo(0L); + } +} diff --git a/src/test/java/test/pivotal/pal/tracker/TimeEntryControllerTest.java b/src/test/java/test/pivotal/pal/tracker/TimeEntryControllerTest.java new file mode 100644 index 000000000..7b2d7dbf7 --- /dev/null +++ b/src/test/java/test/pivotal/pal/tracker/TimeEntryControllerTest.java @@ -0,0 +1,122 @@ +package test.pivotal.pal.tracker; + +import io.pivotal.pal.tracker.domain.TimeEntry; +import io.pivotal.pal.tracker.controllers.TimeEntryController; +import io.pivotal.pal.tracker.repositories.TimeEntryRepository; +import org.junit.Before; +import org.junit.Test; +import org.springframework.boot.actuate.metrics.CounterService; +import org.springframework.boot.actuate.metrics.GaugeService; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; + +import java.time.LocalDate; +import java.util.List; + +import static java.util.Arrays.asList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.*; + +public class TimeEntryControllerTest { + private TimeEntryRepository timeEntryRepository; + private TimeEntryController controller; + private CounterService counter; + private GaugeService gauge; + + @Before + public void setUp() throws Exception { + timeEntryRepository = mock(TimeEntryRepository.class); + counter = mock(CounterService.class); + gauge = mock(GaugeService.class); + controller = new TimeEntryController(timeEntryRepository, counter, gauge); + } + + @Test + public void testCreate() throws Exception { + TimeEntry timeEntryToCreate = new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8); + TimeEntry expectedResult = new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8); + doReturn(expectedResult) + .when(timeEntryRepository) + .create(any(TimeEntry.class)); + + + ResponseEntity response = controller.create(timeEntryToCreate); + + + verify(timeEntryRepository).create(timeEntryToCreate); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED); + assertThat(response.getBody()).isEqualTo(expectedResult); + } + + @Test + public void testRead() throws Exception { + TimeEntry expected = new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8); + doReturn(expected) + .when(timeEntryRepository) + .find(1L); + + ResponseEntity response = controller.read(1L); + + verify(timeEntryRepository).find(1L); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isEqualTo(expected); + } + + @Test + public void testRead_NotFound() throws Exception { + doReturn(null) + .when(timeEntryRepository) + .find(1L); + + ResponseEntity response = controller.read(1L); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); + } + + @Test + public void testList() throws Exception { + List expected = asList( + new TimeEntry(1L, 123L, 456L, LocalDate.parse("2017-01-08"), 8), + new TimeEntry(2L, 789L, 321L, LocalDate.parse("2017-01-07"), 4) + ); + doReturn(expected).when(timeEntryRepository).list(); + + ResponseEntity> response = controller.list(); + + verify(timeEntryRepository).list(); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isEqualTo(expected); + } + + @Test + public void testUpdate() throws Exception { + TimeEntry expected = new TimeEntry(1L, 987L, 654L, LocalDate.parse("2017-01-07"), 4); + doReturn(expected) + .when(timeEntryRepository) + .update(eq(1L), any(TimeEntry.class)); + + ResponseEntity response = controller.update(1L, expected); + + verify(timeEntryRepository).update(1L, expected); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isEqualTo(expected); + } + + @Test + public void testUpdate_NotFound() throws Exception { + doReturn(null) + .when(timeEntryRepository) + .update(eq(1L), any(TimeEntry.class)); + + ResponseEntity response = controller.update(1L, new TimeEntry(987L, 654L, LocalDate.parse("2017-01-07"), 4)); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); + } + + @Test + public void testDelete() throws Exception { + ResponseEntity response = controller.delete(1L); + verify(timeEntryRepository).delete(1L); + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); + } +} diff --git a/src/test/java/test/pivotal/pal/tracker/WelcomeControllerTest.java b/src/test/java/test/pivotal/pal/tracker/WelcomeControllerTest.java new file mode 100644 index 000000000..191cf1214 --- /dev/null +++ b/src/test/java/test/pivotal/pal/tracker/WelcomeControllerTest.java @@ -0,0 +1,25 @@ +package test.pivotal.pal.tracker; + +import io.pivotal.pal.tracker.controllers.WelcomeController; +import org.junit.Before; +import org.junit.Test; +import org.springframework.boot.actuate.metrics.CounterService; + +import static org.mockito.Mockito.*; + +import static org.assertj.core.api.Assertions.assertThat; + +public class WelcomeControllerTest { + + private CounterService counter; + @Before + public void setUp() throws Exception { + counter = mock(CounterService.class); + } + + @Test + public void itSaysHello() throws Exception { + WelcomeController controller = new WelcomeController("A welcome message", counter); + assertThat(controller.sayHello()).isEqualTo("A welcome message"); + } +} diff --git a/src/test/java/test/pivotal/pal/trackerapi/HealthApiTest.java b/src/test/java/test/pivotal/pal/trackerapi/HealthApiTest.java new file mode 100644 index 000000000..74b3f9ca0 --- /dev/null +++ b/src/test/java/test/pivotal/pal/trackerapi/HealthApiTest.java @@ -0,0 +1,50 @@ +package test.pivotal.pal.trackerapi; + +import com.jayway.jsonpath.DocumentContext; +import io.pivotal.pal.tracker.PalTrackerApplication; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.context.embedded.LocalServerPort; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.boot.web.client.RestTemplateBuilder; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.junit4.SpringRunner; + +import static com.jayway.jsonpath.JsonPath.parse; +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +@RunWith(SpringRunner.class) +@SpringBootTest(classes = PalTrackerApplication.class, webEnvironment = RANDOM_PORT) +public class HealthApiTest { + + @LocalServerPort + private String port; + private TestRestTemplate restTemplate; + + @Before + public void setUp() throws Exception { + RestTemplateBuilder builder = new RestTemplateBuilder() + .rootUri("http://localhost:" + port) + .basicAuthorization("user", "password"); + + restTemplate = new TestRestTemplate(builder); + } + + @Test + public void healthTest() { + ResponseEntity response = this.restTemplate.getForEntity("/health", String.class); + + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + + DocumentContext healthJson = parse(response.getBody()); + + assertThat(healthJson.read("$.status", String.class)).isEqualTo("UP"); + assertThat(healthJson.read("$.db.status", String.class)).isEqualTo("UP"); + assertThat(healthJson.read("$.diskSpace.status", String.class)).isEqualTo("UP"); + } +} diff --git a/src/test/java/test/pivotal/pal/trackerapi/SecurityApiTest.java b/src/test/java/test/pivotal/pal/trackerapi/SecurityApiTest.java new file mode 100644 index 000000000..72099994b --- /dev/null +++ b/src/test/java/test/pivotal/pal/trackerapi/SecurityApiTest.java @@ -0,0 +1,52 @@ +package test.pivotal.pal.trackerapi; + +import io.pivotal.pal.tracker.PalTrackerApplication; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.context.embedded.LocalServerPort; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.boot.web.client.RestTemplateBuilder; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.junit4.SpringRunner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +@RunWith(SpringRunner.class) +@SpringBootTest(classes = PalTrackerApplication.class, webEnvironment = RANDOM_PORT) +public class SecurityApiTest { + + @LocalServerPort + private String port; + private TestRestTemplate authorizedRestTemplate; + + @Autowired + private TestRestTemplate unAuthorizedRestTemplate; + + @Before + public void setUp() throws Exception { + RestTemplateBuilder builder = new RestTemplateBuilder() + .rootUri("http://localhost:" + port) + .basicAuthorization("user", "password"); + + authorizedRestTemplate = new TestRestTemplate(builder); + } + + @Test + public void unauthorizedTest() { + ResponseEntity response = this.unAuthorizedRestTemplate.getForEntity("/", String.class); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + } + + @Test + public void authorizedTest() { + ResponseEntity response = this.authorizedRestTemplate.getForEntity("/", String.class); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + } +} diff --git a/src/test/java/test/pivotal/pal/trackerapi/TimeEntryApiTest.java b/src/test/java/test/pivotal/pal/trackerapi/TimeEntryApiTest.java new file mode 100644 index 000000000..2d001a972 --- /dev/null +++ b/src/test/java/test/pivotal/pal/trackerapi/TimeEntryApiTest.java @@ -0,0 +1,151 @@ +package test.pivotal.pal.trackerapi; + +import com.jayway.jsonpath.DocumentContext; +import com.mysql.cj.jdbc.MysqlDataSource; +import io.pivotal.pal.tracker.PalTrackerApplication; +import io.pivotal.pal.tracker.domain.TimeEntry; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.context.embedded.LocalServerPort; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.boot.web.client.RestTemplateBuilder; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.junit4.SpringRunner; + +import java.time.LocalDate; +import java.util.Collection; +import java.util.TimeZone; + +import static com.jayway.jsonpath.JsonPath.parse; +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +@RunWith(SpringRunner.class) +@SpringBootTest(classes = PalTrackerApplication.class, webEnvironment = RANDOM_PORT) +public class TimeEntryApiTest { + + @LocalServerPort + private String port; + private TestRestTemplate restTemplate; + private TimeEntry timeEntry = new TimeEntry(123L, 456L, LocalDate.parse("2017-01-08"), 8); + + @Before + public void setUpRestTemplate() throws Exception { + RestTemplateBuilder builder = new RestTemplateBuilder() + .rootUri("http://localhost:" + port) + .basicAuthorization("user", "password"); + + restTemplate = new TestRestTemplate(builder); + } + + @Before + public void setUp() throws Exception { + MysqlDataSource dataSource = new MysqlDataSource(); + dataSource.setUrl(System.getenv("SPRING_DATASOURCE_URL")); + + JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); + jdbcTemplate.execute("TRUNCATE time_entries"); + + TimeZone.setDefault(TimeZone.getTimeZone("UTC")); + } + + @Test + public void testCreate() throws Exception { + ResponseEntity createResponse = restTemplate.postForEntity("/time-entries", timeEntry, String.class); + + + assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED); + + DocumentContext createJson = parse(createResponse.getBody()); + assertThat(createJson.read("$.id", Long.class)).isGreaterThan(0); + assertThat(createJson.read("$.projectId", Long.class)).isEqualTo(123L); + assertThat(createJson.read("$.userId", Long.class)).isEqualTo(456L); + assertThat(createJson.read("$.date", String.class)).isEqualTo("2017-01-08"); + assertThat(createJson.read("$.hours", Long.class)).isEqualTo(8); + } + + @Test + public void testList() throws Exception { + Long id = createTimeEntry(); + + + ResponseEntity listResponse = restTemplate.getForEntity("/time-entries", String.class); + + + assertThat(listResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + + DocumentContext listJson = parse(listResponse.getBody()); + + Collection timeEntries = listJson.read("$[*]", Collection.class); + assertThat(timeEntries.size()).isEqualTo(1); + + Long readId = listJson.read("$[0].id", Long.class); + assertThat(readId).isEqualTo(id); + } + + @Test + public void testRead() throws Exception { + Long id = createTimeEntry(); + + + ResponseEntity readResponse = this.restTemplate.getForEntity("/time-entries/" + id, String.class); + + + assertThat(readResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + DocumentContext readJson = parse(readResponse.getBody()); + assertThat(readJson.read("$.id", Long.class)).isEqualTo(id); + assertThat(readJson.read("$.projectId", Long.class)).isEqualTo(123L); + assertThat(readJson.read("$.userId", Long.class)).isEqualTo(456L); + assertThat(readJson.read("$.date", String.class)).isEqualTo("2017-01-08"); + assertThat(readJson.read("$.hours", Long.class)).isEqualTo(8); + } + + @Test + public void testUpdate() throws Exception { + Long id = createTimeEntry(); + TimeEntry updatedTimeEntry = new TimeEntry(2L, 3L, LocalDate.parse("2017-01-09"), 9); + + + ResponseEntity updateResponse = restTemplate.exchange("/time-entries/" + id, HttpMethod.PUT, new HttpEntity<>(updatedTimeEntry, null), String.class); + + + assertThat(updateResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + + DocumentContext updateJson = parse(updateResponse.getBody()); + assertThat(updateJson.read("$.id", Long.class)).isEqualTo(id); + assertThat(updateJson.read("$.projectId", Long.class)).isEqualTo(2L); + assertThat(updateJson.read("$.userId", Long.class)).isEqualTo(3L); + assertThat(updateJson.read("$.date", String.class)).isEqualTo("2017-01-09"); + assertThat(updateJson.read("$.hours", Long.class)).isEqualTo(9); + } + + @Test + public void testDelete() throws Exception { + Long id = createTimeEntry(); + + + ResponseEntity deleteResponse = restTemplate.exchange("/time-entries/" + id, HttpMethod.DELETE, null, String.class); + + + assertThat(deleteResponse.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT); + + ResponseEntity deletedReadResponse = this.restTemplate.getForEntity("/time-entries/" + id, String.class); + assertThat(deletedReadResponse.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); + } + + private Long createTimeEntry() { + HttpEntity entity = new HttpEntity<>(timeEntry); + + ResponseEntity response = restTemplate.exchange("/time-entries", HttpMethod.POST, entity, TimeEntry.class); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED); + + return response.getBody().getId(); + } +} diff --git a/src/test/java/test/pivotal/pal/trackerapi/WelcomeApiTest.java b/src/test/java/test/pivotal/pal/trackerapi/WelcomeApiTest.java new file mode 100644 index 000000000..813901f55 --- /dev/null +++ b/src/test/java/test/pivotal/pal/trackerapi/WelcomeApiTest.java @@ -0,0 +1,39 @@ +package test.pivotal.pal.trackerapi; + +import io.pivotal.pal.tracker.PalTrackerApplication; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.context.embedded.LocalServerPort; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.boot.web.client.RestTemplateBuilder; +import org.springframework.test.context.junit4.SpringRunner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +@RunWith(SpringRunner.class) +@SpringBootTest(classes = PalTrackerApplication.class, webEnvironment = RANDOM_PORT) +public class WelcomeApiTest { + + @LocalServerPort + private String port; + private TestRestTemplate restTemplate; + + @Before + public void setUp() throws Exception { + RestTemplateBuilder builder = new RestTemplateBuilder() + .rootUri("http://localhost:" + port) + .basicAuthorization("user", "password"); + + restTemplate = new TestRestTemplate(builder); + } + + + @Test + public void exampleTest() { + String body = this.restTemplate.getForObject("/", String.class); + assertThat(body).isEqualTo("Hello from test"); + } +} diff --git a/src/test/kotlin/io/pivotal/pal/tracker/PalTrackerApplicationTests.kt b/src/test/kotlin/io/pivotal/pal/tracker/PalTrackerApplicationTests.kt new file mode 100644 index 000000000..78a8a1d18 --- /dev/null +++ b/src/test/kotlin/io/pivotal/pal/tracker/PalTrackerApplicationTests.kt @@ -0,0 +1,16 @@ +package io.pivotal.pal.tracker + +import org.junit.Test +import org.junit.runner.RunWith +import org.springframework.boot.test.context.SpringBootTest +import org.springframework.test.context.junit4.SpringRunner + +@RunWith(SpringRunner::class) +@SpringBootTest +class PalTrackerApplicationTests { + + @Test + fun contextLoads() { + } + +}