Mocking static methods

I’m working on a pretty old application with no unit tests whatsoever, and I’m trying to write some as I add features and fix bugs.

After successively finding out about MS Fakes, then that it’s only included in VS2012+ Premium/Ultimate and very hard to include in a continuous integration chain, I was pretty stumped until I found this, which works incredibly well.

Another option to transform the static method into a static Func or Action. For instance.

Original code:

C#

class Math { public static int Add(int x, int y) { return x + y; } }

1
2
3
4
5
6
7
8

class Math
{
    public static int Add(int x, int y)
    {
        return x + y;
    }
}

You want to “mock” the Add method, but you can’t. Change the above code to this:

C#

public static Func<int, int, int> Add = (x, y) => { return x + y; };

1
2
3
4
5

public static Func<int, int, int> Add = (x, y) =>
{
    return x + y;
};

Existing client code doesn’t have to change (maybe recompile), but source stays the same.

Now, from the unit-test, to change the behavior of the method, just reassign an in-line function to it:

C#

[TestMethod] public static void MyTest() { Math.Add = (x, y) => { return 11; }; }

1
2
3
4
5
6
7
8
9

[TestMethod]
public static void MyTest()
{
    Math.Add = (x, y) =>
    {
        return 11;
    };
}

Put whatever logic you want in the method, or just return some hard-coded value, depending on what you’re trying to do.

This may not necessarily be something you can do each time, but in practice, I found this technique works just fine.

C, C++ and C++/CLI cheat sheet

No explanation of the basic concepts, just a memory help when you don’t use C/C++ frequently, or if you’re a beginner with some bases.

First question: why pointers? Answers: because functions arguments are passed by value in C and C++. Because arrays and strings are crazy in C.

How to read pointers

Here is a handy way of remembering how pointers syntax works.

In variable declaration

Go from the right to the left of the declaration, from the innermost parenthesis, going back to the right when hitting “)”

Read the name of the declaration
* is “a pointer to”
[] is “an array of”
() is “a function returning”
Finally, read the type

int *p[]; reads “p is an array of pointers to int”.
int *(*foo())(); reads “foo is a function returning a pointer to a function returning a pointer to int”.

In variable usage

Variable usage reads from left to right.

Determine “get” (read variable) or “set” (write variable)
* is “the value pointed to by”
& is “the address of”
[i] is “the element at position i”
Read the variable name

*p = 5;  reads “set the value pointed to by p”.
x = &i;  reads “get the address of i”.
printf("%i", *foo[0]);  reads “get the value pointed to by the element at position 0 of foo”.

C pointers

Manipulating a variable through a pointer is called dereferencing. It is used through an indirection expression.
Manipulating pointers through variables is called decaying.

Given an integer:

int i = 42;

1	int i = 42;

Create an pointer:

int* p = &i; // or int *p = &i; // preferred syntax

1
2
3

int* p = &i;
// or
int *p = &i; // preferred syntax
Get the memory location of the variable:

printf("%i", p); // or printf("%i", &i); // or pritf("%i", &*p); // get the address of the value pointed to by p

1
2
3
4
5

printf("%i", p);
// or
printf("%i", &i);
// or
pritf("%i", &*p); // get the address of the value pointed to by p
Get the value of the variable:

printf("%i", i); // or printf("%i", *p); // or printf("%i", *&*&*&*p); // if you want to be stupid

1
2
3
4
5

printf("%i", i);
// or
printf("%i", *p);
// or
printf("%i", *&*&*&*p); // if you want to be stupid
Set the value of the variable:

i = 42; // or *p = 42;

1
2
3

i = 42;
// or
*p = 42;
Setting a pointer to null allows to assign it to a variable later:

int *p = NULL; if (p) { // use *p }

1
2
3
4

int *p = NULL;
if (p) {
// use *p
}

C arrays

Arrays mostly can’t be manipulated directly, but rather through pointers.
The variable array is, for most intents and purposes, a pointer to the first element of the array (until it’s incremented).

Given an array of integers:

int array[] = { 45, 67, 89 };

1	int array[] = { 45, 67, 89 };

This doesn’t really creates an array. It creates 3 integers side-by-side, and stores the memory location of the first one.
array == &array == &array[0]
When you pass an array as an argument to a function, you really pass a pointer to the array’s first element, because the array decays to a pointer.
Incrementing a pointer to an array really moves the pointer to the next element of the array (the pointer is incremented by the size of the type of the pointer).

array++; // now the "array" pointer points to the second element.

1

array++; // now the "array" pointer points to the second element.
The subscript operator (the [] in array[0]) has nothing to do with arrays themselves, you can also use it on a pointer:

int *ar_p = array; printf("%i", ar_p[0]); // outputs the memory location of the first element printf("%i", *ar_p[0]); // outputs the value of the first element

1
2
3

int *ar_p = array;
printf("%i", ar_p[0]); // outputs the memory location of the first element
printf("%i", *ar_p[0]); // outputs the value of the first element

C structures

Given a structure:

struct foo {
  char name[10];
  int result;
};

struct foo f; // note you have to specify "struct" in the declaration

struct foo {

char name[10];

int result;

};

struct foo f; // note you have to specify "struct" in the declaration

Accessing members of the structure through the variable:

f.result = 42; printf("%i", f.result); // outputs "42"

1
2

f.result = 42;
printf("%i", f.result); // outputs "42"
Accessing the members through a pointer:

struct foo *p = f; (*p).result = 42; // or p->result = 42; // using a pointer-to-member operator

1
2
3
4

struct foo *p = f;
(*p).result = 42;
// or
p->result = 42; // using a pointer-to-member operator

C++ references

C++ is much less in love with pointers than C, and prefers using reference variables. They are mostly used in the same way as pointers, but their address can’t change (they always points to the same variable).
The main usage of a reference variable is for function parameters, to pass the variables by reference (by default it’s by value), which allows to not use pointers.

Given an integer:

int i = 42;

1	int i = 42;

Create a reference to a variable with int &r = i; ; this is called binding a reference to an object
You do not need to dereference a reference to access the variable’s value:

i = 42; // or int &r = i; r = 42; // should generate about the same machine code as int *p = i; *p = 42;

1
2
3
4
5
6
7
8

i = 42;
// or
int &r = i;
r = 42;

// should generate about the same machine code as
int *p = i;
*p = 42;
To make sure the arguments are passed by reference in a method:

void foo(int &bar) { bar = 42; } // call it with the variable itself int i = 0; foo(i); printf("%i", i); // outputs 42

1
2
3
4
5
6
7
8

void foo(int &bar) {
bar = 42;
}

// call it with the variable itself
int i = 0;
foo(i);
printf("%i", i); // outputs 42
On the other hand, the same method using pointers must be passed the variables by reference in the call:

void foo(int *bar) { *bar = 42; } // call it with the references to the variable foo(&i);

1
2
3
4
5
6

void foo(int *bar) {
*bar = 42;
}

// call it with the references to the variable
foo(&i);

Managed instances

Instances of managed objects should be used through handles ( ^ , also called “hat”). It can be read “is a handle to the instance of the managed class”. Then, you use the handle as if it was the actual instance.

Note that, even though you don’t have to use managed objects in C++/CLI, you have to declare instances of managed objects with a handle.

public ref class Foo {
  int result; // native member
  System::String^ name; // managed member
};

// while the convention for pointers is to prefix "*" to the pointer name,
// the convention for handles is to suffix "^" to the class name
Foo^ f = gcnew Foo();
printf("%s", f.name);

public ref class Foo {

int result; // native member

System::String^ name; // managed member

};

// while the convention for pointers is to prefix "*" to the pointer name,

// the convention for handles is to suffix "^" to the class name

Foo^ f = gcnew Foo();

printf("%s", f.name);

Managed pointers

Because of garbage collection (which changes memory addresses), you can’t just use a regular C/C++ pointer to a managed objects. The managed pointers are called interior pointers. A good overview can be found here.

The syntax for interior pointers is very… declarative:

interior_ptr<int> p = &f->result;

1	interior_ptr<int> p = &f->result;

Native pointers are automatically converted to interior pointers (the inverse is not true):

void foo(interior_ptr<int> i) {
  *i = 42;
}

foo(&f->result); // passing a native pointer to the method

void foo(interior_ptr<int> i) {

*i = 42;

}

foo(&f->result); // passing a native pointer to the method

As with pointers in C++, usage interior pointers is not recommended, and you should rather use managed references.

Managed references

A managed reference is called a tracking reference and uses % instead of & .

void foo(int %i) {
  i = 42;
}

foo(f->result);

void foo(int %i) {

i = 42;

}

foo(f->result);

Managed pointers and references have some weirdness, for which this SO post goes into further details.

C++/CLI wrapping a C library: cheatsheet

Because once in a while I write a C++/CLI wrapper around a C library, but since I do it so infrequently I forget everything each time. Here is a list of pointers (haha) for common pitfalls and problems.

Compiling and debugging

You have to wrap the .h into an #ifdef __cplusplus extern “C” :

#ifdef __cplusplus
extern "C" {
#endif

// contents of the .h file

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

extern "C" {

#endif

// contents of the .h file

#ifdef __cplusplus

}

#endif

You also need to remove the /clr option for C files.
Right click your C files > Properties > C/C++ > General > Common Language RunTime Support > No CLR Support.

In your managed class, to include an unmanaged C header, use managed(push|pop)

#pragma managed(push, off)
#include "../../map_packer/packer.h"
#pragma managed(pop)

#pragma managed(push, off)

#include "../../map_packer/packer.h"

#pragma managed(pop)

Because Linux and Windows get along so well, you may also have to redefine a few C methods in your header file.

// Only for Visual C++
#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".
// see: stackoverflow.com/a/24435157/2354542
#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method
// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers
// but there is no security concern in my library, so I don't care much
inline long int random() {
    return rand();
}
#endif

// Only for Visual C++

#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".

// see: stackoverflow.com/a/24435157/2354542

#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method

// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers

// but there is no security concern in my library, so I don't care much

inline long int random() {

return rand();

}

#endif

If you wish to create a C# unit test project (using xUnit for instance), with Visual Studio 2012 and later, you will have to do a few things:

In the C++/CLI project’s properties, in Debugging, choose the Debugger Type “Mixed”
In the Visual Studio options, Debugging, check “Managed C++ Compatibility Mode” (in VS2012) / “Use Managed Compatibility Mode” (in VS2013).

To build using MSBuild, you may have to change the toolset to VS2012: project properties > General > Platform Toolset = Visual Studio 2012 (v110). And set the Configuration Type to Dynamic Library (.dll) while you’re at it.

Managed and unmanaged objects

gcnew instantiates a managed objects, which will be garbage collected. Always use it for the managed objects.

To easily call the native structures through managed classes, use the internal constructor and ToNative methods.

Powershell for data mining Access databases into SQL Server

I need to do some data extraction from several hundreds of Access databases extracted from zip files. The extracted data will allow us to do some statistics on our customer’s behavior.
In order to do that, I decided to use Powershell, because it has all the features I need, bundled in one neat language.

The scaffolding for the scripts uses PSake for the task launcher, Pester for Powershell unit tests, and a few Nuget packages (including PSake).

In a vendor folder, add the Nuget exe, as well as a packages.config file listing the necessary Nuget packages. I have added PSake, and NUnitOrange to transform the Pester results to a nice HTML report.
I’m not using the Pester Nuget package because it includes the Pester unit tests, and some of them fail, which breaks my build (in addition to adding a thousand tests I don’t care about). Instead, I directly include the Pester scripts, and I cleaned up the samples and tests.

Since the script needs to read Access databases using some sort of ADODB or OLEDB provider, you will have to install either the Access 2007 or Access 2010 provider. If you’re like me (with Office x86 already installed), you won’t be able to install the Access 2010 x64 provider, which will trigger “The Jet/ACE OLEDB provider is not registered on the local machine” errors. So you will have to run the x86 version of Powershell. Which means you will have to use the x86 version of the SQLPS module (make sure you download the x86 version). Don’t worry, the SQL 2012 version of SQLPS is compatible with older SQL Servers (at least 2008 R2).

The batch bootstrapper is inspired by the bootstrapper from Pester:

@echo off

rem Install nuget packages
%~dp0vendor\nuget.exe Install %~dp0vendor\packages.config -o %~dp0packages

SET INPUT=%~dp0input
SET OUTPUT=%~dp0output
IF NOT '%1'=='' SET INPUT=%1
IF NOT '%2'=='' SET OUTPUT=%2

rem Detect 32 or 64 bits Windows: http://stackoverflow.com/a/24590583/6776
SET PSPATH=powershell
reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x86" > NUL && set OS=32BIT || set OS=64BIT
if %OS%==64BIT SET PSPATH=%SystemRoot%\syswow64\WindowsPowerShell\v1.0\powershell.exe

rem See: https://github.com/pester/Pester/blob/master/Build.bat
%PSPATH% -NoProfile -ExecutionPolicy Bypass -Command ^
    "$psakeDir = ([array](dir %~dp0packages\psake.*))[-1] ; Import-Module $psakeDir\tools\psake.psm1 ; Invoke-psake %~dp0tasks.ps1 Mining -properties @{'in'='%INPUT%';'out'='%OUTPUT%'}"

@echo off

rem Install nuget packages

%~dp0vendor\nuget.exe Install %~dp0vendor\packages.config -o %~dp0packages

SET INPUT=%~dp0input

SET OUTPUT=%~dp0output

IF NOT '%1'=='' SET INPUT=%1

IF NOT '%2'=='' SET OUTPUT=%2

rem Detect 32 or 64 bits Windows: http://stackoverflow.com/a/24590583/6776

SET PSPATH=powershell

reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x86" > NUL && set OS=32BIT || set OS=64BIT

if %OS%==64BIT SET PSPATH=%SystemRoot%\syswow64\WindowsPowerShell\v1.0\powershell.exe

rem See: https://github.com/pester/Pester/blob/master/Build.bat

%PSPATH% -NoProfile -ExecutionPolicy Bypass -Command ^

"$psakeDir = ([array](dir %~dp0packages\psake.*))[-1] ; Import-Module $psakeDir\tools\psake.psm1 ; Invoke-psake %~dp0tasks.ps1 Mining -properties @{'in'='%INPUT%';'out'='%OUTPUT%'}"

The tasks in tasks.ps1 are pretty standard and minimalist, so that the maximum is tested in modules via Pester.

Reading Access databases is as simple as using OleDb, old-school style:

function Read-AccessDataSet (
  [string] $file,
  [string] $query
)
{
    $conn = New-Object System.Data.OleDb.OleDbConnection "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=$file"
    $conn.Open()
    $cmd  = New-Object System.Data.OleDb.OleDbCommand($query, $conn)

    $adapter = New-Object System.Data.OleDb.OleDbDataAdapter $cmd
    $dataset = New-Object System.Data.DataSet
    $adapter.Fill($dataset) | Out-Null # returns the number of rows

    $conn.Close()

    return $dataset
}

function Read-AccessDataSet (

[string] $file,

[string] $query

)

{

$conn = New-Object System.Data.OleDb.OleDbConnection "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=$file"

$conn.Open()

$cmd = New-Object System.Data.OleDb.OleDbCommand($query, $conn)

$adapter = New-Object System.Data.OleDb.OleDbDataAdapter $cmd

$dataset = New-Object System.Data.DataSet

$adapter.Fill($dataset) | Out-Null # returns the number of rows

$conn.Close()

return $dataset

}

And the corresponding Pester tests, using actual Access test databases:

$here = Split-Path -Parent $MyInvocation.MyCommand.Path

Import-Module "$here\db.psm1" -Force

Describe "database module" {
    $in = Resolve-Path "$here\..\tests\input"

    Context "reading Access DB" {
        It "should read multiple Access rows" {
            (Read-AccessDataSet -file "$in\input.dat" -query "SELECT * FROM Users").Tables[0].Rows.Count | Should Be 10
        }
    }
}

$here = Split-Path -Parent $MyInvocation.MyCommand.Path

Import-Module "$here\db.psm1" -Force

Describe "database module" {

$in = Resolve-Path "$here\..\tests\input"

Context "reading Access DB" {

It "should read multiple Access rows" {

(Read-AccessDataSet -file "$in\input.dat" -query "SELECT * FROM Users").Tables[0].Rows.Count | Should Be 10

}

Executing SQL scripts uses the much more powerful Invoke-SqlCmd cmdlet from the SQLPS module. The most is that it returns a Powershell object, so I can do something like this:

$users = Invoke-SqlCommand -query "SELECT * FROM users"

foreach ($user in $users) {
  write "id: $($user.id) ; name: $($user.name)"
}

$users = Invoke-SqlCommand -query "SELECT * FROM users"

foreach ($user in $users) {

write "id: $($user.id) ; name: $($user.name)"

}

WPF Behaviors: adding mouse-event adorners

This is part 3 of the WPF drag & drop exploration. Part 2 can be found here.

Let’s recap what we have right now. We have a sample application that allow us to freely drag items across an area. Now, since there might be multiple items stacking on top of each other, we want the user to be sure which item will be moved. For that, we want to add a visual indication on the item. This kind of stuff is called an adorner in WPF.

Now, you will see many samples of code-driven adorners implementation. But we don’t want to break the MVVM pattern, and to do that, we want the adorner to be implemented in the view.

So we’ll create an Adorner that allows us to use a DataTemplate. For that, I’ll just copy some existing code :

public class TemplateAdorner : Adorner
{
    private readonly FrameworkElement frameworkElementAdorner;

    public TemplateAdorner(UIElement adornedElement, FrameworkElement frameworkElementAdorner) : base(adornedElement)
    {
        this.frameworkElementAdorner = frameworkElementAdorner;
        this.AddVisualChild(frameworkElementAdorner);
        this.AddLogicalChild(frameworkElementAdorner);
    }

    protected override int VisualChildrenCount { get { return 1; } }

    protected override Size ArrangeOverride(Size finalSize)
    {
        this.frameworkElementAdorner.Arrange(new Rect(new Point(0, 0), finalSize));
        return finalSize;
    }

    protected override Visual GetVisualChild(int index) { return this.frameworkElementAdorner; }

    protected override Size MeasureOverride(Size constraint)
    {
        this.frameworkElementAdorner.Width = constraint.Width;
        this.frameworkElementAdorner.Height = constraint.Height;

        return constraint;
    }
}

public class TemplateAdorner : Adorner

{

private readonly FrameworkElement frameworkElementAdorner;

public TemplateAdorner(UIElement adornedElement, FrameworkElement frameworkElementAdorner) : base(adornedElement)

{

this.frameworkElementAdorner = frameworkElementAdorner;

this.AddVisualChild(frameworkElementAdorner);

this.AddLogicalChild(frameworkElementAdorner);

}

protected override int VisualChildrenCount { get { return 1; } }

protected override Size ArrangeOverride(Size finalSize)

{

this.frameworkElementAdorner.Arrange(new Rect(new Point(0, 0), finalSize));

return finalSize;

}

protected override Visual GetVisualChild(int index) { return this.frameworkElementAdorner; }

protected override Size MeasureOverride(Size constraint)

{

this.frameworkElementAdorner.Width = constraint.Width;

this.frameworkElementAdorner.Height = constraint.Height;

return constraint;

}

We can now use this adorner in the behavior.

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
    // the mouse over adorner template property
    public static readonly DependencyProperty MouseOverAdornerTemplateProperty =
        DependencyProperty.Register(
            "MouseOverAdornerTemplate",
            typeof(DataTemplate),
            typeof(DragOnCanvasBehavior),
            new PropertyMetadata(new PropertyChangedCallback((d, o) =>
            {
                if (((DragOnCanvasBehavior)d).mouseOverAdornerControl != null)
                {
                    ((DragOnCanvasBehavior)d).mouseOverAdornerControl.ContentTemplate = (DataTemplate)o.NewValue;
                }
            })));
    
    // the template
    public DataTemplate MouseOverAdornerTemplate
    {
        get { return (DataTemplate)this.GetValue(MouseOverAdornerTemplateProperty); }
        set { this.SetValue(MouseOverAdornerTemplateProperty, value); }
    }

    // stores the adorner instance
    private TemplateAdorner mouseOverAdorner;

    // stores the visual control
    private ContentControl mouseOverAdornerControl;

    // whether the adorner is initialized
    private bool mouseOverAdornerInitialized = false;

    // whether the adorner is shown
    private bool mouseOverAdornerShown = false;

    // the commands to hide/show the adorner
    public ICommand HideMouseOverAdorner { get; private set; }
    public ICommand ShowMouseOverAdorner { get; private set; }

    // binds the commands with the methods
    public DragOnCanvasBehavior()
    {
        // [...]

        this.ShowMouseOverAdorner = new RelayCommand((o) =>
        {
            this.OnShowMouseOverAdorner();
        });

        this.HideMouseOverAdorner = new RelayCommand((o) =>
        {
            this.OnHideMouseOverAdorner();
        });
    }

    // shows the adorner
    private void OnShowMouseOverAdorner()
    {
        if (this.mouseOverAdornerShown)
        {
            return;
        }

        this.InitializeAdorner(this.MouseOverAdornerTemplate, ref this.mouseOverAdornerControl, ref this.mouseOverAdorner, ref this.mouseOverAdornerInitialized);

        this.mouseOverAdornerControl.Visibility = Visibility.Visible;
        this.mouseOverAdornerShown = true;
    }

    // hides the adorner
    private void OnHideMouseOverAdorner()
    {
        this.mouseOverAdornerControl.Visibility = Visibility.Collapsed;
        this.mouseOverAdornerShown = false;
    }

    // initializes an adorner (we'll need to reuse this later on)
    private void InitializeAdorner(DataTemplate template, ref ContentControl control, ref TemplateAdorner adorner, ref bool initialized)
    {
        if (initialized)
        {
            return;
        }

        if (template != null)
        {
            AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this.AssociatedObject as UIElement);

            if (adornerLayer == null)
            {
                throw new NullReferenceException(string.Format("No adorner found in attached object: {0}", this.AssociatedObject));
            }

            control = new ContentControl();
            adornerLayer.Add(adorner = new TemplateAdorner(this.AssociatedObject as UIElement, control));
            control.Content = template.LoadContent();

            Binding bindingMargin = new Binding("AdornerMargin");
            bindingMargin.Source = this;
            BindingOperations.SetBinding(adorner, ContentControl.MarginProperty, bindingMargin);
        }

        var dataContext = (this.AssociatedObject as FrameworkElement).DataContext;
        if (control.DataContext == null)
        {
            control.DataContext = dataContext;
        }

        control.Visibility = Visibility.Collapsed;

        initialized = true;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

// the mouse over adorner template property

public static readonly DependencyProperty MouseOverAdornerTemplateProperty =

DependencyProperty.Register(

"MouseOverAdornerTemplate",

typeof(DataTemplate),

typeof(DragOnCanvasBehavior),

new PropertyMetadata(new PropertyChangedCallback((d, o) =>

{

if (((DragOnCanvasBehavior)d).mouseOverAdornerControl != null)

{

((DragOnCanvasBehavior)d).mouseOverAdornerControl.ContentTemplate = (DataTemplate)o.NewValue;

}

})));

// the template

public DataTemplate MouseOverAdornerTemplate

{

get { return (DataTemplate)this.GetValue(MouseOverAdornerTemplateProperty); }

set { this.SetValue(MouseOverAdornerTemplateProperty, value); }

}

// stores the adorner instance

private TemplateAdorner mouseOverAdorner;

// stores the visual control

private ContentControl mouseOverAdornerControl;

// whether the adorner is initialized

private bool mouseOverAdornerInitialized = false;

// whether the adorner is shown

private bool mouseOverAdornerShown = false;

// the commands to hide/show the adorner

public ICommand HideMouseOverAdorner { get; private set; }

public ICommand ShowMouseOverAdorner { get; private set; }

// binds the commands with the methods

public DragOnCanvasBehavior()

{

// [...]

this.ShowMouseOverAdorner = new RelayCommand((o) =>

{

this.OnShowMouseOverAdorner();

});

this.HideMouseOverAdorner = new RelayCommand((o) =>

{

this.OnHideMouseOverAdorner();

});

}

// shows the adorner

private void OnShowMouseOverAdorner()

{

if (this.mouseOverAdornerShown)

{

return;

}

this.InitializeAdorner(this.MouseOverAdornerTemplate, ref this.mouseOverAdornerControl, ref this.mouseOverAdorner, ref this.mouseOverAdornerInitialized);

this.mouseOverAdornerControl.Visibility = Visibility.Visible;

this.mouseOverAdornerShown = true;

}

// hides the adorner

private void OnHideMouseOverAdorner()

{

this.mouseOverAdornerControl.Visibility = Visibility.Collapsed;

this.mouseOverAdornerShown = false;

}

// initializes an adorner (we'll need to reuse this later on)

private void InitializeAdorner(DataTemplate template, ref ContentControl control, ref TemplateAdorner adorner, ref bool initialized)

{

if (initialized)

{

return;

}

if (template != null)

{

AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this.AssociatedObject as UIElement);

if (adornerLayer == null)

{

throw new NullReferenceException(string.Format("No adorner found in attached object: {0}", this.AssociatedObject));

}

control = new ContentControl();

adornerLayer.Add(adorner = new TemplateAdorner(this.AssociatedObject as UIElement, control));

control.Content = template.LoadContent();

Binding bindingMargin = new Binding("AdornerMargin");

bindingMargin.Source = this;

BindingOperations.SetBinding(adorner, ContentControl.MarginProperty, bindingMargin);

}

var dataContext = (this.AssociatedObject as FrameworkElement).DataContext;

if (control.DataContext == null)

{

control.DataContext = dataContext;

}

control.Visibility = Visibility.Collapsed;

initialized = true;

}

Now, we just need to create the adorner’s DataTemplate, and wire up the events. We just have to add an AdornerDecorator in the controls tree, otherwise the adorner may get a random behavior (it would be attached to the window), or not work at all.

<ItemsControl.ItemTemplate>
    <DataTemplate>
        <AdornerDecorator>
            <Border
                x:Name="DraggableBorder">
                <!-- contents -->

                <i:Interaction.Behaviors>
                    <behaviors:DragOnCanvasBehavior
                        DraggableItem="{Binding}">
                        <behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>
                            <DataTemplate>
                                <Border
                                    DataContext="DraggableBorder"
                                    BorderBrush="Black"
                                    BorderThickness="3"
                                    Width="{Binding Path=Width}"
                                    Height="{Binding Path=Height}"></Border>
                            </DataTemplate>
                        </behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

                        <i:Interaction.Triggers>
                            <!-- Dragging events -->

                            <i:EventTrigger EventName="MouseEnter">
                                <i:InvokeCommandAction CommandName="ShowMouseOverAdorner" />
                            </i:EventTrigger>
                            <i:EventTrigger EventName="MouseLeave">
                                <i:InvokeCommandAction CommandName="HideMouseOverAdorner" />
                            </i:EventTrigger>
                        </i:Interaction.Triggers>
                    </behaviors:DragOnCanvasBehavior>
                </i:Interaction.Behaviors>
            </Border>
        </AdornerDecorator>
    </DataTemplate>
</ItemsControl.ItemTemplate>

<ItemsControl.ItemTemplate>

<Border

x:Name="DraggableBorder">

<i:Interaction.Behaviors>

<behaviors:DragOnCanvasBehavior

DraggableItem="{Binding}">

<behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

<Border

DataContext="DraggableBorder"

BorderBrush="Black"

BorderThickness="3"

Width="{Binding Path=Width}"

Height="{Binding Path=Height}"></Border>

</DataTemplate>

</behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

<i:Interaction.Triggers>

<i:EventTrigger EventName="MouseEnter">

<i:InvokeCommandAction CommandName="ShowMouseOverAdorner" />

</i:EventTrigger>

<i:EventTrigger EventName="MouseLeave">

<i:InvokeCommandAction CommandName="HideMouseOverAdorner" />

</i:EventTrigger>

</i:Interaction.Triggers>

</behaviors:DragOnCanvasBehavior>

</i:Interaction.Behaviors>

</Border>

</AdornerDecorator>

</DataTemplate>

</ItemsControl.ItemTemplate>

Note that from the adorner’s DataTemplate, we set the DataContext property, so that we can bind the adorner’s properties directly to the ones of the item view model.

Now, on mouse-over, a black border will appear, and will disappear when the mouse leaves. There are a few problems with this method: most notably, the adorner flickers when the mouse stays over it. But we’ll try to tackle them later on.

WPF Behaviors: switching to Windows.Interactivity.Behavior

This is part 2 of the WPF drag & drop exploration. Part 1 can be found here. Among other things, this CodeProject sample helped me much.

Yesterday I created a WPF behavior following WPF conventions for custom dependency properties. While trying to add an adorner to my item (more on that later), I noticed many samples were using System.Windows.Interactivity.Behavior<T>, which I thought was Blend-related, but apparently is not. Because it is much more concise to write and provides useful overridable methods, I decided to switch to it instead.
In addition, with the previous code, I had a problem when defining multiple dependency properties on my behavior, so I needed to find a way to solve this also.

The first thing is of course to inherit from Behavior<T>. You will find it in the System.Windows.Interactivity namespace, which is not included in .Net. You can grab it through the Blend SDK, in a Nuget package, or it’s included in MVVM frameworks like Caliburn.Micro or MVVM Light.

using System.Windows.Interactivity;

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
}

using System.Windows.Interactivity;

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

}

Then, we can remove the Getxxx and Setxxx methods, and replace them with an actual property (that does the same thing). We can also access the behavior instance from the dependency property variable, so we don’t need the instance singleton anymore. We will, however, need to attach the mouse events to the draggable item through ICommands. Since there are no standard ICommand implementation that we can use, we must create one ourselves. I have copied a “standard” implementation from CodeProject, and you will find many similar implementations if you do a quick Google search:

public class RelayCommand : ICommand
{
    private readonly Predicate<object> canExecute;
    private readonly Action<object> execute;

    public RelayCommand(Action<object> execute) : this(execute, DefaultCanExecute)
    {
    }

    public RelayCommand(Action<object> execute, Predicate<object> canExecute)
    {
        if (execute == null)
        {
            throw new ArgumentNullException("execute");
        }

        if (canExecute == null)
        {
            throw new ArgumentNullException("canExecute");
        }

        this.execute = execute;
        this.canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add
        {
            CommandManager.RequerySuggested += value;
        }
        remove
        {
            CommandManager.RequerySuggested -= value;
        }
    }

    public bool CanExecute(object parameter)
    {
        return this.canExecute != null && this.canExecute(parameter);
    }

    public void Execute(object parameter)
    {
        this.execute(parameter);
    }

    private static bool DefaultCanExecute(object parameter)
    {
        return true;
    }
}

public class RelayCommand : ICommand

{

private readonly Predicate<object> canExecute;

private readonly Action<object> execute;

public RelayCommand(Action<object> execute) : this(execute, DefaultCanExecute)

{

}

public RelayCommand(Action<object> execute, Predicate<object> canExecute)

{

if (execute == null)

{

throw new ArgumentNullException("execute");

}

if (canExecute == null)

{

throw new ArgumentNullException("canExecute");

}

this.execute = execute;

this.canExecute = canExecute;

}

public event EventHandler CanExecuteChanged

{

add

{

CommandManager.RequerySuggested += value;

}

remove

{

CommandManager.RequerySuggested -= value;

}

public bool CanExecute(object parameter)

{

return this.canExecute != null && this.canExecute(parameter);

}

public void Execute(object parameter)

{

this.execute(parameter);

}

private static bool DefaultCanExecute(object parameter)

{

return true;

}

This command will be the bridge between the view and the other layers of the application.

Now, on to inheriting from Behavior<T>. You will notice that I have changed a few names here and there, because they weren’t reflecting the reality of the application anymore: IDragDropHandler becomes IDraggable ; the DropHandler property becomes DraggableItem. I also have replaced the mouse event names with descriptive names (OnStartDrag instead of “mouse button down”), especially since we will now be able to bind these handlers to any event.

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
    // this registers the DraggableItem property on the behavior
    public static readonly DependencyProperty DraggableItemProperty =
        DependencyProperty.RegisterAttached(
            "DraggableItem",
            typeof(IDraggable),
            typeof(DragOnCanvasBehavior),
            new PropertyMetadata(new PropertyChangedCallback((d, e) =>
            {
                ((DragOnCanvasBehavior)d).draggable = (IDraggable)e.NewValue;
            })));

    // stores the draggable item instance for further access
    private IDraggable draggable;

    // replaces the Getxxx and Setxxx methods
    public IDraggable DraggableItem
    {
        get
        {
            return (IDraggable)this.GetValue(DraggableItemProperty);
        }
        set
        {
            this.SetValue(DraggableItemProperty, value);
        }
    }

    // define the commands available to the view
    public ICommand Dragging { get; private set; }
    public ICommand StartDrag { get; private set; }
    public ICommand StopDrag { get; private set; }

    // defines what the available commands will do
    public DragOnCanvasBehavior()
    {
        this.StartDrag = new RelayCommand((o) =>
        {
            this.OnStartDrag();
        });

        this.StopDrag = new RelayCommand((o) =>
        {
            this.OnStopDrag();
        });

        this.Dragging = new RelayCommand((o) =>
        {
            this.OnDragging();
        });
    }

    // actually handle the events
    private void OnDragging() {}
    private void OnStartDrag() {}
    private void OnStopDrag() {}
}

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

// this registers the DraggableItem property on the behavior

public static readonly DependencyProperty DraggableItemProperty =

DependencyProperty.RegisterAttached(

"DraggableItem",

typeof(IDraggable),

typeof(DragOnCanvasBehavior),

new PropertyMetadata(new PropertyChangedCallback((d, e) =>

{

((DragOnCanvasBehavior)d).draggable = (IDraggable)e.NewValue;

})));

// stores the draggable item instance for further access

private IDraggable draggable;

// replaces the Getxxx and Setxxx methods

public IDraggable DraggableItem

{

get

{

return (IDraggable)this.GetValue(DraggableItemProperty);

}

set

{

this.SetValue(DraggableItemProperty, value);

}

// define the commands available to the view

public ICommand Dragging { get; private set; }

public ICommand StartDrag { get; private set; }

public ICommand StopDrag { get; private set; }

// defines what the available commands will do

public DragOnCanvasBehavior()

{

this.StartDrag = new RelayCommand((o) =>

{

this.OnStartDrag();

});

this.StopDrag = new RelayCommand((o) =>

{

this.OnStopDrag();

});

this.Dragging = new RelayCommand((o) =>

{

this.OnDragging();

});

}

// actually handle the events

private void OnDragging() {}

private void OnStartDrag() {}

private void OnStopDrag() {}

}

You will notice that we don’t attach the commands to any particular item event anymore. This is because it’s handled by the view. It kind of makes sense, because a different device may have a different method of dragging. The rest of the view can be found in part 1.

<ItemsControl.ItemTemplate>
    <DataTemplate>
        <Border>
            <!-- contents -->

            <i:Interaction.Behaviors>
                <behaviors:DragOnCanvasBehavior DraggableItem="{Binding}">
                    <i:Interaction.Triggers>
                        <i:EventTrigger EventName="PreviewMouseLeftButtonDown">
                            <i:InvokeCommandAction CommandName="StartDrag" />
                        </i:EventTrigger>
                        <i:EventTrigger EventName="PreviewMouseLeftButtonUp">
                            <i:InvokeCommandAction CommandName="StopDrag" />
                        </i:EventTrigger>
                        <i:EventTrigger EventName="PreviewMouseMove">
                            <i:InvokeCommandAction CommandName="Dragging" />
                        </i:EventTrigger>
                    </i:Interaction.Triggers>
                </behaviors:DragOnCanvasBehavior>
            </i:Interaction.Behaviors>
        </Border>
    </DataTemplate>
</ItemsControl.ItemTemplate>

<ItemsControl.ItemTemplate>

<i:Interaction.Behaviors>

<behaviors:DragOnCanvasBehavior DraggableItem="{Binding}">

<i:Interaction.Triggers>

<i:EventTrigger EventName="PreviewMouseLeftButtonDown">

<i:InvokeCommandAction CommandName="StartDrag" />

</i:EventTrigger>

<i:EventTrigger EventName="PreviewMouseLeftButtonUp">

<i:InvokeCommandAction CommandName="StopDrag" />

</i:EventTrigger>

<i:EventTrigger EventName="PreviewMouseMove">

<i:InvokeCommandAction CommandName="Dragging" />

</i:EventTrigger>

</i:Interaction.Triggers>

</behaviors:DragOnCanvasBehavior>

</i:Interaction.Behaviors>

</Border>

</DataTemplate>

</ItemsControl.ItemTemplate>

The events handlers are also similar to the ones in part 1. The only difference is that they access the item through Behavior<T> properties. For instance :

private void OnStartDrag()
{
    // use Mouse.GetPosition() to get the mouse coordinates
    this.mouseStartPosition = Mouse.GetPosition(Application.Current.MainWindow);

    // cast this.AssociatedObject to get the item control
    ((UIElement)this.AssociatedObject).CaptureMouse();
}

private void OnStartDrag()

{

// use Mouse.GetPosition() to get the mouse coordinates

this.mouseStartPosition = Mouse.GetPosition(Application.Current.MainWindow);

// cast this.AssociatedObject to get the item control

((UIElement)this.AssociatedObject).CaptureMouse();

}

That’s it! Your behavior event handlers are now linked through the view, which means better testing, and better flexibility.

WPF Drag&drop items in a canvas: communicate between behavior and ViewModel

The source code of the sample application is available at GitHub. It has been strongly inspired by Gong WPF DragDrop and has started life as a copy of another “WPF behavior lab”.

The final goal of the application is to allow a user to freely drag an item in a canvas, and that the items “snap” among themselves, so that the user can align them easily. I’m taking it as an opportunity to learn more about WPF.

The first thing I had to learn was how to create and use custom behaviors. They allow to bind elements from the View into the ViewModel using custom properties.
In “pure” WPF (Blend has different behavior conventions), a behavior is a regular class, with a few conventions to declare a custom property. It is called a Dependency Property. It’s pretty easy to bind a simple value (boolean, integer…), examples are plentiful.

Now, in the view, I want to say “when the user moves this item, this method should be run”, because I want not only the item to move, but also the container to compare the item’s new position to its neighbors. A custom property can be anything a variable can be, but not a method. So, to circumvent this, the behavior must be aware of the ViewModel, but obviously we don’t want to strongly link the behavior with the ViewModel.

The ViewModel will have to implement an interface
The View will be bound to this ViewModel through {Binding}
The Behavior will use this interface’s methods to send messages to the ViewModel

public class DragOnCanvasBehavior
{
    // This declares a "DropHandler" property that we will be able to use in the view
    // The name (xxxProperty) and variable modifiers (public static reaonly) must follow the proper conventions
    public static readonly DependencyProperty DropHandlerProperty =
        DependencyProperty.RegisterAttached(
            "DropHandler",
            typeof(IDragDropHandler),
            typeof(DragOnCanvasBehavior),
            new PropertyMetadata(OnDropHandlerChanged));

    // This will actually "link" to the ViewModel, which should implement IDragDropHandler
    private IDragDropHandler DropHandler { get; set; }

    // This is a convention-required method (Getxxx)
    // It will retrieve the property's value
    public static IDragDropHandler GetDropHandler(UIElement target)
    {
        return (IDragDropHandler)target.GetValue(DropHandlerProperty);
    }

    // This is a convention-required method (Setxxx)
    // It will set the property's value
    public static void SetDropHandler(UIElement target, IDragDropHandler value)
    {
        target.SetValue(DropHandlerProperty, value);
    }

    // This called using the callback of the xxxProperty (overload of DependencyProperty.RegisterAttached)
    // It will be run when the value is changed (meaning that Setxxx might be run multiple times with the same value)
    private static void OnDropHandlerChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        // cast the usable elements
        UIElement element = (UIElement)sender;
        IDragDropHandler handler = (IDragDropHandler)(e.NewValue);

        // we can now use the elements.
        // for instance, we can assign handlers to the UIElement:
        element.MouseLeftButtonDown += Whatever;
    }
}

public class DragOnCanvasBehavior

{

// This declares a "DropHandler" property that we will be able to use in the view

// The name (xxxProperty) and variable modifiers (public static reaonly) must follow the proper conventions

public static readonly DependencyProperty DropHandlerProperty =

DependencyProperty.RegisterAttached(

"DropHandler",

typeof(IDragDropHandler),

typeof(DragOnCanvasBehavior),

new PropertyMetadata(OnDropHandlerChanged));

// This will actually "link" to the ViewModel, which should implement IDragDropHandler

private IDragDropHandler DropHandler { get; set; }

// This is a convention-required method (Getxxx)

// It will retrieve the property's value

public static IDragDropHandler GetDropHandler(UIElement target)

{

return (IDragDropHandler)target.GetValue(DropHandlerProperty);

}

// This is a convention-required method (Setxxx)

// It will set the property's value

public static void SetDropHandler(UIElement target, IDragDropHandler value)

{

target.SetValue(DropHandlerProperty, value);

}

// This called using the callback of the xxxProperty (overload of DependencyProperty.RegisterAttached)

// It will be run when the value is changed (meaning that Setxxx might be run multiple times with the same value)

private static void OnDropHandlerChanged(object sender, DependencyPropertyChangedEventArgs e)

{

// cast the usable elements

UIElement element = (UIElement)sender;

IDragDropHandler handler = (IDragDropHandler)(e.NewValue);

// we can now use the elements.

// for instance, we can assign handlers to the UIElement:

element.MouseLeftButtonDown += Whatever;

}

The IDragDropHandler interface is very simple. The Moved method will notify the ViewModel that the item has been moved, and the Dropped method that the mouse button has been released.

public interface IDragDropHandler
{
    void Dropped();
    void Moved(double x, double y);
}

public interface IDragDropHandler

{

void Dropped();

void Moved(double x, double y);

}

Now, the behavior will use these methods. To do that, we need to create mouse click and move handlers and assign them to the UIElement. Because the OnxxxChanged method is static, but the click/move handlers are not, we need a way to “memorize” the handlers. We’ll do that through a singleton instance:

public class DragOnCanvasBehavior
{
    // we'll use this singleton instance of the behavior to access the DropHandler and the mouse events
    private static DragOnCanvasBehavior Instance = new DragOnCanvasBehavior();

    // initialize the instance and attach events to the element
    private static void OnDropHandlerChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        UIElement element = (UIElement)sender;
        IDragDropHandler handler = (IDragDropHandler)(e.NewValue);

        // re-initialize the singleton (otherwise different items will have the same behavior)
        Instance = new DragOnCanvasBehavior();
        // attach the handler to the singleton
        Instance.DropHandler = handler;

        // attach or detach the handler to the element
        // remember that the handler can be removed at run-time, so we need handle null values
        if (Instance.DropHandler != null)
        {
            element.MouseLeftButtonDown += Instance.ElementOnMouseLeftButtonDown;
            element.MouseLeftButtonUp += Instance.ElementOnMouseLeftButtonUp;
            element.MouseMove += Instance.ElementOnMouseMove;
        }
        else
        {
            element.MouseLeftButtonDown -= Instance.ElementOnMouseLeftButtonDown;
            element.MouseLeftButtonUp -= Instance.ElementOnMouseLeftButtonUp;
            element.MouseMove -= Instance.ElementOnMouseMove;
        }
    }

    // when the user starts dragging
    private void ElementOnMouseLeftButtonDown(object sender, MouseButtonEventArgs mouseButtonEventArgs)
    {
        // save the mouse position on button down
        // we only want a diff of the mouse position so we don't care much about which element we use as reference
        this.mouseStartPosition = this.GetMousePositionFromMainWindow(mouseButtonEventArgs);
        ((UIElement)sender).CaptureMouse();
    }

    // when the user stops dragging
    private void ElementOnMouseLeftButtonUp(object sender, MouseButtonEventArgs mouseButtonEventArgs)
    {
        UIElement element = (UIElement)sender;
        element.ReleaseMouseCapture();

        // Send a message to the viewmodel that the mouse button has been released
        if (this.DropHandler != null)
        {
            this.DropHandler.Dropped();
        }
    }

    // while the user is dragging
    private void ElementOnMouseMove(object sender, MouseEventArgs mouseEventArgs)
    {
        // don't do anything if no button is clicked (or there is no handler)
        if (!((UIElement)sender).IsMouseCaptured || this.DropHandler == null)
        {
            return;
        }

        // calculate element movement
        Point mouseNewPos = this.GetMousePositionFromMainWindow(mouseEventArgs);
        Vector movement = (mouseNewPos - this.mouseStartPosition);

        // make sure the mouse has moved since last time we were here
        // (the MouseMove is run in loop while the button is clicked, even if the mouse isn't moving)
        if (movement.Length > 0)
        {
            // save current mouse position
            this.mouseStartPosition = mouseNewPos;
            
            // save the element movement
            Point elementNewPos = this.elementPosition + movement; 
            this.elementPosition = elementNewPos;

            // notify the viewmodel that the element has been moved
            this.DropHandler.Moved(elementNewPos.X, elementNewPos.Y);
        }
    }

    // get the mouse position relative to the main window
    private Point GetMousePositionFromMainWindow(MouseEventArgs mouseEventArgs)
    {
        Window mainWindow = Application.Current.MainWindow;
        return mouseEventArgs.GetPosition(mainWindow);
    }
}

public class DragOnCanvasBehavior

{

// we'll use this singleton instance of the behavior to access the DropHandler and the mouse events

private static DragOnCanvasBehavior Instance = new DragOnCanvasBehavior();

// initialize the instance and attach events to the element

private static void OnDropHandlerChanged(object sender, DependencyPropertyChangedEventArgs e)

{

UIElement element = (UIElement)sender;

IDragDropHandler handler = (IDragDropHandler)(e.NewValue);

// re-initialize the singleton (otherwise different items will have the same behavior)

Instance = new DragOnCanvasBehavior();

// attach the handler to the singleton

Instance.DropHandler = handler;

// attach or detach the handler to the element

// remember that the handler can be removed at run-time, so we need handle null values

if (Instance.DropHandler != null)

{

element.MouseLeftButtonDown += Instance.ElementOnMouseLeftButtonDown;

element.MouseLeftButtonUp += Instance.ElementOnMouseLeftButtonUp;

element.MouseMove += Instance.ElementOnMouseMove;

}

else

{

element.MouseLeftButtonDown -= Instance.ElementOnMouseLeftButtonDown;

element.MouseLeftButtonUp -= Instance.ElementOnMouseLeftButtonUp;

element.MouseMove -= Instance.ElementOnMouseMove;

}

// when the user starts dragging

private void ElementOnMouseLeftButtonDown(object sender, MouseButtonEventArgs mouseButtonEventArgs)

{

// save the mouse position on button down

// we only want a diff of the mouse position so we don't care much about which element we use as reference

this.mouseStartPosition = this.GetMousePositionFromMainWindow(mouseButtonEventArgs);

((UIElement)sender).CaptureMouse();

}

// when the user stops dragging

private void ElementOnMouseLeftButtonUp(object sender, MouseButtonEventArgs mouseButtonEventArgs)

{

UIElement element = (UIElement)sender;

element.ReleaseMouseCapture();

// Send a message to the viewmodel that the mouse button has been released

if (this.DropHandler != null)

{

this.DropHandler.Dropped();

}

// while the user is dragging

private void ElementOnMouseMove(object sender, MouseEventArgs mouseEventArgs)

{

// don't do anything if no button is clicked (or there is no handler)

if (!((UIElement)sender).IsMouseCaptured || this.DropHandler == null)

{

return;

}

// calculate element movement

Point mouseNewPos = this.GetMousePositionFromMainWindow(mouseEventArgs);

Vector movement = (mouseNewPos - this.mouseStartPosition);

// make sure the mouse has moved since last time we were here

// (the MouseMove is run in loop while the button is clicked, even if the mouse isn't moving)

if (movement.Length > 0)

{

// save current mouse position

this.mouseStartPosition = mouseNewPos;

// save the element movement

Point elementNewPos = this.elementPosition + movement;

this.elementPosition = elementNewPos;

// notify the viewmodel that the element has been moved

this.DropHandler.Moved(elementNewPos.X, elementNewPos.Y);

}

// get the mouse position relative to the main window

private Point GetMousePositionFromMainWindow(MouseEventArgs mouseEventArgs)

{

Window mainWindow = Application.Current.MainWindow;

return mouseEventArgs.GetPosition(mainWindow);

}

Now, the behavior is notifying the ViewModel that it is being moved. Let’s handle the movement:

// I'm using Fody.PropertyChanged to implement INotifyProperyChanged
// I'm also using Caliburn.Micro as MVVM framwork

[ImplementPropertyChanged]
public class ItemViewModel : PropertyChangedBase, IDragDropHandler
{
    private readonly IEventAggregator events;

    public ItemViewModel(IEventAggregator events)
    {
        this.events = events;
        this.events.Subscribe(this);

        this.Width = 100;
        this.Height = 100;
        this.X = 0;
        this.Y = 0;
    }

    public int Height { get; set; }
    public int Width { get; set; }
    public double X { get; set; }
    public double Y { get; set; }

    public void Dropped()
    {
      // TODO: do something (probably publish an event)
    }

    public void Moved(double x, double y)
    {
        this.X = x;
        this.Y = y;

        // Notify the container that the item is moved, so that it can calculate snapping
        this.events.PublishOnUIThread(new ItemMovedEvent(this.X, this.Y, this.Width, this.Height, this.ID));
    }
}

// I'm using Fody.PropertyChanged to implement INotifyProperyChanged

// I'm also using Caliburn.Micro as MVVM framwork

[ImplementPropertyChanged]

public class ItemViewModel : PropertyChangedBase, IDragDropHandler

{

private readonly IEventAggregator events;

public ItemViewModel(IEventAggregator events)

{

this.events = events;

this.events.Subscribe(this);

this.Width = 100;

this.Height = 100;

this.X = 0;

this.Y = 0;

}

public int Height { get; set; }

public int Width { get; set; }

public double X { get; set; }

public double Y { get; set; }

public void Dropped()

{

// TODO: do something (probably publish an event)

}

public void Moved(double x, double y)

{

this.X = x;

this.Y = y;

// Notify the container that the item is moved, so that it can calculate snapping

this.events.PublishOnUIThread(new ItemMovedEvent(this.X, this.Y, this.Width, this.Height, this.ID));

}

Now that we have a ViewModel that know when it’s being moved, let’s actually allow the user to move it. First, let’s write a container for the items:

[ImplementPropertyChanged]
public class MainViewModel : PropertyChangedBase, IHandle<ItemMovedEvent>
{
    private readonly IEventAggregator events;

    public MainViewModel(IEventAggregator events)
    {
        this.events = events;
        this.events.Subscribe(this);

        this.Items = new BindableCollection<ItemViewModel>();
    }

    // the items displayed on the canvas
    public BindableCollection<ItemViewModel> Items { get; set; }

    // adds an item to the collection
    public void AddItem()
    {
        this.Items.Add(new ItemViewModel(this.events));
    }

    // fired when an item has been moved
    public void Handle(ItemMovedEvent message)
    {
        // TODO: handle snapping to other elements
    }
}

[ImplementPropertyChanged]

public class MainViewModel : PropertyChangedBase, IHandle<ItemMovedEvent>

{

private readonly IEventAggregator events;

public MainViewModel(IEventAggregator events)

{

this.events = events;

this.events.Subscribe(this);

this.Items = new BindableCollection<ItemViewModel>();

}

// the items displayed on the canvas

public BindableCollection<ItemViewModel> Items { get; set; }

// adds an item to the collection

public void AddItem()

{

this.Items.Add(new ItemViewModel(this.events));

}

// fired when an item has been moved

public void Handle(ItemMovedEvent message)

{

// TODO: handle snapping to other elements

}

Then the view (I’m removing things like styling for brevity). Note that it follows Caliburn.Micro conventions on naming (among other things), so it automatically binds some things, like the ItemsControl items through its name.

<UserControl xmlns:cal="http://www.caliburnproject.org"
             xmlns:behaviors="clr-namespace:DragSnap.Behaviors">
    <Grid>
        <Button
            Content="Add an item to the canvas"
            cal:Message.Attach="[Event Click] = [Action AddItem()]" />

        <ItemsControl x:Name="Items">
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <Canvas />
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
            <ItemsControl.ItemContainerStyle>
                <!-- This is what actually moves the items in the canvas -->
                <Style TargetType="ContentPresenter">
                    <Setter Property="Canvas.Left" Value="{Binding Path=X}" />
                    <Setter Property="Canvas.Top" Value="{Binding Path=Y}" />
                    <Setter Property="Width" Value="{Binding Path=Width}" />
                    <Setter Property="Height" Value="{Binding Path=Height}" />
                </Style>
            </ItemsControl.ItemContainerStyle>
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <!-- The {Binding} binds the property's value to the ViewModel itself -->
                    <Border behaviors:DragOnCanvasBehavior.DropHandler="{Binding}">
                        <!-- Whatever content you want -->
                    </Border>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </Grid>
</UserControl>

<UserControl xmlns:cal="http://www.caliburnproject.org"

xmlns:behaviors="clr-namespace:DragSnap.Behaviors">

<Grid>

<Button

Content="Add an item to the canvas"

cal:Message.Attach="[Event Click] = [Action AddItem()]" />

<ItemsControl.ItemsPanel>

</ItemsPanelTemplate>

</ItemsControl.ItemsPanel>

<ItemsControl.ItemContainerStyle>

</Style>

</ItemsControl.ItemContainerStyle>

<ItemsControl.ItemTemplate>

</Border>

</DataTemplate>

</ItemsControl.ItemTemplate>

</ItemsControl>

</Grid>

</UserControl>

To summarize:

The behavior is attached to the item’s viewmodel from the view
The behavior memorizes the item instance through the IDragDropHandler interface, and assigns mouse events to the item
The mouse events call the IDragDropHandler methods
The item’s viewmodel implements these methods and handles coordinates changes itself (which are visually updated through binding in the view)
The item viewmodel notifies the container viewmodel of its coordinates changes through Caliburn.Micro events

Unit testing your Powershell scripts using Pester

In order to stabilize our middle office, we need to test it. Not that it’s buggy, but hey, testing is good.

We have a huge 500-lines script that processes PDF files through a bunch of programs. We need to test a few things:

Every step and each piece of the code must be working
The configuration files must be properly read
The proper programs must be run in the proper order
The processed PDFs must look like what we’re expecting

To do that, we have a lot of work to do.

There is a series of great articles on Pester on PowerShell Magazine.

Refactor your script

First, we need to extract the methods and code blocks we will test. Our script is not that hard to refactor into a bunch of methods, since it’s pretty well organized so far. A simple refactor will simply be moving a bunch of independent code blocks into methods, regrouped and externalized by feature.

Prefer using modules to do that. Create your methods into .psm1 files. It will allow you to just Import-Module mymodule.psm1 and use it the same way as if you were dot-sourcing your file (. .\myfile.ps1), but will allow you to do more awesome things later; for instance, you can get the list of available commands through Get-Command -Module mymodule, get the comment-based help of your module methods through Get-Help my-module-method, get tab-expansion on your methods, etc.

If you’re not sure how to refactor your script to extract units of work, I can’t really help you there, and you should go learn more about unit testing; there are a lot of places where you can do that.

Unit Test your extracted code

There is an awesome unit test and BDD tool called Pester. Download the latest nuget package into your scripts directory by running nuget install pester. PsGet also has a Pester package, but including the Pester files with your sources (or a way to get them like with Nuget) is very important if you intend to run your tests on a continuous integration platform, especially if you externalize them on a service like AppVeyor.

Create a _run_tests.ps1 file (or whatever your naming convention calls for), with the very simple following contents:

$here = Split-Path -Parent $MyInvocation.MyCommand.Path
Import-Module "$here\Pester\Pester.psm1"
Invoke-Pester

$here = Split-Path -Parent $MyInvocation.MyCommand.Path

Import-Module "$here\Pester\Pester.psm1"

Invoke-Pester

Invoke-Pester will run all the “*.Tests.ps1” files it finds in the current directory. Unfortunately, the Pester Nuget package comes with the Pester tests, and it’s pretty annoying to see the thousands of unit tests in the middle of yours. You can either not use Invoke-Pester and roll your own “look for *.Tests.ps1 file except in the Pester folder” method, or (like I did) forget about nuget update pester and remove the test files from the Pester folder.

To create unit test files, you can either write them manually, or use the New-Fixture module command, which will create both a file to contain your methods, and a test file to test your methods. If you’re working with modules, you will not really be able to use the power of this command, but if you’re creating a new script, it will provide you with a BDD workflow.

Your test file for your module will look like this:

$here = Split-Path -Parent $MyInvocation.MyCommand.Path
$root = "$here\..\.."
Import-Module "$root\modules\mail.psm1" -Force

Describe "mail" {
    Context "config file is provided" {
        It "gets sender from the config" {
            (Read-MailConfig -configFile "$here\mail.Tests.config").from | Should Be "test@example.com"
        }

        It "gets client from the config" {
            (Read-MailConfig -configFile "$here\mail.Tests.config").client.Host | Should Be "smtp.gmail.com"
        }

        It "gets login from the config" {
            (Read-MailConfig -configFile "$here\mail.Tests.config").client.Credentials.UserName | Should Be "testlogin"
        }
    }

    Context "config file is missing" {
        It "throws an error when no config is passed" {
            { Read-MailConfig } | Should Throw
        }
    }
}

$here = Split-Path -Parent $MyInvocation.MyCommand.Path

$root = "$here\..\.."

Import-Module "$root\modules\mail.psm1" -Force

Describe "mail" {

Context "config file is provided" {

It "gets sender from the config" {

(Read-MailConfig -configFile "$here\mail.Tests.config").from | Should Be "test@example.com"

}

It "gets client from the config" {

(Read-MailConfig -configFile "$here\mail.Tests.config").client.Host | Should Be "smtp.gmail.com"

}

It "gets login from the config" {

(Read-MailConfig -configFile "$here\mail.Tests.config").client.Credentials.UserName | Should Be "testlogin"

}

Context "config file is missing" {

It "throws an error when no config is passed" {

{ Read-MailConfig } | Should Throw

}

As you can see, for now I’m using a custom config files with the expected values filled. This is not the best way to unit test, so we’re going to use mocking.

Mock the system methods

Here is the true power of Pester and Powershell: the ability to mock system methods. Your method reads files from the disk? No problem. Just provide an alternative implementation and you don’t have to setup a bunch of test data and config files.

My Read-MailConfig looks like this:

function Read-MailConfig (
	[string]$configFile
)
{
	if (($configFile -eq $null) -or ($configFile -eq "")) {
		throw "Mandatory config file to read"
	}

	$config = @{}
	[xml]$MainConfigEmail = Get-Content $configFile
	$config.from = $MainConfigEmail.infos.email.from
	$config.client = New-Object Net.Mail.SmtpClient($MainConfigEmail.infos.email.server)
	# further configure the client

	return (New-Object PsObject -Property $config)
}

function Read-MailConfig (

[string]$configFile

)

{

if (($configFile -eq $null) -or ($configFile -eq "")) {

throw "Mandatory config file to read"

}

$config = @{}

[xml]$MainConfigEmail = Get-Content $configFile

$config.from = $MainConfigEmail.infos.email.from

$config.client = New-Object Net.Mail.SmtpClient($MainConfigEmail.infos.email.server)

# further configure the client

return (New-Object PsObject -Property $config)

}

So, there is a Get-Content method that I want to mock and control its return value. I can now modify my test so that the values used by my test are right next to them:

Describe "mail" {
    Context "config file is provided" {
        Mock&nbsp;-ModuleName mail Get-Content { "<infos><email><from>test@example.com</from><server>smtp.gmail.com</server><login>testlogin</login><pass>password</pass></email></infos>" }

        It "gets sender from the config" {
            (Read-MailConfig -configFile "whatever.config").from | Should Be "test@example.com"
        }
    }
}

Describe "mail" {

Context "config file is provided" {

Mock -ModuleName mail Get-Content { "<infos><email><from>test@example.com</from><server>smtp.gmail.com</server><login>testlogin</login><pass>password</pass></email></infos>" }

It "gets sender from the config" {

(Read-MailConfig -configFile "whatever.config").from | Should Be "test@example.com"

}

Note the usage of -ModuleName mail in the Mock call: modules have their own scope (which is not the case of plain dot-sourced script files), and so need a bit more work to inject mocks.

My mail module actually sends emails through the System.Net.Mail classes, but Pester can’t mock .Net objects (note that .Net mocking frameworks can’t mock most system classes either).

In order to bypass that, we’re going to extract the .Net object calls into separate methods doing only that, we’re going to mock this extraction, and not test the .Net method call:

# Sends an error email to the ones in the config file
function Send-ErrorMessage(
  [string]$Title,
  [string]$Body
)
{
  $config = Read-MailConfig -configFile ".\general.config"

  try {
    $message = New-Object System.Net.Mail.MailMessage($config.from, $config.from, $Title, $Body)
    # configure $message

    Send-Mail -client $config.client -message $message
  } catch {
    # handle exception
  }
}

# sends an email
function Send-Mail(
  [Net.Mail.SmtpClient]$client,
  [Net.Mail.MailMessage]$message
)
{
  $client.send($message)
}

# Sends an error email to the ones in the config file

function Send-ErrorMessage(

[string]$Title,

[string]$Body

)

{

$config = Read-MailConfig -configFile ".\general.config"

try {

$message = New-Object System.Net.Mail.MailMessage($config.from, $config.from, $Title, $Body)

# configure $message

Send-Mail -client $config.client -message $message

} catch {

# handle exception

}

# sends an email

function Send-Mail(

[Net.Mail.SmtpClient]$client,

[Net.Mail.MailMessage]$message

)

{

$client.send($message)

}

And the test:

Context "sends an email" {
    Mock -ModuleName mail Send-Mail { return "Success" }
    Mock -ModuleName mail Read-MailConfig {
        $config = @{}
        $config.client = $null
        $config.from = "test@example.com"
        return $config
    }

    It "sends an error message" {
        Send-ErrorMessage -Title "test" -Body "test" | Should Be "Success"
    }
}

Context "sends an email" {

Mock -ModuleName mail Send-Mail { return "Success" }

Mock -ModuleName mail Read-MailConfig {

$config = @{}

$config.client = $null

$config.from = "test@example.com"

return $config

}

It "sends an error message" {

Send-ErrorMessage -Title "test" -Body "test" | Should Be "Success"

}

Use TestDrive to test file system processes

If you need to test for complex file access, mocking system methods will quickly become too hard. For instance, I need to test two methods: one that removes files older than X days, and one that removes empty folders. Using TestDrive is much more straightforward, simple and compact than mocking the Get-ChildItem cmdlet:

Describe "cleanup module" {
    Context "folder has old and new files" {
        New-item "TestDrive:\old.txt" -Type file
        # change the file creation date
        $oldFile = Get-Item "TestDrive:\old.txt"
        $oldFile.CreationTime = (Get-Date).AddDays(-3)
        New-item "TestDrive:\new.txt" -Type file

        It "removes the old files" {
            Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)
            Test-Path "TestDrive:\old.txt" | Should Be $false
        }

        It "leaves the new files" {
            Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)
            Test-Path "TestDrive:\new.txt" | Should Be $true
        }
    }

    Context "folders doesn't have old files" {
        New-item "TestDrive:\new1.txt" -Type file
        New-item "TestDrive:\new2.txt" -Type file

        It "does nothing" {
            Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)
            Test-Path "TestDrive:\new1.txt" | Should Be $true
            Test-Path "TestDrive:\new2.txt" | Should Be $true
        }
    }

    Context "path has empty folders" {
        New-item "TestDrive:\empty" -Type directory

        It "removes the folder" {
            Remove-EmptyFolders -path "TestDrive:"
            Test-Path "TestDrive:\empty" | Should Be $false
        }
    }

    Context "path does not have empty folders" {
        New-item "TestDrive:\notempty" -Type directory
        New-item "TestDrive:\notempty\file.txt" -Type file

        It "does not removes the folder" {
            Remove-EmptyFolders -path "TestDrive:"
            Test-Path "TestDrive:\notempty" | Should Be $true
        }
    }
}

Describe "cleanup module" {

Context "folder has old and new files" {

New-item "TestDrive:\old.txt" -Type file

# change the file creation date

$oldFile = Get-Item "TestDrive:\old.txt"

$oldFile.CreationTime = (Get-Date).AddDays(-3)

New-item "TestDrive:\new.txt" -Type file

It "removes the old files" {

Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)

Test-Path "TestDrive:\old.txt" | Should Be $false

}

It "leaves the new files" {

Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)

Test-Path "TestDrive:\new.txt" | Should Be $true

}

Context "folders doesn't have old files" {

New-item "TestDrive:\new1.txt" -Type file

New-item "TestDrive:\new2.txt" -Type file

It "does nothing" {

Remove-OldFiles -path "TestDrive:" -olderThan (Get-Date).AddDays(-2)

Test-Path "TestDrive:\new1.txt" | Should Be $true

Test-Path "TestDrive:\new2.txt" | Should Be $true

}

Context "path has empty folders" {

New-item "TestDrive:\empty" -Type directory

It "removes the folder" {

Remove-EmptyFolders -path "TestDrive:"

Test-Path "TestDrive:\empty" | Should Be $false

}

Context "path does not have empty folders" {

New-item "TestDrive:\notempty" -Type directory

New-item "TestDrive:\notempty\file.txt" -Type file

It "does not removes the folder" {

Remove-EmptyFolders -path "TestDrive:"

Test-Path "TestDrive:\notempty" | Should Be $true

}

Unit testing custom querystring-based authorization on a WebApi controller

I needed to add a very simple authorization mechanism to my API: use a query string parameter “api_key”, so that it’s compatible with Swagger (using Swashbuckle, there is a field “api_key” in the Swagger UI) and is easily callable through Ruby On Rails.

Following and adapting a nice tutorial, I have done the following.

Implement the authorization filter

Create an interface for your API key “getter”:

public interface IApiKeyProvider
{
    string GetApiKey();
}

public interface IApiKeyProvider

{

string GetApiKey();

}

Implement this interface; here it’s extremely simple:

public class WebConfigApiKeyProvider : IApiKeyProvider
{
    public string GetApiKey()
    {
        return ConfigurationManager.AppSettings["api_key"];
    }
}

public class WebConfigApiKeyProvider : IApiKeyProvider

{

public string GetApiKey()

{

return ConfigurationManager.AppSettings["api_key"];

}

Inject this interface through your dependency injector of choice. You don’t have to modify your controllers, which is great.

Then create a filter attribute to use this implementation:

public class ApiKeyAuthorizeAttribute : ActionFilterAttribute
{
    private const string apiKeyParamName = "api_key";

    public override void OnActionExecuting(HttpActionContext filterContext)
    {
        // get the IApiKeyProvider instance that has been injected (oh MVC4 that provides a dependency resolver, I love you)
        var provider = filterContext.ControllerContext.Configuration.DependencyResolver.GetService(typeof(IApiKeyProvider)) as IApiKeyProvider;
        // get the query string parameter ;
        // it must be parsed from the full query, since it's not actually part of the action, but an additional parameter
        var queryStringCollection = HttpUtility.ParseQueryString(filterContext.Request.RequestUri.Query);
        string apiKey = queryStringCollection[apiKeyParamName];

        if (string.IsNullOrEmpty(apiKey) || apiKey != provider.GetApiKey())
        {
            throw new HttpResponseException(HttpStatusCode.Unauthorized);
        }

        base.OnActionExecuting(filterContext);
    }
}

public class ApiKeyAuthorizeAttribute : ActionFilterAttribute

{

private const string apiKeyParamName = "api_key";

public override void OnActionExecuting(HttpActionContext filterContext)

{

// get the IApiKeyProvider instance that has been injected (oh MVC4 that provides a dependency resolver, I love you)

var provider = filterContext.ControllerContext.Configuration.DependencyResolver.GetService(typeof(IApiKeyProvider)) as IApiKeyProvider;

// get the query string parameter ;

// it must be parsed from the full query, since it's not actually part of the action, but an additional parameter

var queryStringCollection = HttpUtility.ParseQueryString(filterContext.Request.RequestUri.Query);

string apiKey = queryStringCollection[apiKeyParamName];

if (string.IsNullOrEmpty(apiKey) || apiKey != provider.GetApiKey())

{

throw new HttpResponseException(HttpStatusCode.Unauthorized);

}

base.OnActionExecuting(filterContext);

}

Now you just have to add the [ApiKeyAuthorize] attribute to your controller(s), and you now need to add the proper api_key query string parameter to all your requests.

Test the filter

A few things to test: that your class uses this attribute, and that the attribute does what it says it does.

Test the attribute presence

Here I’m using XUnit and FluentAssertions.
It’s just a matter of listing the attributes on the class, and checking that an attribute matching the one created exists.

[Fact]
public void Archives_controller_has_attribute()
{
    var attributes = typeof(ArchivesController).GetCustomAttributes(true);
    attributes.Count().Should().BeGreaterThan(0, "because there should be at least an attribute");
    var attribute = attributes.OfType<ApiKeyAuthorizeAttribute>().Single();
    attribute.Should().NotBeNull("because there should be an IApiKeyProvider on the archives controller");
}

[Fact]

public void Archives_controller_has_attribute()

{

var attributes = typeof(ArchivesController).GetCustomAttributes(true);

attributes.Count().Should().BeGreaterThan(0, "because there should be at least an attribute");

var attribute = attributes.OfType<ApiKeyAuthorizeAttribute>().Single();

attribute.Should().NotBeNull("because there should be an IApiKeyProvider on the archives controller");

}

Test the attribute inner workings

What are we testing there? That the attribute throws a HttpResponseException when no parameter exists or when the value is wrong, and that it doesn’t throw an exception when it matches.

Setup the tests

Using XUnit and Moq, the test setup looks like this:

private ApiKeyAuthorizeAttribute attribute = new ApiKeyAuthorizeAttribute();
private HttpActionContext context = ContextUtil.CreateActionContext();
private Mock<IStorageModel> storageModelMock = new Mock<IStorageModel>();
private Mock<IApiKeyProvider> apiKeyProviderMock = new Mock<IApiKeyProvider>();

public ApiKeyAuthorizeAttributeTests()
{
    apiKeyProviderMock.Setup(p => p.GetApiKey()).Returns("abc");
    storageModelMock.Setup(s => s.CreationArchived(It.IsAny<string>())).Returns(true);
    storageModelMock.Setup(s => s.CreationArchives(It.IsAny<string>())).Returns(new List<Archive>());
    storageModelMock.Setup(s => s.ListArchives(It.IsAny<int>(), It.IsAny<int>())).Returns(new List<Archive>());
    InjectionSetup.Register(context.ControllerContext.Configuration, storageModelMock.Object, apiKeyProviderMock.Object);
}

private ApiKeyAuthorizeAttribute attribute = new ApiKeyAuthorizeAttribute();

private HttpActionContext context = ContextUtil.CreateActionContext();

private Mock<IStorageModel> storageModelMock = new Mock<IStorageModel>();

private Mock<IApiKeyProvider> apiKeyProviderMock = new Mock<IApiKeyProvider>();

public ApiKeyAuthorizeAttributeTests()

{

apiKeyProviderMock.Setup(p => p.GetApiKey()).Returns("abc");

storageModelMock.Setup(s => s.CreationArchived(It.IsAny<string>())).Returns(true);

storageModelMock.Setup(s => s.CreationArchives(It.IsAny<string>())).Returns(new List<Archive>());

storageModelMock.Setup(s => s.ListArchives(It.IsAny<int>(), It.IsAny<int>())).Returns(new List<Archive>());

InjectionSetup.Register(context.ControllerContext.Configuration, storageModelMock.Object, apiKeyProviderMock.Object);

}

The ContextUtil.CreateActionContext method can be picked from the ASP.Net source. The corresponding tests can be found here.

My InjectionSetup.Register is a unit-test-specific injection that allows to use a specific instance instead of creating one, here using LightInject:

public static void Register(HttpConfiguration config, IStorageModel storageModel, IApiKeyProvider apiKeyProvider)
{
    var container = new ServiceContainer();
    container.Register<IStorageModel>((factory) => storageModel);
    container.Register<IApiKeyProvider>((factory) => apiKeyProvider);
    container.RegisterApiControllers();
    container.EnableWebApi(config);
}

public static void Register(HttpConfiguration config, IStorageModel storageModel, IApiKeyProvider apiKeyProvider)

{

var container = new ServiceContainer();

container.Register<IStorageModel>((factory) => storageModel);

container.Register<IApiKeyProvider>((factory) => apiKeyProvider);

container.RegisterApiControllers();

container.EnableWebApi(config);

}

Test the attribute

Still using XUnit and FluentAssertions, three simple tests allow to check that the responses are what is expected:

[Fact]
public void Missing_key_throws_error()
{
    context.Request.RequestUri = new Uri("http://localhost/api/archives");
    Action act = () => attribute.OnActionExecuting(context);
    act.ShouldThrow<HttpResponseException>("because a non-authorized action should throw an exception").And.Response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, "because the request should not be authorized");
}

[Fact]
public void Wrong_key_throws_error()
{
    context.Request.RequestUri = new Uri("http://localhost/api/archives?api_key=wrong");
    Action act = () => attribute.OnActionExecuting(context);
    act.ShouldThrow<HttpResponseException>("because a wrong API key should throw an exception").And.Response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, "because the request should not be authorized");
}

[Fact]
public void Right_key_passes()
{
    context.Request.RequestUri = new Uri("http://localhost/api/archives?api_key=abc");
    Action act = () => attribute.OnActionExecuting(context);
    act.ShouldNotThrow<HttpResponseException>("because an authorized action should not throw an exception");
}

[Fact]

public void Missing_key_throws_error()

{

context.Request.RequestUri = new Uri("http://localhost/api/archives");

Action act = () => attribute.OnActionExecuting(context);

act.ShouldThrow<HttpResponseException>("because a non-authorized action should throw an exception").And.Response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, "because the request should not be authorized");

}

[Fact]

public void Wrong_key_throws_error()

{

context.Request.RequestUri = new Uri("http://localhost/api/archives?api_key=wrong");

Action act = () => attribute.OnActionExecuting(context);

act.ShouldThrow<HttpResponseException>("because a wrong API key should throw an exception").And.Response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, "because the request should not be authorized");

}

[Fact]

public void Right_key_passes()

{

context.Request.RequestUri = new Uri("http://localhost/api/archives?api_key=abc");

Action act = () => attribute.OnActionExecuting(context);

act.ShouldNotThrow<HttpResponseException>("because an authorized action should not throw an exception");

}

Testing Entity Framework layer in database-first mode

In your app, you may have a “query” layer, where all your Linq queries are regrouped. If you don’t, you should. Having your queries inside your controller leads to poor testing and strong coupling.

You will want to test that your queries return what they say they return. In order to do that, you need to mock your Entity Framework entities container.

There is an awesome and complete tutorial here, explaining everything.

If you’re stuck on Visual Studio 2010, you will need to do a few things: first, download and install the ADO.NET DbContext Generator code template, so that your entities use the DbSet type. Then, open your Entity Framework container, right click inside and select “Add a code generation element” (or something like that, my VS is not in english) and select the DbContext elements you just downloaded. You will then be able to customize the way your entities are generated (awesome tool).

In all Visual Studio versions, if you’re not using code-first like the tutorial, you will have to modify the template generation to mark your entities list as virtual (so that they can be mocked). Open your xxx.Context.tt file, find the line with DbSet<<#=Code.Escape(entitySet.ElementType)#>> and add virtual in front of it. Now you can check out the generated xxx.Context.cs file to be sure it’s not doing crazy things.

While you’re at it, since you’re modifying the code templates, follow these awesome instructions to xml-document your generated entities.

Now, following the MSDN article, in your query tests (the ones returning a set of data), you will have to manually create the data to return, and “bind” it to the mock instance. Since you will have to do that in each of your query tests, don’t forget to extract it to a method:

/// <summary>
/// Sets up the mock set of entities to be used in tests
/// </summary>
/// <typeparam name="T">The type of the entities</typeparam>
/// <param name="mockSet">The mock set of entities to configure</param>
/// <param name="data">The data to use</param>
private void SetupMockEntities<T>(Mock mockSet, IQueryable<T> data)
{
    mockSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(data.Provider);
    mockSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(data.Expression);
    mockSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(data.ElementType);
    mockSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
}

/// <summary>

/// Sets up the mock set of entities to be used in tests

/// </summary>

/// <typeparam name="T">The type of the entities</typeparam>

/// <param name="mockSet">The mock set of entities to configure</param>

/// <param name="data">The data to use</param>

private void SetupMockEntities<T>(Mock mockSet, IQueryable<T> data)

{

mockSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(data.Provider);

mockSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(data.Expression);

mockSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(data.ElementType);

mockSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

}

Code musings in C#

Mocking static methods

C, C++ and C++/CLI cheat sheet

How to read pointers

In variable declaration

In variable usage

C pointers

C arrays

C structures

C++ references

Managed instances

Managed pointers

Managed references

Further readings

C++/CLI wrapping a C library: cheatsheet

Compiling and debugging

Managed and unmanaged objects

Powershell for data mining Access databases into SQL Server

WPF Behaviors: adding mouse-event adorners

WPF Behaviors: switching to Windows.Interactivity.Behavior

WPF Drag&drop items in a canvas: communicate between behavior and ViewModel

Unit testing your Powershell scripts using Pester

Refactor your script

Unit Test your extracted code

Mock the system methods

Use TestDrive to test file system processes

Unit testing custom querystring-based authorization on a WebApi controller

Implement the authorization filter

Test the filter

Test the attribute presence

Test the attribute inner workings

Setup the tests

Test the attribute

Testing Entity Framework layer in database-first mode