/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database.</param>
/// <param name="lockBuilder">Lock builder.</param>
/// <param name="logger">Logging.</param>
public GameRoundLockDataManager(ISqlServerDatabase database, IObjectBuilder <ObjectLockEntity <GameRoundId>, ObjectLock <GameRoundId> > lockBuilder, ILogger <GameRoundLockDataManager> logger)
: base(database: database,
lockBuilder: lockBuilder,
new ObjectLockProcedures(clear: @"Locking.GameRound_Clear", acquire: @"Locking.GameRound_Acquire", release: @"Locking.GameRound_Release", isLocked: @"Locking.GameRound_IsLocked"),
logger: logger)
{
}
public WebServerTests(
DockerFixture fixture,
ITestOutputHelper helper)
{
_helper = helper;
_database = fixture.GenerateDatabase(Guid.NewGuid().ToString("N"));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">The database to connect to.</param>
/// <param name="brokenTransactionBuilder">Builder of <see cref="BrokenTransaction" /> objects.</param>
/// <param name="pendingTransactionBuilder">Builder of <see cref="PendingTransaction" /> objects.</param>
public TransactionDataManager(ISqlServerDatabase database,
IObjectCollectionBuilder <BrokenTransactionEntity, BrokenTransaction> brokenTransactionBuilder,
IObjectBuilder <PendingTransactionEntity, PendingTransaction> pendingTransactionBuilder)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._brokenTransactionBuilder = brokenTransactionBuilder ?? throw new ArgumentNullException(nameof(brokenTransactionBuilder));
this._pendingTransactionBuilder = pendingTransactionBuilder ?? throw new ArgumentNullException(nameof(pendingTransactionBuilder));
}
public StreamStoreFactory(string databaseName = "Poc", bool deleteDatabaseOnDispose = false)
{
_deleteDatabaseOnDispose = deleteDatabaseOnDispose;
DatabaseName = databaseName;
_localInstance = new LocalSqlServerDatabase(DatabaseName);
ConnectionString = CreateConnectionString();
}
public MsSqlStreamStoreFixture(string schema)
{
_schema = schema;
_databaseName = $"StreamStoreTests-{Guid.NewGuid():n}";
_localInstance = Environment.OSVersion.IsWindows()
? (ISqlServerDatabase) new LocalSqlServerDatabase(_databaseName)
: new DockerSqlServerDatabase(_databaseName);
ConnectionString = CreateConnectionString();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">The database to connect to.</param>
/// <param name="pendingTransactionBuilder">Builder of <see cref="PendingTransaction" /> objects.</param>
/// <param name="networkTransactionReceiptDataTableBuilder">Builder of pending transactions data tables.</param>
/// <param name="pendingTransactionsDataTableBuilder">Builder of state transactions data tables.</param>
public PendingTransactionDataManager(ISqlServerDatabase database,
IObjectCollectionBuilder <PendingTransactionEntity, PendingTransaction> pendingTransactionBuilder,
ISqlDataTableBuilder <NetworkTransactionReceiptEntity> networkTransactionReceiptDataTableBuilder,
ISqlDataTableBuilder <PendingTransaction> pendingTransactionsDataTableBuilder)
{
this._networkTransactionReceiptDataTableBuilder = networkTransactionReceiptDataTableBuilder ?? throw new ArgumentNullException(nameof(networkTransactionReceiptDataTableBuilder));
this._pendingTransactionsDataTableBuilder = pendingTransactionsDataTableBuilder ?? throw new ArgumentNullException(nameof(pendingTransactionsDataTableBuilder));
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._pendingTransactionBuilder = pendingTransactionBuilder ?? throw new ArgumentNullException(nameof(pendingTransactionBuilder));
}
public SqlServerDatabase(string databaseName)
{
if (Environment.GetEnvironmentVariable("CI") == null)
{
_database = new EmbeddedDockerSqlServerDatabase(databaseName);
}
else
{
_database = new ComposedDockerSqlServerDatabase(databaseName);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database.</param>
/// <param name="lockBuilder">Lock builder.</param>
/// <param name="objectLockProcedures">The procedures that should be used for accessing the Database locks.</param>
/// <param name="logger">Logging.</param>
protected ObjectLockDataManagerBase(ISqlServerDatabase database,
IObjectBuilder <ObjectLockEntity <TDataType>, ObjectLock <TDataType> > lockBuilder,
ObjectLockProcedures objectLockProcedures,
ILogger logger)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._lockBuilder = lockBuilder ?? throw new ArgumentNullException(nameof(lockBuilder));
this._objectLockProcedures = objectLockProcedures ?? throw new ArgumentNullException(nameof(objectLockProcedures));
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
this._machineName = Environment.MachineName;
}
public SqlServer()
{
if (Environment.GetEnvironmentVariable("CI") == null)
{
_inner = new SqlServerEmbeddedContainer();
}
else
{
_inner = new SqlServerComposedContainer();
}
}
public SqlServer()
{
if (Environment.GetEnvironmentVariable("CI") == null)
{
_inner = new SqlServerEmbeddedContainer();
}
else
{
_inner = new SqlServerComposedContainer();
}
MemoryStreamManager = new RecyclableMemoryStreamManager();
}
public MsSqlStreamStoreV3Fixture(string schema, bool disableDeletionTracking = false, string databaseNameOverride = null)
{
_schema = schema;
_disableDeletionTracking = disableDeletionTracking;
_databaseNameOverride = databaseNameOverride;
_databaseName = databaseNameOverride ?? $"StreamStoreTests-{Guid.NewGuid():n}";
_localInstance = Environment.OSVersion.IsWindows()
? (ISqlServerDatabase) new LocalSqlServerDatabase(_databaseName)
: new DockerSqlServerDatabase(_databaseName);
ConnectionString = CreateConnectionString();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database.</param>
/// <param name="lockBuilder">Lock builder.</param>
/// <param name="logger">Logging.</param>
public GameManagerLockDataManager(ISqlServerDatabase database,
IObjectBuilder <ObjectLockEntity <EthereumAddress>, ObjectLock <EthereumAddress> > lockBuilder,
ILogger <GameManagerLockDataManager> logger)
: base(database: database,
lockBuilder: lockBuilder,
new ObjectLockProcedures(clear: @"Locking.GameManager_Clear",
acquire: @"Locking.GameManager_Acquire",
release: @"Locking.GameManager_Release",
isLocked: @"Locking.GameManager_IsLocked"),
logger: logger)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">The database to connect to.</param>
/// <param name="gameRoundBuilder">Game round builder.</param>
/// <param name="blockNumberBuilder">Block number builder.</param>
/// <param name="winAmountTableBuilder">Win amount table builder</param>
/// <param name="gameHistoryBuilder">Game history builder.</param>
/// <param name="transactionHashBuilder"></param>
public GameRoundDataManager(ISqlServerDatabase database,
IObjectCollectionBuilder <GameRoundEntity, GameRound> gameRoundBuilder,
IObjectBuilder <BlockNumberEntity, BlockNumber> blockNumberBuilder,
ISqlDataTableBuilder <WinAmountEntity> winAmountTableBuilder,
IObjectCollectionBuilder <GameHistoryEntity, GameHistory> gameHistoryBuilder,
IObjectCollectionBuilder <TransactionHashEntity, TransactionHash> transactionHashBuilder)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._gameRoundBuilder = gameRoundBuilder ?? throw new ArgumentNullException(nameof(gameRoundBuilder));
this._blockNumberBuilder = blockNumberBuilder ?? throw new ArgumentNullException(nameof(blockNumberBuilder));
this._winAmountTableBuilder = winAmountTableBuilder ?? throw new ArgumentNullException(nameof(winAmountTableBuilder));
this._gameHistoryBuilder = gameHistoryBuilder ?? throw new ArgumentNullException(nameof(gameHistoryBuilder));
this._transactionHashBuilder = transactionHashBuilder ?? throw new ArgumentNullException(nameof(transactionHashBuilder));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database to read from.</param>
/// <param name="transactionHashDataTableBuilder">Transaction hash table builder.</param>
/// <param name="contractsDataTableBuilder">Contract address table builder.</param>
/// <param name="eventRiskyTransactionsDataTableBuilder">Event Risky Transactions Data Table Builder.</param>
/// <param name="eventRiskyTransactionsBuilder">Builder of <see cref="AwaitingConfirmationsTransaction" /> from <see cref="AwaitingConfirmationsTransactionEntity" />.</param>
/// <param name="eventIndexBuilder">An Event index builder</param>
/// <param name="eventCheckpointBuilder">Builder of <see cref="EventContractCheckpoint" /> from <see cref="EventContractCheckpointEntity" />.</param>
/// <param name="transactionHashBuilder">Builder of <see cref="TransactionHash" /> from, <see cref="EventTransactionHashEntity" /> objects.</param>
public EventDataManager(ISqlServerDatabase database,
ISqlDataTableBuilder <EventTransactionEntity> transactionHashDataTableBuilder,
ISqlDataTableBuilder <ContractAddressEntity> contractsDataTableBuilder,
ISqlDataTableBuilder <AwaitingConfirmationsTransactionDataTableEntity> eventRiskyTransactionsDataTableBuilder,
IObjectCollectionBuilder <AwaitingConfirmationsTransactionEntity, AwaitingConfirmationsTransaction> eventRiskyTransactionsBuilder,
ISqlDataTableBuilder <EventIndexEntity> eventIndexBuilder,
IObjectCollectionBuilder <EventContractCheckpointEntity, EventContractCheckpoint> eventCheckpointBuilder,
IObjectCollectionBuilder <EventTransactionHashEntity, TransactionHash> transactionHashBuilder)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._transactionHashDataTableBuilder = transactionHashDataTableBuilder ?? throw new ArgumentNullException(nameof(transactionHashDataTableBuilder));
this._contractsDataTableBuilder = contractsDataTableBuilder ?? throw new ArgumentNullException(nameof(contractsDataTableBuilder));
this._eventRiskyTransactionsDataTableBuilder = eventRiskyTransactionsDataTableBuilder ?? throw new ArgumentNullException(nameof(eventRiskyTransactionsDataTableBuilder));
this._eventRiskyTransactionsBuilder = eventRiskyTransactionsBuilder ?? throw new ArgumentNullException(nameof(eventRiskyTransactionsBuilder));
this._eventIndexBuilder = eventIndexBuilder ?? throw new ArgumentNullException(nameof(eventIndexBuilder));
this._eventCheckpointBuilder = eventCheckpointBuilder ?? throw new ArgumentNullException(nameof(eventCheckpointBuilder));
this._transactionHashBuilder = transactionHashBuilder ?? throw new ArgumentNullException(nameof(transactionHashBuilder));
this._machineName = Environment.MachineName;
}
public CriteriaRepository(ISqlServerDatabase sqlServerDatabase)
{
_sqlServerDatabase = sqlServerDatabase;
}
public CostRepository(ISqlServerDatabase sqlServerDatabase)
{
_sqlServerDatabase = sqlServerDatabase;
}
public LabelTranslationRepository(ISqlServerDatabase sqlServerDatabase, ICriteriaValueRepository criteriaValueRepository)
{
_sqlServerDatabase = sqlServerDatabase;
_criteriaValueRepository = criteriaValueRepository;
}
public UniqueValueGeneratingTests(DockerFixture fixture, ITestOutputHelper output)
{
_output = output;
_database = fixture.GenerateDatabase(Guid.NewGuid().ToString("N"));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">The database to connect to.</param>
public EthereumAccountNonceDataManager(ISqlServerDatabase database)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._machineName = Environment.MachineName;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">The database to connect to.</param>
/// <param name="transactionSubmissionStatusBuilder">Builder of <see cref="TransactionSubmissionStatus" /> objects.</param>
public TransactionStatusDataManager(ISqlServerDatabase database, IObjectCollectionBuilder <TransactionSubmissionStatusEntity, TransactionSubmissionStatus> transactionSubmissionStatusBuilder)
{
this._transactionSubmissionStatusBuilder = transactionSubmissionStatusBuilder ?? throw new ArgumentNullException(nameof(transactionSubmissionStatusBuilder));
this._database = database ?? throw new ArgumentNullException(nameof(database));
}
public DatabaseService(ISqlServerDatabase sqlServerDatabase)
{
this._conn = sqlServerDatabase;
}
public LabelRepository(ISqlServerDatabase sqlServerDatabase)
{
_sqlServerDatabase = sqlServerDatabase;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database to connect to.</param>
/// <param name="accountBuilder">Builder of <see cref="ConfiguredAccount" /> items.</param>
public AccountDataManager(ISqlServerDatabase database, IObjectCollectionBuilder <ConfiguredAccountEntity, ConfiguredAccount> accountBuilder)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
this._accountBuilder = accountBuilder ?? throw new ArgumentNullException(nameof(accountBuilder));
}
public override void SetSqlConnection(string sqlConnectionString)
{
SqlServerDatabase = new SqlServerDatabase(sqlConnectionString);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="database">The database connection.</param>
public FaucetDataManager(ISqlServerDatabase database)
{
this._database = database ?? throw new ArgumentNullException(nameof(database));
}
public CriteriaValueRepository(ISqlServerDatabase sqlServerDatabase, ICriteriaRepository criteriaRepository)
{
_sqlServerDatabase = sqlServerDatabase;
_criteriaRepository = criteriaRepository;
}
