#59: create adjust endpoint for reading checkpoint defintion of partioning

model/src/main/scala/za/co/absa/atum/model/dto/PartitioningDTO.scala

@@ -18,5 +18,6 @@ package za.co.absa.atum.model.dto
 
 case class PartitioningDTO (
   partitioning: Seq[PartitionDTO],
-  parentPartitioning: Option[Seq[PartitionDTO]]
+  parentPartitioning: Option[Seq[PartitionDTO]],
+  author: String
 )

server/src/main/scala/za/co/absa/atum/server/api/controller/PrototypeController.scala

@@ -19,9 +19,9 @@ package za.co.absa.atum.server.api.controller
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.http.HttpStatus
 import org.springframework.web.bind.annotation._
-import za.co.absa.atum.model.dto.CheckpointDTO
+import za.co.absa.atum.model.dto.{AtumContextDTO, CheckpointDTO}
+import za.co.absa.atum.model.dto.{AdditionalDataDTO, AtumContextDTO, CheckpointDTO, MeasureDTO, PartitioningDTO}
 import za.co.absa.atum.server.api.service.DatabaseService
-
 import java.util.concurrent.CompletableFuture
 
 
@@ -40,4 +40,17 @@ class PrototypeController @Autowired()(databaseService: DatabaseService){
   def createCheckpoint(@RequestBody checkpoint: CheckpointDTO): CompletableFuture[CheckpointDTO] = {
     databaseService.saveCheckpoint(checkpoint)
   }
+
+  /**
+   * Creates a partitioning in a DB and returns an Atum Context out of it.
+   *
+   * @param partitioningInfo DTO (JSON-like) object containing fields that will be used for creating a partitioning.
+   * @return A new AtumContext object that uses newly obtained partitioning.
+   */
+  @PostMapping(Array("/createPartitioning"))
+  @ResponseStatus(HttpStatus.OK)
+  def createPartitioningIfNotExists(@RequestBody partitioningInfo: PartitioningDTO): AtumContextDTO = {
+    databaseService.createPartitioningIfNotExists(partitioningInfo)
+  }
+
 }

server/src/main/scala/za/co/absa/atum/server/api/service/DatabaseService.scala

@@ -16,19 +16,22 @@
 
 package za.co.absa.atum.server.api.service
 
-import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.stereotype.Service
-import za.co.absa.atum.model.dto.CheckpointDTO
+<<<<<<< HEAD
+import za.co.absa.atum.model.dto.{AdditionalDataDTO, AtumContextDTO, CheckpointDTO, MeasureDTO, PartitionDTO, PartitioningCreationDTO}
+=======
+import za.co.absa.atum.model.dto.{CheckpointDTO, PartitionDTO, PartitioningDTO}
+>>>>>>> d9fcb0d2c85e2893d1ce37926f08fc99881d0d06
 import za.co.absa.atum.server.api.implicits.scalaToJavaFuture
 import za.co.absa.atum.server.api.provider.PostgresAccessProvider
 
 import java.util.concurrent.CompletableFuture
 import scala.concurrent.ExecutionContext
 
 @Service
-class DatabaseService @Autowired()() {
+class DatabaseService (@Autowired postgresAccessProvider: PostgresAccessProvider = new PostgresAccessProvider){
 
-  val postgresAccessProvider: PostgresAccessProvider = new PostgresAccessProvider
+//  private val postgresAccessProvider: PostgresAccessProvider = new PostgresAccessProvider
 
   /** This service function saves the checkpoint into the database. */
   def saveCheckpoint(checkpoint: CheckpointDTO): CompletableFuture[CheckpointDTO] = {
@@ -38,4 +41,17 @@ class DatabaseService @Autowired()() {
     } yield checkpoint
   }
 
+  /**
+   * Function to create partitioning based on the provided fields
+   *
+   * @param partitioningInfo json information to be added while creating a partition
+   */
+  def createPartitioningIfNotExists(partitioningInfo: PartitioningDTO): AtumContextDTO = {
+    // Todo - db function call to be implemented in #23
+    val partitioning = Seq()
+    val measures = Set.empty[MeasureDTO]
+    val additionalData = AdditionalDataDTO(additionalData = Map.empty)
+
+    AtumContextDTO(partitioning, measures, additionalData)
+  }
 }

server/src/test/scala/za/co/absa/atum/server/api/service/DatabaseServiceTest.scala

@@ -0,0 +1,71 @@
+package za.co.absa.atum.server.api.service
+
+import org.junit.jupiter.api.BeforeEach
+import org.mockito.{Mockito, MockitoSugar}
+import org.scalatest.{BeforeAndAfter, BeforeAndAfterEach}
+import za.co.absa.atum.model.dto._
+import za.co.absa.atum.server.api.provider.PostgresAccessProvider
+import org.scalatest.concurrent.ScalaFutures
+
+import java.time.OffsetDateTime
+import java.util.UUID
+import za.co.absa.atum.model.dto.MeasureResultDTO.{ResultValueType, TypedValue}
+import org.scalatest.flatspec.AsyncFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.Future
+
+class DatabaseServiceTest extends AsyncFlatSpec with Matchers with MockitoSugar with ScalaFutures with BeforeAndAfterEach {
+
+    // Mock dependencies
+    val postgresAccessProvider: PostgresAccessProvider = mock[PostgresAccessProvider]
+    val databaseService = new DatabaseService(postgresAccessProvider)
+
+
+    "saveCheckpoint" should "return a CompletableFuture containing the saved CheckpointDTO" in {
+      // Construct an instance of CheckpointDTOC
+      val id = UUID.randomUUID()
+      val measure = MeasureDTO("measurementName", Seq("controlColumn1", "controlColumn2"))
+      val mainValue = TypedValue("Value1", ResultValueType.String)
+      val supportValue = Map("supportKey" -> TypedValue("supportValue", ResultValueType.String))
+      val measureResult = MeasureResultDTO(mainValue, supportValue)
+      val partition = PartitionDTO("key", "value")
+      val partitioning = PartitioningDTO(Seq(partition), Some(Seq(partition)))
+
+      val measurement = MeasurementDTO(measure, measureResult)
+
+      val checkpoint = CheckpointDTO(
+        id = id,
+        name = "myCheckpoint",
+        author = "Author1",
+        measuredByAtumAgent = true,
+        partitioning = Seq(partition),
+        processStartTime = OffsetDateTime.now(),
+        processEndTime = Some(OffsetDateTime.now().plusHours(1)),
+        measurements = Seq(measurement)
+      )
+
+      // Mock behavior of postgresAccessProvider.runs.writeCheckpoint
+      when(postgresAccessProvider.runs.writeCheckpoint(checkpoint))
+        .thenReturn(Future.successful(Unit))
+
+      // Act & Assert
+      val result = databaseService.saveCheckpoint(checkpoint)
+      print(result)
+    assert(result.get() == checkpoint)
+    }
+
+    // Test case 2: SaveCheckpoint Function with Null Input
+    "SaveCheckpoint" should "handle null or invalid input gracefully" in {
+
+      val invalidCheckpoint = null
+
+      // Act & Assert
+      assertThrows[Exception] {
+        databaseService.saveCheckpoint(invalidCheckpoint)
+      }
+    }
+
+    //  test("testReadCheckpoint") {}
+
+}