Spring Boot에서 Repository로 DynamoDB 조작하기 (1) - 설정부터 실행까지

public class Comment {
    private String id;
    private Integer mentionId;
    private String name;
    private String content;
    private boolean deleted;
    private LocalDateTime createdAt;
    private LocalDateTime deletedAt;
}

class AwsDynamoDbSdkTestToLearn {
    private AmazonDynamoDB amazonDynamoDb;

    @BeforeEach
    void setup() {
        AWSCredentials awsCredentials = new BasicAWSCredentials("key1", "key2");
        AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
        EndpointConfiguration endpointConfiguration = new EndpointConfiguration("http://localhost:8000", "ap-northeast-2");

        amazonDynamoDb = AmazonDynamoDBClientBuilder.standard()
                .withCredentials(awsCredentialsProvider)
                  .withEndpointConfiguration(endpointConfiguration).build();;
    }
}

@Test
@Disabled
void createTable_ValidInput_TableHasBeenCreated() {
    CreateTableRequest createTableRequest = (new CreateTableRequest())
            .withAttributeDefinitions(
                    new AttributeDefinition("id", ScalarAttributeType.S),
                    new AttributeDefinition("mentionId", ScalarAttributeType.N),
                    new AttributeDefinition("createdAt", ScalarAttributeType.S)
            ).withTableName("Comment").withKeySchema(
                    new KeySchemaElement("id", KeyType.HASH)
            ).withGlobalSecondaryIndexes(
                    (new GlobalSecondaryIndex())
                            .withIndexName("byMentionId")
                            .withKeySchema(
                                    new KeySchemaElement("mentionId", KeyType.HASH),
                                    new KeySchemaElement("createdAt", KeyType.RANGE))
                            .withProjection(
                                    (new Projection()).withProjectionType(ProjectionType.ALL))
                            .withProvisionedThroughput(new ProvisionedThroughput(1L, 1L))
            ).withProvisionedThroughput(
                    new ProvisionedThroughput(1L, 1L)
            );

    boolean hasTableBeenCreated = TableUtils.createTableIfNotExists(amazonDynamoDb, createTableRequest);
    then(hasTableBeenCreated).isTrue();
}

@Test
@Disabled
void putItem_ShouldBeCalledAfterTableCreation_StatusOk() {
    Map<String, AttributeValue> item = new HashMap<>();

    item.put("id", (new AttributeValue()).withS("uuid"));
    item.put("mentionId", (new AttributeValue()).withN("1"));
    item.put("content", (new AttributeValue()).withS("comment content"));
    item.put("deleted", (new AttributeValue()).withBOOL(false));
    item.put("createdAt", (new AttributeValue()).withS("1836-03-07T02:21:30.536Z"));

    PutItemRequest putItemRequest = (new PutItemRequest())
            .withTableName("Comment")
            .withItem(item);

    PutItemResult putItemResult = amazonDynamoDb.putItem(putItemRequest);
    then(putItemResult.getSdkHttpMetadata().getHttpStatusCode()).isEqualTo(200);
}

class AwsDynamoDbSdkTestToLearn {
  private AmazonDynamoDB amazonDynamoDb;
  private Map<String, AttributeValue> item;

  @BeforeEach
  void setup() {
      AWSCredentials awsCredentials = new BasicAWSCredentials("key1", "key2");
      AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);

      amazonDynamoDb = AmazonDynamoDBClientBuilder.standard()
              .withCredentials(awsCredentialsProvider)
              .withEndpointConfiguration(
                      new AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "ap-northeast-2"))
              .build();

      item = new HashMap<>();
      item.put("id", (new AttributeValue()).withS("uuid"));
      item.put("mentionId", (new AttributeValue()).withN("1"));
      item.put("content", (new AttributeValue()).withS("comment content"));
      item.put("deleted", (new AttributeValue()).withBOOL(false));
      item.put("createdAt", (new AttributeValue()).withS("to be changed"));
      item.put("deletedAt", (new AttributeValue()).withS("to be changed"));
  }
...

@Test
@Disabled
void getItem_ShouldBeCalledAfterPuttingItem_FoundItem() {
    Map<String, AttributeValue> key = new HashMap<>();
    key.put("id", (new AttributeValue()).withS("uuid"));

    GetItemRequest getItemRequest = (new GetItemRequest())
            .withTableName("Comment")
            .withKey(key);

    GetItemResult getItemResult = amazonDynamoDb.getItem(getItemRequest);

    then(getItemResult.getItem()).containsAllEntriesOf(item);
}

@Test
@Disabled
void deleteItem_ShouldBeCalledAfterPuttingItem_StatsOk() {
    Map<String, AttributeValue> key = new HashMap<>();
    key.put("id", (new AttributeValue()).withS("uuid"));

    DeleteItemRequest deleteItemRequest = (new DeleteItemRequest())
            .withTableName("Comment")
            .withKey(key);

    DeleteItemResult deleteItemResult = amazonDynamoDb.deleteItem(deleteItemRequest);

    then(deleteItemResult.getSdkHttpMetadata().getHttpStatusCode()).isEqualTo(200);
}

@Test
@Disabled
void getItem_ShouldBeCalledAfterDeletingItem_NullItem() {
    Map<String, AttributeValue> key = new HashMap<>();
    key.put("id", (new AttributeValue()).withS("uuid"));

    GetItemRequest getItemRequest = (new GetItemRequest())
            .withTableName("Comment")
            .withKey(key);

    GetItemResult getItemResult = amazonDynamoDb.getItem(getItemRequest);

    then(getItemResult.getItem()).isNull();
}

class AwsDynamoDbMapperTestToLearn {
    private AmazonDynamoDB amazonDynamoDb;
    private DynamoDBMapper dynamoDbMapper;

    @BeforeEach
    void setup() {
        AWSCredentials awsCredentials = new BasicAWSCredentials("key1", "key2");
        AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
        EndpointConfiguration endpointConfiguration = new EndpointConfiguration("http://localhost:8000", "ap-northeast-2");

        amazonDynamoDb = AmazonDynamoDBClientBuilder.standard()
                .withCredentials(awsCredentialsProvider)
                  .withEndpointConfiguration(endpointConfiguration).build();;

        dynamoDbMapper = new DynamoDBMapper(amazonDynamoDb, DynamoDBMapperConfig.DEFAULT);
    }

    @Test
    @Disabled
    void createTable_ValidInput_TableHasBeenCreated() {
        CreateTableRequest createTableRequest = dynamoDbMapper.generateCreateTableRequest(Comment.class)
                .withProvisionedThroughput(new ProvisionedThroughput(1L, 1L));

        createTableRequest.getGlobalSecondaryIndexes().forEach(
                idx -> idx
                        .withProvisionedThroughput(new ProvisionedThroughput(1L, 1L))
                        .withProjection(new Projection().withProjectionType("ALL"))
        );
        then(TableUtils.createTableIfNotExists(amazonDynamoDb, createTableRequest)).isTrue();
    }
}

@Getter
@Setter // Setters are used in aws-dynamodb-sdk
@NoArgsConstructor
@DynamoDBTable(tableName = "Comment")
public class Comment {
    @DynamoDBHashKey(attributeName = "id")
    @DynamoDBAutoGeneratedKey
    private String id;

    @DynamoDBAttribute
    @DynamoDBIndexHashKey(globalSecondaryIndexName = "byMentionId")
    private Integer mentionId;

    @DynamoDBAttribute
    private String name;

    @DynamoDBAttribute
    private String content;

    @DynamoDBAttribute
    @DynamoDBTyped(DynamoDBAttributeType.BOOL)
    private boolean deleted;

    @DynamoDBAttribute
    @DynamoDBIndexRangeKey(globalSecondaryIndexName = "byMentionId")
    private LocalDateTime createdAt;

    @DynamoDBAttribute
    private LocalDateTime deletedAt;

  ...
}

public class DynamoDbConfig {
    public static class LocalDateTimeConverter implements DynamoDBTypeConverter<Date, LocalDateTime> {
        @Override
        public Date convert(LocalDateTime source) {
            return Date.from(source.toInstant(ZoneOffset.UTC));
        }

        @Override
        public LocalDateTime unconvert(Date source) {
            return source.toInstant().atZone(TimeZone.getDefault().toZoneId()).toLocalDateTime();
        }
    }
}

// Comment.java
...
public class Comment {
    ...

    @DynamoDBAttribute
    @DynamoDBIndexRangeKey(globalSecondaryIndexName = "byMentionId")
    @DynamoDBTypeConverted(converter = LocalDateTimeConverter.class)
    private LocalDateTime createdAt;
    @DynamoDBAttribute
    @DynamoDBTypeConverted(converter = LocalDateTimeConverter.class)
    private LocalDateTime deletedAt;

    ...

@Test
@Disabled
void saveItem_ShouldBeCalledAfterTableCreation_IdIsNotNull() {
    Comment comment = Comment.builder()
                .name("name")
                .mentionId(1)
                .content("content").build();
    then(comment.getId()).isNull();

    dynamoDbMapper.save(comment);
    then(comment.getId()).isNotEmpty();
}

@SpringBootTest(classes = {DynamoDbConfig.class})
class AwsDynamoDbMapperTestToLearn {
    private AmazonDynamoDB amazonDynamoDb;
    private DynamoDBMapper dynamoDbMapper;
    private Comment comment;

    @BeforeEach
    void setup() {
        AWSCredentials awsCredentials = new BasicAWSCredentials("key1", "key2");
        AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
        EndpointConfiguration endpointConfiguration = new EndpointConfiguration("http://localhost:8000", "ap-northeast-2");

        amazonDynamoDb = AmazonDynamoDBClientBuilder.standard()
                .withCredentials(awsCredentialsProvider)
                  .withEndpointConfiguration(endpointConfiguration).build();;

        dynamoDbMapper = new DynamoDBMapper(amazonDynamoDb, DynamoDBMapperConfig.DEFAULT);

        comment = Comment.builder()
                .mentionId(1)
                .name("name")
                .content("content").build();
    }

    ...

@Test
@Disabled
void saveAndLoadItem_ShouldBeCalledAfterTableCreation_FoundItem() {
    then(comment.getId()).isNull();
    dynamoDbMapper.save(comment);
    then(comment.getId()).isNotEmpty();

    Comment foundComment = dynamoDbMapper.load(Comment.class, comment.getId());

    then(foundComment)
            .hasFieldOrPropertyWithValue("id", comment.getId());
}

@Test
@Disabled
void saveAndUpdateItem_ShouldBeCalledAfterTableCreation_UpdatedItem() {
    // given
    then(comment.getId()).isNull();
    dynamoDbMapper.save(comment);
    final String commentId = comment.getId();

    then(commentId).isNotEmpty();
    then(comment).hasFieldOrPropertyWithValue("content", "content");

    // update and save content
    comment.update("modified content");
    dynamoDbMapper.save(comment);

    // then
    Comment foundComment = dynamoDbMapper.load(Comment.class, commentId);
    then(foundComment)
            .hasFieldOrPropertyWithValue("content", "modified content");
}

@Test
@Disabled
void saveAndDeleteItem_ShouldBeCalledAfterTableCreation_SameScannedCounts() {
    then(comment.getId()).isNull();
    dynamoDbMapper.save(comment);
    final String commentId = comment.getId();
    then(comment.getId()).isNotEmpty();

    dynamoDbMapper.delete(comment);

    Comment comment = dynamoDbMapper.load(Comment.class, commentId);
    then(comment).isNull();
}

@Test
@Disabled
void deleteTable_ShouldBeCalledAfterTableCreation_TableHasBeenCreated() {
    DeleteTableRequest deleteTableRequest = dynamoDbMapper.generateDeleteTableRequest(Comment.class);
    then(TableUtils.deleteTableIfExists(amazonDynamoDb, deleteTableRequest)).isTrue();
}

// spring-data-dynamodb 5.1.0
@Configuration
@EnableDynamoDBRepositories(basePackages = "guestbook.comments.domain")
public class DynamoDbConfig {
    @Value("${amazon.dynamodb.endpoint}")
    private String amazonDynamoDbEndpoint;

    @Value("${amazon.dynamodb.region}")
    private String amazonDynamoDbRegion;

    @Value("${amazon.aws.accesskey}")
    private String amazonAwsAccessKey;

    @Value("${amazon.aws.secretkey}")
    private String amazonAwsSecretKey;

    @Primary
    @Bean
    public DynamoDBMapper dynamoDbMapper(AmazonDynamoDB amazonDynamoDb) {
        return new DynamoDBMapper(amazonDynamoDb, DynamoDBMapperConfig.DEFAULT);
    }

    @Bean
    public DynamoDBMapper dynamoDBMapper(AmazonDynamoDB amazonDynamoDb, DynamoDBMapperConfig config) {
        return new DynamoDBMapper(amazonDynamoDb, config);
    }

    @Bean(name = "amazonDynamoDB")
    public AmazonDynamoDB amazonDynamoDb() {
        AWSStaticCredentialsProvider credentialsProvider = new AWSStaticCredentialsProvider(
                new BasicAWSCredentials(amazonAwsAccessKey, amazonAwsSecretKey));
        EndpointConfiguration endpointConfiguration =
                new EndpointConfiguration(amazonDynamoDbEndpoint, amazonDynamoDbRegion);

        return AmazonDynamoDBClientBuilder.standard()
                .withCredentials(credentialsProvider)
                .withEndpointConfiguration(endpointConfiguration).build();
    }

    // LocalDateTime Converter 생략
}

@SpringBootTest(classes = {DynamoDbConfig.class})
public class CommentRepositoryTest {
    private @Autowired CommentRepository commentRepository;
    private @Autowired AmazonDynamoDB amazonDynamoDb;
    private @Autowired DynamoDBMapper dynamoDbMapper;

    // TODO: It is weired to create and delete table for each test. Refactor it somehow...
    @BeforeEach
    void createTable() {
        CreateTableRequest createTableRequest = dynamoDbMapper.generateCreateTableRequest(Comment.class)
                .withProvisionedThroughput(new ProvisionedThroughput(1L, 1L));

        createTableRequest.getGlobalSecondaryIndexes().forEach(
                idx -> idx
                        .withProvisionedThroughput(new ProvisionedThroughput(1L, 1L))
                        .withProjection(new Projection().withProjectionType("ALL"))
        );
        TableUtils.createTableIfNotExists(amazonDynamoDb, createTableRequest);
    }

    @AfterEach
    void deleteTable() {
        DeleteTableRequest deleteTableRequest = dynamoDbMapper.generateDeleteTableRequest(Comment.class);
        TableUtils.deleteTableIfExists(amazonDynamoDb, deleteTableRequest);
    }

    @Test
    void createComment_ValidInput_CreatedComment() {
        Comment createdComment = commentRepository.save(Comment.builder()
                .mentionId(1)
                .name("name")
                .content("content").build());

        then(createdComment)
                .hasNoNullFieldsOrPropertiesExcept("deletedAt")
                .hasFieldOrPropertyWithValue("mentionId", 1)
                .hasFieldOrPropertyWithValue("name", "name")
                .hasFieldOrPropertyWithValue("content", "content");
    }
}

@Test
void findCreatedComment_ById_FoundComment() {
    // given
    String id = commentRepository.save(Comment.builder()
            .mentionId(1)
            .name("name")
            .content("content").build()
    ).getId();

    // when
    Comment foundComment = commentRepository.findById(id)
            .orElseThrow(() -> new CommentNotFoundException(id));

    // then
    then(foundComment)
            .hasNoNullFieldsOrPropertiesExcept("deletedAt")
            .hasFieldOrPropertyWithValue("mentionId", 1)
            .hasFieldOrPropertyWithValue("name", "name")
            .hasFieldOrPropertyWithValue("content", "content");
}

@Test
void updateComment_ValidInput_UpdatedComment() {
    // given
    String id = commentRepository.save(Comment.builder()
            .mentionId(1)
            .name("name")
            .content("content").build()
    ).getId();

    // when
    Comment foundComment = commentRepository.findById(id)
            .orElseThrow(() -> new CommentNotFoundException(id));
    foundComment.update("updated content");
    Comment modifiedComment = commentRepository.save(foundComment);

    // then
    then(modifiedComment)
            .hasNoNullFieldsOrPropertiesExcept("deletedAt")
            .hasFieldOrPropertyWithValue("mentionId", 1)
            .hasFieldOrPropertyWithValue("name", "name")
            .hasFieldOrPropertyWithValue("content", "updated content");
}

@Test
void deleteCreatedComment_TryToFindDeletedComment_ThrowCommentNotFoundException() {
    // given
    Comment createdComment = commentRepository.save(Comment.builder()
            .mentionId(1)
            .name("name")
            .content("content").build());

    // when
    commentRepository.delete(createdComment);

    // then
    thenThrownBy(() -> commentRepository.findById(createdComment.getId())
            .orElseThrow(() -> new CommentNotFoundException(createdComment.getId())))
            .isExactlyInstanceOf(CommentNotFoundException.class);
}

@Test
void findComments_ByMentionIdAndOrderByCreatedAtDescDeletedFalse_FoundCommentsInDesignatedOrder() {
    // given
    int size = 10;
    IntStream.range(0, size).forEach(i -> commentRepository.save(Comment.builder()
            .mentionId(1)
            .name("name " + i)
            .content("content " + i).build()));

    // when
    List<Comment> foundComment = commentRepository
            .findAllByMentionIdOrderByCreatedAtAsc(1);

    // then
    then(foundComment.size()).isEqualTo(size);
    IntStream.range(1, size).forEach(i -> {
        Comment prev = foundComment.get(i - 1);
        Comment next = foundComment.get(i);
        then(prev.getCreatedAt().isBefore(next.getCreatedAt())).isTrue();
    });
}