Added tests for DB Converters

Closes #482

src/Marr.Data/Reflection/SimpleReflectionStrategy.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -19,6 +19,7 @@ namespace Marr.Data.Reflection
             var key = entityType.FullName + name;
             if (!MemberCache.TryGetValue(key, out member))
             {
+                var test = entityType.GetMembers();
                 member = entityType.GetMember(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
                 MemberCache[key] = member;
             }

src/NzbDrone.Core.Test/Datastore/Converters/BooleanIntConverterFixture.cs

@@ -0,0 +1,59 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class BooleanIntConverterFixture : CoreTest<Core.Datastore.Converters.BooleanIntConverter>
+    {
+        [TestCase(true, 1)]
+        [TestCase(false, 0)]
+        public void should_return_int_when_saving_boolean_to_db(bool input, int expected)
+        {
+            Subject.ToDB(input).Should().Be(expected);
+        }
+
+        [Test]
+        public void should_return_db_null_for_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(null).Should().Be(DBNull.Value);
+        }
+
+        [TestCase(1, true)]
+        [TestCase(0, false)]
+        public void should_return_bool_when_getting_int_from_db(int input, bool expected)
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = (long)input
+                          };
+
+            Subject.FromDB(context).Should().Be(expected);
+        }
+
+        [Test]
+        public void should_return_db_null_for_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_throw_for_non_boolean_equivalent_number_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = (long)2
+                          };
+
+            Assert.Throws<ConversionException>(() => Subject.FromDB(context));
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/CommandConverterFixture.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Data;
+using FluentAssertions;
+using Marr.Data.Converters;
+using Moq;
+using NUnit.Framework;
+using NzbDrone.Common.Serializer;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+using NzbDrone.Core.Tv.Commands;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class CommandConverterFixture : CoreTest<CommandConverter>
+    {
+        [Test]
+        public void should_return_json_string_when_saving_boolean_to_db()
+        {
+            var command = new RefreshSeriesCommand();
+
+            Subject.ToDB(command).Should().BeOfType<string>();
+        }
+
+        [Test]
+        public void should_return_null_for_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(null).Should().Be(null);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(DBNull.Value).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_return_command_when_getting_json_from_db()
+        {
+            var dataRecordMock = new Mock<IDataRecord>();
+            dataRecordMock.Setup(s => s.GetOrdinal("Name")).Returns(0);
+            dataRecordMock.Setup(s => s.GetString(0)).Returns("RefreshSeries");
+
+            var context = new ConverterContext
+                          {
+                              DataRecord = dataRecordMock.Object,
+                              DbValue = new RefreshSeriesCommand().ToJson()
+                          };
+
+            Subject.FromDB(context).Should().BeOfType<RefreshSeriesCommand>();
+        }
+
+        [Test]
+        public void should_return_null_for_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(null);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/DoubleConverterFixture.cs

@@ -0,0 +1,70 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class DoubleConverterFixture : CoreTest<DoubleConverter>
+    {
+        [Test]
+        public void should_return_double_when_saving_double_to_db()
+        {
+            var input = 10.5D;
+
+            Subject.ToDB(input).Should().Be(input);
+        }
+
+        [Test]
+        public void should_return_null_for_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(null).Should().Be(null);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(DBNull.Value).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_return_double_when_getting_double_from_db()
+        {
+            var expected = 10.5D;
+
+            var context = new ConverterContext
+                          {
+                              DbValue = expected
+                          };
+
+            Subject.FromDB(context).Should().Be(expected);
+        }
+
+        [Test]
+        public void should_return_double_when_getting_string_from_db()
+        {
+            var expected = 10.5D;
+
+            var context = new ConverterContext
+                          {
+                              DbValue = $"{expected}"
+                          };
+
+            Subject.FromDB(context).Should().Be(expected);
+        }
+
+        [Test]
+        public void should_return_null_for_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(DBNull.Value);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/EnumIntConverterFixture.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Reflection;
+using FluentAssertions;
+using Marr.Data.Converters;
+using Marr.Data.Mapping;
+using Moq;
+using NUnit.Framework;
+using NzbDrone.Core.Test.Framework;
+using NzbDrone.Core.Tv;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class EnumIntConverterFixture : CoreTest<Core.Datastore.Converters.EnumIntConverter>
+    {
+        [Test]
+        public void should_return_int_when_saving_enum_to_db()
+        {
+            Subject.ToDB(SeriesTypes.Standard).Should().Be((int)SeriesTypes.Standard);
+        }
+
+        [Test]
+        public void should_return_db_null_for_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(null).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_return_enum_when_getting_int_from_db()
+        {
+            var mockMemberInfo = new Mock<MemberInfo>();
+            mockMemberInfo.SetupGet(s => s.DeclaringType).Returns(typeof(Series));
+            mockMemberInfo.SetupGet(s => s.Name).Returns("SeriesType");
+
+            var expected = SeriesTypes.Standard;
+
+            var context = new ConverterContext
+                          {
+                              ColumnMap = new ColumnMap(mockMemberInfo.Object) { FieldType = typeof(SeriesTypes) },
+                              DbValue = (long)expected
+                          };
+
+            Subject.FromDB(context).Should().Be(expected);
+        }
+
+        [Test]
+        public void should_return_null_for_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(null);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/GuidConverterFixture.cs

@@ -0,0 +1,51 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class GuidConverterFixture : CoreTest<GuidConverter>
+    {
+        [Test]
+        public void should_return_string_when_saving_guid_to_db()
+        {
+            var guid = Guid.NewGuid();
+
+            Subject.ToDB(guid).Should().Be(guid.ToString());
+        }
+
+        [Test]
+        public void should_return_db_null_for_null_value_when_saving_to_db()
+        {
+            Subject.ToDB(null).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_return_guid_when_getting_string_from_db()
+        {
+            var guid = Guid.NewGuid();
+
+            var context = new ConverterContext
+                          {
+                              DbValue = guid.ToString()
+                          };
+
+            Subject.FromDB(context).Should().Be(guid);
+        }
+
+        [Test]
+        public void should_return_empty_guid_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(Guid.Empty);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/Int32ConverterFixture.cs

@@ -0,0 +1,58 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class Int32ConverterFixture : CoreTest<Int32Converter>
+    {
+        [Test]
+        public void should_return_int_when_saving_int_to_db()
+        {
+            var i = 5;
+
+            Subject.ToDB(5).Should().Be(5);
+        }
+
+        [Test]
+        public void should_return_int_when_getting_int_from_db()
+        {
+            var i = 5;
+
+            var context = new ConverterContext
+                          {
+                              DbValue = i
+                          };
+
+            Subject.FromDB(context).Should().Be(i);
+        }
+
+        [Test]
+        public void should_return_int_when_getting_string_from_db()
+        {
+            var i = 5;
+
+            var context = new ConverterContext
+                          {
+                              DbValue = i.ToString()
+                          };
+
+            Subject.FromDB(context).Should().Be(i);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(DBNull.Value);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/OsPathConverterFixture.cs

@@ -0,0 +1,49 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Common.Disk;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+using NzbDrone.Test.Common;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class OsPathConverterFixture : CoreTest<OsPathConverter>
+    {
+        [Test]
+        public void should_return_string_when_saving_os_path_to_db()
+        {
+            var path = @"C:\Test\TV".AsOsAgnostic();
+            var osPath = new OsPath(path);
+
+            Subject.ToDB(osPath).Should().Be(path);
+        }
+
+        [Test]
+        public void should_return_os_path_when_getting_string_from_db()
+        {
+            var path = @"C:\Test\TV".AsOsAgnostic();
+            var osPath = new OsPath(path);
+
+            var context = new ConverterContext
+                          {
+                              DbValue = path
+                          };
+
+            Subject.FromDB(context).Should().Be(osPath);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(DBNull.Value);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/QualityIntConverterFixture.cs

@@ -0,0 +1,58 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Qualities;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class QualityIntConverterFixture : CoreTest<QualityIntConverter>
+    {
+        [Test]
+        public void should_return_int_when_saving_quality_to_db()
+        {
+            var quality = Quality.Bluray1080p;
+
+            Subject.ToDB(quality).Should().Be(quality.Id);
+        }
+
+        [Test]
+        public void should_return_0_when_saving_db_null_to_db()
+        {
+            Subject.ToDB(DBNull.Value).Should().Be(0);
+        }
+
+        [Test]
+        public void should_throw_when_saving_another_object_to_db()
+        {
+            Assert.Throws<InvalidOperationException>(() => Subject.ToDB("Not a quality"));
+        }
+
+        [Test]
+        public void should_return_quality_when_getting_string_from_db()
+        {
+            var quality = Quality.Bluray1080p;
+
+            var context = new ConverterContext
+                          {
+                              DbValue = quality.Id
+                          };
+
+            Subject.FromDB(context).Should().Be(quality);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(Quality.Unknown);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/TimeSpanConverterFixture.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Globalization;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class TimeSpanConverterFixture : CoreTest<TimeSpanConverter>
+    {
+        [Test]
+        public void should_return_string_when_saving_timespan_to_db()
+        {
+            var timeSpan = TimeSpan.FromMinutes(5);
+
+            Subject.ToDB(timeSpan).Should().Be(timeSpan.ToString("c", CultureInfo.InvariantCulture));
+        }
+
+        [Test]
+        public void should_return_null_when_saving_empty_string_to_db()
+        {
+            Subject.ToDB("").Should().Be(null);
+        }
+
+        [Test]
+        public void should_return_time_span_when_getting_time_span_from_db()
+        {
+            var timeSpan = TimeSpan.FromMinutes(5);
+
+            var context = new ConverterContext
+                          {
+                              DbValue = timeSpan
+                          };
+
+            Subject.FromDB(context).Should().Be(timeSpan);
+        }
+
+        [Test]
+        public void should_return_time_span_when_getting_string_from_db()
+        {
+            var timeSpan = TimeSpan.FromMinutes(5);
+
+            var context = new ConverterContext
+                          {
+                              DbValue = timeSpan.ToString("c", CultureInfo.InvariantCulture)
+                          };
+
+            Subject.FromDB(context).Should().Be(timeSpan);
+        }
+
+        [Test]
+        public void should_return_time_span_zero_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(TimeSpan.Zero);
+        }
+    }
+}

src/NzbDrone.Core.Test/Datastore/Converters/UtcConverterFixture.cs

@@ -0,0 +1,51 @@
+using System;
+using FluentAssertions;
+using Marr.Data.Converters;
+using NUnit.Framework;
+using NzbDrone.Core.Datastore.Converters;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.Datastore.Converters
+{
+    [TestFixture]
+    public class UtcConverterFixture : CoreTest<UtcConverter>
+    {
+        [Test]
+        public void should_return_date_time_when_saving_date_time_to_db()
+        {
+            var dateTime = DateTime.Now;
+
+            Subject.ToDB(dateTime).Should().Be(dateTime.ToUniversalTime());
+        }
+
+        [Test]
+        public void should_return_db_null_when_saving_db_null_to_db()
+        {
+            Subject.ToDB(DBNull.Value).Should().Be(DBNull.Value);
+        }
+
+        [Test]
+        public void should_return_time_span_when_getting_time_span_from_db()
+        {
+            var dateTime = DateTime.Now.ToUniversalTime();
+
+            var context = new ConverterContext
+                          {
+                              DbValue = dateTime
+            };
+
+            Subject.FromDB(context).Should().Be(dateTime);
+        }
+
+        [Test]
+        public void should_return_db_null_for_db_null_value_when_getting_from_db()
+        {
+            var context = new ConverterContext
+                          {
+                              DbValue = DBNull.Value
+                          };
+
+            Subject.FromDB(context).Should().Be(DBNull.Value);
+        }
+    }
+}

src/NzbDrone.Core.Test/MediaFiles/MediaFileDeletionService/DeleteEpisodeFileFixture.cs

@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using FizzWare.NBuilder;
 using Moq;
 using NUnit.Framework;
@@ -63,6 +63,8 @@ namespace NzbDrone.Core.Test.MediaFiles.MediaFileDeletionService
         [Test]
         public void should_throw_if_root_folder_does_not_exist()
         {
+            ExceptionVerification.ExpectedWarns(1);
+
             Assert.Throws<NzbDroneClientException>(() => Subject.DeleteEpisodeFile(_series, _episodeFile));
         }
 
@@ -70,6 +72,9 @@ namespace NzbDrone.Core.Test.MediaFiles.MediaFileDeletionService
         public void should_should_throw_if_root_folder_is_empty()
         {
             GivenRootFolderExists();
+
+            ExceptionVerification.ExpectedWarns(1);
+
             Assert.Throws<NzbDroneClientException>(() => Subject.DeleteEpisodeFile(_series, _episodeFile));
         }
 

src/NzbDrone.Core.Test/NzbDrone.Core.Test.csproj

@@ -115,6 +115,16 @@
     <Compile Include="DataAugmentation\Scene\SceneMappingServiceFixture.cs" />
     <Compile Include="DataAugmentation\DailySeries\DailySeriesDataProxyFixture.cs" />
     <Compile Include="Datastore\BasicRepositoryFixture.cs" />
+    <Compile Include="Datastore\Converters\UtcConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\TimeSpanConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\QualityIntConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\OsPathConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\Int32ConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\GuidConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\EnumIntConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\DoubleConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\CommandConverterFixture.cs" />
+    <Compile Include="Datastore\Converters\BooleanIntConverterFixture.cs" />
     <Compile Include="Datastore\Converters\ProviderSettingConverterFixture.cs" />
     <Compile Include="Datastore\DatabaseFixture.cs" />
     <Compile Include="Datastore\DatabaseRelationshipFixture.cs" />

src/NzbDrone.Core/Datastore/Converters/GuidConverter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Marr.Data.Converters;
 using Marr.Data.Mapping;
 
@@ -25,6 +25,11 @@ namespace NzbDrone.Core.Datastore.Converters
 
         public object ToDB(object clrValue)
         {
+            if (clrValue == null)
+            {
+                return DBNull.Value;
+            }
+
             var value = clrValue;
 
             return value.ToString();

src/NzbDrone.Core/Datastore/Converters/Int32Converter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Marr.Data.Converters;
 using Marr.Data.Mapping;
 
@@ -23,17 +23,7 @@ namespace NzbDrone.Core.Datastore.Converters
 
         public object FromDB(ColumnMap map, object dbValue)
         {
-            if (dbValue == DBNull.Value)
+            return FromDB(new ConverterContext { ColumnMap = map, DbValue = dbValue });
-            {
-                return DBNull.Value;
-            }
-
-            if (dbValue is int)
-            {
-                return dbValue;
-            }
-
-            return Convert.ToInt32(dbValue);
         }
 
         public object ToDB(object clrValue)

src/NzbDrone.Core/Datastore/Converters/QualityIntConverter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Marr.Data.Converters;
 using Marr.Data.Mapping;
 using NzbDrone.Core.Qualities;
@@ -27,9 +27,9 @@ namespace NzbDrone.Core.Datastore.Converters
 
         public object ToDB(object clrValue)
         {
-            if(clrValue == DBNull.Value) return 0;
+            if (clrValue == DBNull.Value) return 0;
 
-            if(clrValue as Quality == null)
+            if (clrValue as Quality == null)
             {
                 throw new InvalidOperationException("Attempted to save a quality that isn't really a quality");
             }

src/NzbDrone.Core/Datastore/Converters/TimeSpanConverter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Globalization;
 using Marr.Data.Converters;
 using Marr.Data.Mapping;
@@ -15,22 +15,17 @@ namespace NzbDrone.Core.Datastore.Converters
                 return TimeSpan.Zero;
             }
 
-            return TimeSpan.Parse(context.DbValue.ToString());
+            if (context.DbValue is TimeSpan)
+            {
+                return context.DbValue;
+            }
+
+            return TimeSpan.Parse(context.DbValue.ToString(), CultureInfo.InvariantCulture);
         }
 
         public object FromDB(ColumnMap map, object dbValue)
         {
-            if (dbValue == DBNull.Value)
+            return FromDB(new ConverterContext { ColumnMap = map, DbValue = dbValue });
-            {
-                return DBNull.Value;
-            }
-
-            if (dbValue is TimeSpan)
-            {
-                return dbValue;
-            }
-
-            return TimeSpan.Parse(dbValue.ToString(), CultureInfo.InvariantCulture);
         }
 
         public object ToDB(object clrValue)