Returning EditCell in EditRows (#302)

Instead of returning DbCellValues inside an EditRow, we should be returning EditCells. This way we can preserve dirty state when scrolling.

test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/CellUpdateTests.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data.Common;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
 using Xunit;
@@ -243,6 +244,36 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
             Assert.Equal(isNull ? (object)DBNull.Value : value, dbc.RawObject);
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void AsEditCellValue(bool isNull)
+        {
+            // Setup: Create a cell update
+            var value = isNull ? "NULL" : "foo";
+            var col = GetWrapper<string>("NTEXT");
+            CellUpdate cu = new CellUpdate(col, value);
+
+            // If: I convert the cell update to an EditCell
+            EditCell ec = cu.AsEditCell;
+
+            // Then:
+            // ... It should not be null
+            Assert.NotNull(ec);
+
+            // ... The display value should be the same as the value we supplied
+            Assert.Equal(value, ec.DisplayValue);
+
+            // ... The null-ness of the value should be the same as what we supplied
+            Assert.Equal(isNull, ec.IsNull);
+
+            // ... We don't care *too* much about the raw value, but we'll check it anyhow
+            Assert.Equal(isNull ? (object)DBNull.Value : value, ec.RawObject);
+
+            // ... The edit cell should be dirty
+            Assert.True(ec.IsDirty);
+        }
+
         private static DbColumnWrapper GetWrapper<T>(string dataTypeName, bool allowNull = true)
         {
             return new DbColumnWrapper(new CellUpdateTestDbColumn(typeof(T), dataTypeName, allowNull));

test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/RowCreateTests.cs

@@ -12,7 +12,6 @@ using Microsoft.SqlTools.ServiceLayer.EditData;
 using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
-using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Test.Common;
 using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
 using Xunit;
@@ -199,12 +198,13 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
             Assert.True(er.IsDirty);
             Assert.Equal(EditRow.EditRowState.DirtyInsert, er.State);
 
-            // ... The row should have a bunch of empty cells (equal to number of columns)
+            // ... The row should have a bunch of empty cells (equal to number of columns) and all are dirty
             Assert.Equal(rc.newCells.Length, er.Cells.Length);
-            Assert.All(er.Cells, dbc =>
+            Assert.All(er.Cells, ec =>
             {
-                Assert.Equal(string.Empty, dbc.DisplayValue);
-                Assert.False(dbc.IsNull);
+                Assert.Equal(string.Empty, ec.DisplayValue);
+                Assert.False(ec.IsNull);
+                Assert.True(ec.IsDirty);
             });
         }
 
@@ -227,16 +227,18 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
             Assert.True(er.IsDirty);
             Assert.Equal(EditRow.EditRowState.DirtyInsert, er.State);
 
-            // ... The row should have a single non-empty cell at the beginning
+            // ... The row should have a single non-empty cell at the beginning that is dirty
             Assert.Equal("foo", er.Cells[0].DisplayValue);
             Assert.False(er.Cells[0].IsNull);
+            Assert.True(er.Cells[0].IsDirty);
 
-            // ... The rest of the cells should be blank
+            // ... The rest of the cells should be blank, but dirty
             for (int i = 1; i < er.Cells.Length; i++)
             {
-                DbCellValue dbc = er.Cells[i];
-                Assert.Equal(string.Empty, dbc.DisplayValue);
-                Assert.False(dbc.IsNull);
+                EditCell ec = er.Cells[i];
+                Assert.Equal(string.Empty, ec.DisplayValue);
+                Assert.False(ec.IsNull);
+                Assert.True(ec.IsDirty);
             }
         }
 

test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/RowDeleteTests.cs

@@ -159,15 +159,16 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
             // ... The ID should be the same as the one provided
             Assert.Equal(0, er.Id);
 
-            // ... The row should match the cells that were given
+            // ... The row should match the cells that were given and should be dirty
             Assert.Equal(cells.Length, er.Cells.Length);
             for (int i = 0; i < cells.Length; i++)
             {
                 DbCellValue originalCell = cells[i];
-                DbCellValue outputCell = er.Cells[i];
+                EditCell outputCell = er.Cells[i];
 
                 Assert.Equal(originalCell.DisplayValue, outputCell.DisplayValue);
                 Assert.Equal(originalCell.IsNull, outputCell.IsNull);
+                Assert.True(outputCell.IsDirty);
                 // Note: No real need to check the RawObject property
             }
         }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/RowUpdateTests.cs

@@ -331,10 +331,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
                 // Note: No real need to check the RawObject property
             }
 
-            // ... The updated cell should match what it was set to
-            DbCellValue newCell = er.Cells[0];
-            Assert.Equal(newCell.DisplayValue, "foo");
-            Assert.Equal(newCell.IsNull, false);
+            // ... The updated cell should match what it was set to and be dirty
+            EditCell newCell = er.Cells[0];
+            Assert.Equal("foo", newCell.DisplayValue);
+            Assert.False(newCell.IsNull);
+            Assert.True(newCell.IsDirty);
         }
 
         [Fact]

test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/SessionTests.cs

@@ -780,6 +780,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
                 {
                     Assert.Equal(cachedRow[j].DisplayValue, er.Cells[j].DisplayValue);
                     Assert.Equal(cachedRow[j].IsNull, er.Cells[j].IsNull);
+                    Assert.False(er.Cells[j].IsDirty);
                 }
 
                 // ... Be clean, since we didn't apply any updates