void CleanUp()
{
DynamoMetadata.Reset();
var db = CreatePocoDynamo();
db.DeleteAllTables(TimeSpan.FromMinutes(1));
}
public void Does_store_FlagsEnum_and_EnumAsInt_as_integers()
{
db.RegisterTable <ModelWithEnums>();
db.InitSchema();
var request = new ModelWithEnums
{
Id = 1,
DefaultEnum = DefaultEnum.Value2,
EnumsAsInt = EnumsAsInt.Value2,
FlagsEnum = FlagsEnum.FlagOne | FlagsEnum.FlagThree,
};
var attrValues = db.Converters.ToAttributeValues(db, request, DynamoMetadata.GetTable <ModelWithEnums>());
Assert.That(attrValues["DefaultEnum"].S, Is.EqualTo("Value2"));
Assert.That(attrValues["EnumsAsInt"].N, Is.EqualTo("2"));
Assert.That(attrValues["FlagsEnum"].N, Is.EqualTo("5"));
db.PutItem(request);
var dto = db.GetItem <ModelWithEnums>(1);
Assert.That(dto.DefaultEnum, Is.EqualTo(DefaultEnum.Value2));
Assert.That(dto.EnumsAsInt, Is.EqualTo(EnumsAsInt.Value2));
Assert.That(dto.FlagsEnum, Is.EqualTo(FlagsEnum.FlagOne | FlagsEnum.FlagThree));
}
public void OneTimeSetUp()
{
DynamoMetadata.Reset();
var db = CreatePocoDynamo();
db.DeleteAllTables(TimeSpan.FromMinutes(1));
appHost = new BasicAppHost()
.Init();
}
public void Does_create_table_with_ProvisionedThroughput()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithProvision>();
var table = DynamoMetadata.GetTable <TableWithProvision>();
Assert.That(table.HashKey.Name, Is.EqualTo("Id"));
Assert.That(table.ReadCapacityUnits, Is.EqualTo(100));
Assert.That(table.WriteCapacityUnits, Is.EqualTo(50));
}
public void Does_create_table_using_convention_names()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithConventionNames>();
var table = DynamoMetadata.GetTable <TableWithConventionNames>();
Assert.That(table.HashKey.Name, Is.EqualTo("HashKey"));
Assert.That(table.RangeKey.Name, Is.EqualTo("RangeKey"));
Assert.That(table.Fields.Length, Is.EqualTo(3));
}
public void Does_create_table_using_composite_index()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithCompositeKey>();
var table = DynamoMetadata.GetTable <TableWithCompositeKey>();
Assert.That(table.HashKey.Name, Is.EqualTo("D"));
Assert.That(table.RangeKey.Name, Is.EqualTo("C"));
Assert.That(table.Fields.Length, Is.EqualTo(5));
}
public void Does_create_table_using_dynamodb_attributes()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithDynamoAttributes>();
var table = DynamoMetadata.GetTable <TableWithDynamoAttributes>();
Assert.That(table.HashKey.Name, Is.EqualTo("D"));
Assert.That(table.RangeKey.Name, Is.EqualTo("C"));
Assert.That(table.Fields.Length, Is.EqualTo(5));
}
public void Does_create_table_and_index_using_Interface_attrs()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithTypedGlobalIndex>();
var table = DynamoMetadata.GetTable <TableWithTypedGlobalIndex>();
Assert.That(table.HashKey.Name, Is.EqualTo("D"));
Assert.That(table.RangeKey.Name, Is.EqualTo("C"));
Assert.That(table.Fields.Length, Is.EqualTo(5));
Assert.That(table.GlobalIndexes.Count, Is.EqualTo(1));
Assert.That(table.GlobalIndexes[0].HashKey.Name, Is.EqualTo("B"));
Assert.That(table.GlobalIndexes[0].RangeKey.Name, Is.EqualTo("D"));
}
public async Task Can_Create_Typed_GlobalIndex()
{
var db = CreatePocoDynamo();
db.RegisterTable <OrderWithGlobalTypedIndex>();
var customer = await CreateCustomerAsync(db);
var table = DynamoMetadata.GetTable <OrderWithGlobalTypedIndex>();
Assert.That(table.GlobalIndexes.Count, Is.EqualTo(1));
Assert.That(table.GlobalIndexes[0].Name, Is.EqualTo(nameof(OrderGlobalCostIndex)));
Assert.That(table.GlobalIndexes[0].HashKey.Name, Is.EqualTo("ProductId"));
Assert.That(table.GlobalIndexes[0].RangeKey.Name, Is.EqualTo("Cost"));
var orders = 10.Times(i => new OrderWithGlobalTypedIndex
{
ProductId = 1,
Qty = i + 2,
Cost = (i + 2) * 2,
LineItem = "Item " + (i + 1),
});
await db.PutRelatedItemsAsync(customer.Id, orders);
var expensiveOrders = await db.QueryAsync(db.FromQueryIndex <OrderGlobalCostIndex>(x => x.ProductId == 1 && x.Cost > 10)).ToListAsync();
Assert.That(expensiveOrders.Count, Is.EqualTo(orders.Count(x => x.ProductId == 1 && x.Cost > 10)));
Assert.That(expensiveOrders.All(x => x.Cost > 10 && x.Id > 0 && x.Qty > 0));
//Note: Local DynamoDb supports projecting attributes not in GlobalIndex, AWS DynamoDB Doesn't
var dbOrders = (await db.QueryIntoAsync <OrderWithGlobalTypedIndex>(db.FromQueryIndex <OrderGlobalCostIndex>(x => x.ProductId == 1 && x.Cost > 10))).ToList();
Assert.That(dbOrders.All(x => x.Cost > 10 && x.Id > 0 && x.Qty > 0 && x.LineItem != null));
dbOrders = (await db.FromQueryIndex <OrderGlobalCostIndex>(x => x.ProductId == 1 && x.Cost > 10).ExecIntoAsync <OrderWithGlobalTypedIndex>()).ToList();
Assert.That(dbOrders.All(x => x.Cost > 10 && x.Id > 0 && x.Qty > 0 && x.LineItem != null));
expensiveOrders = await db.ScanAsync(db.FromScanIndex <OrderGlobalCostIndex>(x => x.Cost > 10)).ToListAsync();
Assert.That(expensiveOrders.All(x => x.Cost > 10 && x.Id > 0 && x.Qty > 0));
var indexOrders = (await db.ScanIntoAsync <OrderWithGlobalTypedIndex>(db.FromScanIndex <OrderGlobalCostIndex>(x => x.Cost > 10))).ToList();
Assert.That(indexOrders.Count, Is.GreaterThan(0));
Assert.That(indexOrders.All(x => x.Cost > 10 && x.Id > 0 && x.Qty > 0 && x.LineItem != null));
}
public void Does_generate_correct_metadata_for_Related_Order_Table()
{
var db = CreatePocoDynamo();
var types = new List <Type>()
.Add <Customer>()
.Add <Order>();
db.RegisterTables(types);
var tables = DynamoMetadata.GetTables();
var customerTable = tables.First(x => x.Type == typeof(Customer));
var orderTable = tables.First(x => x.Type == typeof(Order));
Assert.That(customerTable.HashKey.Name, Is.EqualTo("Id"));
Assert.That(customerTable.RangeKey, Is.Null);
Assert.That(orderTable.HashKey.Name, Is.EqualTo("CustomerId"));
Assert.That(orderTable.RangeKey.Name, Is.EqualTo("Id"));
}
public void Does_ignore_fields()
{
var db = CreatePocoDynamo();
db.RegisterTable <TableWithIgnoredFields>();
db.InitSchema();
db.PutItem(new TableWithIgnoredFields
{
Id = 1,
FirstName = "Foo",
LastName = "Bar",
IsIgnored = 10,
});
var row = db.GetItem <TableWithIgnoredFields>(1);
Assert.That(row.DisplayName, Is.EqualTo("Foo Bar"));
Assert.That(row.IsIgnored, Is.EqualTo(0));
var table = DynamoMetadata.GetTable <TableWithIgnoredFields>();
var request = new GetItemRequest
{
TableName = table.Name,
Key = db.Converters.ToAttributeKeyValue(db, table.HashKey, 1),
};
var raw = db.DynamoDb.GetItem(request);
Assert.That(raw.Item.ContainsKey("Id"));
Assert.That(raw.Item.ContainsKey("FirstName"));
Assert.That(raw.Item.ContainsKey("LastName"));
Assert.That(!raw.Item.ContainsKey("DisplayName"));
Assert.That(!raw.Item.ContainsKey("IsIgnored"));
var json = row.ToJson();
Assert.That(json, Is.Not.Contains("LastName"));
}
public async Task Can_Create_RangeTest_Async()
{
var db = CreatePocoDynamo();
await db.CreateTableIfMissingAsync(DynamoMetadata.RegisterTable <RangeTest>());
var createdDate = DateTime.UtcNow;
await db.PutItemAsync(new RangeTest {
Id = "test",
CreatedDate = createdDate,
Data = "Data",
});
var dto = await db.GetItemAsync <RangeTest>("test", createdDate);
dto.PrintDump();
Assert.That(dto.Id, Is.EqualTo("test"));
Assert.That(dto.Data, Is.EqualTo("Data"));
Assert.That(dto.CreatedDate, Is.EqualTo(createdDate)
.Within(TimeSpan.FromMinutes(1)));
}
public DynamoDbSequenceSource(IPocoDynamo db)
{
this.db = db;
this.table = DynamoMetadata.RegisterTable <Seq>();
}
public static void Reset <T>(this ISequenceSource seq, int startingAt = 0)
{
var tableName = DynamoMetadata.GetType <T>().Name;
seq.Reset(tableName, startingAt);
}
public static long Increment <T>(this ISequenceSource seq, int amount = 1)
{
var tableName = DynamoMetadata.GetType <T>().Name;
return(seq.Increment(tableName, amount));
}
public static long Current <T>(this ISequenceSource seq)
{
var tableName = DynamoMetadata.GetType <T>().Name;
return(seq.Increment(tableName, 0));
}
public static long[] GetNextSequences <T>(this ISequenceSource seq, int noOfSequences)
{
return(GetNextSequences(seq, DynamoMetadata.GetType <T>(), noOfSequences));
}
