Skip to content

Commit e2ace61

Browse files
DreamescaperDreamescaper
authored
Add tests for DynamoDBEntryConversion (#3586)
1 parent af13bc7 commit e2ace61

File tree

1 file changed

+266
-1
lines changed

1 file changed

+266
-1
lines changed

‎sdk/test/Services/DynamoDBv2/UnitTests/Custom/DynamoDBEntryConversionTests.cs

+266-1
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,13 @@
11
using Amazon.DynamoDBv2;
2+
using Amazon.DynamoDBv2.DocumentModel;
23
using Microsoft.VisualStudio.TestTools.UnitTesting;
34
using System;
45
using System.Collections.Generic;
6+
using System.IO;
57
using System.Linq;
68
using System.Reflection;
79

8-
namespace AWSSDK_DotNet35.UnitTests
10+
namespace AWSSDK_DotNet.UnitTests
911
{
1012
[TestClass]
1113
public class DynamoDBEntryConversionTests
@@ -22,6 +24,226 @@ public void ValidateAllConvertersAreRegisteredForConversionV2()
2224
AssertAllConvertersAreRegistered(DynamoDBEntryConversion.V2, "ConverterV2");
2325
}
2426

27+
[DataTestMethod]
28+
[DynamicData(nameof(V1PrimitiveData))]
29+
public void V1_ConvertToEntry_Primitives(object value, DynamoDBEntry expectedPrimitive)
30+
{
31+
var actualPrimitive = DynamoDBEntryConversion.V1.ConvertToEntry(value.GetType(), value);
32+
Assert.AreEqual(expectedPrimitive, actualPrimitive);
33+
}
34+
35+
[DataTestMethod]
36+
[DynamicData(nameof(V1PrimitiveData))]
37+
public void V1_ConvertFromEntry_Primitives(object expectedValue, DynamoDBEntry primitive)
38+
{
39+
var actualValue = DynamoDBEntryConversion.V1.ConvertFromEntry(expectedValue.GetType(), primitive);
40+
Assert.AreEqual(expectedValue, actualValue);
41+
}
42+
43+
[DataTestMethod]
44+
[DynamicData(nameof(V2PrimitiveData))]
45+
public void V2_ConvertToEntry_Primitives(object value, DynamoDBEntry expectedPrimitive)
46+
{
47+
var actualPrimitive = DynamoDBEntryConversion.V2.ConvertToEntry(value.GetType(), value);
48+
Assert.AreEqual(expectedPrimitive, actualPrimitive);
49+
}
50+
51+
[DataTestMethod]
52+
[DynamicData(nameof(V2PrimitiveData))]
53+
public void V2_ConvertFromEntry_Primitives(object expectedValue, DynamoDBEntry primitive)
54+
{
55+
var actualValue = DynamoDBEntryConversion.V2.ConvertFromEntry(expectedValue.GetType(), primitive);
56+
Assert.AreEqual(expectedValue, actualValue);
57+
}
58+
59+
[DataTestMethod]
60+
[DynamicData((nameof(DynamoDBEntryConversions)))]
61+
public void ConvertToEntry_MemoryStream(DynamoDBEntryConversion conversion)
62+
{
63+
var memoryStream = new MemoryStream(ByteArray);
64+
var entry = conversion.ConvertToEntry(memoryStream);
65+
Assert.AreEqual(new Primitive(ByteArray), entry);
66+
}
67+
68+
[DataTestMethod]
69+
[DynamicData((nameof(DynamoDBEntryConversions)))]
70+
public void ConvertFromEntry_MemoryStream(DynamoDBEntryConversion conversion)
71+
{
72+
var entry = new Primitive(ByteArray);
73+
var memoryStream = conversion.ConvertFromEntry<MemoryStream>(entry);
74+
CollectionAssert.AreEqual(ByteArray, memoryStream.ToArray());
75+
}
76+
77+
[DataTestMethod]
78+
[DynamicData((nameof(DynamoDBEntryConversions)))]
79+
public void ConvertToEntry_DateTime(DynamoDBEntryConversion conversion)
80+
{
81+
var dateTime = new DateTime(2024, 07, 03, 01, 31, 47, DateTimeKind.Utc);
82+
var entry = conversion.ConvertToEntry(dateTime);
83+
Assert.AreEqual(new Primitive("2024-07-03T01:31:47.000Z", false), entry);
84+
}
85+
86+
[DataTestMethod]
87+
[DynamicData((nameof(DynamoDBEntryConversions)))]
88+
public void ConvertFromEntry_DateTime(DynamoDBEntryConversion conversion)
89+
{
90+
var entry = new Primitive("2024-07-03T01:31:47.000Z", false);
91+
var actualDateTime = conversion.ConvertFromEntry<DateTime>(entry);
92+
var expectedDateTime = new DateTime(2024, 07, 03, 01, 31, 47, DateTimeKind.Utc);
93+
Assert.AreEqual(expectedDateTime, actualDateTime);
94+
}
95+
96+
[DataTestMethod]
97+
[DynamicData((nameof(DynamoDBEntryConversions)))]
98+
public void ConvertToEntry_Dictionary(DynamoDBEntryConversion conversion)
99+
{
100+
var dictionary = new Dictionary<string, object>
101+
{
102+
["key1"] = "str",
103+
["key2"] = 123,
104+
["key3"] = new Dictionary<string, object>
105+
{
106+
["innerKey"] = "innerStr"
107+
}
108+
};
109+
110+
var document = conversion.ConvertToEntry(dictionary).AsDocument();
111+
112+
var expectedDocument = new Document
113+
{
114+
["key1"] = new Primitive("str"),
115+
["key2"] = new Primitive("123", true),
116+
["key3"] = new Document
117+
{
118+
["innerKey"] = new Primitive("innerStr")
119+
}
120+
};
121+
Assert.AreEqual(expectedDocument, document);
122+
}
123+
124+
[DataTestMethod]
125+
[DynamicData((nameof(DynamoDBEntryConversions)))]
126+
public void ConvertFromEntry_DynamoDbList_ToArray(DynamoDBEntryConversion conversion)
127+
{
128+
var dynamoDbList = new DynamoDBList(new DynamoDBEntry[]
129+
{
130+
new Primitive("A"), new Primitive("B"), new Primitive("C")
131+
});
132+
var convertedArray = conversion.ConvertFromEntry<string[]>(dynamoDbList);
133+
CollectionAssert.AreEqual(new[] { "A", "B", "C" }, convertedArray);
134+
}
135+
136+
[DataTestMethod]
137+
[DynamicData((nameof(DynamoDBEntryConversions)))]
138+
public void ConvertFromEntry_DynamoDbList_ToList(DynamoDBEntryConversion conversion)
139+
{
140+
var dynamoDbList = new DynamoDBList(new DynamoDBEntry[]
141+
{
142+
new Primitive("1", true), new Primitive("2", true), new Primitive("3", true)
143+
});
144+
var convertedList = conversion.ConvertFromEntry<List<int>>(dynamoDbList);
145+
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, convertedList);
146+
}
147+
148+
[DataTestMethod]
149+
[DynamicData((nameof(DynamoDBEntryConversions)))]
150+
public void ConvertFromEntry_PrimitiveList_ToArray(DynamoDBEntryConversion conversion)
151+
{
152+
var primitiveList = new PrimitiveList(DynamoDBEntryType.String)
153+
{
154+
Entries = { "A", "B", "C" }
155+
};
156+
var convertedArray = conversion.ConvertFromEntry<string[]>(primitiveList);
157+
CollectionAssert.AreEqual(new[] { "A", "B", "C" }, convertedArray);
158+
}
159+
160+
[DataTestMethod]
161+
[DynamicData((nameof(DynamoDBEntryConversions)))]
162+
public void ConvertFromEntry_PrimitiveList_ToList(DynamoDBEntryConversion conversion)
163+
{
164+
var primitiveList = new PrimitiveList(DynamoDBEntryType.Numeric)
165+
{
166+
Entries = { 1, 2, 3 }
167+
};
168+
var convertedList = conversion.ConvertFromEntry<List<int>>(primitiveList);
169+
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, convertedList);
170+
}
171+
172+
[DataTestMethod]
173+
[DynamicData((nameof(DynamoDBEntryConversions)))]
174+
public void ConvertFromEntry_PrimitiveList_ToHashSet(DynamoDBEntryConversion conversion)
175+
{
176+
var primitiveList = new PrimitiveList(DynamoDBEntryType.Numeric)
177+
{
178+
Entries = { 0, 1, 2 }
179+
};
180+
var convertedHashSet = conversion.ConvertFromEntry<HashSet<long>>(primitiveList);
181+
Assert.IsTrue(convertedHashSet.SetEquals(new long[] { 0, 1, 2 }));
182+
}
183+
184+
[TestMethod]
185+
public void V1_ConvertToEntry_Array()
186+
{
187+
var array = new[] { "A", "B", "C" };
188+
var entry = DynamoDBEntryConversion.V1.ConvertToEntry(array);
189+
var expectedList = new PrimitiveList { Entries = { "A", "B", "C" } };
190+
Assert.AreEqual(expectedList, entry);
191+
}
192+
193+
[TestMethod]
194+
public void V1_ConvertToEntry_List()
195+
{
196+
var list = new List<int> { 3, 2, 1 };
197+
var entry = DynamoDBEntryConversion.V1.ConvertToEntry(list);
198+
var expectedList = new PrimitiveList(DynamoDBEntryType.Numeric) { Entries = { 3, 2, 1 } };
199+
Assert.AreEqual(expectedList, entry);
200+
}
201+
202+
[TestMethod]
203+
public void V1_ConvertToEntry_HashSet()
204+
{
205+
var hashSet = new HashSet<long> { 0, 1, 2 };
206+
var entry = DynamoDBEntryConversion.V1.ConvertToEntry(hashSet);
207+
var expectedList = new PrimitiveList(DynamoDBEntryType.Numeric) { Entries = { 0, 1, 2 } };
208+
Assert.AreEqual(expectedList, entry);
209+
}
210+
211+
[TestMethod]
212+
public void V2_ConvertToEntry_Array()
213+
{
214+
var array = new[] { "A", "B", "C" };
215+
var entry = DynamoDBEntryConversion.V2.ConvertToEntry(array);
216+
var expectedList = new DynamoDBList(new DynamoDBEntry[]
217+
{
218+
new Primitive("A"), new Primitive("B"), new Primitive("C")
219+
});
220+
Assert.AreEqual(expectedList, entry);
221+
}
222+
223+
[TestMethod]
224+
public void V2_ConvertToEntry_List()
225+
{
226+
var list = new List<int> { 3, 2, 1 };
227+
var entry = DynamoDBEntryConversion.V2.ConvertToEntry(list);
228+
var expectedList = new DynamoDBList(new DynamoDBEntry[]
229+
{
230+
new Primitive("3", true), new Primitive("2", true), new Primitive("1", true)
231+
});
232+
Assert.AreEqual(expectedList, entry);
233+
}
234+
235+
[TestMethod]
236+
public void V2_ConvertToEntry_HashSet()
237+
{
238+
var hashSet = new HashSet<long> { 0, 1, 2 };
239+
var entry = DynamoDBEntryConversion.V2.ConvertToEntry(hashSet);
240+
var expectedList = new PrimitiveList(DynamoDBEntryType.Numeric)
241+
{
242+
Entries = { new Primitive("0", true), new Primitive("1", true), new Primitive("2", true) }
243+
};
244+
Assert.AreEqual(expectedList, entry);
245+
}
246+
25247
private void AssertAllConvertersAreRegistered(DynamoDBEntryConversion conversion, string suffix)
26248
{
27249
var converters = GetConverters(suffix);
@@ -67,5 +289,48 @@ private IEnumerable<object> GetConverters(string suffix)
67289
yield return constructor.Invoke(new object[0]);
68290
}
69291
}
292+
293+
private static byte[] ByteArray = new byte[] { 1, 2, 3, 4, 5 };
294+
295+
private static IEnumerable<object[]> DynamoDBEntryConversions { get; } = new object[][]
296+
{
297+
new object[] { DynamoDBEntryConversion.V1 },
298+
new object[] { DynamoDBEntryConversion.V2 },
299+
};
300+
301+
private static IEnumerable<object[]> CommonPrimitiveData { get; } = new object[][]
302+
{
303+
new object[] { (short)-1, new Primitive("-1", true) },
304+
new object[] { (ushort)1, new Primitive("1", true) },
305+
new object[] { (int)-2, new Primitive("-2", true) },
306+
new object[] { (uint)2, new Primitive("2", true) },
307+
new object[] { (long)-3, new Primitive("-3", true) },
308+
new object[] { (ulong)3, new Primitive("3", true) },
309+
new object[] { (byte)4, new Primitive("4", true) },
310+
new object[] { (sbyte)5, new Primitive("5", true) },
311+
new object[] { (float)1.23, new Primitive("1.23", true) },
312+
new object[] { (double)2.34, new Primitive("2.34", true) },
313+
new object[] { (decimal)3.45, new Primitive("3.45", true) },
314+
new object[] { (char)'c', new Primitive("c", false) },
315+
new object[] { "stringValue", new Primitive("stringValue", false) },
316+
new object[] { new Guid("6a34ff83-9d2b-4893-950f-1da35414f9b0"), new Primitive("6a34ff83-9d2b-4893-950f-1da35414f9b0", false) },
317+
new object[] { TestEnum.A, new Primitive("0", true) },
318+
new object[] { TestEnum.B, new Primitive("1", true) },
319+
new object[] { ByteArray, new Primitive(ByteArray) }
320+
};
321+
322+
public static IEnumerable<object[]> V1PrimitiveData { get; } = CommonPrimitiveData.Concat(new object[][]
323+
{
324+
new object[] { true, new Primitive("1", true) },
325+
new object[] { false, new Primitive("0", true) }
326+
});
327+
328+
public static IEnumerable<object[]> V2PrimitiveData { get; } = CommonPrimitiveData.Concat(new object[][]
329+
{
330+
new object[] { true, new DynamoDBBool(true) },
331+
new object[] { false, new DynamoDBBool(false) }
332+
});
333+
334+
private enum TestEnum { A, B, C }
70335
}
71336
}

0 commit comments

Comments
 (0)