Unit-Test ein angehängtes Verhalten wpf

Question

Ich bin immer noch grokking angehangenen Verhaltensweisen im Allgemeinen, und bin nicht in der Lage zu sehen, wie man einen Unit-Test für einen schreiben.

Ich habe etwas Code unten aus Sacha Barbers Cinch-Framework eingefügt, der es erlaubt, ein Fenster über angehängtes Verhalten zu schließen. Kann mir jemand einen Beispiel-Unit-Test zeigen?

Danke!
Berryl

#region Close 

    /// <summary>Dependency property which holds the ICommand for the Close event</summary> 
    public static readonly DependencyProperty CloseProperty = 
     DependencyProperty.RegisterAttached("Close", 
      typeof(ICommand), typeof(Lifetime), 
       new UIPropertyMetadata(null, OnCloseEventInfoChanged)); 

    /// <summary>Attached Property getter to retrieve the CloseProperty ICommand</summary> 
    public static ICommand GetClose(DependencyObject source) 
    { 
     return (ICommand)source.GetValue(CloseProperty); 
    } 

    /// <summary>Attached Property setter to change the CloseProperty ICommand</summary> 
    public static void SetClose(DependencyObject source, ICommand command) 
    { 
     source.SetValue(CloseProperty, command); 
    } 

    /// <summary>This is the property changed handler for the Close property.</summary> 
    private static void OnCloseEventInfoChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) 
    { 
     var win = sender as Window; 
     if (win == null) return; 

     win.Closing -= OnWindowClosing; 
     win.Closed -= OnWindowClosed; 

     if (e.NewValue == null) return; 

     win.Closing += OnWindowClosing; 
     win.Closed += OnWindowClosed; 
    } 

    /// <summary> 
    /// This method is invoked when the Window.Closing event is raised. 
    /// It checks with the ICommand.CanExecute handler 
    /// and cancels the event if the handler returns false. 
    /// </summary> 
    private static void OnWindowClosing(object sender, CancelEventArgs e) 
    { 
     var dpo = (DependencyObject)sender; 
     var ic = GetClose(dpo); 
     if (ic == null) return; 

     e.Cancel = !ic.CanExecute(GetCommandParameter(dpo)); 
    } 

    /// <summary> 
    /// This method is invoked when the Window.Closed event is raised. 
    /// It executes the ICommand.Execute handler. 
    /// </summary> 
    static void OnWindowClosed(object sender, EventArgs e) 
    { 
     var dpo = (DependencyObject)sender; 
     var ic = GetClose(dpo); 
     if (ic == null) return; 

     ic.Execute(GetCommandParameter(dpo)); 
    } 

    #endregion 

Answer 1

Sie würden wahrscheinlich eine Lambda in Ihrem ICommand mit einem DelegateCommand oder RelayCommand verwenden. Mehrere Implementierungen von diesen existieren überall und Cinch kann etwas ähnliches haben. Wirklich einfache Version (als Beispiel, nicht für den produktiven Einsatz gedacht):

public class DelegateCommand : ICommand { 
    private Action _execute = null; 

    public void Execute(object parameter) { 
     _execute(); 
    } 

    public DelegateCommand(Action execute) { 
     _execute = execute; 
    } 

    #region stuff that doesn't affect functionality 
    public bool CanExecute(object parameter) { 
     return true; 
    } 
    public event EventHandler CanExecuteChanged { 
     add { } 
     remove { } 
    } 
    #endregion 
} 

Dann wird Ihr Testkörper wie folgt aussehen könnte:

bool wascalled = false; 

var execute = new DelegateCommand(
    () => { 
     wascalled = true; 
    }); 

var window = new Window(); 
SomeClass.SetClose(window, execute); 

// does the window need to be shown for Close() to work? Nope. 

window.Close(); 

AssertIsTrue(wascalled); 

Dies ist eine stark vereinfachte Beispiel. Es gibt natürlich andere Tests, die Sie durchführen möchten. In diesem Fall sollten Sie eine vollständigere Implementierung von DelegateCommand erstellen oder finden, die unter anderem auch CanExecute ordnungsgemäß implementiert.

Answer 2

DependencyProperty verändern und Wert Zwang auf ihrem eigenen Aussehen wie 'Impossible Abhängigkeiten' für mich. Ein Verweis auf Windows macht die Sache noch schwieriger. Ich denke, dass ich hier mit Humble Object pattern gehen würde ...