public DataRecipeHandler(ICoeveryServices coeveryServices, ITransactionManager transactionManager)
 {
     _coeveryServices = coeveryServices;
     _transactionManager = transactionManager;
     Logger = NullLogger.Instance;
     T = NullLocalizer.Instance;
 }

        public SpamFilterPartHandler(
            IRepository<SpamFilterPartRecord> repository,
            ITransactionManager transactionManager,
            ISpamService spamService
            ) {
            _transactionManager = transactionManager;
            _spamService = spamService;

            Filters.Add(StorageFilter.For(repository));

            OnCreating<SpamFilterPart>((context, part) => {
                part.Status = _spamService.CheckForSpam(part);
            });

            OnPublishing<SpamFilterPart>((context, part) => {
                if (part.Status == SpamStatus.Spam) {
                    if (part.Settings.GetModel<SpamFilterPartSettings>().DeleteSpam) {
                        _transactionManager.Cancel();
                    }

                    context.Cancel = true;
                }
            });

        }

 public SagePayService(ITransactionManager transactionManager, ICartSessionManager cartSessionManager, IGetUserGuid getUserGuid, ICartGuidResetter cartGuidResetter)
 {
     _transactionManager = transactionManager;
     _cartSessionManager = cartSessionManager;
     _getUserGuid = getUserGuid;
     _cartGuidResetter = cartGuidResetter;
 }

 public DataRecipeHandler(IOrchardServices orchardServices, ITransactionManager transactionManager, IRecipeJournal recipeJournal) {
     _orchardServices = orchardServices;
     _transactionManager = transactionManager;
     _recipeJournal = recipeJournal;
     Logger = NullLogger.Instance;
     T = NullLocalizer.Instance;
 }

 public void Init(IEnumerable<Type> dataMigrations) {
    
     var builder = new ContainerBuilder();
     _folders = new StubFolders();
     var contentDefinitionManager = new Mock<IContentDefinitionManager>().Object;
     
     builder.RegisterInstance(new ShellSettings { DataTablePrefix = "TEST_"});
     
     builder.RegisterType<SqlServerDataServicesProvider>().As<IDataServicesProvider>();
     builder.RegisterType<DataServicesProviderFactory>().As<IDataServicesProviderFactory>();
     builder.RegisterType<NullInterpreter>().As<IDataMigrationInterpreter>();
     builder.RegisterInstance(_folders).As<IExtensionFolders>();
     builder.RegisterInstance(contentDefinitionManager).As<IContentDefinitionManager>();
     builder.RegisterType<ExtensionManager>().As<IExtensionManager>();
     builder.RegisterType<DataMigrationManager>().As<IDataMigrationManager>();
     builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
     builder.RegisterType<StubCacheManager>().As<ICacheManager>();
     builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();
     builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>();
     _session = _sessionFactory.OpenSession();
     builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>().As<ITransactionManager>();
     foreach(var type in dataMigrations) {
         builder.RegisterType(type).As<IDataMigration>();
     }
     _container = builder.Build();
     _container.Resolve<IExtensionManager>();
     _dataMigrationManager = _container.Resolve<IDataMigrationManager>();
     _repository = _container.Resolve<IRepository<DataMigrationRecord>>();
     _transactionManager = _container.Resolve<ITransactionManager>();
     InitDb();
 }

        public void Init() {
            _session = _sessionFactory.OpenSession();
            foreach (var killType in new[] { typeof(ContentTypeDefinitionRecord), typeof(ContentPartDefinitionRecord), typeof(ContentFieldDefinitionRecord) }) {
                foreach (var killRecord in _session.CreateCriteria(killType).List()) {
                    _session.Delete(killRecord);
                }
            }
            _session.Flush();
            _session.Close();
            _session.Dispose();
            _session = _sessionFactory.OpenSession();

            var builder = new ContainerBuilder();
            builder.RegisterAutoMocking();
            builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>();
            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
            builder.RegisterType(typeof(SettingsFormatter)).As(typeof(ISettingsFormatter));
            builder.RegisterType<Signals>().As<ISignals>();
            builder.RegisterType<StubCacheManager>().As<ICacheManager>();
            builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();

            _session = _sessionFactory.OpenSession();
            builder.RegisterInstance(_transactionManager = new TestTransactionManager(_session)).As<ITransactionManager>();

            _container = builder.Build();

        }

 public MembershipService(IWebsite website, IMemberDao memberDao, IRoleDao roleDao, ITransactionManager transactionManager)
 {
     this._website = website;
     this._memberDao = memberDao;
     this._roleDao = roleDao;
     this._transactionManager = transactionManager;
 }

 public FileManagerService(IWebsite website, IFileStorage fileStorage, IStorageItemRepository storageItemRepository, ITransactionManager transactionManager)
 {
     this._fileStorage = fileStorage;
     this._website = website;
     this._transactionManager = transactionManager;
     this._storageItemRepository = storageItemRepository;
 }

 public ImageService(IWebsite website, IImageStorage imageStorage, IImageRepository imageRepository, ITransactionManager transactionManager)
 {
     this._website = website;
     this._imageStorage = imageStorage;
     this._imageRepository = imageRepository;
     this._transactionManager = transactionManager;
 }

 public PageProvider(ITransactionManager trans,  IRepository<SubSite> repoSite, IRepository<WebPage> repoPage, IRepository<WebPageWidget> repoControl)
 {
     this.trans = trans;
     this.repoSite = repoSite;
     this.repoPage = repoPage;
     this.repoControl = repoControl;
 }

 public override void Init() {
     base.Init();
     _distributedLockService = _container.Resolve<DistributedLockService>();
     _applicationEnvironment = (StubApplicationEnvironment)_container.Resolve<IApplicationEnvironment>();
     _distributedLockRepository = _container.Resolve<IRepository<DistributedLockRecord>>();
     _transactionManager = _container.Resolve<ITransactionManager>();
 }

 public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
     : base(factory) {
     this.lifecycleManager = lifecycleManager;
     this.persistor = persistor;
     this.transactionManager = transactionManager;
     NakedObject = nakedObjectAdapter;
 }

 public SessionLocator(
     ISessionFactoryHolder sessionFactoryHolder,
     ITransactionManager transactionManager) {
     _sessionFactoryHolder = sessionFactoryHolder;
     _transactionManager = transactionManager;
     Logger = NullLogger.Instance;
 }

		public PerTransactionLifestyleManagerBase(ITransactionManager manager)
		{
			Contract.Requires(manager != null);
			Contract.Ensures(_Manager != null);
			_Logger.Debug("created");
			_Manager = manager;
		}

 internal DatabaseSession(IDatabaseCommandFactory databaseCommandFactory, ITransactionManager transactionManager, IDatabaseReaderFactory databaseReaderFactory, IConnectionHandler connectionHandler)
 {
     _databaseCommandFactory = databaseCommandFactory;
     _transactionManager = transactionManager;
     _databaseReaderFactory = databaseReaderFactory;
     _connectionHandler = connectionHandler;
 }

 public RepoTimelineProvider(IIdGenerator generator, ITransactionManager trans, IRepository<TimelineItem> repoTi, IRepository<TimelineItemHistory> repoTih)
 {
     this.generator = generator;
     this.trans = trans;
     this.repoTi = repoTi;
     this.repoTih = repoTih;
 }

		public TransactionalConnectionFactory(
			ITransactionManager manager, String connectionString,
			Type dbConnectionType)
		{
			_manager = manager;
			_connectionString = connectionString;
			_dbConnectionType = dbConnectionType;
		}

 public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) {
     try {
         property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + property, e);
     }
 }

 public void SetUp()
 {
     var container = new WindsorContainer();
     DependencyResolver.SetResolver(new WindsorDependencyResolver(container));
     container.Register(Component.For<ITransactionManager>().ImplementedBy<TestITransactionManager>().Named("transaction.manager"));
     manager = DependencyResolver.Current.GetService<ITransactionManager>();
     attribute = new MvcTransactionAttribute();
 }

		/// <summary>
		/// 	Constructor.
		/// </summary>
		/// <param name = "getSession"></param>
		public SessionManager(Func<ISession> getSession, ITransactionManager transactionManager)
		{
			Contract.Requires(getSession != null);
			Contract.Ensures(this.getSession != null);

			this.getSession = getSession;
			this.transactionManager = transactionManager;
		}