public Verificator(MockBehavior behavior, IErrorFormatter errorFormatter)
{
Contract.Requires(errorFormatter != null, "errorFormatter should not be null.");
_behavior = behavior;
_errorFormatter = errorFormatter;
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
OwinContext = Fakes.CreateOwinContext();
EntitiesContext = (MockEntitiesContext = new Mock<IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock<IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock<IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock<INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock<IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock<IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock<IIndexingService>()).Object;
AutoCuratePackage = (MockAutoCuratePackage = new Mock<IAutomaticallyCuratePackageCommand>()).Object;
MockPackageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>()))
.Returns(Task.CompletedTask);
PackageFileService = MockPackageFileService.Object;
MessageService = (MockMessageService = new Mock<IMessageService>()).Object;
MockConfigurationService = new Mock<ConfigurationService>();
MockConfigurationService.SetupGet(s => s.Features.TrackPackageDownloadCountInLocalDatabase)
.Returns(false);
ConfigurationService = MockConfigurationService.Object;
AuditingService = new TestAuditingService();
TestUtility.SetupHttpContextMockForUrlGeneration(new Mock<HttpContextBase>(), this);
}
private static object[] BuildArgs(MockBehavior mockBehavior, object[] args)
{
if (args == null)
return new[] {(object)mockBehavior};
var list = new List<object> {mockBehavior};
list.AddRange(args);
return list.ToArray();
}
public InstructorControllerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
QueryRepositoryMock = new Mock<IQueryRepository>(_MockBehaviour);
Initalise();
}
private static Mock CreateMockOf(Type type, MockBehavior mockBehavior, object[] args = null)
{
var mockType = typeof (Mock<>).MakeGenericType(type);
var mock = (Mock) Activator.CreateInstance(mockType, BuildArgs(mockBehavior, args));
if (args != null)//if mock created for a class then make it partial
mock.CallBase = true;
return mock;
}
public CourseControllerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
CourseApplicationServiceMock = new Mock<ICourseApplicationService>(_MockBehaviour);
QueryRepositoryMock = new Mock<IQueryRepository>(_MockBehaviour);
Initalise();
}
public OrchardServicesMock(MockBehavior mockBehavior)
{
ContentManagerMock = new ContentManagerMock(mockBehavior);
TransactionManagerMock = new TransactionManagerMock(mockBehavior);
AuthorizerMock = new AuthorizerMock(mockBehavior);
NotifierMock = new NotifierMock(mockBehavior);
WorkContextMock = new WorkContextMock(mockBehavior);
New = new ShapeFactoryMock();
}
private Mock<IInsertMode> CreateAndAddInsertMode(MockBehavior behavior = MockBehavior.Strict)
{
var mode = _factory.Create<IInsertMode>(behavior);
mode.SetupGet(x => x.ModeKind).Returns(ModeKind.Insert);
mode.Setup(x => x.OnLeave());
mode.Setup(x => x.OnClose());
_vimBufferRaw.RemoveMode(_vimBuffer.InsertMode);
_vimBufferRaw.AddMode(mode.Object);
return mode;
}
///<summary>
///Creates a new call sequence for call order verification.
///</summary>
///<param name="behavior">Determines how verification works.
///Loose sequence verifies that calls were made in the specified order allowing any calls to happen inbetween them.
///Strict sequence does not allow any calls inbetween</param>
public CallSequence(MockBehavior behavior = MockBehavior.Default)
{
if (behavior == MockBehavior.Loose)
{
callSequenceCursorStrategy = new LooseCallSequenceCursorStrategy();
}
else
{
callSequenceCursorStrategy = new StrictCallSequenceCursorStrategy();
}
}
private Mock<INormalMode> CreateAndAddNormalMode(MockBehavior behavior = MockBehavior.Strict)
{
var mode = _factory.Create<INormalMode>(behavior);
mode.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal);
mode.SetupGet(x => x.KeyRemapMode).Returns(FSharpOption.Create(KeyRemapMode.Normal));
mode.Setup(x => x.OnLeave());
mode.Setup(x => x.OnClose());
_vimBufferRaw.RemoveMode(_vimBufferRaw.NormalMode);
_vimBufferRaw.AddMode(mode.Object);
return mode;
}
public void RunTest1()
{
MockBehavior mockBehavior = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
bt.Start(mockBehavior);
CheckIntEqual(0, mockBehavior.m_InitializeCalled, "Init test");
bt.Tick();
CheckIntEqual(1, mockBehavior.m_InitializeCalled, "Single tick");
}
private Mock<IVisualMode> CreateAndAddVisualLineMode(MockBehavior behavior = MockBehavior.Strict)
{
var mode = _factory.Create<IVisualMode>(behavior);
mode.SetupGet(x => x.ModeKind).Returns(ModeKind.VisualLine);
mode.SetupGet(x => x.KeyRemapMode).Returns(KeyRemapMode.Visual);
mode.Setup(x => x.OnLeave());
mode.Setup(x => x.OnClose());
_vimBufferRaw.RemoveMode(_vimBuffer.VisualLineMode);
_vimBufferRaw.AddMode(mode.Object);
return mode;
}
public static IMockRepository Create(IUnityContainer container, MockBehavior behavior = MockBehavior.Default)
{
//register with unity with lifetime when it disposes
container.RegisterType<IMockRepository, TestMockRepository>(
new ContainerControlledLifetimeManager()
, new Interceptor<InterfaceInterceptor>()
, new InterceptionBehavior<AddMocksToUnityBehavior>()
, new InjectionConstructor(behavior));
//resolve the repository
return container.Resolve<IMockRepository>();
}
/// <summary>
/// Creates a stub file system with some basic operations implemented correctly.
/// </summary>
/// <returns>A mock file system.</returns>
public static Mock<IFileSystem> CreateStubFileSystem(MockBehavior mockBehavior)
{
Mock<IFileSystem> mockFileSystem = new Mock<IFileSystem>(mockBehavior);
mockFileSystem
.Setup(p => p.Path.Combine(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((a, b) => a + "/" + b);
mockFileSystem
.Setup(p => p.Path.ChangeExtension(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((filename, newExtension) => Path.ChangeExtension(filename, newExtension));
return mockFileSystem;
}
public Mock(MockBehavior behavior, params object[] args)
{
if (args == null)
{
args = new object[] { null };
}
this.Behavior = behavior;
this.Interceptor = new Interceptor(behavior, typeof(T), this);
this.constructorArguments = args;
this.ImplementedInterfaces.Add(typeof(IMocked <T>));
this.CheckParameters();
}
public MockRegistration(
bool canRefresh = true,
MockBehavior behavior = MockBehavior.Loose,
Action <Mock <T> > configureAction = null,
Func <T> factory = null)
: this(factory != null
? new Mock <T>(factory, behavior)
: new Mock <T>(behavior))
{
Configure = configureAction;
CanRefresh = canRefresh;
Refresh();
}
public static IAggregateDependenciesSnapshotProvider Implement(
IDependenciesSnapshotProvider getSnapshotProvider = null,
MockBehavior mockBehavior = MockBehavior.Default)
{
var mock = new Mock <IAggregateDependenciesSnapshotProvider>(mockBehavior);
if (getSnapshotProvider != null)
{
mock.Setup(x => x.GetSnapshotProvider(It.IsAny <string>()))
.Returns(getSnapshotProvider);
}
return(mock.Object);
}
public void RunTest3()
{
MockBehavior t = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
BehaviorObserver del = DelegateHandler;
bt.Start(t, del);
bt.Tick();
CheckIntEqual(0, t.m_TerminateCalled, "1st terminate called");
t.m_ReturnStatus = Status.BH_SUCCESS;
bt.Tick();
CheckIntEqual(1, t.m_TerminateCalled, "2nd terminate called");
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
EntitiesContext = (MockEntitiesContext = new Mock<IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock<IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock<IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock<INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock<IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock<IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock<IIndexingService>()).Object;
MockPackageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>())).Returns(Task.FromResult(0));
PackageFileService = MockPackageFileService.Object;
}
public void RunTest2()
{
MockBehavior t = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
BehaviorObserver del = DelegateHandler;
bt.Start(t, del);
bt.Tick();
CheckIntEqual(1, t.m_UpdateCalled, "Single tick");
t.m_ReturnStatus = Status.BH_SUCCESS;
bt.Tick();
CheckIntEqual(2, t.m_UpdateCalled, "2nd tick return success");
}
/// <summary>
/// Initializes an instance of AutoMockers.
/// </summary>
/// <param name="mockBehavior">The behavior to use for created mocks.</param>
/// <param name="defaultValue">The default value to use for created mocks.</param>
/// <param name="callBase">Whether to call the base virtual implementation for created mocks.</param>
public AutoMocker(MockBehavior mockBehavior, DefaultValue defaultValue, bool callBase)
{
MockBehavior = mockBehavior;
DefaultValue = defaultValue;
CallBase = callBase;
Resolvers = new List <IMockResolver>
{
new MockResolver(mockBehavior, defaultValue, callBase),
new FuncResolver(),
new LazyResolver(),
new EnumerableResolver()
};
}
public ValidationMessageHandlerFactsBase(MockBehavior mockBehavior)
{
ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >();
CorePackageServiceMock = new Mock <IEntityService <Package> >(mockBehavior);
ValidationSetProviderMock = new Mock <IValidationSetProvider <Package> >(mockBehavior);
ValidationSetProcessorMock = new Mock <IValidationSetProcessor>(mockBehavior);
ValidationOutcomeProcessorMock = new Mock <IValidationOutcomeProcessor <Package> >(mockBehavior);
TelemetryServiceMock = new Mock <ITelemetryService>(mockBehavior);
LoggerMock = new Mock <ILogger <PackageValidationMessageHandler> >(); // we generally don't care about how logger is called, so it's loose all the time
ConfigurationAccessorMock
.SetupGet(ca => ca.Value)
.Returns(Configuration);
}
/// <summary>
/// Method that is turned into the actual call from .Query{T}, to
/// transform the queryable query into a normal enumerable query.
/// This method is never used directly by consumers.
/// </summary>
private static IEnumerable<T> CreateMocks<T>(MockBehavior behavior) where T : class
{
do
{
var mock = new Mock<T>(behavior);
if (behavior != MockBehavior.Strict)
{
mock.SetupAllProperties();
}
yield return mock.Object;
}
while (true);
}
public static ITargetFrameworkProvider Implement(
ITargetFramework getNearestFramework = null,
MockBehavior mockBehavior = MockBehavior.Default)
{
var mock = new Mock <ITargetFrameworkProvider>(mockBehavior);
if (getNearestFramework != null)
{
mock.Setup(x => x.GetNearestFramework(It.IsAny <ITargetFramework>(), It.IsAny <IEnumerable <ITargetFramework> >()))
.Returns(getNearestFramework);
}
return(mock.Object);
}
public InterceptStrategyContext(Mock Mock
, Type targetType
, Dictionary <string, List <Delegate> > invocationLists
, List <ICallContext> actualInvocations
, MockBehavior behavior
, List <IProxyCall> orderedCalls
)
{
this.Behavior = behavior;
this.Mock = Mock;
this.InvocationLists = invocationLists;
this.ActualInvocations = actualInvocations;
this.TargetType = targetType;
this.OrderedCalls = orderedCalls;
}
public RabbitMqBuilderTest()
{
const MockBehavior mockBehavior = MockBehavior.Strict;
SetupLoggerMock(mockBehavior);
SetupLoggerFactoryMock(mockBehavior);
SetupConnectionMock(mockBehavior);
SetupConnectionFactoryMock(mockBehavior);
SetupSettingsMock(mockBehavior);
SetupMessagingWorkersFactoryMock(mockBehavior);
_builder = new RabbitMqBuilder(_configMock.Object, _loggerFactoryMock.Object, _messagingWorkersFactoryMock.Object)
{
ConnectionFactory = _connectionFactoryMock.Object
};
}
/// <summary>
/// Retrieves the mock for the specified service type.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="mockBehavior">
/// The <see cref="MockBehavior" /> of the mock.
/// </param>
/// <returns>
/// The service mock.
/// </returns>
public Mock <TService> Mock <TService>(MockBehavior mockBehavior) where TService : class
{
TService service = Try.Get <TService>(Create <TService>);
var existingMock = service as IMocked <TService>;
if (existingMock != null)
{
return(existingMock.Mock);
}
Mock <TService> mock = _registrationSource.Repository.Create <TService>(mockBehavior);
Update(mock.Object);
return(mock);
}
public void CanAddGameObjectDirectlyToGameStageThroughAddGameObject()
{
var gameStage = new MockGameStage();
var gameObject = new GameObject();
var behavior = new MockBehavior();
gameObject.AddComponent(behavior);
gameStage.AddGameObject(gameObject);
var gameObjectToAdd = new GameObject();
behavior.AddGameObject(gameObjectToAdd);
Assert.IsTrue(gameStage.GameObjects.Contains(gameObjectToAdd));
}
public void WhenAddingMockBehavior_ThenCanInterceptSelectively()
{
var calculator = new ICalculatorProxy();
var behavior = new MockBehavior();
calculator.AddBehavior(behavior);
calculator.AddBehavior(new DefaultValueBehavior());
calculator.AddBehavior(m => m.MethodBase.Name == "get_Mode", (m, n) => m.CreateValueReturn("Basic"));
var mode = calculator.Mode;
var add = calculator.Add(3, 2);
Assert.Equal("Basic", mode);
Assert.Equal(0, add);
}
public InterceptStrategyContext(Mock Mock
, Type targetType
, Dictionary<string, List<Delegate>> invocationLists
, List<ICallContext> actualInvocations
, MockBehavior behavior
, List<IProxyCall> orderedCalls
)
{
this.Behavior = behavior;
this.Mock = Mock;
this.InvocationLists = invocationLists;
this.ActualInvocations = actualInvocations;
this.TargetType = targetType;
this.OrderedCalls = orderedCalls;
}
public static IDependencyModel Implement(string providerType = null,
string id = null,
string originalItemSpec = null,
string path = null,
string caption = null,
IEnumerable <string> dependencyIDs = null,
bool?resolved = null,
MockBehavior mockBehavior = MockBehavior.Default)
{
var mock = new Mock <IDependencyModel>(mockBehavior);
if (providerType != null)
{
mock.Setup(x => x.ProviderType).Returns(providerType);
}
if (id != null)
{
mock.Setup(x => x.Id).Returns(id);
}
if (originalItemSpec != null)
{
mock.Setup(x => x.OriginalItemSpec).Returns(originalItemSpec);
}
if (path != null)
{
mock.Setup(x => x.Path).Returns(path);
}
if (caption != null)
{
mock.Setup(x => x.Caption).Returns(caption);
}
if (dependencyIDs != null)
{
mock.Setup(x => x.DependencyIDs).Returns(ImmutableList <string> .Empty.AddRange(dependencyIDs));
}
if (resolved.HasValue)
{
mock.Setup(x => x.Resolved).Returns(resolved.Value);
}
return(mock.Object);
}
public MockedProperty(string id, MockBehavior behavior = MockBehavior.Strict, params object[] values) : base(behavior)
{
this.Id = id;
this.Values = new List <object>(values);
this.Setup(m => m.DisplayName).Returns(() => this.DisplayName);
this.Setup(m => m.Id).Returns(() => this.Id);
this.Setup(m => m.LocalName).Returns(() => this.LocalName);
this.Setup(m => m.PropertyType).Returns(() => this.PropertyType);
this.Setup(m => m.QueryName).Returns(() => this.QueryName);
this.Setup(m => m.Value).Returns(() => this.Values.First());
this.Setup(m => m.Values).Returns(() => new List <object>(this.Values));
this.Setup(m => m.IsMultiValued).Returns(() => this.IsMultiValued);
this.Setup(m => m.FirstValue).Returns(() => this.Values.First());
this.Setup(m => m.ValueAsString).Returns(() => this.Values.First() != null ? this.Values.First().ToString() : null);
this.Setup(m => m.ValuesAsString).Returns(() => string.Join(",", this.Values));
}
public MessagingManagerTest()
{
_mockBehavior = MockBehavior.Strict;
_builderMock = new Mock <IBuilder>(_mockBehavior);
_loggerFactoryMock = new Mock <ILoggerFactory>(_mockBehavior);
_consumerMock = new Mock <IConsumer>(_mockBehavior);
_loggerMock = new Mock <ILogger>(_mockBehavior);
_consumerMock.Setup(c => c.Start(It.IsAny <IProcessor>(), It.IsAny <string>()));
_consumerMock.Setup(c => c.Stop());
_builderMock.Setup(b => b.BuildConsumer()).Returns(_consumerMock.Object);
var mockMap = new Mock <IDictionary <string, Type> >();
_builderMock.SetupGet(b => b.MessageQueueMap).Returns(mockMap.Object);
_loggerFactoryMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(_loggerMock.Object);
_loggerMock.Setup(l => l.Log(It.IsAny <LogLevel>(), It.IsAny <EventId>(), It.IsAny <FormattedLogValues>(), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()));
}
public MockedFolderType(bool modificationDateUpdatable = true, MockBehavior behavior = MockBehavior.Strict) : base(behavior)
{
this.Id = BaseTypeId.CmisFolder.GetCmisValue();
this.BaseType = this.Object;
this.IsBaseType = true;
this.BaseTypeId = BaseTypeId.CmisFolder;
this.Description = "mocked C# folder type";
this.DisplayName = "mocked folder type";
var modificationDateDefinition = new MockedPropertyDateTimeDefinition()
{
Id = PropertyIds.LastModificationDate,
Updatability = modificationDateUpdatable ? Updatability.ReadWrite : Updatability.ReadOnly
}.Object;
this.PropertyDefinitions.Add(modificationDateDefinition);
}
public void SetupBehaviorOfReferenceTypePropertyGetterSetter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooReferenceTypeProperty <object> >(arrangements);
// When
var getterArrangements = mockArrangements.That(b => b.GetterSetter);
var setterArrangements = mockArrangements.ThatAssigning(b => b.GetterSetter = 0);
// Then
Assert.NotNull(getterArrangements);
Assert.NotNull(setterArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooReferenceTypeProperty <object>, object?> >(getterArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooReferenceTypeProperty <object> > >(setterArrangements);
}
/// <summary>
/// Creates a mock object of the indicated type.
/// </summary>
/// <param name="behavior">Behavior of the mock.</param>
/// <typeparam name="T">The type of the mocked object.</typeparam>
/// <returns>The mocked object created.</returns>
public static T Of <T>(MockBehavior behavior) where T : class
{
// This method was originally implemented as follows:
//
// return Mocks.CreateMockQuery<T>().First<T>();
//
// which involved a lot of avoidable `IQueryable` query provider overhead and lambda compilation.
// What it really boils down to is this (much faster) code:
var mock = new Mock <T>(behavior);
if (behavior != MockBehavior.Strict)
{
mock.SetupAllProperties();
}
return(mock.Object);
}
public MockedDocumentType(bool modificationDateUpdatable = true, MockBehavior behavior = MockBehavior.Strict) : base(behavior)
{
this.Id = BaseTypeId.CmisDocument.GetCmisValue();
this.BaseType = this.Object;
this.BaseTypeId = BaseTypeId.CmisDocument;
this.Description = "mocked C# document type";
this.DisplayName = "mocked document type";
var modificationDateDefinition = new MockedPropertyDateTimeDefinition()
{
Id = PropertyIds.LastModificationDate,
Updatability = modificationDateUpdatable ? Updatability.ReadWrite : Updatability.ReadOnly
}.Object;
this.PropertyDefinitions.Add(modificationDateDefinition);
this.Setup(m => m.ContentStreamAllowed).Returns(ContentStreamAllowed.Allowed);
this.Setup(m => m.GetChildren()).Returns(new MockedItemList <IObjectType>().Object);
}
/// <summary>
/// Return an instance of a class that has been converted to a mock class.
/// This variant allows calls to the Setup method such that the methods
/// can be subonred into returning a desired result for testing purposes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="aMockBehavior"></param>
/// <returns></returns>
public Mock <T> GetMock <T>
(MockBehavior aMockBehavior = DEFAULT_MOCK_BEHAVIOR) where T : class
{
Type vType = typeof(T);
// If you're asking for a mock, it better be an inteface!
vType.IsInterface.Should().Be(true);
if (aMockBehavior == MockBehavior.Strict)
{
return(_Kernel.GetMock <T>());
}
// FRAGILE! VerifyAll() won't verify this mock!
Mock <T> vInstance = new Mock <T>(aMockBehavior);
_Kernel.Rebind <T>().ToConstant(vInstance.Object);
return(new Mock <T>(aMockBehavior));
}
/// <summary>
/// Return an instance of a class that has been converted to a mock class.
/// This variant allows calls to the Setup method such that the methods
/// can be subonred into returning a desired result for testing purposes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="aMockBehavior"></param>
/// <returns></returns>
public Mock <T> GetMock <T>
(MockBehavior aMockBehavior = DefaultMockBehavior) where T : class
{
Type vType = typeof(T);
// If you're asking for a mock, it better be an inteface!
Assert.That(vType.IsInterface, Is.True);
if (aMockBehavior == MockBehavior.Strict)
{
return(_Kernel.GetMock <T>());
}
// FRAGILE! VerifyAll() won't verify this mock!
Mock <T> vInstance = new Mock <T>(aMockBehavior);
_Kernel.Rebind <T>().ToConstant(vInstance.Object);
return(new Mock <T>(aMockBehavior));
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
OwinContext = Fakes.CreateOwinContext();
EntitiesContext = (MockEntitiesContext = new Mock <IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock <IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock <IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock <INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock <IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock <IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock <IIndexingService>()).Object;
MockPackageFileService = new Mock <IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>())).Returns(Task.FromResult(0));
PackageFileService = MockPackageFileService.Object;
TestUtility.SetupHttpContextMockForUrlGeneration(new Mock <HttpContextBase>(), this);
}
public MockedFolder(string name, string id = null, IFolder parent = null, MockBehavior behavior = MockBehavior.Strict) : base(name, id, behavior)
{
this.parent = parent;
this.Setup(m => m.ParentId).Returns(this.parent != null ? this.parent.Id : (string)null);
this.Setup(m => m.GetChildren()).Returns(this.children.Object);
this.Setup(m => m.GetChildren(It.IsAny <IOperationContext>())).Returns(this.children.Object);
this.Setup(m => m.IsRootFolder).Returns(this.parent == null);
this.Setup(m => m.FolderParent).Returns(() => this.parent);
this.ObjectType = new MockedFolderType(behavior: behavior).Object;
// this.Setup(m => m.Path).Returns(this.parent.Path + "/" + this.name);
this.Setup(m => m.LastModificationDate).Returns(this.lastModification);
this.Setup(m => m.CreationDate).Returns(this.creationDate);
this.UpdateChangeToken();
// this.Setup(m => m.Move(It.Is<IObjectId>(obj => obj.Id == this.Object.ParentId), It.IsAny<IObjectId>())).Returns(this.Object);
this.Setup(m => m.DeleteTree(It.IsAny <bool>(), It.IsAny <UnfileObject?>(), It.IsAny <bool>())).Returns <bool, UnfileObject?, bool>((a, u, c) => this.DeleteTree(a, u, c));
this.Setup(m => m.Delete(It.IsAny <bool>())).Callback <bool>((allVersions) => this.Delete(allVersions));
}
protected TaskUnitTestBase(MockBehavior propertiesMockBehavior = MockBehavior.Strict)
{
Tasks = new Mock <ITaskFluentInterface>();
CoreTasks = new Mock <ICoreTaskFluentInterface>();
Context = new Mock <ITaskContextInternal>();
Properties = new Mock <IBuildPropertiesSession>(propertiesMockBehavior);
Context.Setup(x => x.Properties).Returns(Properties.Object);
Context.Setup(x => x.Tasks()).Returns(Tasks.Object);
Context.Setup(x => x.CoreTasks()).Returns(CoreTasks.Object);
RunProgramTask = new Mock <IRunProgramTask>();
RunProgramTask.Setup(x => x.WithArguments(It.IsAny <string>())).Returns(RunProgramTask.Object);
RunProgramTask.Setup(x => x.WithArguments(It.IsAny <string[]>())).Returns(RunProgramTask.Object);
RunProgramTask.Setup(x => x.WorkingFolder(It.IsAny <string>())).Returns(RunProgramTask.Object);
RunProgramTask.Setup(x => x.CaptureErrorOutput()).Returns(RunProgramTask.Object);
RunProgramTask.Setup(x => x.CaptureOutput()).Returns(RunProgramTask.Object);
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
OwinContext = Fakes.CreateOwinContext();
EntitiesContext = (MockEntitiesContext = new Mock<IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock<IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock<IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock<INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock<IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock<IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock<IIndexingService>()).Object;
MockPackageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>())).Returns(Task.FromResult(0));
PackageFileService = MockPackageFileService.Object;
TestUtility.SetupHttpContextMockForUrlGeneration(new Mock<HttpContextBase>(), this);
}
public RabbitMqConsumerTest()
{
const MockBehavior mockBehavior = MockBehavior.Strict;
SetupChannelMock(mockBehavior);
SetupMessageMock(mockBehavior);
SetupBuilderMock(mockBehavior);
SetupManagerMock(mockBehavior);
SetupProcessorMock(mockBehavior);
SetupPublisherMock(mockBehavior);
SetupMessageProcessorMock(mockBehavior);
_consumer = new RabbitMqConsumer(_channelMock.Object, _publisherMock.Object, _builderMock.Object, _managerMock.Object, _messageProcessorMock.Object);
SetupBasicPropertiesMock(mockBehavior);
var userData = Encoding.UTF8.GetBytes(UserJson);
_basicDeliverEventArgs = new BasicDeliverEventArgs(ConsumerTag, 1, false, string.Empty, QueueName, _basicPropertiesMock.Object, userData);
}
public Mock(MockBehavior behavior, params object[] args)
{
if (args == null)
{
args = new object[] { null };
}
this.Name = GenerateMockName();
this.Behavior = behavior;
this.Interceptor = new Interceptor(behavior, typeof(T), this);
this.constructorArguments = args;
this.ImplementedInterfaces.AddRange(typeof(T).GetInterfaces().Where(i => (i.IsPublic || i.IsNestedPublic) && !i.IsImport));
this.ImplementedInterfaces.Add(typeof(IMocked <T>));
this.CheckParameters();
}
public MockHttpSessionState(MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
sessionStorage = new Dictionary <string, object>();
this.Setup(p => p[It.IsAny <string>()]).Returns((string index) => sessionStorage[index]);
this.Setup(p => p.Add(It.IsAny <string>(), It.IsAny <object>())).Callback <string, object>((name, obj) =>
{
if (!sessionStorage.ContainsKey(name))
{
sessionStorage.Add(name, obj);
}
else
{
sessionStorage[name] = obj;
}
});
}
/// <summary>
/// Create <typeparamref name="T" /> type as a Mock service and return this instance.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="behavior"></param>
public static Mock <T> Create <T>(MockBehavior behavior = MockBehavior.Strict) where T : class
{
var service = Get <T>();
if (service != null)
{
return(service);
}
var mockedType = MakeGenericMockedType <T>();
var mockInstance = (Mock <T>)Activator.CreateInstance(mockedType, behavior);
Services.Add(mockInstance);
return(mockInstance);
}
private Mock <Pin> CreatePinMock(Activity activity, MockBehavior mockBehavior = MockBehavior.Strict)
{
var lifelineMock = new Mock <Lifeline>(null, null, null, 0);
lifelineMock.Setup(lifeline => lifeline.Index).Returns(0);
var startPinMock = new Mock <Pin>(mockBehavior, null, lifelineMock.Object, PinType.None);
startPinMock.Setup(pin => pin.Orientation).Returns(Orientation.None);
if (activity != null)
{
startPinMock.Setup(pin => pin.SetActivity(activity));
}
return(startPinMock);
}
public MockHttpContext(IAuthentication auth, MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
//request
Browser = new MockHttpBrowserCapabilities(mockBehavior);
Browser.Setup(b => b.IsMobileDevice).Returns(false);
Request = new MockHttpRequest(mockBehavior);
Request.Setup(r => r.Cookies).Returns(Cookies);
Request.Setup(r => r.ValidateInput());
Request.Setup(r => r.UserAgent).Returns("Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11");
Request.Setup(r => r.Browser).Returns(Browser.Object);
this.Setup(p => p.Request).Returns(Request.Object);
//response
Cache = new MockHttpCachePolicy(MockBehavior.Loose);
Response = new MockHttpResponse(mockBehavior);
Response.Setup(r => r.Cookies).Returns(Cookies);
Response.Setup(r => r.Cache).Returns(Cache.Object);
this.Setup(p => p.Response).Returns(Response.Object);
//user
if (auth != null)
{
this.Setup(p => p.User).Returns(() => auth.CurrentUser);
}
else
{
this.Setup(p => p.User).Returns(new UserProvider("", null));
}
//Session State
SessionState = new MockHttpSessionState();
this.Setup(p => p.Session).Returns(SessionState.Object);
//Server Utility
ServerUtility = new MockHttpServerUtility(mockBehavior);
this.Setup(p => p.Server).Returns(ServerUtility.Object);
//Items
var items = new ListDictionary();
this.Setup(p => p.Items).Returns(items);
}
public ReAttachMocks(MockBehavior behavior = MockBehavior.Strict)
{
CreateMockDebugger(behavior);
CreateMockDTE(behavior);
CreateMockMenuCommandService(behavior);
MockReAttachReporter = new ReAttachTraceReporter(); // Use real reporting for simplicity.
MockReAttachUi = new Mock<IReAttachUi>(behavior);
MockReAttachHistory = new Mock<IReAttachHistory>(behavior);
MockReAttachHistoryItems = new ReAttachTargetList(ReAttachConstants.ReAttachHistorySize);
MockReAttachHistory.Setup(h => h.Items).Returns(MockReAttachHistoryItems);
MockReAttachDebugger = new Mock<IReAttachDebugger>(behavior);
// Wire up all services and modules.
MockReAttachPackage = new Mock<IReAttachPackage>(behavior);
MockReAttachPackage.Setup(p => p.GetService(typeof(IMenuCommandService))).Returns(MockMenuService.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SVsShellDebugger))).Returns(MockDebugger.Object);
MockReAttachPackage.Setup(p => p.GetService(typeof(SDTE))).Returns(MockDTE.Object);
MockReAttachPackage.Setup(p => p.Reporter).Returns(MockReAttachReporter);
MockReAttachPackage.Setup(p => p.Ui).Returns(MockReAttachUi.Object);
MockReAttachPackage.Setup(p => p.History).Returns(MockReAttachHistory.Object);
MockReAttachPackage.Setup(p => p.Debugger).Returns(MockReAttachDebugger.Object);
}
public ModifyStudentHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public ModifyInstructorAndCoursesHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public InstructorControllerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
InstructorApplicationServiceMock = new Mock<IInstructorApplicationService>(_MockBehaviour);
QueryRepositoryMock = new Mock<IQueryRepository>(_MockBehaviour);
Initalise();
}
public DepartmentControllerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
DepartmentApplicationServiceMock = new Mock<IDepartmentApplicationService>(_MockBehaviour);
QueryRepositoryMock = new Mock<IQueryRepository>(_MockBehaviour);
Initalise();
}
public DeleteInstructorHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public DeleteDepartmentHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public CreateInstructorWithCoursesHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public UpdateCourseHandlerFactory(MockBehavior mockBehaviour)
{
_MockBehaviour = mockBehaviour;
RepositoryMock = new Mock<IRepository>(_MockBehaviour);
Initalise();
}
public Interceptor(MockBehavior behavior, Type targetType, Mock mock)
{
InterceptionContext = new InterceptorContext(mock, targetType, behavior);
}
public Interceptor(MockBehavior behavior, Type targetType, Mock mock)
{
this.behavior = behavior;
this.targetType = targetType;
this.Mock = mock;
}
