Question

I am developing a WPF application with the MVVM pattern.

I know that the MVVM pattern is good to seprate the GUI and the logic of the application, so I can test the GUI and the logic independently.

However, if I need to send some messages to the user, is it a good idea to use a messageBox or not? Because I am reading about some solutions, all of them try to implement a new view a its view model… etc. But I don’t see very well the utility.

I mean that if I want to notify something to the user, my results depends on the decision of the user, how can I separate my tests (GUI and logic)? What is the benefit of not using directly a messageBox instead a new view with the viewmodel and all the extra work that this requiered? Because in both cases my results depends of the user decision. How can I test my application in this case?

Answer 1

Because I am reading about some solutions, all of them try to
implement a new view a its view model… etc. But I don’t see very
well the utility.

How do you unit test a method which is opening message boxes?

What if the specification changes and you need to use a different (custom) message box, or even only log an error (to be displayed in a summary report later on)? Then you need to find and replace each and every msgBox.Show call.

I mean that if I want to notify something to the user, my results
depends on the decision of the user, how can I separate my tests (GUI
and logic)?

By creating an event, which is triggered when you need a decision to be made. Then you’re getting the decision back. You don’t care where it came from.

Because in both cases my results depends of the user decision. How can
I test my application in this case?

Very simply. You just mock your user reply. You can (and probably should) test both possible scenarioes, so just attach two “fake” event handlers: one returning positive decision, one returning negative decision, as if your user actually clicked “Yes” or “No” in some messagebox.

See http://joyfulwpf.blogspot.com/2009/05/mvvm-communication-among-viewmodels.html for example.

ASpirin‘s suggestion of injecting a notifier is also a good design choice.

Some sketchy, oversimplified implementation:

using System;
using System.Windows.Forms;

namespace Demo
{
    public delegate bool DecisionHandler(string question);
    /// <remarks>
    /// Doesn't know a thing about message boxes
    /// </remarks>    
    public class MyViewModel
    {
        public event DecisionHandler OnDecision;

        private void SomeMethod()
        {
            // something...

            // I don't know who or what replies! I don't care, as long as I'm getting the decision!
            // Have you made your decision for Christ?!! And action. ;)
            var decision = OnDecision("Do you really want to?"); 

            if (decision)
            {
                // action
            }
            else
            {
                // another action
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // this ViewModel will be getting user decision from an actual message box
            var vm = new MyViewModel();
            vm.OnDecision += DecideByMessageBox;

            // unlike that one, which we can easily use for testing purposes
            var vmForTest = new MyViewModel();
            vmForTest.OnDecision += SayYes;    
        }        

        /// <summary>
        /// This event handler shows a message box
        /// </summary>        
        static bool DecideByMessageBox(string question)
        {
            return MessageBox.Show(question, String.Empty, MessageBoxButtons.YesNo) == DialogResult.Yes;
        }
        /// <summary>
        /// Simulated positive reply
        /// </summary>        
        static bool SayYes(string question)
        {
            return true;
        }
    }
}