EC-749

it/src/main/scala/encry/it/api/HttpApi.scala

@@ -90,6 +90,15 @@ trait HttpApi { // scalastyle:ignore
     )
   }
 
+  def bestFullHeaderId: Future[String] = get("/info") flatMap { r =>
+    val response = jsonAnswerAs[Json](r.getResponseBody)
+    val eitherId = response.hcursor.downField("bestFullHeaderId").as[Option[String]]
+    eitherId.fold[Future[String]](
+      e => Future.failed(new Exception(s"Error getting `bestFullHeaderId` from /info response: $e\n$response", e)),
+      maybeId => Future.successful(maybeId.getOrElse(""))
+    )
+  }
+
   def balances: Future[Map[String, Long]] = get("/wallet/info") flatMap { r =>
     val response = jsonAnswerAs[Json](r.getResponseBody)
     val eitherBalance = response.hcursor.downField("balances").as[Map[String, String]]
@@ -148,13 +157,23 @@ trait HttpApi { // scalastyle:ignore
     waitFor[Int](_.headersHeight, h => h >= expectedHeight, retryingInterval)
   }
 
+  def waitForBestFullHeaderId(expectedId: String, retryingInterval: FiniteDuration = 1.minute): Future[String] = {
+    waitFor[String](_.bestFullHeaderId, id => id == expectedId, retryingInterval)
+  }
+
   def waitFor[A](f: this.type => Future[A], cond: A => Boolean, retryInterval: FiniteDuration): Future[A] = {
     timer.retryUntil(f(this), cond, retryInterval)
   }
 
   def connect(addressAndPort: String): Future[Unit] = post("/peers/connect", addressAndPort).map(_ => ())
 
+  def shutdown: Future[Unit] = post("/node/shutdown", "").map(_ => ())
+
   def postJson[A: Encoder](path: String, body: A): Future[Response] =
     post(path, body.asJson.toString())
 
+  def error(): Unit = {
+
+  }
+
 }

it/src/main/scala/encry/it/configs/Configs.scala

@@ -22,6 +22,12 @@ object Configs {
     """.stripMargin
   )
 
+  def connectOnlyWithKnownPeers(connectOnlyWithKnownPeersEnable: Boolean): Config = ConfigFactory.parseString(
+    s"""
+       |encry.network.connectOnlyWithKnownPeers=$connectOnlyWithKnownPeersEnable
+    """.stripMargin
+  )
+
   def miningDelay(miningDelay: Int): Config = ConfigFactory.parseString(
     s"""
        |encry.node.miningDelay=${miningDelay}s
@@ -44,4 +50,23 @@ object Configs {
        |encry.wallet.seed="$key"
      """.stripMargin
   )
+
+  def networkAddress(address: String): Config = ConfigFactory.parseString(
+    s"""
+       |encry.network.bindAddress = "$address"
+     """.stripMargin
+  )
+
+  def apiAddress(address: String): Config = ConfigFactory.parseString(
+    s"""
+       |encry.restApi.bindAddress = "$address"
+     """.stripMargin
+  )
+
+  def constantsClass(name: String): Config = ConfigFactory.parseString(
+    s"""
+       |encry.node.constantsClass="$name"
+    """.stripMargin
+  )
+
 }

it/src/main/scala/encry/it/docker/Docker.scala

@@ -29,7 +29,7 @@ import scala.collection.JavaConverters._
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.concurrent.{Await, Future, blocking}
-import scala.util.Random
+import scala.util.{Random, Try}
 import scala.util.control.NonFatal
 
 case class Docker(suiteConfig: Config = empty,
@@ -210,13 +210,13 @@ case class Docker(suiteConfig: Config = empty,
       .build()
   }
 
-  def startNodeInternal(nodeConfig: Config): Node =
+  def startNodeInternal(nodeConfig: Config, specialVolumeOpt: Option[(String, String)] = None): Node =
     try {
       val settings = EncryAppSettings.fromConfig(nodeConfig.withFallback(configTemplate))
       val nodeNumber = settings.network.nodeName.map(_.replace("node", "").toInt).getOrElse(0)
       val ip = ipForNode(nodeNumber)
 
-      val containerConfig = buildPeerContainerConfig(nodeConfig, EncryAppSettings.fromConfig(nodeConfig), ip)
+      val containerConfig = buildPeerContainerConfig(nodeConfig, EncryAppSettings.fromConfig(nodeConfig), ip, specialVolumeOpt)
 
       val containerId = {
         val containerName = networkName + "-" + settings.network.nodeName.getOrElse("NodeWithoutName") + "-" + uuidShort
@@ -233,8 +233,8 @@ case class Docker(suiteConfig: Config = empty,
       client.startContainer(containerId)
       val containerInfo = client.inspectContainer(containerId)
       val ports = containerInfo.networkSettings().ports()
-      val hostPort = extractHostPort(ports, 9001)
-      val hostRestApiPort = extractHostPort(ports, 9051) //get port from settings
+      val hostPort = extractHostPort(ports, extractNetworkPortFromConfig(nodeConfig).getOrElse(9001))
+      val hostRestApiPort = extractHostPort(ports,  extractApiPortFromConfig(nodeConfig).getOrElse(9051))
       val node = new Node(nodeConfig, hostRestApiPort, containerId, attachedNetwork.ipAddress(), hostPort, http)
       nodes.add(node)
       logger.debug(s"Started $containerId -> ${node.name}")
@@ -246,10 +246,19 @@ case class Docker(suiteConfig: Config = empty,
         throw e
     }
 
+  def stopNode(node: Node, secondsToWaitBeforeKilling: Int = 0) {
+    client.stopContainer(node.containerId, secondsToWaitBeforeKilling)
+  }
 
   def extractHostPort(portBindingMap: JMap[String, JList[PortBinding]], containerPort: Int): Int =
     portBindingMap.get(s"$containerPort/tcp").get(0).hostPort().toInt
 
+  def extractNetworkPortFromConfig(config: Config): Option[Int] =
+    Try(config.getString("encry.network.bindAddress").split(":")(1).toInt).toOption
+
+  def extractApiPortFromConfig(config: Config): Option[Int] =
+    Try(config.getString("encry.restApi.bindAddress").split(":")(1).toInt).toOption
+
   private def saveNodeLogs(): Unit = {
     val logDir = Paths.get(System.getProperty("user.dir"), "target", "logs")
     Files.createDirectories(logDir)

it/src/main/scala/encry/it/util/WaitUtils.scala

@@ -0,0 +1,22 @@
+package encry.it.util
+
+import scala.annotation.tailrec
+import scala.concurrent.duration.Duration
+
+object WaitUtils {
+
+  def waitForEqualsId(id1Func: => String, id2Func: => String)(implicit duration: Duration): (String, String) = {
+    @tailrec
+    def loop(id1Func: => String, id2Func: => String, maxTries: Long): (String, String) = {
+      val id1: String = id1Func
+      val id2: String = id2Func
+      if (id1 != id2 && maxTries > 0) {
+        Thread.sleep(1000)
+        loop(id1Func, id2Func, maxTries - 1)
+      } else (id1, id2)
+    }
+
+    loop(id1Func, id2Func, duration.toSeconds)
+  }
+
+}

it/src/test/scala/encry/it/MinerWalletBalanceTest.scala → it/src/test/scala/encry/it/miner/MinerWalletBalanceTest.scala

@@ -1,4 +1,4 @@
-package encry.it
+package encry.it.miner
 
 import com.typesafe.config.Config
 import encry.consensus.EncrySupplyController

it/src/test/scala/encry/it/net/NodeRestartTest.scala

@@ -0,0 +1,78 @@
+package encry.it.net
+
+import java.nio.file.Paths
+
+import encry.it.configs.Configs
+import encry.it.docker.Docker.defaultConf
+import encry.it.docker.DockerAfterAll
+import encry.it.util.WaitUtils._
+import encry.it.utils.FutureAwait._
+import org.encryfoundation.common.utils.Algos
+import org.scalatest.{AsyncFunSuite, Matchers}
+import scorex.utils.Random
+
+import scala.concurrent.duration._
+
+class NodeRestartTest extends AsyncFunSuite with Matchers with DockerAfterAll {
+
+  implicit val futureDuration: FiniteDuration = 10 minutes
+
+  test("Nodes should sync after restart with new offlineGeneration and port") {
+    val node1 = docker
+      .startNodeInternal(Configs.mining(true)
+        .withFallback(Configs.nodeName("node1"))
+        .withFallback(Configs.offlineGeneration(true))
+        .withFallback(Configs.knownPeers(Seq()))
+        .withFallback(defaultConf)
+      )
+
+    val userDir = Paths.get(System.getProperty("user.dir"))
+    val volumeName = Algos.encode(Random.randomBytes(32))
+    val containerMountPath = userDir + "/encry/data"
+
+    val node21 = docker
+      .startNodeInternal(Configs.mining(true)
+        .withFallback(Configs.nodeName("node21"))
+        .withFallback(Configs.offlineGeneration(false))
+        .withFallback(Configs.knownPeers(Seq()))
+        .withFallback(defaultConf),
+        Some(volumeName, containerMountPath)
+      )
+
+    node1.connect(s"${node21.nodeIp}:9001").await
+    node21.connect(s"${node1.nodeIp}:9001").await
+
+    node1.waitForFullHeight(5).await
+
+    node21.shutdown
+    Thread.sleep(5000)
+    docker.stopNode(node21, 5)
+    Thread.sleep(7000)
+
+    node1.waitForFullHeight(10).await
+
+    val node22 = docker
+      .startNodeInternal(Configs.mining(true)
+        .withFallback(Configs.nodeName("node22"))
+        .withFallback(Configs.offlineGeneration(true))
+        .withFallback(Configs.knownPeers(Seq()))
+        .withFallback(Configs.networkAddress("0.0.0.0:9002"))
+        .withFallback(Configs.apiAddress("0.0.0.0:9052"))
+        .withFallback(defaultConf),
+        Some(volumeName, containerMountPath)
+      )
+
+    node1.waitForFullHeight(15).await
+
+    node1.connect(s"${node22.nodeIp}:9002").await
+    node22.connect(s"${node1.nodeIp}:9001").await
+
+    node1.waitForFullHeight(20).await
+
+    val (bestFullHeaderId1, bestFullHeaderId2) =
+      waitForEqualsId(node1.bestFullHeaderId.await, node22.bestFullHeaderId.await)
+
+    bestFullHeaderId2 shouldEqual bestFullHeaderId1
+  }
+
+}

it/src/test/scala/encry/it/net/ThreeNodesKnowAboutEachOtherTest.scala

@@ -0,0 +1,59 @@
+package encry.it.net
+
+import encry.it.configs.Configs
+import encry.it.docker.Docker.defaultConf
+import encry.it.docker.DockerAfterAll
+import encry.it.util.WaitUtils._
+import encry.it.utils.FutureAwait._
+import org.scalatest.{FunSuite, Matchers}
+
+import scala.concurrent.duration._
+
+class ThreeNodesKnowAboutEachOtherTest extends FunSuite with Matchers with DockerAfterAll {
+
+  implicit val futureDuration: FiniteDuration = 10 minutes
+  val heightSeparation = 10 //blocks
+
+  test("nodes know about each other should sync") {
+
+    val node1 = docker
+      .startNodeInternal(Configs.nodeName("node1")
+        .withFallback(Configs.mining(true))
+        .withFallback(Configs.offlineGeneration(true))
+        .withFallback(Configs.networkAddress("0.0.0.0:9001"))
+        .withFallback(Configs.knownPeers(Seq()))
+        .withFallback(defaultConf)
+      )
+
+    node1.waitForFullHeight(heightSeparation).await
+
+    val node2 = docker
+      .startNodeInternal(Configs.nodeName("node2")
+        .withFallback(Configs.mining(true))
+        .withFallback(Configs.offlineGeneration(false))
+        .withFallback(Configs.networkAddress("0.0.0.0:9001"))
+        .withFallback(Configs.knownPeers(Seq((node1.nodeIp, 9001))))
+        .withFallback(defaultConf)
+      )
+
+    node1.connect(s"${node2.nodeIp}:9001").await
+
+    node1.waitForFullHeight(heightSeparation * 2).await
+
+    val node3 = docker
+      .startNodeInternal(Configs.nodeName("node3")
+        .withFallback(Configs.mining(true))
+        .withFallback(Configs.offlineGeneration(false))
+        .withFallback(Configs.networkAddress("0.0.0.0:9001"))
+        .withFallback(Configs.knownPeers(Seq((node1.nodeIp, 9001), (node2.nodeIp, 9001))))
+        .withFallback(defaultConf)
+      )
+
+    waitForEqualsId(node1.bestFullHeaderId.await, node3.bestFullHeaderId.await)
+
+    val (bestFullHeaderId2, bestFullHeaderId3) =
+      waitForEqualsId(node2.bestFullHeaderId.await, node3.bestFullHeaderId.await)
+
+    bestFullHeaderId2 shouldEqual bestFullHeaderId3
+  }
+}

it/src/test/scala/encry/it/net/TwoNodesTest.scala

@@ -0,0 +1,44 @@
+package encry.it.net
+
+import encry.it.configs.Configs
+import encry.it.docker.Docker.defaultConf
+import encry.it.docker.{Docker, DockerAfterAll}
+import encry.it.util.WaitUtils._
+import encry.it.utils.FutureAwait._
+import org.scalatest.{FunSuite, Matchers}
+
+import scala.concurrent.duration._
+
+class TwoNodesTest extends FunSuite with Matchers with DockerAfterAll {
+
+  implicit val futureDuration: FiniteDuration = 10 minutes
+  val heightSeparation = 10 //blocks
+
+  test("Late node should sync with one node") {
+
+    val miningNodeConfig = Configs.mining(true)
+      .withFallback(Configs.offlineGeneration(true))
+      .withFallback(Configs.knownPeers(Seq()))
+      .withFallback(Configs.networkAddress("0.0.0.0:9001"))
+      .withFallback(Docker.defaultConf)
+
+    val node1 = docker
+      .startNodeInternal(miningNodeConfig.withFallback(Configs.nodeName("node1")))
+
+    node1.waitForFullHeight(heightSeparation).await
+
+    val node2 = docker
+      .startNodeInternal(
+        Configs.nodeName("node2")
+          .withFallback(Configs.mining(false))
+          .withFallback(Configs.knownPeers(Seq((node1.nodeIp, 9001))))
+          .withFallback(defaultConf)
+      )
+
+    val (bestFullHeaderId1, bestFullHeaderId2) =
+      waitForEqualsId(node1.bestFullHeaderId.await, node2.bestFullHeaderId.await)
+
+    bestFullHeaderId2 shouldEqual bestFullHeaderId1
+  }
+
+}