Add support for spaces with DMS v3

src/main/scala/com/cognite/sdk/scala/v1/resources/spaces.scala

@@ -5,55 +5,58 @@ package com.cognite.sdk.scala.v1.resources
 
 import com.cognite.sdk.scala.common._
 import com.cognite.sdk.scala.v1._
-import io.circe.generic.semiauto.deriveDecoder
-import io.circe.{Decoder, Printer}
+import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
+import io.circe.{Decoder, Encoder, Printer}
 import sttp.client3._
 import sttp.client3.circe._
 
 class Spaces[F[_]](val requestSession: RequestSession[F])
     extends WithRequestSession[F]
     with BaseUrl {
   import Spaces._
-  override val baseUrl = uri"${requestSession.baseUrl}/datamodelstorage/spaces"
+  override val baseUrl = uri"${requestSession.baseUrl}/models/spaces"
 
-  def createItems(externalIds: Seq[String]): F[Seq[String]] = {
+  def createItems(spaces: Seq[SpaceCreate]): F[Seq[Space]] = {
     implicit val printer: Printer = Printer.noSpaces.copy(dropNullValues = true)
-    requestSession.post[Seq[String], Items[CogniteExternalId], Items[CogniteId]](
-      Items(externalIds.map(CogniteExternalId(_))),
+    requestSession.post[Seq[Space], Items[Space], Items[SpaceCreate]](
+      Items(spaces),
       uri"$baseUrl",
-      value => value.items.map(_.externalId)
+      value => value.items
     )
   }
 
-  def deleteItems(externalIds: Seq[String]): F[Unit] =
-    requestSession.post[Unit, Unit, Items[CogniteId]](
-      Items(externalIds.map(CogniteExternalId(_))),
+  def deleteItems(spaces: Seq[String]): F[Unit] = {
+    implicit val printer: Printer = Printer.noSpaces.copy(dropNullValues = true)
+    requestSession.post[Unit, Unit, Items[SpaceId]](
+      Items(spaces.map(SpaceId(_))),
       uri"$baseUrl/delete",
       _ => ()
     )
+  }
 
-  def list(): F[Seq[String]] =
-    requestSession.post[Seq[String], Items[CogniteExternalId], Unit](
-      (),
-      uri"$baseUrl/list",
-      value => value.items.map(_.externalId)
-    )
-
-  def retrieveByExternalIds(
-      externalIds: Seq[String]
-  ): F[Seq[String]] =
+  def retrieveBySpaceIds(spaces: Seq[String]): F[Seq[Space]] = {
+    implicit val printer: Printer = Printer.noSpaces.copy(dropNullValues = true)
     requestSession
-      .post[Seq[String], Items[CogniteExternalId], Items[CogniteId]](
-        Items(
-          externalIds.map(CogniteExternalId(_))
-        ),
+      .post[Seq[Space], Items[Space], Items[SpaceId]](
+        Items(spaces.map(SpaceId(_))),
         uri"$baseUrl/byids",
-        value => value.items.map(_.externalId)
+        value => value.items
       )
+  }
 
 }
 
 object Spaces {
-  implicit val externalIdItemsDecoder: Decoder[Items[CogniteExternalId]] =
-    deriveDecoder[Items[CogniteExternalId]]
+  implicit val spaceCreateEncoder: Encoder[SpaceCreate] = deriveEncoder[SpaceCreate]
+  implicit val spaceCreateItemsEncoder: Encoder[Items[SpaceCreate]] =
+    deriveEncoder[Items[SpaceCreate]]
+
+  implicit val spaceIdEncoder: Encoder[SpaceId] = deriveEncoder[SpaceId]
+  implicit val spaceIdItemsEncoder: Encoder[Items[SpaceId]] = deriveEncoder[Items[SpaceId]]
+
+  implicit val spaceEncoder: Encoder[Space] = deriveEncoder[Space]
+  implicit val spaceItemsEncoder: Encoder[Items[Space]] = deriveEncoder[Items[Space]]
+
+  implicit val spaceDecoder: Decoder[Space] = deriveDecoder[Space]
+  implicit val spaceItemsDecoder: Decoder[Items[Space]] = deriveDecoder[Items[Space]]
 }

src/main/scala/com/cognite/sdk/scala/v1/spaces.scala

@@ -0,0 +1,27 @@
+// Copyright 2020 Cognite AS
+// SPDX-License-Identifier: Apache-2.0
+
+package com.cognite.sdk.scala.v1
+
+import java.time.Instant
+import com.cognite.sdk.scala.common._
+
+final case class Space(
+    space: String,
+    description: Option[String] = None,
+    name: Option[String] = None,
+    createdTime: Instant = Instant.ofEpochMilli(0),
+    lastUpdatedTime: Instant = Instant.ofEpochMilli(0)
+) extends WithCreatedTime
+    with ToCreate[SpaceCreate] {
+  override def toCreate: SpaceCreate =
+    SpaceCreate(space, name, description)
+}
+
+final case class SpaceCreate(
+    space: String,
+    description: Option[String],
+    name: Option[String]
+)
+
+final case class SpaceId(space: String)

src/test/scala/com/cognite/sdk/scala/v1/SpacesTest.scala

@@ -0,0 +1,42 @@
+// Copyright 2020 Cognite AS
+// SPDX-License-Identifier: Apache-2.0
+
+package com.cognite.sdk.scala.v1
+
+import cats.effect.unsafe.implicits.global
+import com.cognite.sdk.scala.common.RetryWhile
+
+import java.util.UUID
+import scala.collection.immutable.Seq
+
+class SpacesTest extends CommonDataModelTestHelper with RetryWhile {
+
+  private val uniqueSpace = s"sdk-test-space-${UUID.randomUUID().toString.substring(8)}"
+
+  private val randomSpace = SpaceCreate(
+    uniqueSpace,
+    Some(s"description-$uniqueSpace"),
+    Some(s"name-$uniqueSpace")
+  )
+
+  // TODO: enable all the tests when fdm team enables delete space, we have limit on the number of spaces created per project
+  "DataModels" should "create space" ignore {
+    val spaces = blueFieldClient.spaces
+      .createItems(Seq(randomSpace))
+      .unsafeRunSync()
+      .toList
+    spaces.map(s => SpaceCreate(s.space, s.description, s.name)) should contain(randomSpace)
+  }
+
+  ignore should "retrieve space by ids" in {
+    val spaces = blueFieldClient.spaces.retrieveBySpaceIds(Seq(uniqueSpace)).unsafeRunSync().toList
+    spaces.map(_.space) should contain(uniqueSpace)
+  }
+
+  ignore should "delete space" in {
+    blueFieldClient.spaces.deleteItems(Seq(uniqueSpace)).unsafeRunSync()
+    val spaces = blueFieldClient.spaces.retrieveBySpaceIds(Seq(uniqueSpace)).unsafeRunSync().toList
+    spaces shouldBe empty
+  }
+
+}