## 1. Project Overview & Quickstart (devlooped/moq) ## File: README.md moq === [](https://www.nuget.org/packages/Moq) [](https://www.nuget.org/packages/Moq) [](https://github.com/sponsors/devlooped) The most popular and friendly mocking library for .NET ```csharp var mock = new Mock(); // WOW! No record/replay weirdness?! :) mock.Setup(library => library.DownloadExists("2.0.0.0")) .Returns(true); // Use the Object property on the mock to get a reference to the object // implementing ILoveThisLibrary, and then exercise it by calling // methods on it ILoveThisLibrary lovable = mock.Object; bool download = lovable.DownloadExists("2.0.0.0"); // Verify that the given method was indeed called with the expected value at most once mock.Verify(library => library.DownloadExists("2.0.0.0"), Times.AtMostOnce()); ``` Moq also is the first and only library so far to provide Linq to Mocks, so that the same behavior above can be achieved much more succinctly: ```csharp ILoveThisLibrary lovable = Mock.Of(l => l.DownloadExists("2.0.0.0") == true); // Exercise the instance returned by Mock.Of by calling methods on it... bool download = lovable.DownloadExists("2.0.0.0"); // Simply assert the returned state: Assert.True(download); // If you want to go beyond state testing and want to // verify the mock interaction instead... Mock.Get(lovable).Verify(library => library.DownloadExists("2.0.0.0")); ``` You can think of Linq to Mocks as "from the universe of mocks, give me one whose behavior matches this expression". Check out the [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) for more examples! ## What? Moq (pronounced "Mock-you" or just "Mock") is the only mocking library for .NET developed from scratch to take full advantage of .NET Linq expression trees and lambda expressions, which makes it the most productive, type-safe and refactoring-friendly mocking library available. And it supports mocking interfaces as well as classes. Its API is extremely simple and straightforward, and doesn't require any prior knowledge or experience with mocking concepts. ## Why? The library was created mainly for developers who aren't currently using any mocking library (or are displeased with the complexities of some other implementation), and who are typically [manually writing their own mocks](https://web.archive.org/web/20200920165817/http://blogs.clariusconsulting.net/kzu/mocks-stubs-and-fakes-its-a-continuum/) (with more or less "fanciness"). Most developers in this situation also happen to be [quite pragmatic and adhere to state](https://web.archive.org/web/20200414170510/http://blogs.clariusconsulting.net/kzu/state-testing-vs-interaction-testing/) (or classic) TDD. It's the result of feeling that the barrier of entry from other mocking libraries is a bit high, and a simpler, more lightweight and elegant approach is possible. Moq achieves all this by taking full advantage of the elegant and compact C# and VB language features collectively known as LINQ (they are not just for queries, as the acronym implies). Moq is designed to be a very practical, unobtrusive and straight-forward way to quickly setup dependencies for your tests. Its API design helps even novice users to fall in the "pit of success" and avoid most common misuses/abuses of mocking. When it was conceived, it was the only mocking library that went against the generalized and somewhat unintuitive (especially for novices) Record/Replay approach from all other libraries (and [that might have been a good thing](https://web.archive.org/web/20200920165939/http://blogs.clariusconsulting.net/kzu/whats-wrong-with-the-recordreplyverify-model-for-mocking-frameworks/) ;)). Not using Record/Replay also means that it's straightforward to move common expectations to a fixture setup method and even override those expectations when needed in a specific unit test. You can read more about the "why" and see some nice screenshots at [kzu's blog](https://web.archive.org/web/20200920164302/http://blogs.clariusconsulting.net/kzu/why-do-we-need-yet-another-net-mocking-framework/). ## Where? See our [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) examples to get a feeling of the extremely simple API and install from [NuGet](http://nuget.org/packages/moq). Read about the announcement at [kzu's blog](https://web.archive.org/web/20201130233544/http://blogs.clariusconsulting.net/kzu/linq-to-mock-moq-is-born/). Get some background on [the state of mock libraries from Scott Hanselman](http://www.hanselman.com/blog/MoqLinqLambdasAndPredicatesAppliedToMockObjects.aspx). ## Who? Moq was originally developed by [Clarius](http://www.clariusconsulting.net), [Manas](http://www.manas.com.ar) and [InSTEDD](http://www.instedd.org). Moq uses [Castle DynamicProxy](http://www.castleproject.org/projects/dynamicproxy/) internally as the interception mechanism to enable mocking. ## Features at a glance Moq offers the following features: * Strong-typed: no strings for expectations, no object-typed return values or constraints * Unsurpassed VS IntelliSense integration: everything supports full VS IntelliSense, from setting expectations, to specifying method call arguments, return values, etc. * No Record/Replay idioms to learn. Just construct your mock, set it up, use it and optionally verify calls to it (you may not verify mocks when they act as stubs only, or when you are doing more classic state-based testing by checking returned values from the object under test) * VERY low learning curve as a consequence of the previous three points. For the most part, you don't even need to ever read the documentation. * Granular control over mock behavior with a simple [MockBehavior](https://www.fuget.org/packages/Moq/4.16.1/lib/netstandard2.1/Moq.dll/Moq/MockBehavior) enumeration (no need to learn what's the theoretical difference between a mock, a stub, a fake, a dynamic mock, etc.) * Mock both interfaces and classes * Override expectations: can set default expectations in a fixture setup, and override as needed on tests * Pass constructor arguments for mocked classes * Intercept and raise events on mocks * Intuitive support for ```out/ref``` arguments We appreciate deeply any feedback that you may have! Feel free to participate in the [chat], or report an issue in the [issue tracker]. [chat]: https://discord.gg/8PtpGdu "Moq channel on Discord" [issue tracker]: https://github.com/moq/moq/issues "Moq issue tracker on GitHub" # Sponsors [](https://github.com/clarius) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/drivenet) [](https://github.com/Keflon) [](https://github.com/tbolon) [](https://github.com/kfrancis) [](https://github.com/rbnswartz) [](https://github.com/jfoshee) [](https://github.com/Mrxx99) [](https://github.com/eajhnsn1) [](https://github.com/Jonathan-Hickey) [](https://github.com/KenBonny) [](https://github.com/SimonCropp) [](https://github.com/agileworks-eu) [](https://github.com/arsdragonfly) [](https://github.com/vezel-dev) [](https://github.com/ChilliCream) [](https://github.com/4OTC) [](https://github.com/DominicSchell) [](https://github.com/adalon) [](https://github.com/torutek) [](https://github.com/mccaffers) [](https://github.com/SeikaLogiciel) [](https://github.com/wizardness) [](https://github.com/eska-gmbh) [](https://github.com/geodata-no) [](https://github.com/sponsors/devlooped) [Learn more about GitHub Sponsors](https://github.com/sponsors) --- ## File: Readme.md moq === [](https://www.nuget.org/packages/Moq) [](https://www.nuget.org/packages/Moq) [](https://github.com/sponsors/devlooped) The most popular and friendly mocking library for .NET ```csharp var mock = new Mock(); // WOW! No record/replay weirdness?! :) mock.Setup(library => library.DownloadExists("2.0.0.0")) .Returns(true); // Use the Object property on the mock to get a reference to the object // implementing ILoveThisLibrary, and then exercise it by calling // methods on it ILoveThisLibrary lovable = mock.Object; bool download = lovable.DownloadExists("2.0.0.0"); // Verify that the given method was indeed called with the expected value at most once mock.Verify(library => library.DownloadExists("2.0.0.0"), Times.AtMostOnce()); ``` Moq also is the first and only library so far to provide Linq to Mocks, so that the same behavior above can be achieved much more succinctly: ```csharp ILoveThisLibrary lovable = Mock.Of(l => l.DownloadExists("2.0.0.0") == true); // Exercise the instance returned by Mock.Of by calling methods on it... bool download = lovable.DownloadExists("2.0.0.0"); // Simply assert the returned state: Assert.True(download); // If you want to go beyond state testing and want to // verify the mock interaction instead... Mock.Get(lovable).Verify(library => library.DownloadExists("2.0.0.0")); ``` You can think of Linq to Mocks as "from the universe of mocks, give me one whose behavior matches this expression". Check out the [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) for more examples! ## What? Moq (pronounced "Mock-you" or just "Mock") is the only mocking library for .NET developed from scratch to take full advantage of .NET Linq expression trees and lambda expressions, which makes it the most productive, type-safe and refactoring-friendly mocking library available. And it supports mocking interfaces as well as classes. Its API is extremely simple and straightforward, and doesn't require any prior knowledge or experience with mocking concepts. ## Why? The library was created mainly for developers who aren't currently using any mocking library (or are displeased with the complexities of some other implementation), and who are typically [manually writing their own mocks](https://web.archive.org/web/20200920165817/http://blogs.clariusconsulting.net/kzu/mocks-stubs-and-fakes-its-a-continuum/) (with more or less "fanciness"). Most developers in this situation also happen to be [quite pragmatic and adhere to state](https://web.archive.org/web/20200414170510/http://blogs.clariusconsulting.net/kzu/state-testing-vs-interaction-testing/) (or classic) TDD. It's the result of feeling that the barrier of entry from other mocking libraries is a bit high, and a simpler, more lightweight and elegant approach is possible. Moq achieves all this by taking full advantage of the elegant and compact C# and VB language features collectively known as LINQ (they are not just for queries, as the acronym implies). Moq is designed to be a very practical, unobtrusive and straight-forward way to quickly setup dependencies for your tests. Its API design helps even novice users to fall in the "pit of success" and avoid most common misuses/abuses of mocking. When it was conceived, it was the only mocking library that went against the generalized and somewhat unintuitive (especially for novices) Record/Replay approach from all other libraries (and [that might have been a good thing](https://web.archive.org/web/20200920165939/http://blogs.clariusconsulting.net/kzu/whats-wrong-with-the-recordreplyverify-model-for-mocking-frameworks/) ;)). Not using Record/Replay also means that it's straightforward to move common expectations to a fixture setup method and even override those expectations when needed in a specific unit test. You can read more about the "why" and see some nice screenshots at [kzu's blog](https://web.archive.org/web/20200920164302/http://blogs.clariusconsulting.net/kzu/why-do-we-need-yet-another-net-mocking-framework/). ## Where? See our [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) examples to get a feeling of the extremely simple API and install from [NuGet](http://nuget.org/packages/moq). Read about the announcement at [kzu's blog](https://web.archive.org/web/20201130233544/http://blogs.clariusconsulting.net/kzu/linq-to-mock-moq-is-born/). Get some background on [the state of mock libraries from Scott Hanselman](http://www.hanselman.com/blog/MoqLinqLambdasAndPredicatesAppliedToMockObjects.aspx). ## Who? Moq was originally developed by [Clarius](http://www.clariusconsulting.net), [Manas](http://www.manas.com.ar) and [InSTEDD](http://www.instedd.org). Moq uses [Castle DynamicProxy](http://www.castleproject.org/projects/dynamicproxy/) internally as the interception mechanism to enable mocking. ## Features at a glance Moq offers the following features: * Strong-typed: no strings for expectations, no object-typed return values or constraints * Unsurpassed VS IntelliSense integration: everything supports full VS IntelliSense, from setting expectations, to specifying method call arguments, return values, etc. * No Record/Replay idioms to learn. Just construct your mock, set it up, use it and optionally verify calls to it (you may not verify mocks when they act as stubs only, or when you are doing more classic state-based testing by checking returned values from the object under test) * VERY low learning curve as a consequence of the previous three points. For the most part, you don't even need to ever read the documentation. * Granular control over mock behavior with a simple [MockBehavior](https://www.fuget.org/packages/Moq/4.16.1/lib/netstandard2.1/Moq.dll/Moq/MockBehavior) enumeration (no need to learn what's the theoretical difference between a mock, a stub, a fake, a dynamic mock, etc.) * Mock both interfaces and classes * Override expectations: can set default expectations in a fixture setup, and override as needed on tests * Pass constructor arguments for mocked classes * Intercept and raise events on mocks * Intuitive support for ```out/ref``` arguments We appreciate deeply any feedback that you may have! Feel free to participate in the [chat], or report an issue in the [issue tracker]. [chat]: https://discord.gg/8PtpGdu "Moq channel on Discord" [issue tracker]: https://github.com/moq/moq/issues "Moq issue tracker on GitHub" # Sponsors [](https://github.com/clarius) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/drivenet) [](https://github.com/Keflon) [](https://github.com/tbolon) [](https://github.com/kfrancis) [](https://github.com/rbnswartz) [](https://github.com/jfoshee) [](https://github.com/Mrxx99) [](https://github.com/eajhnsn1) [](https://github.com/Jonathan-Hickey) [](https://github.com/KenBonny) [](https://github.com/SimonCropp) [](https://github.com/agileworks-eu) [](https://github.com/arsdragonfly) [](https://github.com/vezel-dev) [](https://github.com/ChilliCream) [](https://github.com/4OTC) [](https://github.com/DominicSchell) [](https://github.com/adalon) [](https://github.com/torutek) [](https://github.com/mccaffers) [](https://github.com/SeikaLogiciel) [](https://github.com/wizardness) [](https://github.com/eska-gmbh) [](https://github.com/geodata-no) [](https://github.com/sponsors/devlooped) [Learn more about GitHub Sponsors](https://github.com/sponsors) --- ## File: readme.md moq === [](https://www.nuget.org/packages/Moq) [](https://www.nuget.org/packages/Moq) [](https://github.com/sponsors/devlooped) The most popular and friendly mocking library for .NET ```csharp var mock = new Mock(); // WOW! No record/replay weirdness?! :) mock.Setup(library => library.DownloadExists("2.0.0.0")) .Returns(true); // Use the Object property on the mock to get a reference to the object // implementing ILoveThisLibrary, and then exercise it by calling // methods on it ILoveThisLibrary lovable = mock.Object; bool download = lovable.DownloadExists("2.0.0.0"); // Verify that the given method was indeed called with the expected value at most once mock.Verify(library => library.DownloadExists("2.0.0.0"), Times.AtMostOnce()); ``` Moq also is the first and only library so far to provide Linq to Mocks, so that the same behavior above can be achieved much more succinctly: ```csharp ILoveThisLibrary lovable = Mock.Of(l => l.DownloadExists("2.0.0.0") == true); // Exercise the instance returned by Mock.Of by calling methods on it... bool download = lovable.DownloadExists("2.0.0.0"); // Simply assert the returned state: Assert.True(download); // If you want to go beyond state testing and want to // verify the mock interaction instead... Mock.Get(lovable).Verify(library => library.DownloadExists("2.0.0.0")); ``` You can think of Linq to Mocks as "from the universe of mocks, give me one whose behavior matches this expression". Check out the [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) for more examples! ## What? Moq (pronounced "Mock-you" or just "Mock") is the only mocking library for .NET developed from scratch to take full advantage of .NET Linq expression trees and lambda expressions, which makes it the most productive, type-safe and refactoring-friendly mocking library available. And it supports mocking interfaces as well as classes. Its API is extremely simple and straightforward, and doesn't require any prior knowledge or experience with mocking concepts. ## Why? The library was created mainly for developers who aren't currently using any mocking library (or are displeased with the complexities of some other implementation), and who are typically [manually writing their own mocks](https://web.archive.org/web/20200920165817/http://blogs.clariusconsulting.net/kzu/mocks-stubs-and-fakes-its-a-continuum/) (with more or less "fanciness"). Most developers in this situation also happen to be [quite pragmatic and adhere to state](https://web.archive.org/web/20200414170510/http://blogs.clariusconsulting.net/kzu/state-testing-vs-interaction-testing/) (or classic) TDD. It's the result of feeling that the barrier of entry from other mocking libraries is a bit high, and a simpler, more lightweight and elegant approach is possible. Moq achieves all this by taking full advantage of the elegant and compact C# and VB language features collectively known as LINQ (they are not just for queries, as the acronym implies). Moq is designed to be a very practical, unobtrusive and straight-forward way to quickly setup dependencies for your tests. Its API design helps even novice users to fall in the "pit of success" and avoid most common misuses/abuses of mocking. When it was conceived, it was the only mocking library that went against the generalized and somewhat unintuitive (especially for novices) Record/Replay approach from all other libraries (and [that might have been a good thing](https://web.archive.org/web/20200920165939/http://blogs.clariusconsulting.net/kzu/whats-wrong-with-the-recordreplyverify-model-for-mocking-frameworks/) ;)). Not using Record/Replay also means that it's straightforward to move common expectations to a fixture setup method and even override those expectations when needed in a specific unit test. You can read more about the "why" and see some nice screenshots at [kzu's blog](https://web.archive.org/web/20200920164302/http://blogs.clariusconsulting.net/kzu/why-do-we-need-yet-another-net-mocking-framework/). ## Where? See our [Quickstart](https://github.com/devlooped/moq/wiki/Quickstart) examples to get a feeling of the extremely simple API and install from [NuGet](http://nuget.org/packages/moq). Read about the announcement at [kzu's blog](https://web.archive.org/web/20201130233544/http://blogs.clariusconsulting.net/kzu/linq-to-mock-moq-is-born/). Get some background on [the state of mock libraries from Scott Hanselman](http://www.hanselman.com/blog/MoqLinqLambdasAndPredicatesAppliedToMockObjects.aspx). ## Who? Moq was originally developed by [Clarius](http://www.clariusconsulting.net), [Manas](http://www.manas.com.ar) and [InSTEDD](http://www.instedd.org). Moq uses [Castle DynamicProxy](http://www.castleproject.org/projects/dynamicproxy/) internally as the interception mechanism to enable mocking. ## Features at a glance Moq offers the following features: * Strong-typed: no strings for expectations, no object-typed return values or constraints * Unsurpassed VS IntelliSense integration: everything supports full VS IntelliSense, from setting expectations, to specifying method call arguments, return values, etc. * No Record/Replay idioms to learn. Just construct your mock, set it up, use it and optionally verify calls to it (you may not verify mocks when they act as stubs only, or when you are doing more classic state-based testing by checking returned values from the object under test) * VERY low learning curve as a consequence of the previous three points. For the most part, you don't even need to ever read the documentation. * Granular control over mock behavior with a simple [MockBehavior](https://www.fuget.org/packages/Moq/4.16.1/lib/netstandard2.1/Moq.dll/Moq/MockBehavior) enumeration (no need to learn what's the theoretical difference between a mock, a stub, a fake, a dynamic mock, etc.) * Mock both interfaces and classes * Override expectations: can set default expectations in a fixture setup, and override as needed on tests * Pass constructor arguments for mocked classes * Intercept and raise events on mocks * Intuitive support for ```out/ref``` arguments We appreciate deeply any feedback that you may have! Feel free to participate in the [chat], or report an issue in the [issue tracker]. [chat]: https://discord.gg/8PtpGdu "Moq channel on Discord" [issue tracker]: https://github.com/moq/moq/issues "Moq issue tracker on GitHub" # Sponsors [](https://github.com/clarius) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/drivenet) [](https://github.com/Keflon) [](https://github.com/tbolon) [](https://github.com/kfrancis) [](https://github.com/rbnswartz) [](https://github.com/jfoshee) [](https://github.com/Mrxx99) [](https://github.com/eajhnsn1) [](https://github.com/Jonathan-Hickey) [](https://github.com/KenBonny) [](https://github.com/SimonCropp) [](https://github.com/agileworks-eu) [](https://github.com/arsdragonfly) [](https://github.com/vezel-dev) [](https://github.com/ChilliCream) [](https://github.com/4OTC) [](https://github.com/DominicSchell) [](https://github.com/adalon) [](https://github.com/torutek) [](https://github.com/mccaffers) [](https://github.com/SeikaLogiciel) [](https://github.com/wizardness) [](https://github.com/eska-gmbh) [](https://github.com/geodata-no) [](https://github.com/sponsors/devlooped) [Learn more about GitHub Sponsors](https://github.com/sponsors) --- ## File: docs/user-guide/index.md --- --- # User Guide This is work in progress and currently under construction. --- ## File: docs/index.md --- --- Welcome to the documentation for Moq! [Quickstart](https://github.com/moq/moq/wiki/Quickstart) \| [User Guide](user-guide/index.md) --- ## File: src/Moq.Tests.ComTypes/README.md # Moq.Types.ComTypes.dll This directory contains an assembly `Moq.Types.ComTypes.dll` containing Component Object Model (COM) interop types, used to test various aspects of Moq compatibility with COM. This assembly can be built from the `ComTypes.idl` definition file also contained in this directory. ## Building ### Requirements In order to build the DLL, you will need the following tools: * **`midl`** (Microsoft's MIDL Compiler) for producing a Type Library from an `.idl` source file. This tool is part of the Windows SDK. See ["Using the MIDL Compiler" on Microsoft Docs](https://docs.microsoft.com/en-us/windows/desktop/Midl/using-the-midl-compiler-2) for more information. * **`tlbimp`** (Microsoft's .NET Framework Type Library to Assembly Converter) for producing a COM interop assembly from a Type Library. This tool is part of the .NET Framework SDK, and it is automatically installed with Visual Studio. See ["Tlbimp.exe (Type Library Importer)" on Microsoft Docs](https://docs.microsoft.com/en-us/dotnet/framework/tools/tlbimp-exe-type-library-importer) for more information. * Optionally, **`peverify`** (Microsoft's .NET Framework PE Verifier) which is also part of the .NET Framework SDK and installed together with Visual Studio. See ["Peverify.exe (PEVerify Tool)" on Microsoft Docs](https://docs.microsoft.com/en-us/dotnet/framework/tools/peverify-exe-peverify-tool) ### Steps Open a command prompt and ensure that the tools mentioned above can be found in the `PATH`. For instance, start Visual Studio's developer command prompt. Next, you can either run the `BuildDLLFromIDL.cmd` batch file found in this directory, or run the following equivalent steps manually: 1. Create a COM Type Library (a `.tlb` file) from the `.idl` definition: ``` midl.exe /mktyplib203 ^ /env win32 ^ /tlb ComTypes.tlb ^ ComTypes.idl ``` 2. Convert the generated type library to a .NET interop types assembly: ``` tlbimp ComTypes.tlb ^ /out:Moq.Tests.ComTypes.dll ^ /namespace:Moq.Tests.ComTypes ^ /keyfile:..\..\Moq.snk ^ /asmversion:4.0.0.0 ``` 3. Optionally verify the generated assembly: ``` peverify Moq.Tests.ComTypes.dll ``` --- ## File: src/Moq/readme.md ## 2. Official Technical Reference & Guides (devlooped/devlooped.github.io) ## File: README.md Devlooped ============ Main site for https://www.devlooped.com. See also our NuGet profile on https://www.nuget.org/profiles/Devlooped. # Sponsors [](https://github.com/clarius) [](https://github.com/MelbourneDeveloper) [](https://github.com/augustoproiete) [](https://github.com/KirillOsenkov) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/eeseewy) [](https://github.com/agocke) [](https://github.com/sponsors/devlooped)   [Learn more about GitHub Sponsors](https://github.com/sponsors) --- ## File: Readme.md Devlooped ============ Main site for https://www.devlooped.com. See also our NuGet profile on https://www.nuget.org/profiles/Devlooped. # Sponsors [](https://github.com/clarius) [](https://github.com/MelbourneDeveloper) [](https://github.com/augustoproiete) [](https://github.com/KirillOsenkov) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/eeseewy) [](https://github.com/agocke) [](https://github.com/sponsors/devlooped)   [Learn more about GitHub Sponsors](https://github.com/sponsors) --- ## File: readme.md Devlooped ============ Main site for https://www.devlooped.com. See also our NuGet profile on https://www.nuget.org/profiles/Devlooped. # Sponsors [](https://github.com/clarius) [](https://github.com/MelbourneDeveloper) [](https://github.com/augustoproiete) [](https://github.com/KirillOsenkov) [](https://github.com/MFB-Technologies-Inc) [](https://github.com/sandrock) [](https://github.com/eeseewy) [](https://github.com/agocke) [](https://github.com/sponsors/devlooped)   [Learn more about GitHub Sponsors](https://github.com/sponsors)