public void BaseTestInitialize()
        {
            JsonConvert.DefaultSettings = () => new JsonSerializerSettings
            {
                Formatting = Formatting.None,
                Converters = new JsonConverter[] { new JsonKnownTypeConverter() }
            };

            var container = new UnityContainer().LoadConfiguration();
            this.dataAccess = container.Resolve<IDataAccess>();
            var formMetadata = this.dataAccess.GetProduct("1000");
            var subpageMetadata = this.dataAccess.GetProduct("5000");
            this.controlList = formMetadata.FormDefinition.Pages.AllControls;
            this.subpageControlList = subpageMetadata.FormDefinition.Pages.AllControls;
            this.validatorList = new RegexValidatorList
                                 {
                                     new RegexValidator
                                     {
                                         Id = "1",
                                         Regex = "^((\\+\\d{1,3}[\\- ]?)??(\\(?\\d{1,4}\\)?[\\- ])?((?:\\d{0,5})\\d{3,4}[\\- ]?\\d{3,4}))?$",
                                         Name = "Phone"
                                     }
                                 };

            IEnumerable<Control> flatControls = this.controlList.Flatten();
            this.defaultControlsAccess = new List<ControlAccess>(flatControls.Select(e => new ControlAccess(e.Id, AccessLevel.Write)));
        }

 /// <summary>
 ///     Creates a TransactionRepository Object
 /// </summary>
 /// <param name="dataAccess">Instanced <see cref="IDataAccess{T}" /> for <see cref="FinancialTransaction" /></param>
 /// <param name="recurringDataAccess">
 ///     Instanced <see cref="IDataAccess{T}" /> for <see cref="RecurringTransaction" />
 /// </param>
 public TransactionRepository(IDataAccess<FinancialTransaction> dataAccess,
     IDataAccess<RecurringTransaction> recurringDataAccess)
 {
     this.dataAccess = dataAccess;
     this.recurringDataAccess = recurringDataAccess;
     data = new ObservableCollection<FinancialTransaction>(this.dataAccess.LoadList());
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SystemWorkflowManager" /> class.
 /// </summary>
 /// <param name="workflowService">Gateway into the workflow subsystem.</param>
 /// <param name="formServiceGateway">Gateway into the forms subsystem.</param>
 /// <param name="dataAccess">The data access.</param>
 public SystemWorkflowManager(IWorkflowService workflowService, IFormServiceGateway formServiceGateway, IDataAccess dataAccess)
 {
     this.workflowService = workflowService;
     this.formServiceGateway = formServiceGateway;
     this.dataAccess = dataAccess;
     this.productCache = new Dictionary<string, ProductVersionList>();
 }

        public BoxEntry(IRecordView view, IDataAccess dataAccess)
        {
            if (view == null) throw new ArgumentNullException("view");

            this.view = view;
            this.dataAccess = dataAccess;
        }

        public SettingsViewModel(IDataAccess dataAccess)
        {
            this.dataAccess = dataAccess;

            LightTheme = Settings.Default.LightTheme;
            DBLocation = Settings.Default.DBLocation;
        }

        public void CreateProperlyFileInDb_Test()
        {
            // Arrange
            ArrangeMocks();
            _dataAccess = MockRepository.GenerateMock<IDataAccess>();
            var service = new ScanningService(_lineProcessor, _dataAccess, _fileReader);

            var actualCreatedFilePath = string.Empty;
            _dataAccess.Expect(x => x.GetFile(Arg<string>.Is.Anything)).WhenCalled(x =>
                                    {
                                        actualCreatedFilePath = (string) x.Arguments[0];
                                    })
                                    .Return(GetTestFileEntity(_testPath));

            _dataAccess.Expect(x => x.SaveWords(Arg<IEnumerable<string>>.Is.Anything)).Return(GetSaveWordsResult());
            _dataAccess.Expect(x => x.AddWordEntries(Arg<List<WEntry>>.Is.Anything));

            // Act
            var actualResult = service.AddScanningFile(_testPath, _token);
            actualResult.Wait(_token);

            // Assert
            _dataAccess.VerifyAllExpectations();
            Assert.AreEqual(_testPath, actualCreatedFilePath);
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="T:Stumps.Server.StumpsServerInstance"/> class.
        /// </summary>
        /// <param name="serverFactory">The factory used to initialize new server instances.</param>
        /// <param name="serverId">The unique identifier of the Stumps server.</param>
        /// <param name="dataAccess">The data access provider used by the instance.</param>
        public StumpsServerInstance(IServerFactory serverFactory, string serverId, IDataAccess dataAccess)
        {
            if (serverFactory == null)
            {
                throw new ArgumentNullException("serverFactory");
            }

            _serverFactory = serverFactory;

            this.ServerId = serverId;

            _lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
            _dataAccess = dataAccess;

            // Setup the objects needed to keep track of Stumps.
            _stumpList = new List<StumpContract>();
            _stumpReference = new Dictionary<string, StumpContract>(StringComparer.OrdinalIgnoreCase);

            // Setup the recordings maintained by the server instance.
            this.Recordings = new Recordings();

            // Initialize the server
            InitializeServer();

            // Initialize the Stumps
            InitializeStumps();
        }

		public static User GetUser(IDataAccess dataAccess, int userId)
		{
			if(dataAccess == null)
				throw new ArgumentNullException("dataAccess");

			return dataAccess.Select<User>(DATA_ENTITY_USER, new Condition("UserId", userId)).FirstOrDefault();
		}

        public TokenLogic(IDataAccess objDataAccess)
        {
            //primesc obiectul, nu e treaba TokenLogic ce dataAccess se foloseste
            //unity are grija de dependency injection

            _dataAccess = objDataAccess;
        }

        /// <summary>
        ///     Creates a AccountRepository Object
        /// </summary>
        /// <param name="dataAccess">Instanced account data Access</param>
        public AccountRepository(IDataAccess<Account> dataAccess)
        {
            this.dataAccess = dataAccess;

            Data = new ObservableCollection<Account>();
            Load();
        }

 public void Setup()
 {
     fakeDataAccess = Substitute.For<IDataAccess>();
     fakeView = Substitute.For<ISearchView>();
     target = new SearchPresenter(fakeDataAccess);
     target.SearchView = fakeView;
 }

        public ShiftRuleFactory(IDataAccess dataAccess)
        {
            LogSession.Main.EnterMethod(this, "ShiftRuleFactory");
            try
            {
                /*--------- Your code goes here-------*/
                this.DataAccess = dataAccess;

                this.m_HardRulesRepository = new ShiftRuleCollection();
                this.m_SoftRulesRepository = new ShiftRuleCollection();

                CreateRulesInstances(ref m_HardRulesRepository, ref m_SoftRulesRepository);

                foreach (var hardRule in this.m_HardRulesRepository)
                {
                    LogSession.Main.LogObject("Hard Rules Repository item", hardRule);
                }
                foreach (var softRule in this.m_SoftRulesRepository)
                {
                    LogSession.Main.LogObject("Soft Rules Repository item", softRule);
                }
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "ShiftRuleFactory");
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="AttachmentManager"/> class.
 /// </summary>
 /// <param name="attachmentAccess">Provides access to application attachments.</param>
 /// <param name="dataAccess">Provides access to the data layer.</param>
 /// <param name="applicationManager">Manages applications.</param>
 /// <param name="entitlementProvider">The entitlement provider.</param>
 public AttachmentManager(IAttachmentAccess attachmentAccess, IDataAccess dataAccess, ApplicationManager applicationManager, IApplicationEntitlementProvider entitlementProvider)
     : base(dataAccess)
 {
     this.attachmentAccess = attachmentAccess;
     this.applicationManager = applicationManager;
     this.entitlementProvider = entitlementProvider;
 }

 public void Setup()
 {
     fakeDataAccess = Substitute.For<IDataAccess>();
     fakeView = Substitute.For<IRecordView>();
     target = new BoxEntry(fakeDataAccess);
     target.View = fakeView;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="UserService"/> class.
        /// </summary>
        /// <param name="dataAccess">The data access.</param>
        /// <exception cref="System.ArgumentNullException">dataAccess</exception>
        public UserService(IDataAccess dataAccess)
		{
			if (dataAccess == null)
				throw new ArgumentNullException ("dataAccess");

			_dataAccess = dataAccess;
		}

        /// <summary>
        ///     Initializes a new instance of the <see cref="T:Stumps.Server.Data.HttpRequestEntityReader"/> class.
        /// </summary>
        /// <param name="serverId">The unique identifier for the server.</param>
        /// <param name="requestEntity">The request entity.</param>
        /// <param name="dataAccess">The data access provider used by the instance.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="serverId"/> is <c>null</c>.
        /// or
        /// <paramref name="requestEntity"/> is <c>null</c>.
        /// or 
        /// <paramref name="dataAccess"/> is <c>null</c>.
        /// </exception>
        public HttpRequestEntityReader(string serverId, HttpRequestEntity requestEntity, IDataAccess dataAccess)
        {
            if (string.IsNullOrWhiteSpace(serverId))
            {
                throw new ArgumentNullException("serverId");
            }

            if (requestEntity == null)
            {
                throw new ArgumentNullException("requestEntity");

            }

            if (dataAccess == null)
            {
                throw new ArgumentNullException("dataAccess");
            }

            _entity = requestEntity;

            this.Headers = new HttpHeaders();
            foreach (var pair in _entity.Headers)
            {
                this.Headers[pair.Name] = pair.Value;
            }

            _body = dataAccess.ServerReadResource(serverId, requestEntity.BodyResourceName) ?? new byte[0];
        }

        /// <summary>
        /// Constructor, sets the parameters
        /// </summary>
        /// <param name="loggerConfiguration">Logger Configuration Factory</param>
        /// <param name="consoleAccess">Console Factory</param>
        /// <param name="dataAccess">DB Data Factory</param>
        /// <param name="fileAccess">File Factory</param>
        public JobLogger(ILoggerConfiguration loggerConfiguration, IConsoleAccess consoleAccess, IDataAccess dataAccess, IFileAccess fileAccess)
        {
            this._dataAccess = dataAccess;
            this._consoleAccess = consoleAccess;
            this._fileAccess = fileAccess;

            this._loggerConfiguration = loggerConfiguration;
        }

        public ScanningService(ILineProcessor lineProcessor, IDataAccess dataAccess, IFileReader fileReader)
        {
            _lineProcessor = lineProcessor;
            _dataAccess = dataAccess;
            _fileReader = fileReader;

            Mapper.CreateMap<WordItem, WordModel>();
        }

        /// <summary>
        ///     Creates a TransactionRepository Object
        /// </summary>
        /// <param name="dataAccess">Instanced <see cref="IDataAccess{T}" /> for <see cref="FinancialTransaction" /></param>
        /// <param name="recurringDataAccess">
        ///     Instanced <see cref="IDataAccess{T}" /> for <see cref="RecurringTransaction" />
        /// </param>
        public TransactionRepository(IDataAccess<FinancialTransaction> dataAccess,
            IDataAccess<RecurringTransaction> recurringDataAccess)
        {
            this.dataAccess = dataAccess;
            this.recurringDataAccess = recurringDataAccess;

            Load();
        }

 /// <summary>
 /// A random static "Factory" method
 /// </summary>
 /// <param name="id">The value for the Id parameter.</param>
 /// <param name="name">The value for the Name parameter.</param>
 /// <param name="dataAccess">The data access.</param>
 public static void RandomRepositoryMethod(Guid id, string name, IDataAccess dataAccess)
 {
     dataAccess.ExecuteNonQuery(
         ConnectionString,
         SomeRandomTableInsertSP,
         DataAccess.CreateParameter("@Id", SqlDbType.UniqueIdentifier, id),
         DataAccess.CreateParameter("@Name", SqlDbType.NVarChar, name));
 }