Merge pull request #236 from Microsoft/tomlm/fixStoreItem

cleemullins · web-flow · commit 35d11f294848 · 2018-03-02T16:19:26.000-08:00
fix storage layers to use IStoreItem correctly
diff --git a/libraries/Microsoft.Bot.Builder.Azure/AzureTableStorage.cs b/libraries/Microsoft.Bot.Builder.Azure/AzureTableStorage.cs
@@ -58,7 +58,7 @@ public async Task<StoreItems> Read(string[] keys)
                 var result = await this.Table.ExecuteAsync(TableOperation.Retrieve<StoreItemEntity>(entityKey.PartitionKey, entityKey.RowKey)).ConfigureAwait(false);
                 if ((HttpStatusCode)result.HttpStatusCode == HttpStatusCode.OK)
                 {
-                    var storeItem = ((StoreItemEntity)result.Result).As<StoreItem>();
+                    var storeItem = ((StoreItemEntity)result.Result).As<IStoreItem>();
                     storeItem.eTag = result.Etag;
                     storeItems[key] = storeItem;
                 }
@@ -72,7 +72,7 @@ public async Task Write(StoreItems changes)
             foreach (var change in changes)
             {
                 var entityKey = GetEntityKey(change.Key);
-                var storeItem = (StoreItem)change.Value;
+                var storeItem = (IStoreItem)change.Value;
                 StoreItemEntity entity = new StoreItemEntity(entityKey, storeItem);
                 if (entity.ETag == null || entity.ETag == "*")
                 {
@@ -99,11 +99,11 @@ protected class StoreItemEntity : TableEntity
 
             public StoreItemEntity() { }
 
-            public StoreItemEntity(EntityKey key, StoreItem obj)
+            public StoreItemEntity(EntityKey key, IStoreItem obj)
                 : this(key.PartitionKey, key.RowKey, obj)
             { }
 
-            public StoreItemEntity(string partitionKey, string rowKey, StoreItem obj)
+            public StoreItemEntity(string partitionKey, string rowKey, IStoreItem obj)
                 : base(partitionKey, rowKey)
             {
                 this.ETag = obj.eTag;
@@ -113,7 +113,7 @@ public StoreItemEntity(string partitionKey, string rowKey, StoreItem obj)
             public string Json { get; set; }
 
             public T As<T>()
-                where T : StoreItem
+                where T : IStoreItem
             {
                 return JsonConvert.DeserializeObject<T>(Json, serializationSettings);
             }
diff --git a/libraries/Microsoft.Bot.Builder.Core/FlexObject.cs b/libraries/Microsoft.Bot.Builder.Core/FlexObject.cs
@@ -203,9 +203,17 @@ public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
 
         public object Clone()
         {
-            return JsonConvert.DeserializeObject<StoreItem>(
-                JsonConvert.SerializeObject(this, SerializationSettings),
-                SerializationSettings);
+            return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(this, SerializationSettings),SerializationSettings);
+        }
+
+        public static T Clone<T>(object obj)
+        {
+            return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(obj, SerializationSettings), SerializationSettings);
+        }
+
+        public static object Clone(object obj)
+        {
+            return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(obj, SerializationSettings), SerializationSettings);
         }
     }
 }
diff --git a/libraries/Microsoft.Bot.Builder.Core/Storage/FileStorage.cs b/libraries/Microsoft.Bot.Builder.Core/Storage/FileStorage.cs
@@ -43,14 +43,14 @@ public async Task<StoreItems> Read(string[] keys)
             var storeItems = new StoreItems();
             foreach (var key in keys)
             {
-                var item = await ReadStoreItem(key).ConfigureAwait(false);
+                var item = await ReadIStoreItem(key).ConfigureAwait(false);
                 if (item != null)
                     storeItems[key] = item;
             }
             return storeItems;
         }
 
-        private async Task<StoreItem> ReadStoreItem(string key)
+        private async Task<IStoreItem> ReadIStoreItem(string key)
         {
             // The funky threading in here is due to concurrency and async methods. 
             // When this method is called, it may happen (in parallel) from any number of
@@ -76,7 +76,7 @@ private async Task<StoreItem> ReadStoreItem(string key)
                         json = await file.ReadToEndAsync().ConfigureAwait(false);
                     }
 
-                    return JsonConvert.DeserializeObject<StoreItem>(json, serializationSettings);
+                    return JsonConvert.DeserializeObject<IStoreItem>(json, serializationSettings);
                 }
                 catch (FileNotFoundException)
                 {
@@ -114,8 +114,8 @@ public async Task Write(StoreItems changes)
                 {
                     try
                     {
-                        StoreItem newValue = change.Value as StoreItem;
-                        StoreItem oldValue = await this.ReadStoreItem(change.Key).ConfigureAwait(false);
+                        IStoreItem newValue = (IStoreItem)change.Value;
+                        IStoreItem oldValue = await this.ReadIStoreItem(change.Key).ConfigureAwait(false);
                         if (oldValue == null ||
                             newValue.eTag == "*" ||
                             oldValue.eTag == newValue.eTag)
diff --git a/libraries/Microsoft.Bot.Builder.Core/Storage/MemoryStorage.cs b/libraries/Microsoft.Bot.Builder.Core/Storage/MemoryStorage.cs
@@ -1,6 +1,7 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Newtonsoft.Json;
 using System;
 using System.Threading.Tasks;
 
@@ -42,7 +43,7 @@ public Task<StoreItems> Read(string[] keys)
                     if (_memory.TryGetValue(key, out object value))
                     {
                         if (value != null)
-                            storeItems[key] = (StoreItem)((ICloneable)value).Clone();
+                            storeItems[key] = FlexObject.Clone<IStoreItem>(value);
                         else 
                             storeItems[key] = null;
                     }
@@ -58,17 +59,17 @@ public Task Write(StoreItems changes)
             {
                 foreach (var change in changes)
                 {
-                    StoreItem newValue = change.Value as StoreItem;
-                    StoreItem oldValue = null;
+                    IStoreItem newValue = change.Value as IStoreItem;
+                    IStoreItem oldValue = null;
 
                     if (_memory.TryGetValue(change.Key, out object x))
-                        oldValue = x as StoreItem;
+                        oldValue = x as IStoreItem;
                     if (oldValue == null ||
                         newValue.eTag == "*" ||
                         oldValue.eTag == newValue.eTag)
                     {
                         // clone and set etag
-                        newValue = newValue.Clone() as StoreItem;
+                        newValue = FlexObject.Clone<IStoreItem>(newValue);
                         newValue.eTag = (_eTag++).ToString();
                         _memory[change.Key] = newValue;
                     }
@@ -80,6 +81,7 @@ public Task Write(StoreItems changes)
             }
             return Task.CompletedTask;
         }
+
     }
 
     /// <summary>
diff --git a/tests/Microsoft.Bot.Builder.Tests/Storage_BaseTests.cs b/tests/Microsoft.Bot.Builder.Tests/Storage_BaseTests.cs
@@ -20,7 +20,8 @@ protected async Task _createObjectTest(IStorage storage)
         {
             var storeItems = new StoreItems();
             storeItems["create1"] = new TestItem() { Id = "1" };
-            dynamic newItem2 = new TestItem() { Id = "2" };
+            dynamic newItem2 = new StoreItem();
+            newItem2.Id = "2";
             newItem2.dyno = "dynamicStuff";
             storeItems["create2"] = newItem2;
 
@@ -56,7 +57,8 @@ protected async Task _typedSerialization(IStorage storage)
         {
             string key = "typed";
             var storeItems = new StoreItems();
-            dynamic testItem = new TestItem() { Id = "1" };
+            dynamic testItem = new StoreItem();
+            testItem.Id = "1";
             testItem.x = new TypedObject() { Name = "test" };
             storeItems[key] = testItem;
 
diff --git a/tests/Microsoft.Bot.Builder.Tests/Storage_MemoryTests.cs b/tests/Microsoft.Bot.Builder.Tests/Storage_MemoryTests.cs
@@ -59,8 +59,10 @@ public async Task TypedSerialization()
         }
     }
 
-    public class TestItem : StoreItem
+    public class TestItem : IStoreItem
     {
+        public string eTag { get; set; }
+
         public string Id { get; set; }
 
         public int Count { get; set; }

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public async Task<StoreItems> Read(string[] keys)`
`58`	`58`	`var result = await this.Table.ExecuteAsync(TableOperation.Retrieve<StoreItemEntity>(entityKey.PartitionKey, entityKey.RowKey)).ConfigureAwait(false);`
`59`	`59`	`if ((HttpStatusCode)result.HttpStatusCode == HttpStatusCode.OK)`
`60`	`60`	`{`
`61`		`- var storeItem = ((StoreItemEntity)result.Result).As<StoreItem>();`
	`61`	`+ var storeItem = ((StoreItemEntity)result.Result).As<IStoreItem>();`
`62`	`62`	`storeItem.eTag = result.Etag;`
`63`	`63`	`storeItems[key] = storeItem;`
`64`	`64`	`}`
`@@ -72,7 +72,7 @@ public async Task Write(StoreItems changes)`
`72`	`72`	`foreach (var change in changes)`
`73`	`73`	`{`
`74`	`74`	`var entityKey = GetEntityKey(change.Key);`
`75`		`- var storeItem = (StoreItem)change.Value;`
	`75`	`+ var storeItem = (IStoreItem)change.Value;`
`76`	`76`	`StoreItemEntity entity = new StoreItemEntity(entityKey, storeItem);`
`77`	`77`	`if (entity.ETag == null \|\| entity.ETag == "*")`
`78`	`78`	`{`
`@@ -99,11 +99,11 @@ protected class StoreItemEntity : TableEntity`
`99`	`99`
`100`	`100`	`public StoreItemEntity() { }`
`101`	`101`
`102`		`- public StoreItemEntity(EntityKey key, StoreItem obj)`
	`102`	`+ public StoreItemEntity(EntityKey key, IStoreItem obj)`
`103`	`103`	`: this(key.PartitionKey, key.RowKey, obj)`
`104`	`104`	`{ }`
`105`	`105`
`106`		`- public StoreItemEntity(string partitionKey, string rowKey, StoreItem obj)`
	`106`	`+ public StoreItemEntity(string partitionKey, string rowKey, IStoreItem obj)`
`107`	`107`	`: base(partitionKey, rowKey)`
`108`	`108`	`{`
`109`	`109`	`this.ETag = obj.eTag;`
`@@ -113,7 +113,7 @@ public StoreItemEntity(string partitionKey, string rowKey, StoreItem obj)`
`113`	`113`	`public string Json { get; set; }`
`114`	`114`
`115`	`115`	`public T As<T>()`
`116`		`- where T : StoreItem`
	`116`	`+ where T : IStoreItem`
`117`	`117`	`{`
`118`	`118`	`return JsonConvert.DeserializeObject<T>(Json, serializationSettings);`
`119`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,9 +203,17 @@ public IEnumerator<KeyValuePair<string, object>> GetEnumerator()`
`203`	`203`
`204`	`204`	`public object Clone()`
`205`	`205`	`{`
`206`		`- return JsonConvert.DeserializeObject<StoreItem>(`
`207`		`- JsonConvert.SerializeObject(this, SerializationSettings),`
`208`		`- SerializationSettings);`
	`206`	`+ return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(this, SerializationSettings),SerializationSettings);`
	`207`	`+ }`
	`208`	`+`
	`209`	`+ public static T Clone<T>(object obj)`
	`210`	`+ {`
	`211`	`+ return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(obj, SerializationSettings), SerializationSettings);`
	`212`	`+ }`
	`213`	`+`
	`214`	`+ public static object Clone(object obj)`
	`215`	`+ {`
	`216`	`+ return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(obj, SerializationSettings), SerializationSettings);`
`209`	`217`	`}`
`210`	`218`	`}`
`211`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,14 +43,14 @@ public async Task<StoreItems> Read(string[] keys)`
`43`	`43`	`var storeItems = new StoreItems();`
`44`	`44`	`foreach (var key in keys)`
`45`	`45`	`{`
`46`		`- var item = await ReadStoreItem(key).ConfigureAwait(false);`
	`46`	`+ var item = await ReadIStoreItem(key).ConfigureAwait(false);`
`47`	`47`	`if (item != null)`
`48`	`48`	`storeItems[key] = item;`
`49`	`49`	`}`
`50`	`50`	`return storeItems;`
`51`	`51`	`}`
`52`	`52`
`53`		`- private async Task<StoreItem> ReadStoreItem(string key)`
	`53`	`+ private async Task<IStoreItem> ReadIStoreItem(string key)`
`54`	`54`	`{`
`55`	`55`	`// The funky threading in here is due to concurrency and async methods.`
`56`	`56`	`// When this method is called, it may happen (in parallel) from any number of`
`@@ -76,7 +76,7 @@ private async Task<StoreItem> ReadStoreItem(string key)`
`76`	`76`	`json = await file.ReadToEndAsync().ConfigureAwait(false);`
`77`	`77`	`}`
`78`	`78`
`79`		`- return JsonConvert.DeserializeObject<StoreItem>(json, serializationSettings);`
	`79`	`+ return JsonConvert.DeserializeObject<IStoreItem>(json, serializationSettings);`
`80`	`80`	`}`
`81`	`81`	`catch (FileNotFoundException)`
`82`	`82`	`{`
`@@ -114,8 +114,8 @@ public async Task Write(StoreItems changes)`
`114`	`114`	`{`
`115`	`115`	`try`
`116`	`116`	`{`
`117`		`- StoreItem newValue = change.Value as StoreItem;`
`118`		`- StoreItem oldValue = await this.ReadStoreItem(change.Key).ConfigureAwait(false);`
	`117`	`+ IStoreItem newValue = (IStoreItem)change.Value;`
	`118`	`+ IStoreItem oldValue = await this.ReadIStoreItem(change.Key).ConfigureAwait(false);`
`119`	`119`	`if (oldValue == null \|\|`
`120`	`120`	`newValue.eTag == "*" \|\|`
`121`	`121`	`oldValue.eTag == newValue.eTag)`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Copyright (c) Microsoft Corporation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT License.`
`3`	`3`
	`4`	`+using Newtonsoft.Json;`
`4`	`5`	`using System;`
`5`	`6`	`using System.Threading.Tasks;`
`6`	`7`
`@@ -42,7 +43,7 @@ public Task<StoreItems> Read(string[] keys)`
`42`	`43`	`if (_memory.TryGetValue(key, out object value))`
`43`	`44`	`{`
`44`	`45`	`if (value != null)`
`45`		`- storeItems[key] = (StoreItem)((ICloneable)value).Clone();`
	`46`	`+ storeItems[key] = FlexObject.Clone<IStoreItem>(value);`
`46`	`47`	`else`
`47`	`48`	`storeItems[key] = null;`
`48`	`49`	`}`
`@@ -58,17 +59,17 @@ public Task Write(StoreItems changes)`
`58`	`59`	`{`
`59`	`60`	`foreach (var change in changes)`
`60`	`61`	`{`
`61`		`- StoreItem newValue = change.Value as StoreItem;`
`62`		`- StoreItem oldValue = null;`
	`62`	`+ IStoreItem newValue = change.Value as IStoreItem;`
	`63`	`+ IStoreItem oldValue = null;`
`63`	`64`
`64`	`65`	`if (_memory.TryGetValue(change.Key, out object x))`
`65`		`- oldValue = x as StoreItem;`
	`66`	`+ oldValue = x as IStoreItem;`
`66`	`67`	`if (oldValue == null \|\|`
`67`	`68`	`newValue.eTag == "*" \|\|`
`68`	`69`	`oldValue.eTag == newValue.eTag)`
`69`	`70`	`{`
`70`	`71`	`// clone and set etag`
`71`		`- newValue = newValue.Clone() as StoreItem;`
	`72`	`+ newValue = FlexObject.Clone<IStoreItem>(newValue);`
`72`	`73`	`newValue.eTag = (_eTag++).ToString();`
`73`	`74`	`_memory[change.Key] = newValue;`
`74`	`75`	`}`
`@@ -80,6 +81,7 @@ public Task Write(StoreItems changes)`
`80`	`81`	`}`
`81`	`82`	`return Task.CompletedTask;`
`82`	`83`	`}`
	`84`	`+`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,10 @@ public async Task TypedSerialization()`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- public class TestItem : StoreItem`
	`62`	`+ public class TestItem : IStoreItem`
`63`	`63`	`{`
	`64`	`+ public string eTag { get; set; }`
	`65`	`+`
`64`	`66`	`public string Id { get; set; }`
`65`	`67`
`66`	`68`	`public int Count { get; set; }`