Esempio n. 1
0
        public async Task SetUp()
        {
            var truncateTableCmd   = "truncate \"unit_tests\".\"bulk_test_entity\";";
            var resetIdSequenceCmd = "ALTER SEQUENCE \"unit_tests\".\"bulk_test_entity_id_seq\" RESTART WITH 1;";

            await using var connection = new NpgsqlConnection(_configuration.ConnectionString);
            await using var command    = new NpgsqlCommand($"{truncateTableCmd}{resetIdSequenceCmd}", connection);
            await connection.OpenAsync();

            await command.ExecuteNonQueryAsync();

            _bulkServiceOptions = new BulkServiceOptions();
            _bulkServiceOptions.AddEntityProfile <TestEntity>(new BulkEntityProfile());

            var insertCommandBuilder = new InsertSqlCommandBuilder(NullLoggerFactory.Instance);
            var deleteCommandBuilder = new Mock <IDeleteSqlCommandBuilder>().Object;
            var updateCommandBuilder = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
            var upsertCommandBuilder = new UpsertSqlCommandBuilder(NullLoggerFactory.Instance);

            _testService = new NpgsqlCommandsBulkService(
                _bulkServiceOptions,
                NullLoggerFactory.Instance,
                insertCommandBuilder,
                updateCommandBuilder,
                deleteCommandBuilder,
                upsertCommandBuilder);
        }
Esempio n. 2
0
        public async Task SetUp()
        {
            _entityProfile = new UpsertEntityProfile(1);
            var truncateTableCmd   = $"truncate {_entityProfile.TableName};";
            var resetIdSequenceCmd = "ALTER SEQUENCE \"unit_tests\".\"entity_with_unique_columns_id_seq\" RESTART WITH 1;";

            using (var connection = new NpgsqlConnection(_configuration.ConnectionString))
                using (var command = new NpgsqlCommand($"{truncateTableCmd}{resetIdSequenceCmd}", connection))
                {
                    await connection.OpenAsync();

                    await command.ExecuteNonQueryAsync();
                }

            var bulkServiceOptions = new BulkServiceOptions
            {
                FailureStrategy = FailureStrategies.StopEverything
            };

            bulkServiceOptions.AddEntityProfile <TestEntity>(_entityProfile);

            var insertCommandBuilder = new InsertSqlCommandBuilder(NullLoggerFactory.Instance);
            var deleteCommandBuilder = new SimpleDeleteSqlCommandBuilder(NullLoggerFactory.Instance);
            var updateCommandBuilder = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
            var upsertCommandBuilder = new UpsertSqlCommandBuilder(NullLoggerFactory.Instance);

            _testService = new NpgsqlCommandsBulkService(
                bulkServiceOptions,
                NullLoggerFactory.Instance,
                insertCommandBuilder,
                updateCommandBuilder,
                deleteCommandBuilder,
                upsertCommandBuilder);
        }
Esempio n. 3
0
        public async Task SetUp()
        {
            var truncateTableCmd   = "truncate \"unit_tests\".\"after_update_tests\";";
            var resetIdSequenceCmd = "alter sequence \"unit_tests\".\"after_update_tests_id_seq\" restart with 1;";

            await using var connection = new NpgsqlConnection(_configuration.ConnectionString);
            await using var command    = new NpgsqlCommand($"{truncateTableCmd}{resetIdSequenceCmd}", connection);
            await connection.OpenAsync();

            await command.ExecuteNonQueryAsync();

            var bulkServiceOptions = new BulkServiceOptions();

            bulkServiceOptions.AddEntityProfile <AfterUpdateEntity>(new AfterUpdateEntityProfile());

            var insertCommandBuilder = new InsertSqlCommandBuilder(NullLoggerFactory.Instance);
            var updateCommandBuilder = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
            var deleteCommandBuilder = new Mock <IDeleteSqlCommandBuilder>().Object;
            var upsertCommandBuilder = new Mock <IUpsertSqlCommandBuilder>().Object;

            _testService = new NpgsqlCommandsBulkService(
                bulkServiceOptions,
                NullLoggerFactory.Instance,
                insertCommandBuilder,
                updateCommandBuilder,
                deleteCommandBuilder,
                upsertCommandBuilder);
        }
Esempio n. 4
0
        public async Task Exception_should_have_only_problem_and_not_operated_elements()
        {
            var bulkServiceOptions = new BulkServiceOptions
            {
                FailureStrategy              = FailureStrategies.StopEverything,
                IsProblemElementsEnabled     = true,
                IsNotOperatedElementsEnabled = true
            };

            bulkServiceOptions.AddEntityProfile <TestEntity>(_entityProfile);

            var insertCommandBuilder = new InsertSqlCommandBuilder(NullLoggerFactory.Instance);
            var deleteCommandBuilder = new SimpleDeleteSqlCommandBuilder(NullLoggerFactory.Instance);
            var updateCommandBuilder = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
            var upsertCommandBuilder = new UpsertSqlCommandBuilder(NullLoggerFactory.Instance);

            _testService = new NpgsqlCommandsBulkService(
                bulkServiceOptions,
                NullLoggerFactory.Instance,
                insertCommandBuilder,
                updateCommandBuilder,
                deleteCommandBuilder,
                upsertCommandBuilder);

            var firstItem = new TestEntity
            {
                RecordId = "for conflict purpose", SensorId = "for conflict purpose", Value = 10
            };
            var elements = new List <TestEntity> {
                firstItem
            };

            using (var connection = new NpgsqlConnection(_configuration.ConnectionString))
            {
                var result = await _testService.InsertAsync(connection, elements, CancellationToken.None);

                Assert.Null(result);

                var secondItem = new TestEntity
                {
                    RecordId = "rec-0", SensorId = "sens-01", Value = 100
                };
                elements.Add(secondItem);
                var ex = Assert.ThrowsAsync <SqlBulkExecutionException <TestEntity> >(() => _testService.InsertAsync(connection, elements, CancellationToken.None));
                Assert.IsNull(ex.OperatedElements);
                Assert.NotNull(ex.NotOperatedElements);
                Assert.NotNull(ex.ProblemElements);

                Assert.IsNotEmpty(ex.ProblemElements);
                Assert.NotNull(ex.ProblemElements.First());
                Assert.AreEqual("for conflict purpose", ex.ProblemElements.First().RecordId);

                Assert.IsNotEmpty(ex.NotOperatedElements);
                Assert.NotNull(ex.NotOperatedElements.First());
                Assert.AreEqual("for conflict purpose", ex.NotOperatedElements.First().RecordId);
                Assert.NotNull(ex.NotOperatedElements.Skip(1).Take(1).First());
                Assert.AreEqual("rec-0", ex.NotOperatedElements.Skip(1).Take(1).First().RecordId);
            }
        }
Esempio n. 5
0
        public async Task Insert_should_rollback_items_that_were_successfully_operated_in_one_portion()
        {
            var bulkServiceOptions = new BulkServiceOptions
            {
                FailureStrategy = FailureStrategies.IgnoreFailure
            };
            var entityProfile = new UpsertEntityProfile(2);

            bulkServiceOptions.AddEntityProfile <TestEntity>(entityProfile);

            var insertCommandBuilder = new InsertSqlCommandBuilder(NullLoggerFactory.Instance);
            var deleteCommandBuilder = new SimpleDeleteSqlCommandBuilder(NullLoggerFactory.Instance);
            var updateCommandBuilder = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
            var upsertCommandBuilder = new UpsertSqlCommandBuilder(NullLoggerFactory.Instance);

            _testService = new NpgsqlCommandsBulkService(
                bulkServiceOptions,
                NullLoggerFactory.Instance,
                insertCommandBuilder,
                updateCommandBuilder,
                deleteCommandBuilder,
                upsertCommandBuilder);

            var firstItem = new TestEntity {
                RecordId = "for conflict purpose", SensorId = "for conflict purpose", Value = 10
            };
            var secondItem = new TestEntity {
                RecordId = "for conflict purpose", SensorId = "for conflict purpose", Value = 100
            };
            var elements = new List <TestEntity> {
                firstItem, secondItem
            };

            using (var connection = new NpgsqlConnection(_configuration.ConnectionString))
            {
                var result = await _testService.InsertAsync(connection, elements, CancellationToken.None);

                Assert.NotNull(result);
                Assert.IsNotEmpty(result.NotOperated);
                Assert.AreEqual(2, result.NotOperated.Count);
            }

            var countOfRows = await _testUtils.HowManyRowsInTableAsync(entityProfile);

            Assert.AreEqual(0, countOfRows);
        }
 public void SetUp()
 {
     _testService = new UpdateSqlCommandBuilder(NullLoggerFactory.Instance);
 }