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]));
}
public async Task ResourceRoots()
{
object target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
var resources = new MockResourceProvider();
var bindings = GetBasicBindingProvider(target, property.Object);
var source = new BindingSource("Resources", BindingSourceType.Resource);
bindings.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(new[] { source });
bindings.Setup(bp => bp.GetResourcesAsync(source, target))
.Returns <BindingSource, object> (async(bs, t) => {
var rs = await resources.GetResourcesAsync(target, CancellationToken.None);
return(rs.ToLookup(r => r.Source));
});
var vm = new CreateBindingViewModel(
new TargetPlatform(new MockEditorProvider(editor.Object), resources, bindings.Object), editor.Object,
property.Object);
Assume.That(vm.SelectedBindingSource, Is.EqualTo(source));
Assert.That(vm.SourceResources, Is.Not.Null);
await vm.SourceResources.Task;
Assert.That(vm.SourceResources.Value.First().Key, Is.EqualTo(DefaultResourceSources[0]));
}
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 CreateBindingWindow(IEnumerable <ResourceDictionary> merged, TargetPlatform platform, IObjectEditor editor, IPropertyInfo property)
{
var vm = new CreateBindingViewModel(platform, editor, property);
vm.CreateValueConverterRequested += OnCreateValueConverterRequested;
DataContext = vm;
InitializeComponent();
Resources.MergedDictionaries.AddItems(merged);
}
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 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 async Task ResourceProperties()
{
object target = new object();
var property = GetBasicProperty();
var editor = GetBasicEditor(target, property.Object);
var resources = new MockResourceProvider();
var source = new BindingSource("Resources", BindingSourceType.Resource);
var bindings = GetBasicBindingProvider(target, property.Object, sources: new [] { source });
bindings.Setup(bp => bp.GetResourcesAsync(source, target))
.Returns <BindingSource, object> (async(bs, t) => {
var rs = await resources.GetResourcesAsync(target, CancellationToken.None);
return(rs.ToLookup(r => r.Source));
});
var vm = new CreateBindingViewModel(
new TargetPlatform(new MockEditorProvider(editor.Object), resources, bindings.Object), editor.Object,
property.Object);
Assume.That(vm.SelectedBindingSource, Is.EqualTo(source));
Assume.That(vm.SourceResources, Is.Not.Null);
await vm.SourceResources.Task;
while (vm.SelectedObjects.Count == 0)
{
await Task.Delay(1);
}
var binding = (MockBinding)vm.SelectedObjects.First();
vm.SelectedResource = vm.SourceResources.Value.First().OfType <Resource <CommonSolidBrush> >().First();
Assert.That(binding.SourceParameter, Is.EqualTo(vm.SelectedResource));
Assume.That(vm.PropertyRoot, Is.Not.Null);
await vm.PropertyRoot.Task;
Assert.That(vm.PropertyRoot.Value.TargetType, Is.EqualTo(typeof(CommonSolidBrush).ToTypeInfo()));
CollectionAssert.AreEqual(ReflectionEditorProvider.GetPropertiesForType(typeof(CommonSolidBrush)),
vm.PropertyRoot.Value.Children.Select(pe => pe.Property));
}
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));
}
