Unit testing PSCmdlet-derived classes

 [Test]
        public void Exemplary_PSCmdlet_Test() {

            var fileInteractorMock = new Mock<IFileInteractor>();
            fileInteractorMock.Setup(m => m.CreateDirectory(null)).Throws<ArgumentNullException>();

            var logger = new SimpleLogger();

            var fileManager = new InvocationFileManager(logger, fileInteractorMock.Object);

            var parser = new InvokeCvApiParameterParser(fileInteractorMock.Object, fileManager, logger);

            var testBLContextProvider = new Mock<IContextProvider>();

            var cmdlet = new InvokeCVApiCommand(testBLContextProvider.Object, fileManager, logger, parser) {
                FunctionFilePath = "fakePath",
                OutputFolder = "fakeOutputFolder"
            };

            var psEmulator = new PowershellEmulator();
            cmdlet.CommandRuntime = psEmulator;
            cmdlet.ProcessInternal();
            var results = psEmulator.OutputObjects;
            //do whatever you want with output
        }

        internal class PowershellEmulator : ICommandRuntime {
            public List<object> OutputObjects { get; } = new List<object>();
            public PSHost Host { get; }
            public PSTransactionContext CurrentPSTransaction { get; }

            public bool ShouldContinue(string query, string caption, ref bool yesToAll, ref bool noToAll) {
                return true;
            }

            public bool ShouldContinue(string query, string caption) {
                return true;
            }

            public bool TransactionAvailable() {
                return true;
            }

            public bool ShouldProcess(string verboseDescription, string verboseWarning, string caption,
                out ShouldProcessReason shouldProcessReason) {
                shouldProcessReason = ShouldProcessReason.None;
                return true;
            }

            public bool ShouldProcess(string verboseDescription, string verboseWarning, string caption) {
                return true;
            }

            public bool ShouldProcess(string target, string action) {
                return true;
            }

            public bool ShouldProcess(string target) {
                return true;
            }

            public void ThrowTerminatingError(ErrorRecord errorRecord) {
                throw new InvalidOperationException("Error in pipeline", errorRecord.Exception);
            }

            public void WriteCommandDetail(string text) {
                WriteObject(text);
            }

            public void WriteDebug(string text) {
                WriteObject(text);
            }

            public void WriteError(ErrorRecord errorRecord) {
                throw new InvalidOperationException("Error in pipeline", errorRecord.Exception);
            }

            public void WriteObject(object sendToPipeline, bool enumerateCollection) {
                WriteObject(sendToPipeline);
            }

            public void WriteObject(object sendToPipeline) {
                OutputObjects.Add(sendToPipeline);
            }

            public void WriteProgress(long sourceId, ProgressRecord progressRecord) {
                WriteObject(progressRecord);
            }

            public void WriteProgress(ProgressRecord progressRecord) {
                WriteObject(progressRecord);
            }

            public void WriteVerbose(string text) {
                WriteObject(text);
            }

            public void WriteWarning(string text) {
                WriteObject(text);
            }
        }