public virtual void BindingShouldUpdateTargetWithBindingContext()
{
bool isInvoked = false;
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock
{
GetActualSource = b => new object(),
Path = path
}
};
var source = new BindingSourceAccessorMock
{
Source = new ObserverMock
{
IsValid = b => true
}
};
DataBinding binding = CreateDataBinding(target, source, bindingManager);
target.SetValue = (func, context, arg3) =>
{
context.ShouldEqual(binding.Context);
arg3.ShouldBeTrue();
isInvoked = true;
return(true);
};
binding.UpdateTarget();
isInvoked.ShouldBeTrue();
}
public virtual void BindingShouldRaiseEventWhenUpdateSourceFalse()
{
bool isInvoked = false;
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
source.SetValue = (func, context, arg3) => false;
binding.BindingUpdated += (sender, args) =>
{
args.Action.ShouldEqual(BindingAction.UpdateSource);
args.Result.ShouldBeFalse();
isInvoked = true;
};
binding.UpdateSource();
isInvoked.ShouldBeTrue();
}
public virtual void BindingShouldCallAttachDetachMethodInBehavior()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
int countAttach = 0;
int countDetach = 0;
var first = new BindingBehaviorMock
{
Id = Guid.Empty,
Attach = binding1 =>
{
countAttach++;
return(true);
},
Detach = binding1 => countDetach++
};
binding.Behaviors.Add(first);
countAttach.ShouldEqual(1);
countDetach.ShouldEqual(0);
binding.Behaviors.Remove(first);
countAttach.ShouldEqual(1);
countDetach.ShouldEqual(1);
}
public void ProviderShouldReturnMultiPathObserverMultiPath()
{
var target = new BindingSourceModel();
var observerProvider = Cretate();
observerProvider.Observe(target, BindingPath.Create(GetMemberPath(target, model => model.NestedModel.IntProperty)), false).ShouldBeType <MultiPathObserver>();
}
public virtual void BindingShouldRaiseExceptionEventWhenUpdateSourceThrowException()
{
bool isInvoked = false;
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock
{
GetActualSource = b => new object(),
Path = path,
IsValid = b => true
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
source.SetValue = (func, context, arg3) => { throw new TestException(); };
binding.BindingException += (sender, args) =>
{
args.Action.ShouldEqual(BindingAction.UpdateSource);
args.Exception.InnerException.ShouldBeType <TestException>();
isInvoked = true;
};
binding.UpdateSource();
isInvoked.ShouldBeTrue();
}
private IExpressionNode VisitExpression(IExpressionNode node)
{
var nodes = new List <IExpressionNode>();
string memberName = node.TryGetMemberName(true, true, nodes);
if (memberName == null)
{
_isMulti = true;
return(node);
}
if (nodes[0] is ResourceExpressionNode)
{
return(GetResourceMember(node, memberName, nodes));
}
IBindingPath path = BindingPath.Create(memberName);
if (path.IsEmpty)
{
return(GetOrAddBindingMember(memberName, (s, i) => new BindingMemberExpressionNode(memberName, s, i)));
}
string firstMember = path.Parts[0];
if (_lamdaParameters.Contains(firstMember))
{
return(node);
}
return(GetOrAddBindingMember(memberName, (s, i) => new BindingMemberExpressionNode(memberName, s, i)));
}
public BindingContextSource(object source, IBindingMemberInfo member)
{
_member = member;
_observer = BindingServiceProvider
.ObserverProvider
.Observe(source, BindingPath.Create(member.Path), true);
_observer.Listener = this;
}
protected virtual ISingleBindingSourceAccessor GetAccessor(object model, string path, IDataContext context, bool isSource)
{
var observer = new MultiPathObserver(model, BindingPath.Create(path), false);
var source = isSource
? new BindingSource(observer)
: new BindingTarget(observer);
return(new BindingSourceAccessor(source, context, !isSource));
}
public void SourceShouldReturnPathFromObserver()
{
var mock = new ObserverMock();
BindingSource target = CreateBindingSource(mock);
target.Path.ShouldBeNull();
mock.Path = BindingPath.Create("test");
target.Path.ShouldEqual(mock.Path);
}
private IExpressionNode GetResourceMember(IExpressionNode node, string memberName, IList <IExpressionNode> nodes)
{
IExpressionNode staticValue;
if (_staticNodes.TryGetValue(node, out staticValue))
{
return(staticValue);
}
IBindingPath path = BindingPath.Create(memberName);
string firstMember = path.Parts[0];
Type type = BindingServiceProvider.ResourceResolver.ResolveType(firstMember, DataContext.Empty, false);
var dynMember = (ResourceExpressionNode)nodes[0];
if (dynMember.Dynamic && type == null)
{
memberName = BindingExtensions.MergePath(path.Parts.Skip(1).ToArray());
return(GetOrAddBindingMember("$" + path.Path, (s, i) => new BindingMemberExpressionNode(firstMember, memberName, s, i)));
}
bool dynamicMember = false;
IExpressionNode firstMemberNode = nodes[1];
if (!_staticNodes.TryGetValue(firstMemberNode, out staticValue))
{
if (type == null)
{
IBindingResourceObject resourceObject = BindingServiceProvider
.ResourceResolver
.ResolveObject(firstMember, DataContext.Empty, true);
var dynamicObject = resourceObject.Value as IDynamicObject;
if (dynamicObject == null || path.Parts.Count <= 1)
{
staticValue = new ConstantExpressionNode(resourceObject.Value, resourceObject.Type);
}
else
{
staticValue = new ConstantExpressionNode(dynamicObject.GetMember(path.Parts[1], Empty.Array <object>()));
dynamicMember = true;
}
}
else
{
staticValue = new ConstantExpressionNode(type, typeof(Type));
}
_staticNodes[firstMemberNode] = staticValue;
if (dynamicMember)
{
_staticNodes[nodes[2]] = staticValue;
}
}
if (firstMemberNode == node || (dynamicMember && node == nodes[2]))
{
return(staticValue);
}
return(node);
}
public static IBindingToSyntax Bind([NotNull] this IBindingBuilder builder, [NotNull] object target,
[NotNull] string targetPath)
{
Should.NotBeNull(builder, "builder");
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(targetPath, "targetPath");
builder.Add(BindingBuilderConstants.Target, target);
builder.Add(BindingBuilderConstants.TargetPath, BindingPath.Create(targetPath));
return(builder.GetOrAddSyntaxBuilder());
}
protected virtual ISingleBindingSourceAccessor GetAccessor(object model, string path, IDataContext context, bool isSource, Func<IDataContext, object> commandParameterDelegate = null)
{
var source = new MultiPathObserver(model, BindingPath.Create(path), false);
if (commandParameterDelegate != null)
{
context = context.ToNonReadOnly();
context.AddOrUpdate(BindingBuilderConstants.CommandParameter, commandParameterDelegate);
}
return new BindingSourceAccessor(source, context, !isSource);
}
public virtual void BindingShouldSuppressCycle()
{
var cycleItem1 = new CycleItem();
var cycleItem2 = new CycleItem();
var dataBinding = CreateDataBinding(
new BindingSourceAccessor(new SinglePathObserver(cycleItem1, BindingPath.Create("Property"), true),
DataContext.Empty, true),
new BindingSourceAccessor(new SinglePathObserver(cycleItem2, BindingPath.Create("Property"), true),
DataContext.Empty, false));
dataBinding.Behaviors.Add(new TwoWayBindingMode());
cycleItem2.Property = 10;
Tracer.Warn("Item1: {0}, Item2: {1}", cycleItem1.Property, cycleItem2.Property);
}
public virtual void BindingShouldBeRegisteredInBindingManager()
{
var target = new object();
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
DataBinding binding = CreateDataBinding(
new BindingSourceAccessorMock {
Source = new ObserverMock {
GetActualSource = b => target, Path = path
}
},
new BindingSourceAccessorMock(), bindingManager);
bindingManager.Register(target, path.Path, binding);
bindingManager.GetBindings(target).Single().ShouldEqual(binding);
bindingManager.GetBindings(target, path.Path).Single().ShouldEqual(binding);
}
public virtual void BindingShouldCorrectInitializeProperties()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
binding.TargetAccessor.ShouldEqual(target);
binding.SourceAccessor.ShouldEqual(source);
binding.Behaviors.ShouldBeEmpty();
}
public static object GetValueFromPath(object src, string strPath, int firstMemberIndex = 0)
{
IBindingPath path = BindingPath.Create(strPath);
for (int index = firstMemberIndex; index < path.Parts.Count; index++)
{
var item = path.Parts[index];
if (src == null)
{
return(null);
}
IBindingMemberInfo member = BindingServiceProvider
.MemberProvider
.GetBindingMember(src.GetType(), item, false, true);
src = member.GetValue(src, null);
}
return(src);
}
public virtual void BindingShouldAddSelfToDataContext()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
var dataContext = binding.Context;
dataContext.Count.ShouldEqual(1);
dataContext.GetData(BindingConstants.Binding).ShouldEqual(binding);
}
public virtual void BindingShouldNotAddSameBehavior()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
var first = new BindingBehaviorMock
{
Id = Guid.Empty,
Attach = binding1 => true
};
binding.Behaviors.Add(first);
ShouldThrow(() => binding.Behaviors.Add(first));
}
public virtual void BindingShouldThrowExceptionDuplicateIdBehavior()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new BindingSourceMock {
GetSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
var first = new BindingBehaviorMock {
Id = Guid.Empty, Attach = binding1 => true
};
var second = new BindingBehaviorMock {
Id = Guid.Empty, Attach = binding1 => true
};
binding.Behaviors.Add(first);
ShouldThrow(() => binding.Behaviors.Add(second));
}
protected virtual IObserver CreateObserver(object source, string path, bool ignoreContext,
IBindingMemberProvider memberProvider = null, IBindingContextManager contextManager = null)
{
if (memberProvider != null)
{
BindingServiceProvider.MemberProvider = memberProvider;
}
if (contextManager != null)
{
BindingServiceProvider.ContextManager = contextManager;
}
var bindingPath = BindingPath.Create(path);
if (bindingPath.IsEmpty)
{
return(new EmptyPathObserver(source, bindingPath));
}
if (bindingPath.IsSingle)
{
return(new SinglePathObserver(source, bindingPath, ignoreContext));
}
return(new MultiPathObserver(source, bindingPath, ignoreContext));
}
public virtual void BindingShouldNotAddBehaviorIfAttachReturnsFalse()
{
IBindingPath path = BindingPath.Create("test");
var bindingManager = new BindingManager();
var target = new BindingSourceAccessorMock
{
Source = new ObserverMock {
GetActualSource = b => new object(), Path = path
}
};
var source = new BindingSourceAccessorMock();
DataBinding binding = CreateDataBinding(target, source, bindingManager);
var first = new BindingBehaviorMock
{
Id = Guid.Empty,
Attach = binding1 => false
};
binding.Behaviors.Add(first);
binding.Behaviors.Count.ShouldEqual(0);
binding.Behaviors.Contains(first).ShouldBeFalse();
}
public void ManagerShouldClearBindingIfBindingIsRegistered()
{
const string path = "test";
var target = new object();
var bindingMock = new DataBindingMock
{
TargetAccessor = new BindingSourceAccessorMock
{
Source = new ObserverMock
{
Path = BindingPath.Create(path),
GetActualSource = b => target
}
}
};
var manager = GetBindingManager();
manager.Register(target, path, bindingMock);
manager.IsRegistered(bindingMock).ShouldBeTrue();
manager.Unregister(bindingMock);
manager.IsRegistered(bindingMock).ShouldBeFalse();
bindingMock.IsDisposed.ShouldBeTrue();
}
private static IObserver CreateSource(object model, string path)
{
return(new MultiPathObserver(model, BindingPath.Create(path), false));
}
private static IBindingSource CreateSource(object model, string path)
{
var observer = new MultiPathObserver(model, BindingPath.Create(path), false);
return(new BindingSource(observer));
}
/// <summary>
/// Updates the relative source value.
/// </summary>
public void UpdateSource([NotNull] object target)
{
if (target == null)
{
throw BindingExceptionManager.InvalidBindingTarget(RelativeSourceNode.Path);
}
var path = RelativeSourceNode.Path ?? String.Empty;
if (!String.IsNullOrEmpty(Path))
{
path = BindingExtensions.MergePath(path, Path);
}
if (RelativeSourceNode.Type != RelativeSourceExpressionNode.SelfType)
{
if (RelativeSourceNode.Type == RelativeSourceExpressionNode.MemberSourceType)
{
target = BindingServiceProvider.ContextManager.GetBindingContext(target);
}
else
{
target = new ParentSourceValue(target, RelativeSourceNode);
}
}
IObserver observer = BindingServiceProvider.ObserverProvider.Observe(target, BindingPath.Create(path), false);
_bindingSource = new BindingSource(observer);
}
public static IBindingModeInfoBehaviorSyntax ToSelf([NotNull] this IBindingToSyntax syntax,
[NotNull] string selfPath)
{
Should.NotBeNull(selfPath, "selfPath");
return(syntax.ToSource(context =>
{
object target = context.GetData(BindingBuilderConstants.Target, true);
return new BindingSource(BindingServiceProvider.ObserverProvider.Observe(target, BindingPath.Create(selfPath), false));
}));
}
public static IBindingModeInfoBehaviorSyntax To([NotNull] this IBindingToSyntax syntax,
[NotNull] string sourcePath)
{
Should.NotBeNull(sourcePath, "sourcePath");
return(syntax.ToSource(context =>
{
IBindingContext bindingContext = BindingServiceProvider
.ContextManager
.GetBindingContext(context.GetData(BindingBuilderConstants.Target, true),
context.GetData(BindingBuilderConstants.TargetPath, true).Path);
IObserver observer = BindingServiceProvider.ObserverProvider.Observe(bindingContext, BindingPath.Create(sourcePath),
false);
return new BindingSource(observer);
}));
}
public static IBindingModeInfoBehaviorSyntax To([NotNull] this IBindingToSyntax syntax, [NotNull] object source,
[NotNull] string sourcePath)
{
Should.NotBeNull(source, "source");
Should.NotBeNull(sourcePath, "sourcePath");
return(syntax.ToSource(context =>
{
IObserver observer = BindingServiceProvider.ObserverProvider.Observe(source, BindingPath.Create(sourcePath), false);
return new BindingSource(observer);
}));
}
protected virtual IBindingPath GetBindingPath(string path)
{
return(BindingPath.Create(path));
}
