jarlakxen / drunk Goto Github PK

package com.github.jarlakxen.drunk
import com.github.jarlakxen.drunk.GraphQLClient.GraphQLResponse
import org.scalatest.FlatSpec
import com.github.jarlakxen.drunk.circe.deriveByTypenameDecoder
import com.typesafe.scalalogging.LazyLogging
import de.salt.d4s.model.entities.{Delivery, DeliveryItem}
import io.circe._
import io.circe.generic.semiauto._
import sangria.macros._
import java.util.concurrent.TimeUnit.MILLISECONDS

import scala.concurrent.duration.Duration
import scala.concurrent.{Await, ExecutionContext, Future, duration}


class GraphQLSoDelClientSpec extends FlatSpec with LazyLogging {

  implicit val deliveryDecoder: Decoder[Delivery] = deriveDecoder
  implicit val deliveryItemDecoder: Decoder[DeliveryItem] = deriveDecoder
  val duration = Duration(4000, MILLISECONDS)

  //case class DeliveryQuery(delivery: Delivery)
  type DeliveryQuery = Map[String, List[Delivery]]
  case class Pagination(offset: Int, size: Int)

  implicit val deliveryQueryDecoder: Decoder[DeliveryQuery] = deriveByTypenameDecoder()

  implicit val pagniationEncoder: Encoder[Pagination] = deriveEncoder
  val client = GraphQLClient(s"http://delivery-generator-mho.d4s.salt-solutions.de/graphql")
  implicit val ec = ExecutionContext.global

  "server" should "respond correctly to deliveryQuery" in {

    val query =
      graphql"""
               query{delivery( id: "4727")
               {
               docid
               docType
               system
               status
               items{itemid product quantity unit date}}
               }
    """

    val page1: GraphQLCursor[DeliveryQuery, Pagination] = client.query(query, Pagination(0, 10))
    val data: Future[GraphQLResponse[DeliveryQuery]] = page1.result

    val result = Await.result(data, duration)

    logger.debug(result.toString)
  }
}

Cannot deduce decoder. Missing __typename: DownField(data)
DecodingFailure(Cannot deduce decoder. Missing __typename, List(DownField(data)))

families = List("ABC", "XYZ")

val query =
    graphql"""
      query getPeople{
        getPeople(families: [$fams]) {
          name
        }
      }
    """
val vars = Map("fams" -> families.mkString("\"", "\",\"", "\"")
val result = client.query[List[People],Map[String,String]](query, vars)

could not find implicit value for parameter dec: io.circe.Decoder[List[People]]