├── .gitattributes ├── .gitignore ├── .travis.yml ├── LICENSE ├── README.md ├── build.sbt ├── project ├── Dependencies.scala ├── build.properties └── plugins.sbt └── src ├── main ├── resources │ ├── application.conf │ ├── db │ │ └── migration │ │ │ └── V1__Create_dummy_table.sql │ ├── docker.conf │ ├── graphiql.html │ └── log4j2.xml └── scala │ └── de │ └── innfactory │ ├── Main.scala │ ├── graphql │ ├── GraphqlRoute.scala │ └── GraphqlSchemaDefinition.scala │ ├── http │ ├── HttpService.scala │ └── SecurityDirectives.scala │ ├── models │ ├── DummyEntity.scala │ └── db │ │ ├── DummyRepository.scala │ │ └── MaybeFilter.scala │ ├── services │ ├── AuthService.scala │ └── DummyService.scala │ └── utils │ ├── AWSCognitoValidation.java │ ├── Authentication.java │ ├── AutoValidate.scala │ ├── Configuration.scala │ ├── FlywayService.scala │ └── Persistence.scala └── test ├── resources └── application.conf └── scala └── de └── innfactory ├── BaseServiceTest.scala ├── ConfigurationTest.scala ├── DummyServiceTest.scala └── utils └── InMemoryPostgresStorage.scala /.gitattributes: -------------------------------------------------------------------------------- 1 | src/main/resources/* linguist-vendored=true 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | *.log 3 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: scala 2 | 3 | scala: 4 | - 2.11.8 5 | 6 | jdk: 7 | - oraclejdk8 8 | 9 | branches: 10 | only: 11 | - master 12 | 13 | notifications: 14 | email: false 15 | 16 | script: 17 | - sbt clean coverage test coverageReport 18 | 19 | after_success: 20 | - bash <(curl -s https://codecov.io/bash) 21 | 22 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "{}" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright {yyyy} {name of copyright owner} 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Akka-http graphQL Bootstrap 2 | ========================= 3 | 4 | [![travis-ci.org](https://travis-ci.org/innFactory/bootstrap-akka-graphql.svg?branch=master)](https://travis-ci.org/innFactory/bootstrap-akka-graphql) 5 | [![codecov.io](https://img.shields.io/codecov/c/github/innFactory/bootstrap-akka-graphql/master.svg?style=flat)](https://codecov.io/github/innFactory/bootstrap-akka-graphql) 6 | [![shields.io](http://img.shields.io/badge/license-Apache2-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.txt) 7 | [![jonato.de](https://img.shields.io/badge/Version-1.0-brightgreen.svg)](https://innFactory.de) 8 | 9 | ## Info 10 | This is a boilerplate template for a akka graphql microservice with slick and flyway database migration. You can use it to create your own GraphQL Services on top of the lightbend stack. 11 | 12 | ### Requirements 13 | * JDK8 [http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)) 14 | * sbt([http://www.scala-sbt.org/release/docs/Getting-Started/Setup.html](http://www.scala-sbt.org/release/docs/Getting-Started/Setup.html)) 15 | * docker for dockerbuild ([https://www.docker.com/community-edition/](https://www.docker.com/community-edition/)) 16 | * aws account if you want to use a cognito userpool for authentifaction ([https://aws.amazon.com/de/](https://aws.amazon.com/de/)) 17 | 18 | ### Implemented Features 19 | 20 | * Integration of *graphiql* ui ```localhost:8080``` 21 | * Integration *sangria* for graphql 22 | * CRUD Repositorys via *slick-repo* with a sample service with get and add implemented 23 | * CORS Support via *akka-http-cors* 24 | * Implemented Authentication with AWS Cognito (JWK) and JWT Token via *nimbusds* (in *Java*) - For Tests All Requests are allowed 25 | * Test coverage with *ScalaTest* and *scoverage* code coverage report 26 | * Ready for *Docker* deployment and *CloudFormation* deployment 27 | * Config file with optional runtime parameters 28 | * In-Memory Postgres SQL database for tests 29 | * Flyway database migration 30 | * *HikariCP* as connection pool 31 | * Logging via *Log4j* with a xml template 32 | 33 | ## Configuration 34 | * Start a PostgreSQL Database via RDS, Docker or locally 35 | * Create a Userpool with AWS Cognito if you need AWS Authentication. 36 | * Configure your application.conf and the docker.conf (`src/main/resources/`) (application.conf in test has to stay as it is, for running in a in-memory postgresql instance) 37 | 38 | ### Environment variables 39 | - `SQL_URL` - database url by scheme `jdbc:postgresql://host:port/database-name` 40 | - `SQL_USER` - database user 41 | - `SQL_PASSWORD` - database password 42 | - `NIC_IP` - IP Address bounded to the http service default is 0.0.0.0 43 | - `NIC_PORT` - TCP Port used for the http service default is 8080 44 | - `USER_POOL` - Define an other cognito user pool than the preconfigured userpool 45 | 46 | 47 | ## Run application 48 | To run application, call: 49 | ``` 50 | sbt run 51 | ``` 52 | If you wanna restart your application without reloading of sbt, use (*revolver* sbt plugin): 53 | ``` 54 | sbt re-start 55 | ``` 56 | 57 | ### Run in Docker 58 | For launching application in Docker, you must configure database docker instance and run docker image, generated by sbt. 59 | 60 | Generating application docker image and publishing on localhost: 61 | ``` 62 | sbt docker:publishLocal 63 | ``` 64 | 65 | Example of running, generated docker image: 66 | ``` 67 | docker run --name akkaHttp -e SQL_USER=dbuser -e SQL_PASSWORD=dbpass -e SQL_URL=jdbcURL -d -p 9090:9000 APPLICATION_IMAGE 68 | ``` 69 | - `APPLICATION_IMAGE` - id or name of application docker image 70 | 71 | look at ```--link``` parameter if the database is also a docker container 72 | 73 | ## Test 74 | To run tests, call: 75 | ``` 76 | sbt test 77 | ``` 78 | 79 | To run all tests, with codecoverage, call: 80 | 81 | ```sbt clean coverage test``` 82 | 83 | To generate a coverage report afterwars the testrun, call: 84 | 85 | ```sbt coverageReport``` 86 | 87 | ## More Info 88 | We will write a blog post soon on innFactory about microservice development. 89 | 90 | ## Copyright & Contributers 91 | Tobias Jonas 92 | 93 | Copyright (C) 2017 [innFactory Cloud- & DataEngineering](https://innFactory.de) 94 | 95 | Published under the Apache 2 License. -------------------------------------------------------------------------------- /build.sbt: -------------------------------------------------------------------------------- 1 | name := "bootstrap-akka-graphql" 2 | organization := "de.innfactory" 3 | version := "1.0.0" 4 | scalaVersion := Version.Scala 5 | 6 | libraryDependencies ++= { 7 | Seq( 8 | Library.akkaActor, 9 | Library.akkaHttp, 10 | Library.akkaHttpCors, 11 | Library.akkaHttpSprayJson, 12 | Library.akkaStream, 13 | Library.log4jCore, 14 | Library.slf4jLog4jBridge, 15 | Library.akkaLog4j, 16 | Library.slick, 17 | Library.slickHikaricp, 18 | Library.postgresql, 19 | Library.slickRepo, 20 | Library.flywaydb, 21 | Library.nimbusds, 22 | Library.sangria, 23 | Library.sangriaSprayJson, 24 | TestLibrary.akkaTestkit, 25 | TestLibrary.akkaHttpTestkit, 26 | TestLibrary.postgresqlEmbedded, 27 | TestLibrary.scalaTest 28 | ) 29 | } 30 | 31 | Revolver.settings 32 | enablePlugins(JavaAppPackaging) 33 | enablePlugins(DockerPlugin) 34 | 35 | dockerExposedPorts := Seq(8080) 36 | dockerEntrypoint := Seq("bin/%s" format executableScriptName.value, "-Dconfig.resource=docker.conf") 37 | -------------------------------------------------------------------------------- /project/Dependencies.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | 3 | object Version { 4 | final val akka = "2.5.3" 5 | final val akkaHttp = "10.0.8" 6 | final val akkaHttpSprayJson = "10.0.9" 7 | final val Scala = "2.11.8" 8 | final val AkkaLog4j = "1.4.0" 9 | final val Log4j = "2.8.2" 10 | final val swagger = "1.5.14" 11 | final val swaggerAkka = "0.9.2" 12 | final val akkaHttpCors = "0.2.1" 13 | final val slickRepo = "1.4.3" 14 | final val postgresql = "9.4-1206-jdbc42" 15 | final val nimbusds = "4.23" 16 | final val slick = "3.2.0" 17 | final val flyway = "3.2.1" 18 | final val sangriaSprayJson = "1.0.0" 19 | final val sangria = "1.2.2" 20 | } 21 | 22 | object Library { 23 | 24 | val swagger = "io.swagger" % "swagger-jaxrs" % Version.swagger 25 | val swaggerAkka = "com.github.swagger-akka-http" %% "swagger-akka-http" % Version.swaggerAkka 26 | 27 | val akkaHttp = "com.typesafe.akka" %% "akka-http" % Version.akkaHttp 28 | val akkaActor = "com.typesafe.akka" %% "akka-actor" % Version.akka 29 | val akkaStream = "com.typesafe.akka" %% "akka-stream" % Version.akka 30 | val akkaHttpCors = "ch.megard" %% "akka-http-cors" % Version.akkaHttpCors 31 | val akkaHttpSprayJson = "com.typesafe.akka" %% "akka-http-spray-json" % Version.akkaHttpSprayJson 32 | 33 | val log4jCore = "org.apache.logging.log4j" % "log4j-core" % Version.Log4j 34 | val slf4jLog4jBridge = "org.apache.logging.log4j" % "log4j-slf4j-impl" % Version.Log4j 35 | val akkaLog4j = "de.heikoseeberger" %% "akka-log4j" % Version.AkkaLog4j 36 | 37 | val slick = "com.typesafe.slick" %% "slick" % Version.slick 38 | val slickHikaricp = "com.typesafe.slick" %% "slick-hikaricp" % "3.2.0" 39 | val postgresql = "org.postgresql" % "postgresql"% Version.postgresql 40 | val slickRepo = "com.byteslounge" %% "slick-repo" % Version.slickRepo 41 | val flywaydb = "org.flywaydb" % "flyway-core" % Version.flyway 42 | 43 | val nimbusds = "com.nimbusds" % "nimbus-jose-jwt" % Version.nimbusds 44 | 45 | val sangriaSprayJson = "org.sangria-graphql" %% "sangria-spray-json" % Version.sangriaSprayJson 46 | val sangria = "org.sangria-graphql" %% "sangria" % Version.sangria 47 | 48 | 49 | } 50 | 51 | object TestVersion { 52 | final val akkaTestkit = "2.5.3" 53 | final val akkaHttpTestkit = "10.0.9" 54 | final val postgresqlEmbedded = "2.2" 55 | final val scalaTest = "3.0.1" 56 | } 57 | 58 | object TestLibrary { 59 | val akkaTestkit = "com.typesafe.akka" %% "akka-testkit" % TestVersion.akkaTestkit % "test" 60 | val akkaHttpTestkit = "com.typesafe.akka" %% "akka-http-testkit" % TestVersion.akkaHttpTestkit % "test" 61 | val postgresqlEmbedded = "ru.yandex.qatools.embed" % "postgresql-embedded" % TestVersion.postgresqlEmbedded % "test" 62 | val scalaTest = "org.scalatest" %% "scalatest" % TestVersion.scalaTest % "test" 63 | } 64 | -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=0.13.15 2 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | resolvers += Classpaths.sbtPluginReleases 2 | 3 | addSbtPlugin("io.spray" %% "sbt-revolver" % "0.8.0") 4 | addSbtPlugin("com.typesafe.sbt" %% "sbt-native-packager" % "1.1.4") 5 | addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.5.0") -------------------------------------------------------------------------------- /src/main/resources/application.conf: -------------------------------------------------------------------------------- 1 | akka { 2 | loglevel = DEBUG 3 | log-dead-letters = 10 4 | log-dead-letters-during-shutdown = off 5 | loggers = [de.heikoseeberger.akkalog4j.Log4jLogger] 6 | logging-filter = de.heikoseeberger.akkalog4j.Log4jLoggingFilter 7 | 8 | actor { 9 | warn-about-java-serializer-usage = off 10 | } 11 | } 12 | 13 | http { 14 | interface = "0.0.0.0" 15 | interface = ${?NIC_IP} 16 | port = 8080 17 | port = ${?NIC_PORT} 18 | self-timeout = 10000 ms 19 | } 20 | 21 | auth { 22 | cognito = "https://cognito-idp.eu-central-1.amazonaws.com/eu-central-1_ABCDEF/.well-known/jwks.json" 23 | cognito = ${?USER_POOL} 24 | allow-all = false 25 | } 26 | 27 | database { 28 | db { 29 | url = "jdbc:postgresql://localhost/akka-bootstrap-graphql2" 30 | url = ${?SQL_URL} 31 | user = "test" 32 | user = ${?SQL_USER} 33 | password = "test" 34 | password = ${?SQL_PASSWORD} 35 | } 36 | profile = "slick.jdbc.PostgresProfile$" 37 | } 38 | 39 | -------------------------------------------------------------------------------- /src/main/resources/db/migration/V1__Create_dummy_table.sql: -------------------------------------------------------------------------------- 1 | CREATE TABLE "dummy" ( 2 | "id" BIGSERIAL PRIMARY KEY , 3 | "dummy" VARCHAR NOT NULL 4 | ); 5 | 6 | INSERT INTO "dummy" ("dummy") VALUES ('a'), ('b'), ('c'), ('d'); -------------------------------------------------------------------------------- /src/main/resources/docker.conf: -------------------------------------------------------------------------------- 1 | include "application.conf" 2 | 3 | database { 4 | db { 5 | url = "jdbc:postgresql://localhost/akka-bootstrap" 6 | url = ${?SQL_URL} 7 | user = "test" 8 | user = ${?SQL_USER} 9 | password = "test" 10 | password = ${?SQL_PASSWORD} 11 | } 12 | profile = "slick.jdbc.PostgresProfile$" 13 | } 14 | -------------------------------------------------------------------------------- /src/main/resources/graphiql.html: -------------------------------------------------------------------------------- 1 | 29 | 30 | 31 | 32 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 |
Loading...
54 | 55 | 150 | 151 | 152 | -------------------------------------------------------------------------------- /src/main/resources/log4j2.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | [%level] [%date{ISO8601}] [%logger] [akkaSource=%X{akkaSource}][sourceThread=%X{sourceThread}] [mdc=ticket-#%X{ticketNumber}: %X{ticketDesc}] %msg%n 8 | 9 | 10 | 11 | 12 | %date{ISO8601} level=[%level] logger=[%logger] akkaSource=[%X{akkaSource}] sourceThread=[%X{sourceThread}] mdc=[ticket-#%X{ticketNumber}: %X{ticketDesc}] - msg=[%msg]%n----%n 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/Main.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory 2 | 3 | import akka.actor.ActorSystem 4 | import akka.event.{Logging, LoggingAdapter} 5 | import akka.http.scaladsl.Http 6 | import akka.stream.ActorMaterializer 7 | import de.innfactory.http.HttpService 8 | import de.innfactory.graphql.GraphQLContextServices 9 | import de.innfactory.services.{AuthService, DummyService} 10 | import de.innfactory.utils.{AWSCognitoValidation, AutoValidate, Configuration, FlywayService} 11 | 12 | import scala.concurrent.ExecutionContext 13 | 14 | object Main extends App with Configuration { 15 | // $COVERAGE-OFF$Main Application Wrapper 16 | implicit val actorSystem = ActorSystem() 17 | implicit val executor: ExecutionContext = actorSystem.dispatcher 18 | implicit val log: LoggingAdapter = Logging(actorSystem, getClass) 19 | implicit val materializer: ActorMaterializer = ActorMaterializer() 20 | 21 | val flywayService = new FlywayService(jdbcUrl, dbUser, dbPassword) 22 | flywayService.migrateDatabaseSchema 23 | 24 | implicit val authService = new AuthService(new AutoValidate) 25 | //implicit val authService = new AuthService(new AWSCognitoValidation(authCognito, log)) Use this Service for AWS ;-) 26 | 27 | val dummyService = new DummyService() 28 | val graphQLContextServices = GraphQLContextServices(authService, dummyService) 29 | val httpService = new HttpService(graphQLContextServices) 30 | Http().bindAndHandle(httpService.routes, httpHost, httpPort) 31 | // $COVERAGE-ON$ 32 | } 33 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/graphql/GraphqlRoute.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.graphql 2 | 3 | import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._ 4 | import akka.http.scaladsl.model.StatusCodes._ 5 | import akka.http.scaladsl.server.Directives._ 6 | import akka.http.scaladsl.server._ 7 | import de.innfactory.http.SecurityDirectives 8 | import de.innfactory.services.AuthService 9 | import sangria.execution.{ErrorWithResolver, Executor, QueryAnalysisError} 10 | import sangria.marshalling.sprayJson._ 11 | import sangria.parser.QueryParser 12 | import spray.json._ 13 | 14 | import scala.concurrent.ExecutionContext 15 | import scala.util.{Failure, Success} 16 | 17 | class GraphqlRoute(graphQLServices: GraphQLContextServices)(implicit executionContext: ExecutionContext, override protected val authService: AuthService) extends SecurityDirectives { 18 | // $COVERAGE-OFF$No changes required 19 | val route: Route = 20 | (post & path("graphql")) { 21 | authenticate { credentials => 22 | entity(as[JsValue]) { requestJson ⇒ 23 | val JsObject(fields) = requestJson 24 | 25 | val JsString(query) = fields("query") 26 | 27 | val operation = fields.get("operationName") collect { 28 | case JsString(op) ⇒ op 29 | } 30 | 31 | val vars = fields.get("variables") match { 32 | case Some(obj: JsObject) ⇒ obj 33 | case _ ⇒ JsObject.empty 34 | } 35 | 36 | val graphQLContext = GraphQLContext(Some(credentials), graphQLServices) 37 | 38 | QueryParser.parse(query) match { 39 | // query parsed successfully, time to execute it! 40 | case Success(queryAst) ⇒ 41 | complete(Executor.execute(GraphqlSchemaDefinition.apiSchema, queryAst, 42 | variables = vars, 43 | operationName = operation, 44 | userContext = graphQLContext 45 | ) 46 | .map(OK → _) 47 | .recover { 48 | case error: QueryAnalysisError ⇒ BadRequest → error.resolveError 49 | case error: ErrorWithResolver ⇒ InternalServerError → error.resolveError 50 | }) 51 | 52 | // can't parse GraphQL query, return error 53 | case Failure(error) ⇒ 54 | complete(BadRequest, JsObject("error" → JsString(error.getMessage))) 55 | } 56 | 57 | 58 | } 59 | } 60 | } ~ 61 | get { 62 | getFromResource("graphiql.html") 63 | } 64 | // $COVERAGE-ON$ 65 | } 66 | 67 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/graphql/GraphqlSchemaDefinition.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.graphql 2 | 3 | import de.innfactory.services.{AuthService, DummyService} 4 | import sangria.schema._ 5 | 6 | import scala.concurrent.ExecutionContext 7 | 8 | case class GraphQLContextServices(authService: AuthService, dummyService: DummyService)(implicit executionContext: ExecutionContext) 9 | case class GraphQLContext(credentials: Option[Map[String, AnyRef]], services: GraphQLContextServices) 10 | 11 | object GraphqlSchemaDefinition { 12 | 13 | val Query = ObjectType( 14 | "Query", fields[GraphQLContext, Unit]( 15 | DummyService.graphqlFields 16 | )) 17 | 18 | val Mutation = ObjectType( 19 | "Mutation", fields[GraphQLContext, Unit]( 20 | DummyService.graphqlMutationsAddDummy 21 | ) 22 | ) 23 | 24 | val apiSchema = Schema(Query, Some(Mutation)) 25 | } 26 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/http/HttpService.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.http 2 | 3 | import akka.actor.ActorSystem 4 | import akka.http.scaladsl.model.HttpMethods._ 5 | import ch.megard.akka.http.cors.scaladsl.CorsDirectives.cors 6 | import ch.megard.akka.http.cors.scaladsl.settings.CorsSettings 7 | import de.innfactory.graphql.{GraphQLContextServices, GraphqlRoute} 8 | import de.innfactory.services.{AuthService, DummyService} 9 | import de.innfactory.utils.Configuration 10 | 11 | import scala.concurrent.ExecutionContext 12 | 13 | class HttpService(graphQLContext: GraphQLContextServices)(implicit executionContext: ExecutionContext, actorSystem: ActorSystem, authService: AuthService) extends Configuration { 14 | 15 | val settings = CorsSettings.defaultSettings.copy(allowedMethods = List(GET, POST, PUT, HEAD, OPTIONS, DELETE)) 16 | val graphqlRoute = new GraphqlRoute(graphQLContext) 17 | val routes = 18 | cors(settings) { 19 | graphqlRoute.route 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/http/SecurityDirectives.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.http 2 | 3 | import akka.http.scaladsl.server.Directive1 4 | import akka.http.scaladsl.server.directives.{BasicDirectives, FutureDirectives, HeaderDirectives, RouteDirectives} 5 | import de.innfactory.services.AuthService 6 | import de.innfactory.utils.Configuration 7 | 8 | trait SecurityDirectives extends Configuration { 9 | 10 | import BasicDirectives._ 11 | import FutureDirectives._ 12 | import HeaderDirectives._ 13 | import RouteDirectives._ 14 | 15 | def authenticate: Directive1[Map[String, AnyRef]] = { 16 | if(allowAll){ 17 | provide(Map()) 18 | }else { 19 | optionalHeaderValueByName("Authorization").flatMap { token => 20 | onSuccess(authService.authenticate(token.getOrElse(""))).flatMap { 21 | case Some(user) => provide(user) 22 | case None => reject 23 | } 24 | } 25 | } 26 | } 27 | 28 | protected val authService: AuthService 29 | 30 | } 31 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/models/DummyEntity.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.models 2 | 3 | import com.byteslounge.slickrepo.meta.Entity 4 | import sangria.macros.derive._ 5 | 6 | @GraphQLDescription(description = "Thats a dummy! Get id or a string...") 7 | case class Dummy(override val id: Option[Long], 8 | @GraphQLDeprecated(deprecationReason = "dummy val is old") dummy: String) extends Entity[Dummy, Long] { 9 | override def withId(id: Long): Dummy = this.copy(id = Some(id)) 10 | } 11 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/models/db/DummyRepository.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.models.db 2 | 3 | import com.byteslounge.slickrepo.meta.Keyed 4 | import com.byteslounge.slickrepo.repository.Repository 5 | import de.innfactory.models.Dummy 6 | import slick.ast.BaseTypedType 7 | import slick.jdbc.JdbcProfile 8 | 9 | class DummyRepository()(implicit override val driver: JdbcProfile) extends Repository[Dummy, Long](driver) { 10 | 11 | import driver.api._ 12 | 13 | val pkType = implicitly[BaseTypedType[Long]] 14 | val tableQuery = TableQuery[Dummys] 15 | type TableType = Dummys 16 | 17 | 18 | class Dummys(tag: slick.lifted.Tag) extends Table[Dummy](tag, "dummy") with Keyed[Long] { 19 | def id = column[Long]("id", O.PrimaryKey, O.AutoInc) 20 | 21 | def dummy = column[String]("dummy") 22 | 23 | def * = (id.?, dummy) <> ((Dummy.apply _).tupled, Dummy.unapply) 24 | } 25 | 26 | 27 | def find(id: Option[Long], 28 | dummy: Option[String] 29 | ): DBIO[Seq[Dummy]] = { 30 | 31 | MaybeFilter(tableQuery) 32 | .filter(id)(v => d => d.id === v) 33 | .filter(dummy)(v => d => d.dummy === v) 34 | .query 35 | .sortBy(table => table.column[Long]("id").asc) 36 | .result 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/models/db/MaybeFilter.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.models.db 2 | 3 | import slick.lifted.CanBeQueryCondition 4 | 5 | import scala.language.higherKinds 6 | 7 | case class MaybeFilter[X, Y, C[_]](val query: slick.lifted.Query[X, Y, C]) { 8 | def filter[T,R:CanBeQueryCondition](data: Option[T])(f: T => X => R) = { 9 | data.map(v => MaybeFilter(query.withFilter(f(v)))).getOrElse(this) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/services/AuthService.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.services 2 | 3 | import de.innfactory.utils.Authentication 4 | 5 | import scala.collection.JavaConverters._ 6 | import scala.concurrent.{ExecutionContext, Future, blocking} 7 | 8 | class AuthService(auth : Authentication)(implicit executionContext: ExecutionContext) { 9 | 10 | def authenticate(accessToken: String): Future[Option[Map[String, AnyRef]]] = Future { 11 | blocking { 12 | val jwtCheck = auth.validateToken(accessToken) 13 | if (jwtCheck == null) { 14 | None 15 | } else { 16 | Some(jwtCheck.asScala.toMap) 17 | } 18 | } 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/services/DummyService.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.services 2 | 3 | import de.innfactory.graphql.GraphQLContext 4 | import de.innfactory.models.Dummy 5 | import de.innfactory.models.db.DummyRepository 6 | import de.innfactory.utils.Persistence 7 | import sangria.macros.derive._ 8 | import sangria.schema.{Args, Argument, Field, ListType, LongType, OptionInputType, OptionType, StringType, fields} 9 | 10 | import scala.concurrent.ExecutionContext 11 | 12 | class DummyService()(implicit executionContext: ExecutionContext) extends Persistence { 13 | val dummyRepository = new DummyRepository() 14 | 15 | def findGraphQL(args : Args) = { 16 | executeOperation { 17 | dummyRepository.find(args.argOpt("id"), args.argOpt("dummy")) 18 | } 19 | } 20 | 21 | @GraphQLField 22 | def addDummy(dummy: String) = { 23 | val d = Dummy(None, dummy) 24 | executeOperation { 25 | dummyRepository.save(d) 26 | } 27 | } 28 | } 29 | 30 | object DummyService { 31 | implicit val graphqlType = deriveObjectType[DummyService, Dummy]() 32 | 33 | val graphqlFields = fields[GraphQLContext, Unit]( 34 | Field("dummy", ListType(graphqlType), 35 | arguments = Argument("id", OptionInputType(LongType), description = "id of the dummy") :: Nil, 36 | resolve = f => f.ctx.services.dummyService.findGraphQL(f.args) 37 | 38 | )).head 39 | 40 | val graphqlMutationsAddDummy = fields[GraphQLContext, Unit](Field("addDummy", OptionType(DummyService.graphqlType), 41 | arguments = Argument("dummy", StringType) :: Nil, 42 | resolve = f => f.ctx.services.dummyService.addDummy(f.arg("dummy")) 43 | )).head 44 | 45 | } -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/AWSCognitoValidation.java: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils; 2 | 3 | import akka.event.LoggingAdapter; 4 | import com.nimbusds.jose.JOSEException; 5 | import com.nimbusds.jose.JWSAlgorithm; 6 | import com.nimbusds.jose.jwk.source.JWKSource; 7 | import com.nimbusds.jose.jwk.source.RemoteJWKSet; 8 | import com.nimbusds.jose.proc.BadJOSEException; 9 | import com.nimbusds.jose.proc.JWSKeySelector; 10 | import com.nimbusds.jose.proc.JWSVerificationKeySelector; 11 | import com.nimbusds.jwt.proc.ConfigurableJWTProcessor; 12 | import com.nimbusds.jwt.proc.DefaultJWTProcessor; 13 | 14 | import java.net.MalformedURLException; 15 | import java.net.URL; 16 | import java.text.ParseException; 17 | import java.util.Map; 18 | 19 | public class AWSCognitoValidation implements Authentication { 20 | // $COVERAGE-OFF$Disabling highlighting until it is rewritten in scala 21 | private JWKSource keySource; 22 | private String remoteJWKUrl = ""; 23 | private LoggingAdapter log; 24 | 25 | public AWSCognitoValidation(String remoteJWKUrl, LoggingAdapter log){ 26 | this.remoteJWKUrl = remoteJWKUrl; 27 | this.log = log; 28 | } 29 | 30 | @Override 31 | public Map validateToken(String token) { 32 | try { 33 | keySource = new RemoteJWKSet(new URL(remoteJWKUrl)); 34 | } catch (MalformedURLException e) { 35 | log.error(e, e.getMessage()); 36 | return null; 37 | } 38 | ConfigurableJWTProcessor jwtProcessor = new DefaultJWTProcessor(); 39 | JWSAlgorithm expectedJWSAlg = JWSAlgorithm.RS256; 40 | JWSKeySelector keySelector = new JWSVerificationKeySelector(expectedJWSAlg, keySource); 41 | jwtProcessor.setJWSKeySelector(keySelector); 42 | 43 | try { 44 | return jwtProcessor.process(token, null).getClaims(); 45 | } catch (ParseException e) { 46 | log.error(e, e.getMessage()); 47 | return null; 48 | } catch (BadJOSEException e) { 49 | log.error(e, e.getMessage()); 50 | return null; 51 | } catch (JOSEException e) { 52 | log.error(e, e.getMessage()); 53 | return null; 54 | } 55 | } 56 | // $COVERAGE-ON$ 57 | } -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/Authentication.java: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils; 2 | 3 | import java.util.Map; 4 | 5 | public interface Authentication { 6 | Map validateToken(String token); 7 | } 8 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/AutoValidate.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils 2 | import java.util 3 | 4 | import scala.collection.JavaConverters._ 5 | 6 | class AutoValidate extends Authentication { 7 | override def validateToken(token: String): util.Map[String, AnyRef] = Map[String, AnyRef]("token" -> token, "autoValidation" -> "true").asJava 8 | } 9 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/Configuration.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils 2 | 3 | import com.typesafe.config.{Config, ConfigFactory} 4 | 5 | import scala.concurrent.duration.{FiniteDuration, MILLISECONDS} 6 | 7 | trait Configuration { 8 | protected val config : Config = ConfigFactory.load() 9 | private val httpConfig = config.getConfig("http") 10 | private val databaseConfig = config.getConfig("database") 11 | private val authenticationConfig = config.getConfig("auth") 12 | 13 | val httpHost = httpConfig.getString("interface") 14 | val httpPort = httpConfig.getInt("port") 15 | val httpSelfTimeout = httpConfig.getDuration("self-timeout") 16 | 17 | val jdbcUrl = databaseConfig.getString("db.url") 18 | val dbUser = databaseConfig.getString("db.user") 19 | val dbPassword = databaseConfig.getString("db.password") 20 | 21 | val authCognito = authenticationConfig.getString("cognito") 22 | val allowAll = authenticationConfig.getBoolean("allow-all") 23 | 24 | private def getDuration(key: String) = FiniteDuration(config.getDuration(key, MILLISECONDS), MILLISECONDS) 25 | } 26 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/FlywayService.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils 2 | 3 | import org.flywaydb.core.Flyway 4 | 5 | class FlywayService(jdbcUrl: String, dbUser: String, dbPassword: String) { 6 | 7 | private[this] val flyway = new Flyway() 8 | flyway.setDataSource(jdbcUrl, dbUser, dbPassword) 9 | 10 | def migrateDatabaseSchema() : Unit = flyway.migrate() 11 | 12 | def dropDatabase() : Unit = flyway.clean() 13 | } 14 | -------------------------------------------------------------------------------- /src/main/scala/de/innfactory/utils/Persistence.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils 2 | 3 | import slick.basic.DatabaseConfig 4 | import slick.dbio.DBIO 5 | import slick.jdbc.JdbcProfile 6 | 7 | import scala.concurrent.Future 8 | 9 | trait Profile { 10 | val profile: JdbcProfile 11 | } 12 | 13 | 14 | trait DbModule extends Profile{ 15 | val db: JdbcProfile#Backend#Database 16 | 17 | implicit def executeOperation[T](databaseOperation: DBIO[T]): Future[T] = { 18 | db.run(databaseOperation) 19 | } 20 | 21 | } 22 | 23 | trait PersistenceModule { 24 | implicit def executeOperation[T](databaseOperation: DBIO[T]): Future[T] 25 | } 26 | 27 | 28 | class Persistence() extends PersistenceModule with DbModule { 29 | private val dbConfig : DatabaseConfig[JdbcProfile] = DatabaseConfig.forConfig("database") 30 | override implicit val profile: JdbcProfile = dbConfig.profile 31 | override implicit val db: JdbcProfile#Backend#Database = dbConfig.db 32 | } -------------------------------------------------------------------------------- /src/test/resources/application.conf: -------------------------------------------------------------------------------- 1 | akka { 2 | loglevel = WARNING 3 | log-dead-letters = 10 4 | log-dead-letters-during-shutdown = off 5 | loggers = [de.heikoseeberger.akkalog4j.Log4jLogger] 6 | logging-filter = de.heikoseeberger.akkalog4j.Log4jLoggingFilter 7 | 8 | actor { 9 | warn-about-java-serializer-usage = off 10 | } 11 | } 12 | 13 | http { 14 | interface = "0.0.0.0" 15 | interface = ${?NIC_IP} 16 | port = 8080 17 | port = ${?NIC_PORT} 18 | self-timeout = 10000 ms 19 | } 20 | 21 | auth { 22 | cognito = "http://" 23 | cognito = ${?USER_POOL} 24 | allow-all = false 25 | } 26 | 27 | database { 28 | db { 29 | url = "jdbc:postgresql://localhost:25535/database-name" 30 | user = "user" 31 | password = "password" 32 | } 33 | profile = "slick.jdbc.PostgresProfile$" 34 | } 35 | 36 | -------------------------------------------------------------------------------- /src/test/scala/de/innfactory/BaseServiceTest.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory 2 | 3 | import akka.http.scaladsl.testkit.ScalatestRouteTest 4 | import de.innfactory.graphql.GraphqlSchemaDefinition.apiSchema 5 | import de.innfactory.graphql.{GraphQLContext, GraphQLContextServices} 6 | import de.innfactory.http.HttpService 7 | import de.innfactory.services.{AuthService, DummyService} 8 | import de.innfactory.utils.AutoValidate 9 | import de.innfactory.utils.InMemoryPostgresStorage._ 10 | import org.scalatest.{Matchers, WordSpec} 11 | import sangria.ast.Document 12 | import sangria.execution.Executor 13 | import sangria.marshalling.sprayJson._ 14 | import sangria.renderer.SchemaRenderer 15 | import spray.json._ 16 | 17 | import scala.concurrent.Await 18 | import scala.concurrent.duration._ 19 | 20 | trait BaseServiceTest extends WordSpec with Matchers with ScalatestRouteTest { 21 | 22 | println(SchemaRenderer.renderSchema(apiSchema)) 23 | 24 | dbProcess.getProcessId 25 | 26 | val dummyService = new DummyService() 27 | implicit val authService = new AuthService(new AutoValidate) 28 | val graphQLContextServices = GraphQLContextServices(authService, dummyService) 29 | 30 | val httpService = new HttpService(graphQLContextServices) 31 | 32 | def executeQuery(query: Document, vars: JsObject = JsObject.empty) = { 33 | val futureResult = Executor.execute(apiSchema, query, 34 | variables = vars, 35 | userContext = GraphQLContext(None, graphQLContextServices) 36 | ) 37 | Await.result(futureResult, 10.seconds) 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/test/scala/de/innfactory/ConfigurationTest.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory 2 | 3 | import com.typesafe.config.ConfigFactory 4 | import de.innfactory.utils.Configuration 5 | import org.scalatest.{Matchers, WordSpec} 6 | 7 | class ConfigurationTest extends WordSpec with Matchers with Configuration { 8 | "Config" should { 9 | "should load all values from configuration file for test" in { 10 | httpHost.isEmpty shouldBe false 11 | httpPort should (be > (0) and be <= (65535)) 12 | httpSelfTimeout.getSeconds.toInt should (be < (60)) 13 | jdbcUrl.isEmpty shouldBe false 14 | jdbcUrl shouldBe "jdbc:postgresql://localhost:25535/database-name" 15 | dbUser.isEmpty shouldBe false 16 | dbPassword.isEmpty shouldBe false 17 | authCognito.startsWith("http") shouldBe true 18 | allowAll shouldBe false 19 | } 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/test/scala/de/innfactory/DummyServiceTest.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory 2 | 3 | import de.innfactory.models.Dummy 4 | import sangria.macros._ 5 | import spray.json._ 6 | 7 | class DummyServiceTest extends BaseServiceTest { 8 | 9 | 10 | "API Schema" should { 11 | "correctly identify dummy 1 as a" in { 12 | val query = 13 | graphql""" 14 | query{dummy(id:1) { 15 | id, 16 | dummy 17 | } 18 | }""" 19 | 20 | executeQuery(query) should be ( 21 | """ 22 | { 23 | "data": { 24 | "dummy": [ 25 | { 26 | "id": 1, 27 | "dummy": "a" 28 | } 29 | ] 30 | } 31 | } 32 | """.parseJson) 33 | } 34 | 35 | "allow to add dummy e with id 5" in { 36 | Dummy(Some(5), "e") //should be created 37 | val query = 38 | graphql""" 39 | mutation { 40 | addDummy(dummy: "e") { 41 | id 42 | dummy 43 | } 44 | } 45 | """ 46 | 47 | executeQuery(query) should be ( 48 | """{ 49 | "data": { 50 | "addDummy": { 51 | "id": 5, 52 | "dummy": "e" 53 | } 54 | } 55 | }""" 56 | .parseJson) 57 | } 58 | } 59 | 60 | } 61 | 62 | 63 | -------------------------------------------------------------------------------- /src/test/scala/de/innfactory/utils/InMemoryPostgresStorage.scala: -------------------------------------------------------------------------------- 1 | package de.innfactory.utils 2 | 3 | import de.flapdoodle.embed.process.runtime.Network._ 4 | import ru.yandex.qatools.embed.postgresql.PostgresStarter 5 | import ru.yandex.qatools.embed.postgresql.config.AbstractPostgresConfig.{Credentials, Net, Storage, Timeout} 6 | import ru.yandex.qatools.embed.postgresql.config.PostgresConfig 7 | import ru.yandex.qatools.embed.postgresql.distribution.Version 8 | 9 | object InMemoryPostgresStorage { 10 | val dbHost = getLocalHost.getHostAddress 11 | val dbPort = 25535 12 | val dbName = "database-name" 13 | val dbUser = "user" 14 | val dbPassword = "password" 15 | val jdbcUrl = s"jdbc:postgresql://$dbHost:$dbPort/$dbName" 16 | 17 | lazy val dbProcess = { 18 | val psqlConfig = new PostgresConfig( 19 | Version.V9_5_5, new Net(dbHost, dbPort), 20 | new Storage(dbName), new Timeout(), 21 | new Credentials(dbUser, dbPassword) 22 | ) 23 | val psqlInstance = PostgresStarter.getDefaultInstance 24 | val flywayService = new FlywayService(jdbcUrl, dbUser, dbPassword) 25 | 26 | val process = psqlInstance.prepare(psqlConfig).start() 27 | flywayService.dropDatabase() 28 | flywayService.migrateDatabaseSchema() 29 | process 30 | } 31 | } 32 | --------------------------------------------------------------------------------