yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make various value editors handle their respective data as concrete types rather than strings or otherwise strange legacy data formats

Browse Source
This commit is contained in:
kjac
2023-02-23 09:12:10 +01:00
parent 710ae3c788
commit 93149160a7
14 changed files with 992 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/DecimalValueEditorTests.cs Normal file
View File

@@ -0,0 +1,97 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class DecimalValueEditorTests
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
private Dictionary<object?,object?> _valuesAndExpectedResults = new();
[SetUp]
public void SetUp() => _valuesAndExpectedResults = new Dictionary<object?, object?>
{
{ 123m, 123m },
{ 123, 123m },
{ -123, -123m },
{ 123.45d, 123.45m },
{ "123.45", 123.45m },
{ "1234.56", 1234.56m },
{ "123,45", 12345m },
{ "1.234,56", null },
{ "123 45", null },
{ "something", null },
{ true, null },
{ new object(), null },
{ new List<string> { "some", "values" }, null },
{ Guid.NewGuid(), null },
{ new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()), null }
};
[Test]
public void Can_Parse_Values_From_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
var fromEditor = FromEditor(value);
Assert.AreEqual(expected, fromEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Parse_Values_To_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
var toEditor = ToEditor(value);
Assert.AreEqual(expected, toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Null_From_Editor_Yields_Null()
{
var result = FromEditor(null);
Assert.IsNull(result);
}
[Test]
public void Null_To_Editor_Yields_Null()
{
var result = ToEditor(null);
Assert.IsNull(result);
}
private static object? FromEditor(object? value)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, null), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static DecimalPropertyEditor.DecimalPropertyValueEditor CreateValueEditor()
{
var valueEditor = new DecimalPropertyEditor.DecimalPropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IJsonSerializer>(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}

214
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/MultiNodeTreePickerTests.cs Normal file
View File

@@ -0,0 +1,214 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class MultiNodeTreePickerTests
{
[Test]
public void Can_Handle_Invalid_Values_From_Editor()
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
var invalidValues = new List<object?>
{
123m,
123,
-123,
123.45d,
"123.45",
"1.234,56",
"1.2.3.4",
"something",
true,
new object(),
Guid.NewGuid(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid())
};
foreach (var value in invalidValues)
{
var fromEditor = FromEditor(value);
Assert.IsNull(fromEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Handle_Invalid_Values_To_Editor()
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
var invalidValues = new List<object?>
{
123m,
123,
-123,
123.45d,
true,
new object(),
Guid.NewGuid(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid())
};
foreach (var value in invalidValues)
{
var toEditor = ToEditor(value);
Assert.IsNull(toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Parse_Single_Value_From_Editor()
{
var value = new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString();
var fromEditor = FromEditor(new[] { value }) as string;
Assert.AreEqual(value, fromEditor);
}
[Test]
public void Can_Parse_Multi_Value_From_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString()
};
var fromEditor = FromEditor(values) as string;
Assert.AreEqual(string.Join(",", values), fromEditor);
}
[Test]
public void Can_Parse_Different_Entity_Types_From_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Member, Guid.NewGuid()).ToString()
};
var fromEditor = FromEditor(values) as string;
Assert.AreEqual(string.Join(",", values), fromEditor);
}
[Test]
public void Can_Skip_Invalid_Values_From_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
"Invalid Value",
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString()
};
var fromEditor = FromEditor(values) as string;
Assert.AreEqual(string.Join(",", values.First(), values.Last()), fromEditor);
}
[Test]
public void Can_Parse_Single_Value_To_Editor()
{
var value = new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString();
var toEditor = ToEditor(value) as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(1, toEditor.Count());
Assert.AreEqual(value, toEditor.First());
}
[Test]
public void Can_Parse_Multi_Value_To_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString()
};
var toEditor = ToEditor(string.Join(",", values)) as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(3, toEditor.Count());
Assert.AreEqual(values[0], toEditor.First());
Assert.AreEqual(values[1], toEditor.Skip(1).First());
Assert.AreEqual(values[2], toEditor.Last());
}
[Test]
public void Can_Parse_Different_Entity_Types_To_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(),
new GuidUdi(Constants.UdiEntityType.Member, Guid.NewGuid()).ToString()
};
var toEditor = ToEditor(string.Join(",", values)) as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(3, toEditor.Count());
Assert.AreEqual(values[0], toEditor.First());
Assert.AreEqual(values[1], toEditor.Skip(1).First());
Assert.AreEqual(values[2], toEditor.Last());
}
[Test]
public void Can_Skip_Invalid_Values_To_Editor()
{
var values = new[]
{
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString(),
"Invalid Value",
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()).ToString()
};
var toEditor = ToEditor(string.Join(",", values)) as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(2, toEditor.Count());
Assert.AreEqual(values[0], toEditor.First());
Assert.AreEqual(values[2], toEditor.Last());
}
[Test]
public void Null_From_Editor_Yields_Null()
{
var result = FromEditor(null);
Assert.IsNull(result);
}
[Test]
public void Null_To_Editor_Yields_Null()
{
var result = ToEditor(null) as IEnumerable<string>;
Assert.IsNull(result);
}
private static object? FromEditor(object? value, int max = 0)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, new MultipleTextStringConfiguration { Max = max }), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static MultiNodeTreePickerPropertyEditor.MultiNodeTreePickerPropertyValueEditor CreateValueEditor()
{
var valueEditor = new MultiNodeTreePickerPropertyEditor.MultiNodeTreePickerPropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IJsonSerializer>(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}

140
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/MultipleTextStringValueEditorTests.cs Normal file
View File

@@ -0,0 +1,140 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class MultipleTextStringValueEditorTests
{
[Test]
public void Can_Handle_Invalid_Values_From_Editor()
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
var invalidValues = new List<object?>
{
123m,
123,
-123,
123.45d,
"123.45",
"1.234,56",
"1.2.3.4",
"something",
true,
new object(),
Guid.NewGuid(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid())
};
foreach (var value in invalidValues)
{
var fromEditor = FromEditor(value);
Assert.IsNull(fromEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Handle_Invalid_Values_To_Editor()
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
var invalidValues = new List<object?>
{
123m,
123,
-123,
123.45d,
true,
new object(),
Guid.NewGuid(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid())
};
foreach (var value in invalidValues)
{
var toEditor = ToEditor(value) as IEnumerable<string>;
Assert.IsNotNull(toEditor, message: $"Failed for: {value}");
Assert.IsEmpty(toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Parse_Single_Value_From_Editor()
{
var fromEditor = FromEditor(new[] { "The Value" }) as string;
Assert.AreEqual("The Value", fromEditor);
}
[Test]
public void Can_Parse_Multi_Value_From_Editor()
{
var fromEditor = FromEditor(new[] { "The First Value", "The Second Value", "The Third Value" }) as string;
Assert.AreEqual("The First Value\nThe Second Value\nThe Third Value", fromEditor);
}
[Test]
public void Can_Parse_Single_Value_To_Editor()
{
var toEditor = ToEditor("The Value") as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(1, toEditor.Count());
Assert.AreEqual("The Value", toEditor.First());
}
[Test]
public void Can_Parse_Multi_Value_To_Editor()
{
var toEditor = ToEditor("The First Value\nThe Second Value\nThe Third Value") as IEnumerable<string>;
Assert.IsNotNull(toEditor);
Assert.AreEqual(3, toEditor.Count());
Assert.AreEqual("The First Value", toEditor.First());
Assert.AreEqual("The Second Value", toEditor.Skip(1).First());
Assert.AreEqual("The Third Value", toEditor.Last());
}
[Test]
public void Null_From_Editor_Yields_Null()
{
var result = FromEditor(null);
Assert.IsNull(result);
}
[Test]
public void Null_To_Editor_Yields_Empty_Collection()
{
var result = ToEditor(null) as IEnumerable<string>;
Assert.IsNotNull(result);
Assert.IsEmpty(result);
}
private static object? FromEditor(object? value, int max = 0)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, new MultipleTextStringConfiguration { Max = max }), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static MultipleTextStringPropertyEditor.MultipleTextStringPropertyValueEditor CreateValueEditor()
{
var valueEditor = new MultipleTextStringPropertyEditor.MultipleTextStringPropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IJsonSerializer>(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}

97
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/NumericValueEditorTests.cs Normal file
View File

@@ -0,0 +1,97 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class NumericValueEditorTests
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
private Dictionary<object?,object?> _valuesAndExpectedResults = new();
[SetUp]
public void SetUp() => _valuesAndExpectedResults = new Dictionary<object?, object?>
{
{ 123m, 123 },
{ 123, 123 },
{ -123, -123 },
{ 123.45d, null },
{ "123.45", null },
{ "1234.56", null },
{ "123,45", null },
{ "1.234,56", null },
{ "123 45", null },
{ "something", null },
{ true, null },
{ new object(), null },
{ new List<string> { "some", "values" }, null },
{ Guid.NewGuid(), null },
{ new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()), null }
};
[Test]
public void Can_Parse_Values_From_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
var fromEditor = FromEditor(value);
Assert.AreEqual(expected, fromEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Parse_Values_To_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
var toEditor = ToEditor(value);
Assert.AreEqual(expected, toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Null_From_Editor_Yields_Null()
{
var result = FromEditor(null);
Assert.IsNull(result);
}
[Test]
public void Null_To_Editor_Yields_Null()
{
var result = ToEditor(null);
Assert.IsNull(result);
}
private static object? FromEditor(object? value)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, null), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static IntegerPropertyEditor.IntegerPropertyValueEditor CreateValueEditor()
{
var valueEditor = new IntegerPropertyEditor.IntegerPropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IJsonSerializer>(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}

132
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/SliderValueEditorTests.cs Normal file
View File

@@ -0,0 +1,132 @@
using System.Text.Json.Nodes;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
using Umbraco.Cms.Infrastructure.Serialization;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class SliderValueEditorTests
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
private List<object?> _invalidValues = new();
[SetUp]
public void SetUp() => _invalidValues = new List<object?>
{
123m,
123,
-123,
123.45d,
"123.45",
"1.234,56",
"1.2.3.4",
"something",
true,
new object(),
new List<string> { "some", "values" },
Guid.NewGuid(),
new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid())
};
[Test]
public void Can_Handle_Invalid_Values_From_Editor()
{
foreach (var value in _invalidValues)
{
var fromEditor = FromEditor(value);
Assert.IsNull(fromEditor, message: $"Failed for: {value}");
}
}
[TestCase("1", 1)]
[TestCase("0", 0)]
[TestCase("-1", -1)]
[TestCase("123456789", 123456789)]
public void Can_Parse_Single_Value_To_Editor(string value, int expected)
{
var toEditor = ToEditor(value) as SliderPropertyEditor.SliderPropertyValueEditor.SliderRange;
Assert.IsNotNull(toEditor);
Assert.AreEqual(toEditor.From, expected);
Assert.AreEqual(toEditor.To, expected);
}
[TestCase("1,1", 1, 1)]
[TestCase("0,0", 0, 0)]
[TestCase("-1,-1", -1, -1)]
[TestCase("10,123456789", 10, 123456789)]
public void Can_Parse_Range_Value_To_Editor(string value, int expectedFrom, int expectedTo)
{
var toEditor = ToEditor(value) as SliderPropertyEditor.SliderPropertyValueEditor.SliderRange;
Assert.IsNotNull(toEditor);
Assert.AreEqual(toEditor.From, expectedFrom);
Assert.AreEqual(toEditor.To, expectedTo);
}
[TestCase(0, 10, "0,10")]
[TestCase(10, 10, "10")]
[TestCase(0, 0, "0")]
[TestCase(-10, -10, "-10")]
[TestCase(10, 123456789, "10,123456789")]
public void Can_Parse_Valid_Value_From_Editor(int from, int to, string expectedResult)
{
var value = JsonNode.Parse($"{{\"from\": {from}, \"to\": {to}}}");
var fromEditor = FromEditor(value) as string;
Assert.AreEqual(expectedResult, fromEditor);
}
[Test]
public void Can_Handle_Invalid_Values_To_Editor()
{
foreach (var value in _invalidValues)
{
var toEditor = ToEditor(value);
Assert.IsNull(toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Null_From_Editor_Yields_Null()
{
var result = FromEditor(null);
Assert.IsNull(result);
}
[Test]
public void Null_To_Editor_Yields_Null()
{
var result = ToEditor(null);
Assert.IsNull(result);
}
private static object? FromEditor(object? value)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, null), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static SliderPropertyEditor.SliderPropertyValueEditor CreateValueEditor()
{
var valueEditor = new SliderPropertyEditor.SliderPropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
new SystemTextJsonSerializer(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}

108
tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/TrueFalsePropertyValueEditorTests.cs Normal file
View File

@@ -0,0 +1,108 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
[TestFixture]
public class TrueFalsePropertyValueEditorTests
{
// annoyingly we can't use decimals etc. in attributes, so we can't turn these into test cases :(
private Dictionary<object?, bool> _valuesAndExpectedResults = new();
[SetUp]
public void SetUp() => _valuesAndExpectedResults = new Dictionary<object?, bool>
{
{ true, true },
{ 1, true },
{ "1", true },
{ "true", true },
{ "TRUE", true },
{ false, false },
{ 0, false },
{ "0", false },
{ "false", false },
{ "FALSE", false },
{ 123m, false },
{ 123, false },
{ -123, false },
{ 123.45d, false },
{ "123.45", false },
{ "1234.56", false },
{ "123,45", false },
{ "1.234,56", false },
{ "123 45", false },
{ "something", false },
{ new object(), false },
{ new List<string> { "some", "values" }, false },
{ Guid.NewGuid(), false },
{ new GuidUdi(Constants.UdiEntityType.Document, Guid.NewGuid()), false }
};
[Test]
public void Can_Parse_Values_From_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
// FromEditor returns 1 or 0, not true or false
var actuallyExpected = expected ? 1 : 0;
var fromEditor = FromEditor(value);
Assert.AreEqual(actuallyExpected, fromEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Can_Parse_Values_To_Editor()
{
foreach (var (value, expected) in _valuesAndExpectedResults)
{
var toEditor = ToEditor(value);
Assert.AreEqual(expected, toEditor, message: $"Failed for: {value}");
}
}
[Test]
public void Null_From_Editor_Yields_False()
{
var result = FromEditor(null);
Assert.AreEqual(0, result);
}
[Test]
public void Null_To_Editor_Yields_False()
{
var result = ToEditor(null);
Assert.AreEqual(false, result);
}
private static object? FromEditor(object? value)
=> CreateValueEditor().FromEditor(new ContentPropertyData(value, null), null);
private static object? ToEditor(object? value)
{
var property = new Mock<IProperty>();
property
.Setup(p => p.GetValue(It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<bool>()))
.Returns(value);
return CreateValueEditor().ToEditor(property.Object);
}
private static TrueFalsePropertyEditor.TrueFalsePropertyValueEditor CreateValueEditor()
{
var valueEditor = new TrueFalsePropertyEditor.TrueFalsePropertyValueEditor(
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IJsonSerializer>(),
Mock.Of<IIOHelper>(),
new DataEditorAttribute("alias", "name", "view"));
return valueEditor;
}
}