public async Task BindingSourceObjectRoots()
{
var target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
var editorProvider = new MockEditorProvider(editor.Object);
var sources = new[] {
new BindingSource("Short Description", BindingSourceType.Object, "Short Description"),
new BindingSource("Long Description", BindingSourceType.Object, "Long Description"),
};
var shortRoots = new[] { new object(), new object() };
var bpmock = new Mock <IBindingProvider> ();
bpmock.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(sources);
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[0], target)).ReturnsAsync(shortRoots);
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[1], target)).ReturnsAsync(new[] { new object() });
bpmock.Setup(bp => bp.GetValueConverterResourcesAsync(It.IsAny <object> ())).ReturnsAsync(new Resource[0]);
var vm = new CreateBindingViewModel(new TargetPlatform(editorProvider, bpmock.Object), editor.Object, property.Object);
await vm.BindingSources.Task;
Assume.That(vm.SelectedBindingSource, Is.EqualTo(sources[0]));
bpmock.Verify(bp => bp.GetRootElementsAsync(sources[0], target));
IReadOnlyList <ObjectTreeElement> roots = await vm.ObjectElementRoots.Task;
Assert.That(roots.Count, Is.EqualTo(2), "Unexpected number of roots");
CollectionAssert.AreEqual(roots.Select(r => r.Editor.Target), shortRoots);
}
public async Task BindingSources()
{
var target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
var editorProvider = new MockEditorProvider(editor.Object);
var sources = new[] {
new BindingSource("Short Description", BindingSourceType.Object, "Short Description"),
new BindingSource("Long Description", BindingSourceType.Object, "Long Description"),
};
var bpmock = new Mock <IBindingProvider> ();
bpmock.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(sources);
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[0], target)).ReturnsAsync(new[] { new object(), new object() });
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[1], target)).ReturnsAsync(new[] { new object() });
bpmock.Setup(bp => bp.GetValueConverterResourcesAsync(It.IsAny <object> ())).ReturnsAsync(new Resource[0]);
var vm = new CreateBindingViewModel(new TargetPlatform(editorProvider, bpmock.Object), editor.Object, property.Object);
Assert.That(vm.BindingSources, Is.Not.Null);
var requested = await vm.BindingSources.Task;
CollectionAssert.AreEqual(sources, requested);
Assert.That(vm.SelectedBindingSource, Is.EqualTo(sources[0]));
}
private CreateBindingViewModel CreateBasicViewModel(BindingSource[] sources = null, object target = null)
{
target = target ?? new object();
Mock <IPropertyInfo> property = GetBasicProperty();
Mock <IObjectEditor> editor = GetBasicEditor(target, property.Object);
var editorProvider = new MockEditorProvider(editor.Object);
Mock <IResourceProvider> resourceProvider = GetBasicResourceProvider(target);
Mock <IBindingProvider> bpmock = GetBasicBindingProvider(target, property.Object, sources);
return(new CreateBindingViewModel(new TargetPlatform(editorProvider, resourceProvider.Object, bpmock.Object), editor.Object, property.Object));
}
public void UncommonPropertiesFiltered()
{
var obj = new TestClassSub();
var property = new Mock <IPropertyInfo> ();
property.Setup(pi => pi.Name).Returns(nameof(TestClass.Property));
property.Setup(pi => pi.Type).Returns(typeof(string));
property.Setup(pi => pi.RealType).Returns(typeof(string).ToTypeInfo());
property.Setup(pi => pi.IsUncommon).Returns(true);
var subProperty = new Mock <IPropertyInfo> ();
subProperty.Setup(pi => pi.Name).Returns(nameof(TestClassSub.SubProperty));
subProperty.Setup(pi => pi.Type).Returns(typeof(int));
subProperty.Setup(pi => pi.RealType).Returns(typeof(int).ToTypeInfo());
subProperty.Setup(pi => pi.IsUncommon).Returns(false);
var editor = new Mock <IObjectEditor> ();
editor.SetTarget(obj);
editor.Setup(e => e.Properties).Returns(new[] { property.Object, subProperty.Object });
var provider = new MockEditorProvider(editor.Object);
var vm = new PanelViewModel(new TargetPlatform(provider));
Assume.That(vm.ArrangeMode, Is.EqualTo(PropertyArrangeMode.Name));
vm.SelectedObjects.Add(obj);
Assume.That(vm.ArrangedEditors, Is.Not.Empty);
Assume.That(vm.ArrangedEditors[0].Editors.Count, Is.EqualTo(2));
Assume.That(vm.IsFiltering, Is.False);
bool changed = false;
vm.PropertyChanged += (sender, args) => {
if (args.PropertyName == nameof(PanelViewModel.IsFiltering))
{
changed = true;
}
};
vm.FilterText = "sub";
Assert.That(vm.ArrangedEditors[0].Editors.Count, Is.EqualTo(1), "Uncommon property wasn't filtered out");
Assert.That(vm.IsFiltering, Is.True);
Assert.That(changed, Is.True);
changed = false;
vm.FilterText = null;
Assert.That(vm.IsFiltering, Is.False);
Assert.That(changed, Is.True);
}
public async Task Types()
{
object target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
var resources = new MockResourceProvider();
var source = new BindingSource("Resources", BindingSourceType.Type);
var type = typeof(MockSampleControl).ToTypeInfo();
var bindings = GetBasicBindingProvider(target, property.Object, sources: new[] { source });
bindings.Setup(bp => bp.GetSourceTypesAsync(source, target))
.ReturnsAsync(new AssignableTypesResult(new[] { type }));
var provider = new MockEditorProvider(editor.Object);
var vm = new CreateBindingViewModel(new TargetPlatform(provider, resources, bindings.Object), editor.Object, property.Object);
Assume.That(vm.SelectedBindingSource, Is.EqualTo(source));
Assume.That(vm.TypeSelector, Is.Not.Null);
while (vm.SelectedObjects.Count == 0 && vm.TypeSelector.IsLoading)
{
await Task.Delay(1);
}
var binding = (MockBinding)vm.SelectedObjects.First();
Assert.That(vm.TypeSelector.SelectedType, Is.Null);
bool propertyChanged = false;
vm.PropertyChanged += (o, e) => {
if (e.PropertyName == nameof(CreateBindingViewModel.PropertyRoot))
{
propertyChanged = true;
}
};
vm.TypeSelector.SelectedType = type;
Assert.That(propertyChanged, Is.True, "INPC didn't change for PropertyRoot on selected source param");
Assert.That(vm.PropertyRoot, Is.Not.Null);
Assert.That(binding.SourceParameter, Is.EqualTo(type));
await vm.PropertyRoot.Task;
CollectionAssert.AreEqual(provider.GetPropertiesForTypeAsync(type).Result,
vm.PropertyRoot.Value.Children.Select(pe => pe.Property));
}
public async Task ValueConverters()
{
var target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
const string objName = "objName";
var nameable = editor.As <INameableObject> ();
nameable.Setup(n => n.GetNameAsync()).ReturnsAsync(objName);
var editorProvider = new MockEditorProvider(editor.Object);
var sources = new[] {
new BindingSource("Short Description", BindingSourceType.Object, "Short Description"),
new BindingSource("Long Description", BindingSourceType.Object, "Long Description"),
};
var visi = new Resource("BooleanToVisibilityConverter");
var bpmock = new Mock <IBindingProvider> ();
bpmock.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(sources);
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[0], target)).ReturnsAsync(new[] { new object(), new object() });
bpmock.Setup(bp => bp.GetRootElementsAsync(sources[1], target)).ReturnsAsync(new[] { new object() });
bpmock.Setup(bp => bp.GetValueConverterResourcesAsync(It.IsAny <object> ())).ReturnsAsync(new [] { visi });
var vm = new CreateBindingViewModel(new TargetPlatform(editorProvider, bpmock.Object), editor.Object, property.Object);
Assert.That(vm.ValueConverters, Is.Not.Null);
await vm.ValueConverters.Task;
Assert.That(vm.ValueConverters.Value, Contains.Item(visi));
if (vm.IncludeAddValueConverter)
{
Assert.That(vm.ValueConverters.Value.Count, Is.EqualTo(3)); // visi, No Converter, Request Converter
}
else
{
Assert.That(vm.ValueConverters.Value.Count, Is.EqualTo(2)); // visi, No Converter
}
}
public async Task ExtraProperties()
{
var provider = new MockEditorProvider();
var vm = CreateBasicViewModel();
var editors = (IList <IObjectEditor>) typeof(CreateBindingViewModel).GetProperty("ObjectEditors", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(vm); // Shortcut
var editor = editors[0];
IEnumerable <IPropertyInfo> properties = (await provider.GetPropertiesForTypeAsync(typeof(MockBinding).ToTypeInfo()));
CollectionAssert.AreEqual(properties, vm.Properties.Cast <PropertyViewModel> ().Select(pvm => pvm.Property));
properties = properties.Where(p => !editor.KnownProperties.ContainsKey(p));
CollectionAssert.AreEqual(properties.Where(p => p.Type == typeof(bool)),
vm.FlagsProperties.Cast <PropertyViewModel> ().Select(pvm => pvm.Property));
CollectionAssert.AreEqual(properties.Where(p => p.Type != typeof(bool)),
vm.BindingProperties.Cast <PropertyViewModel> ().Select(pvm => pvm.Property));
}
public async Task PropertyRootChildren()
{
var target = new object();
var property = new Mock <IPropertyInfo> ();
property.SetupGet(p => p.ValueSources).Returns(ValueSources.Local | ValueSources.Binding);
property.SetupGet(p => p.Type).Returns(typeof(object));
property.SetupGet(p => p.Name).Returns("name");
property.SetupGet(p => p.RealType).Returns(typeof(object).ToTypeInfo());
property.SetupGet(p => p.CanWrite).Returns(true);
var editor = GetBasicEditor(target, property.Object);
var controlTarget = new MockWpfControl();
var controlEditor = new MockObjectEditor(controlTarget);
var provider = new MockEditorProvider(controlEditor);
var source = new BindingSource("Control", BindingSourceType.Object);
var bpmock = new Mock <IBindingProvider> ();
bpmock.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(new[] { source });
bpmock.Setup(bp => bp.GetRootElementsAsync(source, target)).ReturnsAsync(new[] { controlTarget });
bpmock.Setup(bp => bp.GetValueConverterResourcesAsync(It.IsAny <object> ())).ReturnsAsync(new Resource[0]);
var vm = new CreateBindingViewModel(new TargetPlatform(provider, bpmock.Object), editor.Object, property.Object);
Assume.That(vm.SelectedBindingSource, Is.EqualTo(source));
Assume.That(vm.PropertyRoot, Is.Not.Null);
await vm.PropertyRoot.Task;
var childrenProperty = controlEditor.Properties.First(p => p.Type == typeof(CommonThickness));
var element = vm.PropertyRoot.Value.Children.First(p => Equals(p.Property, childrenProperty));
Assert.That(element.Children, Is.Not.Null);
await element.Children.Task;
var expected = await provider.GetPropertiesForTypeAsync(typeof(CommonThickness).ToTypeInfo());
CollectionAssert.AreEqual(expected, element.Children.Value.Select(te => te.Property));
}
public void PropertyDisplayNameable()
{
var target = new object();
const string propName = "propertyName";
var property = GetBasicProperty(propName);
var editor = GetBasicEditor(target, property.Object);
const string objName = "objName";
var nameable = editor.As <INameableObject> ();
nameable.Setup(n => n.GetNameAsync()).ReturnsAsync(objName);
var editorProvider = new MockEditorProvider(editor.Object);
var bpmock = new Mock <IBindingProvider> ();
var vm = new CreateBindingViewModel(new TargetPlatform(editorProvider, bpmock.Object), editor.Object, property.Object);
Assert.That(vm.PropertyDisplay, Does.Not.Contains("Object"));
Assert.That(vm.PropertyDisplay, Contains.Substring(objName));
Assert.That(vm.PropertyDisplay, Contains.Substring(propName));
}
public void PropertyDisplayType()
{
var target = new object();
const string propName = "propertyName";
var property = GetBasicProperty(propName);
var editor = new Mock <IObjectEditor> ();
editor.SetupGet(e => e.Properties).Returns(new[] { property.Object });
editor.SetupGet(e => e.Target).Returns(target);
editor.SetupGet(e => e.TargetType).Returns(typeof(object).ToTypeInfo());
var editorProvider = new MockEditorProvider(editor.Object);
var bpmock = new Mock <IBindingProvider> ();
var vm = new CreateBindingViewModel(new TargetPlatform(editorProvider, bpmock.Object), editor.Object, property.Object);
Assert.That(vm.PropertyDisplay, Contains.Substring("Object"));
Assert.That(vm.PropertyDisplay, Contains.Substring(propName));
}
