下面列出了怎么用com.amazonaws.services.dynamodbv2.model.ScalarAttributeType的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
public void testCreate() {
AmazonDynamoDB proxyClient = getProxyClient();
AmazonDynamoDB awsClient = getAwsClient();
CreateTableRequest req = new CreateTableRequest()
.withTableName("foo")
.withProvisionedThroughput(new ProvisionedThroughput().withReadCapacityUnits(100L).withWriteCapacityUnits(100L))
.withKeySchema(new KeySchemaElement("Name", KeyType.HASH))
.withAttributeDefinitions(new AttributeDefinition("Name", ScalarAttributeType.S));
proxyClient.createTable(req);
awsClient.createTable(req);
DescribeTableResult r = proxyClient.describeTable("foo");
DescribeTableResult r2 = proxyClient.describeTable("foo");
Date now = new Date();
r.getTable().withCreationDateTime(now);
r2.getTable().withCreationDateTime(now);
Assert.assertEquals(r, r2);
}
@Override
public final Response createTable(final Request request) {
final CreateTableRequest createTableRequest = new CreateTableRequest(
Arrays.asList(
new AttributeDefinition(request.getPartitionKey(), ScalarAttributeType.S),
new AttributeDefinition(request.getSortKey(), ScalarAttributeType.N)),
request.getTableName(),
Arrays.asList(
new KeySchemaElement(request.getPartitionKey(), KeyType.HASH),
new KeySchemaElement(request.getSortKey(), KeyType.RANGE)),
new ProvisionedThroughput(request.getReadCapacityUnits(), request.getWriteCapacityUnits()));
TableUtils.createTableIfNotExists(this.dynamoDBClient, createTableRequest);
try {
TableUtils.waitUntilActive(this.dynamoDBClient, request.getTableName());
} catch (final AmazonClientException | InterruptedException e) {
return new Response(null, "Failed in table active check in API version V2: " + e.getMessage());
}
return new Response(request.getTableName() + " created with API version V2.", null);
}
@Override
public final Response createTable(final Request request) {
if (tableExist(request.getTableName())) {
return new Response(null, request.getTableName() + " already exist. Checked with version V1.");
}
Table table = dynamoDB.createTable(request.getTableName(),
Arrays.asList(
new KeySchemaElement(request.getPartitionKey(), KeyType.HASH), //Partition key
new KeySchemaElement(request.getSortKey(), KeyType.RANGE)), //Sort key
Arrays.asList(
new AttributeDefinition(request.getPartitionKey(), ScalarAttributeType.S),
new AttributeDefinition(request.getSortKey(), ScalarAttributeType.N)),
new ProvisionedThroughput(request.getReadCapacityUnits(), request.getWriteCapacityUnits()));
if (request.isWaitForActive()) {
try {
table.waitForActive();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return new Response(request.getTableName() + " created with API version V1.", null);
}
void createTable(String tableName, DynamoDB client) {
Table table = client.getTable(tableName);
try {
System.out.println("Attempting to create table; please wait...");
table = client.createTable(tableName,
Arrays.asList(
new KeySchemaElement("pk", KeyType.HASH), // Partition key
new KeySchemaElement("sk", KeyType.RANGE)), // Sort key
Arrays.asList(
new AttributeDefinition("pk", ScalarAttributeType.N),
new AttributeDefinition("sk", ScalarAttributeType.N)),
new ProvisionedThroughput(10L, 10L));
table.waitForActive();
System.out.println("Successfully created table. Table status: " +
table.getDescription().getTableStatus());
} catch (Exception e) {
System.err.println("Unable to create table: ");
e.printStackTrace();
}
}
private static CreateTableResult createDynamoTable(String tableName) {
ImmutableList<AttributeDefinition> attributeDefinitions =
ImmutableList.of(
new AttributeDefinition(ATTR_NAME_1, ScalarAttributeType.S),
new AttributeDefinition(ATTR_NAME_2, ScalarAttributeType.N));
ImmutableList<KeySchemaElement> ks =
ImmutableList.of(
new KeySchemaElement(ATTR_NAME_1, KeyType.HASH),
new KeySchemaElement(ATTR_NAME_2, KeyType.RANGE));
ProvisionedThroughput provisionedthroughput = new ProvisionedThroughput(1000L, 1000L);
CreateTableRequest request =
new CreateTableRequest()
.withTableName(tableName)
.withAttributeDefinitions(attributeDefinitions)
.withKeySchema(ks)
.withProvisionedThroughput(provisionedthroughput);
return dynamoDBClient.createTable(request);
}
@Override
public CreateTableRequest getTableSchema() {
return super.getTableSchema()
.withAttributeDefinitions(
new AttributeDefinition()
.withAttributeName(Constants.JANUSGRAPH_HASH_KEY)
.withAttributeType(ScalarAttributeType.S),
new AttributeDefinition()
.withAttributeName(Constants.JANUSGRAPH_RANGE_KEY)
.withAttributeType(ScalarAttributeType.S))
.withKeySchema(
new KeySchemaElement()
.withAttributeName(Constants.JANUSGRAPH_HASH_KEY)
.withKeyType(KeyType.HASH),
new KeySchemaElement()
.withAttributeName(Constants.JANUSGRAPH_RANGE_KEY)
.withKeyType(KeyType.RANGE));
}
@BeforeClass
public static void setUpTestData() throws Exception {
String keyName = "id";
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(TABLE_NAME)
.withKeySchema(new KeySchemaElement().withAttributeName(keyName).withKeyType(KeyType.HASH))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(keyName).withAttributeType(
ScalarAttributeType.S));
createTableRequest.setProvisionedThroughput(new ProvisionedThroughput().withReadCapacityUnits(10L)
.withWriteCapacityUnits(5L));
TableUtils.createTableIfNotExists(dynamo, createTableRequest);
TableUtils.waitUntilActive(dynamo, TABLE_NAME);
createTestData();
}
@BeforeClass
public static void setUp() throws Exception {
// Create a table
DynamoDBTestBase.setUpTestBase();
String keyName = KEY_NAME;
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(TABLE_NAME)
.withKeySchema(new KeySchemaElement().withAttributeName(keyName).withKeyType(KeyType.HASH))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(keyName).withAttributeType(
ScalarAttributeType.S));
createTableRequest.setProvisionedThroughput(new ProvisionedThroughput().withReadCapacityUnits(10L)
.withWriteCapacityUnits(5L));
if (TableUtils.createTableIfNotExists(dynamo, createTableRequest)) {
TableUtils.waitUntilActive(dynamo, TABLE_NAME);
}
}
protected static void setUpTableWithRangeAttribute() throws Exception {
setUp();
String keyName = DynamoDBCryptoIntegrationTestBase.KEY_NAME;
String rangeKeyAttributeName = "rangeKey";
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(TABLE_WITH_RANGE_ATTRIBUTE)
.withKeySchema(new KeySchemaElement().withAttributeName(keyName).withKeyType(KeyType.HASH),
new KeySchemaElement().withAttributeName(rangeKeyAttributeName).withKeyType(KeyType.RANGE))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(keyName).withAttributeType(
ScalarAttributeType.N),
new AttributeDefinition().withAttributeName(rangeKeyAttributeName).withAttributeType(
ScalarAttributeType.N));
createTableRequest.setProvisionedThroughput(new ProvisionedThroughput().withReadCapacityUnits(10L)
.withWriteCapacityUnits(5L));
if (TableUtils.createTableIfNotExists(dynamo, createTableRequest)) {
TableUtils.waitUntilActive(dynamo, TABLE_WITH_RANGE_ATTRIBUTE);
}
}
@BeforeClass
public static void setUp() throws Exception {
DynamoDBCryptoIntegrationTestBase.setUp();
dynamoMapper = TestDynamoDBMapperFactory.createDynamoDBMapper(dynamo);
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(tableName)
.withKeySchema(new KeySchemaElement().withAttributeName(hashKeyName).withKeyType(KeyType.HASH))
.withKeySchema(new KeySchemaElement().withAttributeName(rangeKeyName).withKeyType(KeyType.RANGE))
.withAttributeDefinitions(new AttributeDefinition().withAttributeName(hashKeyName)
.withAttributeType(ScalarAttributeType.S))
.withAttributeDefinitions(new AttributeDefinition().withAttributeName(rangeKeyName)
.withAttributeType(ScalarAttributeType.N));
createTableRequest.setProvisionedThroughput(DEFAULT_PROVISIONED_THROUGHPUT);
if (TableUtils.createTableIfNotExists(dynamo, createTableRequest)) {
TableUtils.waitUntilActive(dynamo, tableName);
}
}
@BeforeClass
public static void setUp() throws Exception {
DynamoDBMapperCryptoIntegrationTestBase.setUp();
// Create a table
String keyName = DynamoDBMapperCryptoIntegrationTestBase.KEY_NAME;
String rangeKeyAttributeName = "rangeKey";
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(TABLE_NAME)
.withKeySchema(new KeySchemaElement().withAttributeName(keyName).withKeyType(KeyType.HASH),
new KeySchemaElement().withAttributeName(rangeKeyAttributeName).withKeyType(KeyType.RANGE))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(keyName).withAttributeType(
ScalarAttributeType.S),
new AttributeDefinition().withAttributeName(rangeKeyAttributeName).withAttributeType(
ScalarAttributeType.S));
createTableRequest.setProvisionedThroughput(new ProvisionedThroughput().withReadCapacityUnits(10L)
.withWriteCapacityUnits(5L));
if (TableUtils.createTableIfNotExists(dynamo, createTableRequest)) {
TableUtils.waitUntilActive(dynamo, TABLE_NAME);
}
}
private CreateTableResult createTable() throws Exception {
List<AttributeDefinition> attributeDefinitions = new ArrayList<AttributeDefinition>();
AttributeDefinition attributeDefinition = new AttributeDefinition()
.withAttributeName(TEST_ATTRIBUTE)
.withAttributeType(ScalarAttributeType.S);
attributeDefinitions.add(attributeDefinition);
String tableName = TEST_TABLE_NAME;
List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();
KeySchemaElement keySchemaElement = new KeySchemaElement()
.withAttributeName(TEST_ATTRIBUTE)
.withKeyType(KeyType.HASH);
ProvisionedThroughput provisionedThroughput = new ProvisionedThroughput()
.withReadCapacityUnits(UNITS)
.withWriteCapacityUnits(UNITS);
CreateTableResult result = dynamoDb.createTable(attributeDefinitions, tableName, keySchema, provisionedThroughput);
return result;
}
@Override
public void createStoreIfAbsent(String storeName, boolean bBinaryValues) {
String tableName = storeToTableName(storeName);
if (!Tables.doesTableExist(m_ddbClient, tableName)) {
// Create a table with a primary hash key named '_key', which holds a string
m_logger.info("Creating table: {}", tableName);
CreateTableRequest createTableRequest = new CreateTableRequest().withTableName(tableName)
.withKeySchema(new KeySchemaElement()
.withAttributeName(ROW_KEY_ATTR_NAME)
.withKeyType(KeyType.HASH))
.withAttributeDefinitions(new AttributeDefinition()
.withAttributeName(ROW_KEY_ATTR_NAME)
.withAttributeType(ScalarAttributeType.S))
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits(READ_CAPACITY_UNITS)
.withWriteCapacityUnits(WRITE_CAPACITY_UNITS));
m_ddbClient.createTable(createTableRequest).getTableDescription();
try {
Tables.awaitTableToBecomeActive(m_ddbClient, tableName);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
private boolean createTable(final String qName, final boolean dataIndexTable) {
return createTable(
qName,
dataIndexTable
? () -> new CreateTableRequest().withTableName(qName).withAttributeDefinitions(
new AttributeDefinition(
DynamoDBRow.GW_PARTITION_ID_KEY,
ScalarAttributeType.B)).withKeySchema(
new KeySchemaElement(DynamoDBRow.GW_PARTITION_ID_KEY, KeyType.HASH))
: () -> new CreateTableRequest().withTableName(qName).withAttributeDefinitions(
new AttributeDefinition(DynamoDBRow.GW_PARTITION_ID_KEY, ScalarAttributeType.B),
new AttributeDefinition(
DynamoDBRow.GW_RANGE_KEY,
ScalarAttributeType.B)).withKeySchema(
new KeySchemaElement(DynamoDBRow.GW_PARTITION_ID_KEY, KeyType.HASH),
new KeySchemaElement(DynamoDBRow.GW_RANGE_KEY, KeyType.RANGE)));
}
public static void main(String[] args) throws Exception {
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
client.setEndpoint("http://localhost:8000");
DynamoDB dynamoDB = new DynamoDB(client);
String tableName = "Movies";
Table table = dynamoDB.createTable(tableName,
Arrays.asList(
new KeySchemaElement("year", KeyType.HASH),
new KeySchemaElement("title", KeyType.RANGE)),
Arrays.asList(
new AttributeDefinition("year", ScalarAttributeType.N),
new AttributeDefinition("title", ScalarAttributeType.S)),
new ProvisionedThroughput(10L, 10L));
try {
TableUtils.waitUntilActive(client, tableName);
System.out.println("Table status: " + table.getDescription().getTableStatus());
} catch (AmazonClientException e) {
e.printStackTrace();
System.exit(1);
}
}
private static CreateTableResult createTable(AmazonDynamoDB ddb, String tableName, String hashKeyName) {
List<AttributeDefinition> attributeDefinitions = new ArrayList<AttributeDefinition>();
attributeDefinitions.add(new AttributeDefinition(hashKeyName, ScalarAttributeType.S));
List<KeySchemaElement> ks = new ArrayList<KeySchemaElement>();
ks.add(new KeySchemaElement(hashKeyName, KeyType.HASH));
ProvisionedThroughput provisionedthroughput = new ProvisionedThroughput(1000L, 1000L);
CreateTableRequest request =
new CreateTableRequest()
.withTableName(tableName)
.withAttributeDefinitions(attributeDefinitions)
.withKeySchema(ks)
.withProvisionedThroughput(provisionedthroughput);
return ddb.createTable(request);
}
private Object getAttributeObject(ScalarAttributeType type, AttributeValue value) {
//Note: only string, number, and binary are allowed for primary keys in dynamodb
switch (type) {
case N:
return Double.parseDouble(value.getN());
case S:
return value.getS();
case B:
return value.getB();
default:
throw new IllegalStateException("Unknown dynamo scalar type: " + type);
}
}
private AttributeDefinition convertToAttribute(ColumnMetadata column)
{
AttributeDefinition ad = new AttributeDefinition();
ad.setAttributeName(column.getName().asInternal());
switch (column.getType().getProtocolCode())
{
case BLOB:
ad.setAttributeType(ScalarAttributeType.B);
break;
case BIGINT:
case BOOLEAN:
case COUNTER:
case DECIMAL:
case DOUBLE:
case FLOAT:
case INT:
case VARINT:
case TINYINT:
case SMALLINT:
ad.setAttributeType(ScalarAttributeType.N);
break;
case TIMEUUID:
case UUID:
case INET:
case DATE:
case VARCHAR:
case ASCII:
case TIME:
ad.setAttributeType(ScalarAttributeType.S);
break;
default:
throw new IllegalArgumentException("Type not supported: " + column.getName().asInternal() + " " + column.getType());
}
return ad;
}
/**
* Creates the FragmentCheckpoint table if it doesn't exist already.
*/
public void createTableIfDoesntExist() {
// Check if table exists
if (!checkIfTableExists()) {
log.info("Creating table : {}", TABLE_NAME);
final CreateTableRequest request = new CreateTableRequest() {{
setAttributeDefinitions(
Collections.singletonList(
new AttributeDefinition(
KVS_STREAM_NAME,
ScalarAttributeType.S)));
setKeySchema(
Collections.singletonList(
new KeySchemaElement(
KVS_STREAM_NAME,
KeyType.HASH)));
setProvisionedThroughput(
new ProvisionedThroughput(1000L, 1000L));
setTableName(TABLE_NAME);
}};
try {
final CreateTableResult result = ddbClient.createTable(request);
log.info("Table created : {}", result.getTableDescription());
} catch (final AmazonDynamoDBException e) {
log.error("Error creating DDB table {}...", TABLE_NAME, e);
throw e;
}
}
}
private TableDescription getHashRangeTable() {
TableDescription description = new TableDescription().withKeySchema(Arrays.asList(
new KeySchemaElement().withAttributeName("hashKey"),
new KeySchemaElement().withAttributeName("rangeKey"))
).withAttributeDefinitions(Arrays.asList(
new AttributeDefinition("hashKey", ScalarAttributeType.S),
new AttributeDefinition("rangeKey", ScalarAttributeType.N))
);
return description;
}
public static void main(String[] args) throws Exception {
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
.withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();
DynamoDB dynamoDB = new DynamoDB(client);
String tableName = "Movies";
try {
System.out.println("Attempting to create table; please wait...");
Table table = dynamoDB.createTable(tableName,
Arrays.asList(new KeySchemaElement("year", KeyType.HASH), // Partition
// key
new KeySchemaElement("title", KeyType.RANGE)), // Sort key
Arrays.asList(new AttributeDefinition("year", ScalarAttributeType.N),
new AttributeDefinition("title", ScalarAttributeType.S)),
new ProvisionedThroughput(10L, 10L));
table.waitForActive();
System.out.println("Success. Table status: " + table.getDescription().getTableStatus());
}
catch (Exception e) {
System.err.println("Unable to create table: ");
System.err.println(e.getMessage());
}
}
/**
* Creates a locking table with the given name.
* <p>
* This method does not check if a table with the given name exists already.
*
* @param dynamodb DynamoDB to be used
* @param tableName table to be used
* @param throughput AWS {@link ProvisionedThroughput throughput requirements} for the given lock setup
* @return a {@link Table reference to the newly created table}
*
* @throws ResourceInUseException
* The operation conflicts with the resource's availability. You attempted to recreate an
* existing table.
*/
public static Table createLockTable(
AmazonDynamoDB dynamodb,
String tableName,
ProvisionedThroughput throughput
) {
CreateTableRequest request = new CreateTableRequest()
.withTableName(tableName)
.withKeySchema(new KeySchemaElement(ID, KeyType.HASH))
.withAttributeDefinitions(new AttributeDefinition(ID, ScalarAttributeType.S))
.withProvisionedThroughput(throughput);
dynamodb.createTable(request).getTableDescription();
return new DynamoDB(dynamodb).getTable(tableName);
}
@Override
public CreateTableRequest getTableSchema() {
return super.getTableSchema()
.withAttributeDefinitions(
new AttributeDefinition()
.withAttributeName(Constants.JANUSGRAPH_HASH_KEY)
.withAttributeType(ScalarAttributeType.S))
.withKeySchema(
new KeySchemaElement()
.withAttributeName(Constants.JANUSGRAPH_HASH_KEY)
.withKeyType(KeyType.HASH));
}
private CreateTableRequest createTableRequest(String tableName) {
return new CreateTableRequest()
.withTableName(tableName)
.withKeySchema(new KeySchemaElement(SKU_CODE, KeyType.HASH),
new KeySchemaElement(STORE, KeyType.RANGE))
.withAttributeDefinitions(
new AttributeDefinition(SKU_CODE, ScalarAttributeType.S),
new AttributeDefinition(STORE, ScalarAttributeType.S))
.withProvisionedThroughput(new ProvisionedThroughput(1L, 1L));
}
/**
* Creates a DynamoDB Table with the correct properties to be used with a ProviderStore.
*
* @param ddb interface for accessing DynamoDB
* @param tableName name of table that stores the meta data of the material.
* @param provisionedThroughput required provisioned throughput of the this table.
* @return result of create table request.
*/
public static CreateTableResult createTable(final AmazonDynamoDB ddb, final String tableName,
final ProvisionedThroughput provisionedThroughput) {
return ddb.createTable(Arrays.asList(new AttributeDefinition(DEFAULT_HASH_KEY,
ScalarAttributeType.S), new AttributeDefinition(DEFAULT_RANGE_KEY,
ScalarAttributeType.N)), tableName, Arrays.asList(new KeySchemaElement(
DEFAULT_HASH_KEY, KeyType.HASH), new KeySchemaElement(DEFAULT_RANGE_KEY,
KeyType.RANGE)), provisionedThroughput);
}
@BeforeClass
public static void setUp() throws Exception {
DynamoDBTestBase.setUpTestBase();
List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();
keySchema.add(new KeySchemaElement("id", KeyType.HASH));
CreateTableRequest req = new CreateTableRequest(
HASH_KEY_ONLY_TABLE_NAME, keySchema)
.withProvisionedThroughput(new ProvisionedThroughput(10L, 10L))
.withAttributeDefinitions(
new AttributeDefinition("id", ScalarAttributeType.S),
new AttributeDefinition("status", ScalarAttributeType.S),
new AttributeDefinition("ts", ScalarAttributeType.S))
.withGlobalSecondaryIndexes(
new GlobalSecondaryIndex()
.withProvisionedThroughput(
new ProvisionedThroughput(10L, 10L))
.withIndexName("statusAndCreation")
.withKeySchema(
new KeySchemaElement("status",
KeyType.HASH),
new KeySchemaElement("ts",
KeyType.RANGE))
.withProjection(
new Projection()
.withProjectionType(ProjectionType.ALL)));
TableUtils.createTableIfNotExists(dynamo, req);
TableUtils.waitUntilActive(dynamo, HASH_KEY_ONLY_TABLE_NAME);
}
/**
* Helper method to create a table in Amazon DynamoDB
*/
protected static void createTestTable(
ProvisionedThroughput provisionedThroughput) {
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(tableName)
.withKeySchema(
new KeySchemaElement().withAttributeName(
hashKeyName).withKeyType(
KeyType.HASH))
.withKeySchema(
new KeySchemaElement().withAttributeName(
rangeKeyName).withKeyType(
KeyType.RANGE))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(
hashKeyName).withAttributeType(
ScalarAttributeType.S))
.withAttributeDefinitions(
new AttributeDefinition().withAttributeName(
rangeKeyName).withAttributeType(
ScalarAttributeType.N));
createTableRequest.setProvisionedThroughput(provisionedThroughput);
TableDescription createdTableDescription = dynamo.createTable(
createTableRequest).getTableDescription();
System.out.println("Created Table: " + createdTableDescription);
assertEquals(tableName, createdTableDescription.getTableName());
assertNotNull(createdTableDescription.getTableStatus());
assertEquals(hashKeyName, createdTableDescription
.getKeySchema().get(0).getAttributeName());
assertEquals(KeyType.HASH.toString(), createdTableDescription
.getKeySchema().get(0).getKeyType());
assertEquals(rangeKeyName, createdTableDescription
.getKeySchema().get(1).getAttributeName());
assertEquals(KeyType.RANGE.toString(), createdTableDescription
.getKeySchema().get(1).getKeyType());
}
public static ScalarAttributeType getAttributeType(final Class<?> propertyClass) {
if (propertyClass == ByteBuffer.class || propertyClass == byte[].class) {
return ScalarAttributeType.B;
} else if (char.class.isAssignableFrom(propertyClass)) {
return ScalarAttributeType.S;
} else if (propertyClass.isPrimitive() || Number.class.isAssignableFrom(propertyClass)
|| Boolean.class.isAssignableFrom(propertyClass)) {
return ScalarAttributeType.N;
} else {
return ScalarAttributeType.S;
}
}
@Test
public void testCreateTableTableAlreadyExistsCorrectKeySchema() {
final Collection<AttributeDefinition> ads = Arrays.asList(new AttributeDefinition("Hash", ScalarAttributeType.S));
final Collection<KeySchemaElement> kses = Arrays.asList(new KeySchemaElement("Hash", KeyType.HASH));
final TableDescription description = new TableDescription().withAttributeDefinitions(ads).withKeySchema(kses)
.withTableName(tableName);
final DescribeTableResult result = new DescribeTableResult().withTable(description);
EasyMock.expect(dynamoDB.describeTable(tableName)).andReturn(result);
final CreateTableRequest request = new CreateTableRequest().withAttributeDefinitions(ads).withKeySchema(kses)
.withTableName(tableName);
PowerMock.replayAll();
assertEquals(description, DynamoDBManager.createTable(dynamoDB, request));
PowerMock.verifyAll();
}
@Test(expected = IllegalStateException.class)
public void testCreateTableTableAlreadyExistsIncorrectKeySchema() {
final Collection<AttributeDefinition> ads = Arrays.asList(new AttributeDefinition("Hash", ScalarAttributeType.S));
final Collection<KeySchemaElement> kses = Arrays.asList(new KeySchemaElement("Hash", KeyType.HASH));
final TableDescription description = new TableDescription().withAttributeDefinitions(ads).withKeySchema(kses)
.withTableName(tableName);
final DescribeTableResult result = new DescribeTableResult().withTable(description);
EasyMock.expect(dynamoDB.describeTable(tableName)).andReturn(result);
final Collection<AttributeDefinition> ads2 = Arrays.asList(new AttributeDefinition("Hash2", ScalarAttributeType.S));
final Collection<KeySchemaElement> kses2 = Arrays.asList(new KeySchemaElement("Hash2", KeyType.HASH));
final CreateTableRequest request = new CreateTableRequest().withAttributeDefinitions(ads2).withKeySchema(kses2)
.withTableName(tableName);
PowerMock.replayAll();
DynamoDBManager.createTable(dynamoDB, request);
}