test.conf

ditto {
  mongodb {
    uri = "mongodb://localhost:27017/test"
  }

  things {
    include "thing-test"

    log-incoming-messages = true

    wot {
      http {
        proxy {
          enabled = false
        }
      }
      cache {
        maximum-size = 10
      }
    }
  }
}

akka {
  loggers = ["akka.event.slf4j.Slf4jLogger"]
  loglevel = "INFO"
  logging-filter = "akka.event.DefaultLoggingFilter"
  logger-startup-timeout = 60s

  # for log messages during the actor system is starting up and shutting down:
  stdout-loglevel = "WARNING"

  log-config-on-start = off

  actor {
    serializers {
      bson = "org.eclipse.ditto.internal.utils.test.mongo.BsonDocumentSerializer"
    }
    serialization-bindings {
      "org.bson.BsonDocument" = bson
    }
  }

  test {
    # factor by which to scale timeouts during tests, e.g. to account for shared
    # build system load
    timefactor = 1.0

    # duration of EventFilter.intercept waits after the block is finished until
    # all required messages are received
    filter-leeway = 3s

    # duration to wait in expectMsg and friends outside of within() block
    # by default
    single-expect-default = 3s

    # The timeout that is added as an implicit by DefaultTimeout trait
    default-timeout = 5s

    calling-thread-dispatcher {
      type = akka.testkit.CallingThreadDispatcherConfigurator
    }
  }
}

akka.contrib.persistence.mongodb.mongo {
  driver = "akka.contrib.persistence.mongodb.ScalaDriverPersistenceExtension"
}

akka.persistence {
  journal.auto-start-journals = [
    "akka-contrib-mongodb-persistence-things-journal"
  ]
  snapshot-store.auto-start-snapshot-stores = [
    "akka-contrib-mongodb-persistence-things-snapshots"
  ]
}

akka-contrib-mongodb-persistence-things-journal {
  class = "akka.persistence.inmemory.journal.InMemoryAsyncWriteJournal"
  plugin-dispatcher = "thing-persistence-dispatcher"

  ask-timeout = 10s

  event-adapters {
    mongodbobject = "org.eclipse.ditto.things.service.persistence.serializer.ThingMongoEventAdapter"
  }

  event-adapter-bindings {
    "org.eclipse.ditto.base.model.signals.events.Event" = mongodbobject
    "org.bson.BsonValue" = mongodbobject
  }
}

akka-contrib-mongodb-persistence-things-snapshots {
  class = "akka.persistence.inmemory.snapshot.InMemorySnapshotStore"
  plugin-dispatcher = "thing-persistence-dispatcher"

  ask-timeout = 10s
}

thing-persistence-dispatcher {
  type = Dispatcher
  executor = "fork-join-executor"
  fork-join-executor {
    # Min number of threads to cap factor-based parallelism number to
    parallelism-min = 4
    # Parallelism (threads) ... ceil(available processors * factor)
    parallelism-factor = 3.0
    # Max number of threads to cap factor-based parallelism number to
    parallelism-max = 32
  }
  throughput = 2
}

wot-dispatcher {
  type = "Dispatcher"
  executor = "thread-pool-executor"
  thread-pool-executor {
    keep-alive-time = 60s
    fixed-pool-size = off
  }
}