private void Setup(IMockFactory factory)
{
var httpContext = factory.DynamicMock <HttpContextBase>();
var request = factory.DynamicMock <HttpRequestBase>();
var response = factory.DynamicMock <HttpResponseBase>();
var server = factory.DynamicMock <HttpServerUtilityBase>();
var cache = HttpRuntime.Cache;
httpContext.ReturnFor(c => c.Session, Session);
httpContext.ReturnFor(c => c.Cache, cache);
httpContext.SetupProperty(c => c.User);
request.ReturnFor(r => r.QueryString, QueryString);
request.ReturnFor(r => r.Form, Form);
request.ReturnFor(r => r.Files, (HttpFileCollectionBase)Files);
request.ReturnFor(r => r.ServerVariables, new NameValueCollection());
request.CallbackFor(r => r.AcceptTypes, () => AcceptTypes);
request.CallbackFor(r => r.Params, () => new NameValueCollection {
QueryString, Form
});
request.CallbackFor(r => r.AppRelativeCurrentExecutionFilePath, () => AppRelativeCurrentExecutionFilePath);
request.CallbackFor(r => r.ApplicationPath, () => ApplicationPath);
request.CallbackFor(r => r.PathInfo, () => PathInfo);
request.CallbackFor(r => r.RawUrl, () => RawUrl);
response.SetupProperty(r => r.Status);
httpContext.ReturnFor(c => c.Request, request.Object);
httpContext.ReturnFor(c => c.Response, response.Object);
httpContext.ReturnFor(c => c.Server, server.Object);
HttpContext = httpContext.Object;
}
static ContainerBuilder CreateBuilder(IMockFactory mockFactory)
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
containerBuilder.RegisterSource(new AutofacMockRegistrationHandler(mockFactory));
return containerBuilder;
}
/// <summary>
/// Creates a factory that will use the first creatable factory type.
/// </summary>
/// <param name="factoryTypes"></param>
internal FirstAvailableMockFactory(params Type[] factoryTypes)
{
foreach (Type factoryType in factoryTypes)
{
try
{
_realFactory = (IMockFactory)Activator.CreateInstance(factoryType);
break;
}
catch (TargetInvocationException ex)
{
//Factories should throw an InvalidOperationException if they can't be
//instantiated due to a missing library. If that happens, we want to
//attempt loading the next available factory.
if (ex.InnerException is InvalidOperationException)
{
continue;
}
throw;
}
}
if (_realFactory == null)
{
throw new InvalidOperationException("Unable to create a factory. Be sure a mocking framework is available.");
}
}
static ContainerBuilder CreateBuilder(IMockFactory mockFactory)
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
containerBuilder.RegisterSource(new AutofacMockRegistrationHandler(mockFactory));
return(containerBuilder);
}
public TinyIoCContainer Create(IMockFactory mockFactory)
{
var container = new TinyIoCContainer();
RegisterScenarios(container);
RegisterScenarioContainer(container, mockFactory);
return(container);
}
public ContainerBuilder Create(IMockFactory mockFactory)
{
var builder = new ContainerBuilder();
RegisterScenarios(builder);
RegisterScenarioContainer(builder, mockFactory);
return(builder);
}
public ObservationContext(ITestState <Subject> test_state_implementation,
ISubjectDependencyBuilder subject_dependency_builder,
IMockFactory mock_factory,
ISubjectFactory subject_factory)
{
this.mock_factory = mock_factory;
this.test_state = test_state_implementation;
this.subject_dependency_builder = subject_dependency_builder;
this.subject_factory = subject_factory;
}
public void GivenIHaveAnObservationContext()
{
this.testState = MockRepository.GenerateMock<ITestState<DummyClassWithSingleParameterisedConstructor>>();
this.subjectDependencyBuilder = MockRepository.GenerateMock<ISubjectDependencyBuilder>();
this.mockFactory = MockRepository.GenerateMock<IMockFactory>();
this.subjectFactory = MockRepository.GenerateMock<ISubjectFactory>();
this.subject = new ObservationContext<DummyClassWithSingleParameterisedConstructor>(
this.testState, this.subjectDependencyBuilder, this.mockFactory, this.subjectFactory);
}
public TinyIoCContainer Create(IMockFactory mockFactory)
{
if (mockFactory == null)
{
mockFactory = new NullMockFactory();
}
var container = new TinyIoCContainer();
RegisterScenarios(container);
RegisterScenarioContainer(container, mockFactory);
return(container);
}
//public AutoMockingContainer(MockRepository mocks, bool resolveProperties)
// : this(new MockRepositoryAdapter(mocks), resolveProperties)
//{
//}
/// <summary>Creates an AutoMocking Container with the given <paramref name="mocks"/> repository.</summary>
/// <param name="mocks">The mocks repository to use</param>
/// <param name="resolveProperties"><c>true</c> if properties should be resolved, otherwise <c>false</c>; the defualt is <c>false</c></param>
public AutoMockingContainer(MockRepository mocks, bool resolveProperties)
{
if (mocks == null)
{
_mockFactory = new AAAMockFactory();
}
else
{
_mockFactory = new DefaultMockFactory(mocks);
}
_mocks = mocks;
_resolveProperties = resolveProperties;
}
private void RegisterScenarioContainer(TinyIoCContainer container, IMockFactory mockFactory)
{
if (mockFactory.GetType() == typeof(NullMockFactory))
{
container.Register <IContainer>((c, p) => new TinyContainer(c.GetChildContainer()));
this.Log()
.DebugFormat("Registered {ScenarioContainer} for IContainer", "TinyContainer");
}
else
{
container.Register <IContainer>((c, p) => new TinyMockingContainer(mockFactory, c.GetChildContainer()));
this.Log()
.DebugFormat("Registered {ScenarioContainer} for IContainer with mock factory {MockFactory}", "TinyMockingContainer", mockFactory.MockProviderName);
}
}
public static void RegisterSpecify(this ContainerBuilder builder, IMockFactory mockFactory = null)
{
if (builder == null)
{
builder = new ContainerBuilder();
}
if (mockFactory == null)
{
mockFactory = new NullMockFactory();
}
RegisterScenarios(builder);
RegisterScenarioContainer(builder, mockFactory);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestControllerBuilder"/> class using
/// the specified mock factory to create any mock objects.
/// </summary>
public TestControllerBuilder(IMockFactory mockFactory)
{
AppRelativeCurrentExecutionFilePath = "~/";
ApplicationPath = "/";
PathInfo = "";
RouteData = new RouteData();
Session = new MockSession();
TempDataDictionary = new TempDataDictionary();
QueryString = new NameValueCollection();
Form = new NameValueCollection();
Files = new WriteableHttpFileCollection();
Setup(mockFactory);
}
private void RegisterScenarioContainer(ContainerBuilder builder, IMockFactory mockFactory)
{
if (mockFactory == null)
{
builder.Register <IContainer>(c => new AutofacContainer(c.Resolve <ILifetimeScope>().BeginLifetimeScope()));
this.Log().DebugFormat("Registered {ScenarioContainer} for IContainer", "TinyContainer");
}
else
{
builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
builder.RegisterSource(new AutofacMockRegistrationHandler(mockFactory));
builder.Register <IContainer>(c => new AutofacContainer(c.Resolve <ILifetimeScope>().BeginLifetimeScope()));
this.Log().DebugFormat("Registered {ScenarioContainer} for IContainer with mock factory {MockFactory}", "TinyMockingContainer", mockFactory.MockProviderName);
}
}
public Testable(params object[] dependancies)
{
this.MockFactory = (IMockFactory)Activator.CreateInstance(typeof(TMockFactory));
// Protects against null errors
this.Dependancies = new Dictionary <Type, object>();
// Inject dependacies for any constructors
var ctor = GetConstructor();
var constructorInstances = CreateInstancesOfConstructorParameters(ctor.GetParameters(), dependancies ?? new object[0]);
this.Instance = (T)ctor.Invoke(constructorInstances.ToArray());
// Inject any dependancies for any property dependancies
var properties = GetPropertiesFromType();
CreateInstancesForProperties(properties, dependancies);
SetPropertyObjects(properties, this.Dependancies);
}
public Mokkit(IMockFactory mockFactory)
{
_mockFactory = mockFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="TinyMockingContainer"/> class.
/// </summary>
/// <param name="mockFactory">The mock factory.</param>
/// <param name="container">The container.</param>
public TinyMockingContainer(IMockFactory mockFactory, TinyIoCContainer container)
: base(container)
{
_mockFactory = mockFactory;
}
public Scenery(IMockFactory mockFactory)
{
_mockFactory = mockFactory;
Mokkit = new Mokkit <TMokkitToken>(mockFactory);
}
public AutoMockingContainer(IMockFactory mockFactory)
: base(CreateBuilder(mockFactory))
{
}
public AutofacMockRegistrationHandler(IMockFactory mockFactory)
{
_mockFactory = mockFactory;
}
public AutofacAutoMockingContainer(IMockFactory mockFactory)
: base(CreateBuilder(mockFactory))
{
}
/// <summary> /// Creates a mock with the given parameters. /// </summary> /// <param name="factory">The <see cref="IMockFactory"/> used to create instances of mocks.</param> /// <param name="mocksAssembly">Assembly where compile-time generated mocks exist.</param> /// <returns>A mock that implements <see cref="IMocked"/> in addition to the specified <typeparamref name="T"/>.</returns> public static T CreateMock <T>(this IMockFactory factory, Assembly mocksAssembly) => (T)factory.CreateMock(mocksAssembly, typeof(T), new Type[0], new object[0]);
public AutofacMockRegistrationHandler(IMockFactory mockFactory)
{
_mockFactory = mockFactory;
}
public SubjectDependencyBuilder(IDependencyBag dependency_bag, IMockFactory mock_factory)
{
this.dependency_bag = dependency_bag;
this.mock_factory = mock_factory;
}
