//Test
        [Fact]
        public void VerifyThatSuccessfulLogonSendsNavigationMessage()
        {
            var creds = SetupSecurityService(_securityMock, true, StatusCode.ValidCredentials);
            //_messengerMock.Setup(x => x.Send(It.IsAny<SetWaitModeMessage>()));
            //_messengerMock.Setup(x => x.Send(It.IsAny<SetWaitModeMessage>()));
            var msg = new NavigateMessage(null, @"Forward");
            _messengerMock.Setup(x => x.Send(msg));

            Messenger.OverrideDefault(_messengerMock.Object);
            var logonvm = CreateLogOnViewModel(creds);

            logonvm.LogOnCommand.Execute(null);
            _messengerMock.Verify(x => x.Send(msg));
        }

        private LogOnViewModel CreateLogOnViewModel(Credentials creds)
        {
            var logonvm = new LogOnViewModel(_securityMock.Object, _recordingListMock.Object)
                              {
                                  UserName = creds.Username,
                                  Password = creds.Password
                              };
            return logonvm;
        }

        private static Credentials SetupSecurityService(Mock<ISecurityService> security, bool isValid, StatusCode statusCode)
        {
            var creds = new Credentials("a", "b");
            security
                .Setup(e => e.IsValidLogin(It.IsAny<Credentials>()))
                .Returns(
                    Task<AuthenticationResponse>.Factory.StartNew(
                        () => new AuthenticationResponse(creds) { IsValid = isValid, Status = statusCode }));

            return creds;
        }

//ViewModel
        private void PerformAuthentication()
        {
            Messenger.Default.Send(new SetWaitModeMessage(true));

            Status = i18n.Authenticating;
            IsAuthenticating = true;
            var creds = new Credentials(UserName, Password);

            var task = _securityService.IsValidLogin(creds);
            task.ContinueWith(IsValidCallbackFaulted, TaskContinuationOptions.OnlyOnFaulted);
            task.ContinueWith(IsValidCallback, TaskContinuationOptions.None);
        }

        private void IsValidCallback(Task<AuthenticationResponse> task)
        {
            IsAuthenticating = false;
            Messenger.Default.Send(new SetWaitModeMessage(false));

            if (Logger.IsInfoEnabled) Logger.Info(CultureInfo.InvariantCulture, @"User was valid? {0}", task.Result.IsValid);
            Status = task.Result.IsValid ? "" : EnumUtils.GetDescription(task.Result.Status, "en");

            if (task.Result.IsValid)
            {
                State.Credentials = task.Result.Credentials;

                if (Logger.IsInfoEnabled) Logger.Info(CultureInfo.InvariantCulture, @"Attempting to retrieve unrecorded audio for user '{0}'", State.Credentials.Username);
                State.RecordingsTask = _recordingsList.GetUnrecorded(State.Credentials);

                Messenger.Default.Send(new NavigateMessage(this, @"Forward"));
            }
        }



Getting error:

Moq.MockException: Expected invocation on the mock at least once, but was never performed: x => x.Send<NavigateMessage>(.msg)

Configured setups:
x => x.Send<NavigateMessage>(.msg), Times.Never

Performed invocations:
Messenger.Send(Acumantra.Names.Recorder.UI.Messages.SetWaitModeMessage)
Messenger.Send(Acumantra.Names.Recorder.UI.Messages.SetWaitModeMessage)
Messenger.Send(Acumantra.Names.Recorder.UI.Messages.NavigateMessage)