diff --git a/src/Marr.Data/Reflection/SimpleReflectionStrategy.cs b/src/Marr.Data/Reflection/SimpleReflectionStrategy.cs index 9e741b013..04d4a7cda 100644 --- a/src/Marr.Data/Reflection/SimpleReflectionStrategy.cs +++ b/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; } diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/BooleanIntConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/BooleanIntConverterFixture.cs new file mode 100644 index 000000000..649a7303e --- /dev/null +++ b/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 + { + [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(() => Subject.FromDB(context)); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/CommandConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/CommandConverterFixture.cs new file mode 100644 index 000000000..ac0a3359e --- /dev/null +++ b/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 + { + [Test] + public void should_return_json_string_when_saving_boolean_to_db() + { + var command = new RefreshSeriesCommand(); + + Subject.ToDB(command).Should().BeOfType(); + } + + [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(); + 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(); + } + + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/DoubleConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/DoubleConverterFixture.cs new file mode 100644 index 000000000..bf4974124 --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/EnumIntConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/EnumIntConverterFixture.cs new file mode 100644 index 000000000..d675086fb --- /dev/null +++ b/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 + { + [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(); + 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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/GuidConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/GuidConverterFixture.cs new file mode 100644 index 000000000..8444fa053 --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/Int32ConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/Int32ConverterFixture.cs new file mode 100644 index 000000000..2c10a0aaf --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/OsPathConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/OsPathConverterFixture.cs new file mode 100644 index 000000000..f7f3da0d8 --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/QualityIntConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/QualityIntConverterFixture.cs new file mode 100644 index 000000000..31ae8b6b3 --- /dev/null +++ b/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 + { + [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(() => 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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/TimeSpanConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/TimeSpanConverterFixture.cs new file mode 100644 index 000000000..c96848179 --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/Datastore/Converters/UtcConverterFixture.cs b/src/NzbDrone.Core.Test/Datastore/Converters/UtcConverterFixture.cs new file mode 100644 index 000000000..904f653d3 --- /dev/null +++ b/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 + { + [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); + } + } +} diff --git a/src/NzbDrone.Core.Test/MediaFiles/MediaFileDeletionService/DeleteEpisodeFileFixture.cs b/src/NzbDrone.Core.Test/MediaFiles/MediaFileDeletionService/DeleteEpisodeFileFixture.cs index c2bef40ac..7b59dec8e 100644 --- a/src/NzbDrone.Core.Test/MediaFiles/MediaFileDeletionService/DeleteEpisodeFileFixture.cs +++ b/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(() => 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(() => Subject.DeleteEpisodeFile(_series, _episodeFile)); } diff --git a/src/NzbDrone.Core.Test/NzbDrone.Core.Test.csproj b/src/NzbDrone.Core.Test/NzbDrone.Core.Test.csproj index 8099210ec..0c803ae98 100644 --- a/src/NzbDrone.Core.Test/NzbDrone.Core.Test.csproj +++ b/src/NzbDrone.Core.Test/NzbDrone.Core.Test.csproj @@ -115,6 +115,16 @@ + + + + + + + + + + diff --git a/src/NzbDrone.Core/Datastore/Converters/GuidConverter.cs b/src/NzbDrone.Core/Datastore/Converters/GuidConverter.cs index b2bf33526..5cab866b2 100644 --- a/src/NzbDrone.Core/Datastore/Converters/GuidConverter.cs +++ b/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(); diff --git a/src/NzbDrone.Core/Datastore/Converters/Int32Converter.cs b/src/NzbDrone.Core/Datastore/Converters/Int32Converter.cs index c96586aa7..443cd1767 100644 --- a/src/NzbDrone.Core/Datastore/Converters/Int32Converter.cs +++ b/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 DBNull.Value; - } - - if (dbValue is int) - { - return dbValue; - } - - return Convert.ToInt32(dbValue); + return FromDB(new ConverterContext { ColumnMap = map, DbValue = dbValue }); } public object ToDB(object clrValue) @@ -43,4 +33,4 @@ namespace NzbDrone.Core.Datastore.Converters public Type DbType { get; private set; } } -} \ No newline at end of file +} diff --git a/src/NzbDrone.Core/Datastore/Converters/QualityIntConverter.cs b/src/NzbDrone.Core/Datastore/Converters/QualityIntConverter.cs index 254dde15e..0b225a8a2 100644 --- a/src/NzbDrone.Core/Datastore/Converters/QualityIntConverter.cs +++ b/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"); } @@ -56,4 +56,4 @@ namespace NzbDrone.Core.Datastore.Converters writer.WriteValue(ToDB(value)); } } -} \ No newline at end of file +} diff --git a/src/NzbDrone.Core/Datastore/Converters/TimeSpanConverter.cs b/src/NzbDrone.Core/Datastore/Converters/TimeSpanConverter.cs index 9ea6b398f..f8080fdff 100644 --- a/src/NzbDrone.Core/Datastore/Converters/TimeSpanConverter.cs +++ b/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()); - } - - public object FromDB(ColumnMap map, object dbValue) - { - if (dbValue == DBNull.Value) + if (context.DbValue is TimeSpan) { - return DBNull.Value; + return context.DbValue; } - if (dbValue is TimeSpan) - { - return dbValue; - } + return TimeSpan.Parse(context.DbValue.ToString(), CultureInfo.InvariantCulture); + } - return TimeSpan.Parse(dbValue.ToString(), CultureInfo.InvariantCulture); + public object FromDB(ColumnMap map, object dbValue) + { + return FromDB(new ConverterContext { ColumnMap = map, DbValue = dbValue }); } public object ToDB(object clrValue) @@ -45,4 +40,4 @@ namespace NzbDrone.Core.Datastore.Converters public Type DbType { get; private set; } } -} \ No newline at end of file +}