Graphql runtime error when using input object with Enum

Question

I am getting the following runtime error when calling my createTest mutation. I have an input object which is called testCreationRequest that contains both an enum and another custom type that also holds an enum. I get the same error for both these cases. I have tried overriding the json formatters and several things regarding implicits and replacing the values with sangrias InputObjectType ReplaceInputField. I am still very new to this programming stack(language included), yet this seems like it should be trivial.

Argument 'testCreationRequest' has invalid value: At path '/testEnum': error.expected.validenumvalue (line 2, column 35):\n  createTest(testCreationRequest: {id: \"testing\", testEnum: ONE, nestedInputObject: {id: \"some test\", testTwoEnum: LEVELTWO}})

The following is my graphql query

mutation {
  createTest(testCreationRequest: {
    id: "testing",
    testEnum: ONE,
    nestedInputObject: {
      id: "some test",
      testTwoEnum: LEVELTWO
    }
  }) {
    id
  }
}

The following snippet contains my graphql types

package models.api.graphql

import graphql.GraphQLContext
import models.db.Test.{Test, TestCreationRequest, NestedInput}
import sangria.schema._
import sangria.macros.derive._
import sangria.marshalling.playJson._

import scala.collection.immutable

object TestModels {
  implicit val TestType: ObjectType[GraphQLContext, Test] =
    deriveObjectType[Unit, Test](
      ObjectTypeDescription("Test")
    )

  implicit val TestTwoEnumType: EnumType[models.enums.TestTwoEnumType] = EnumType(
    "TestTwoEnumType",
    Some("testing two..."),
    List(
      EnumValue("LEVELONE",
        value = models.enums.TestTwoEnumType.LevelOne),
      EnumValue("LEVELTWO",
        value = models.enums.TestTwoEnumType.LevelTwo),
      EnumValue("LEVELTHREE",
        value = models.enums.TestTwoEnumType.LevelThree)
    )
  )

  implicit val TestEnumType: EnumType[models.enums.TestEnumType] = EnumType(
    "TestEnumType",
    Some("testing..."),
    List(
      EnumValue("ONE",
        value = models.enums.TestEnumType.One),
      EnumValue("TWO",
        value = models.enums.TestEnumType.Two),
      EnumValue("THREE",
        value = models.enums.TestEnumType.Three)
    )
  )

  implicit val NestedType: InputObjectType[NestedInput] = deriveInputObjectType[NestedInput]()

  implicit lazy val TestCreationRequestType: InputObjectType[TestCreationRequest] =
    deriveInputObjectType[TestCreationRequest](
      ReplaceInputField("testEnum", InputField("testEnum", TestEnumType)),
      ReplaceInputField("nestedInputObject", InputField("nestedInputObject", OptionInputType(NestedType)))
    )

  val TestCreationRequestArg: Argument[TestCreationRequest] = Argument("testCreationRequest", TestCreationRequestType)
}

And here are the models, and enums.

package models.db.Test

import models.enums.{TestEnumType, TestTwoEnumType}
import play.api.libs.json.{Json, OFormat}

case class NestedInput (
                  id: String,
                  testTwoEnum: Option[TestTwoEnumType]
                )

object NestedInput {
  implicit val format: OFormat[NestedInput] = Json.format[NestedInput]
}

case class TestCreationRequest (
                                   id: String,
                                   testEnum: TestEnumType,
                                   nestedInputObject: Option[NestedInput]
                                 )

object TestCreationRequest {
  implicit val format: OFormat[TestCreationRequest] = Json.format[TestCreationRequest]
}

package models.db.Test

import play.api.libs.json.{Json, OFormat, OWrites, Reads}

case class Test(
                    id: String
                  )

object Test {
  implicit val reads: Reads[Test] = Json.reads[Test]
  implicit val writes: OWrites[Test] = Json.writes[Test]
  implicit val format: OFormat[Test] = Json.format[Test]
}

package models.enums

import enumeratum._
import play.api.libs.json.{Format}

import scala.collection.immutable

sealed trait TestEnumType extends EnumEntry

object TestEnumType extends Enum[TestEnumType] with PlayJsonEnum[TestEnumType] {
  val values: immutable.IndexedSeq[TestEnumType] = findValues

  case object One extends TestEnumType
  case object Two extends TestEnumType
  case object Three extends TestEnumType

  override implicit val jsonFormat: Format[TestEnumType] = EnumFormats.formats(TestEnumType)
}

package models.enums

import enumeratum._
import play.api.libs.json.{Format}

import scala.collection.immutable

sealed trait TestTwoEnumType extends EnumEntry

object TestTwoEnumType extends Enum[TestTwoEnumType] with PlayJsonEnum[TestTwoEnumType] {
  val values: immutable.IndexedSeq[TestTwoEnumType] = findValues

  case object LevelOne extends TestTwoEnumType
  case object LevelTwo extends TestTwoEnumType
  case object LevelThree extends TestTwoEnumType

  override implicit val jsonFormat: Format[TestTwoEnumType] = EnumFormats.formats(TestTwoEnumType)
}

Please let me know if you need anymore details. Any help is appreciated :)