public void HasProperty_should_pass_constant_expressions()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
Assert.DoesNotThrow(()
=> entityProfile.HasProperty <TestEntity, int>("id", x => 10));
}
public DataResponse <EntityProfile> GetUserDeviceIdById(int UserId)
{
DataResponse <EntityProfile> response = new DataResponse <EntityProfile>();
try
{
base.DBInit();
var query = DBEntity.UserProfiles.Where(a => a.UserId == UserId).FirstOrDefault();
var entity = new EntityProfile
{
Id = query.UserId.Value,
DeviceId = query.DeviceId
};
if (query != null)
{
response.CreateResponse(entity, DataResponseStatus.OK);
}
else
{
response.CreateResponse(DataResponseStatus.InternalServerError);
}
}
catch (Exception ex)
{
response.ThrowError(ex);
}
finally
{
base.DBClose();
}
return(response);
}
public void HasProperty_should_pass_binary_expressions()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
Assert.DoesNotThrow(() => entityProfile.HasProperty <TestEntity, int>("id", x => x.Id + x.IntValue));
Assert.DoesNotThrow(() => entityProfile.HasProperty <TestEntity, int>("value", x => x.Id + 10));
}
public void Should_build_params_for_string_id()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.IntValue);
entityProfile.HasProperty <TestEntity, string>(x => x.RecordId)
.ThatIsPrivateKey();
var elements = new List <TestEntity>
{
new TestEntity {
IntValue = 12, RecordId = "rec-01", SensorId = "sen-0"
},
new TestEntity {
IntValue = 13, RecordId = "rec-02", SensorId = "sen-1"
}
};
var result = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(result);
var commandResult = result.FirstOrDefault();
Assert.NotNull(commandResult);
Assert.NotNull(commandResult.SqlParameters);
Assert.AreEqual(2, commandResult.SqlParameters.Count);
Assert.IsTrue(Regex.IsMatch(commandResult.Command, DELETE_PARAM_PATTERN, RegexOptions.IgnoreCase));
}
public void Should_not_put_constraint_columns_into_update_set_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasPropertyAsPartOfUniqueConstraint <TestEntity, string>(x => x.RecordId);
entityProfile.HasUniqueConstraint("business_identity");
entityProfile.HasProperty <TestEntity, string>(x => x.SensorId);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
var upsertSetPattern = "(set\\s+\"record_id\"\\s*=\\s*(\"\\w+\".)?\"\\w+\".\"\\w+\"\\s*)|,\\s*\"record_id\"\\s*=";
Assert.IsFalse(Regex.IsMatch(commandResult.Command, upsertSetPattern, RegexOptions.IgnoreCase));
}
private static bool IsKeepProfile(EntityProfile dataFilter, bool isCleanProfiles)
{
var isIncluded = dataFilter.IsIncluded;
if (isCleanProfiles && !isIncluded)
{
return(false);
}
var isEntityRenameFilled = dataFilter.EntityRename.IsFilled();
var isEntityAnnotationsFilled = dataFilter.EntityAnnotations.IsFilled();
var isIsGenerateMetaFilled = dataFilter.IsGenerateMeta;
var isIsOptionsetLabelsFilled = dataFilter.IsOptionsetLabels;
var isIsLookupLabelsFilled = dataFilter.IsLookupLabels;
var isValueClearModeFilled = dataFilter.ValueClearMode != null;
var isEnglishLabelFieldFilled = dataFilter.EnglishLabelField.IsFilled();
var isCollectionsFilled = dataFilter.IsBasicDataFilled;
var isKeepFilter = isIncluded || isEntityRenameFilled || isEntityAnnotationsFilled || isIsGenerateMetaFilled ||
isIsOptionsetLabelsFilled || isIsLookupLabelsFilled ||
isValueClearModeFilled || isEnglishLabelFieldFilled ||
isCollectionsFilled;
return(isKeepFilter);
}
public void Should_build_correct_id_property_name()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.IntValue);
entityProfile.HasProperty <TestEntity, string>(x => x.RecordId)
.ThatIsPrivateKey();
var elements = new List <TestEntity>
{
new TestEntity {
IntValue = 12, RecordId = "rec-01", SensorId = "sen-0"
},
new TestEntity {
IntValue = 13, RecordId = "rec-02", SensorId = "sen-1"
}
};
var result = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(result);
var commandResult = result.FirstOrDefault();
Assert.NotNull(commandResult);
Assert.IsTrue(commandResult.Command.Contains("where \"record_id\" in"));
}
public void NPCFactoryCreate()
{
ItemsFactory wfactory = new ItemsFactory();
NPCFactory factory = new NPCFactory(wfactory);
var creationProfile = new EntityProfile(10, EntityOccupation.Fisherman, EntityRace.None, 10);
IEntity entity = factory.Create(creationProfile);
}
public void Should_match_insert_cmd_without_returning_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasPropertyAsPartOfUniqueConstraint <TestEntity, string>(x => x.RecordId);
entityProfile.HasUniqueConstraint("business_identity");
entityProfile.HasProperty <TestEntity, string>(x => x.SensorId);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
// Check that the whole command still matches the upsert pattern
Assert.IsTrue(Regex.IsMatch(commandResult.Command, UpsertConsts.UPSERT_PATTERN, RegexOptions.IgnoreCase));
// Check that there is no returning clause in the result command
Assert.IsFalse(commandResult.Command.Contains("returning"));
}
public void Should_match_upsert_cmd_of_one_element()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(entity => entity.Id)
.ThatIsAutoGenerated()
.ThatIsPrivateKey();
entityProfile.HasPropertyAsPartOfUniqueConstraint <TestEntity, string>(entity => entity.RecordId);
entityProfile.HasPropertyAsPartOfUniqueConstraint <TestEntity, string>(entity => entity.SensorId);
entityProfile.HasProperty <TestEntity, int>(entity => entity.IntValue);
var elements = new List <TestEntity>
{
new TestEntity {
RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
Assert.IsTrue(Regex.IsMatch(commandResult.Command, UpsertConsts.UPSERT_PATTERN, RegexOptions.IgnoreCase));
}
public void HasProperty_should_not_pass_constant_expressions_without_column()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
var ex = Assert.Throws <ArgumentException>(() => entityProfile.HasProperty <TestEntity, int>(x => 10));
Assert.AreEqual("column", ex.ParamName);
}
public void Should_set_date_column_types()
{
var entityProfile = new EntityProfile(typeof(EntityWithDateTime));
var propertyProfile = entityProfile.HasProperty <EntityWithDateTime, Date>(x => x.Date);
Assert.AreEqual(NpgsqlDbType.Date, propertyProfile.DbColumnType);
}
public void Should_return_true_given_nullable_double_member()
{
var entityProfile = new EntityProfile(typeof(EntityWithNullableProperty));
var propInfo = entityProfile.HasProperty <EntityWithNullableProperty, double?>(entity => entity.NullableDouble);
Assert.IsFalse(propInfo.IsDynamicallyInvoked());
}
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);
}
public ModelViewProfile Insert(ModelViewProfile model)
{
var objRepository = new RepositoryProfile();
model.Status = true;
if (objRepository.GetAll().Where(p => p.Profile.ToUpper() == model.Profile.ToUpper()) != null)
{
throw new Exception("Duplicate");
}
EntityProfile data = new EntityProfile()
{
ProfileID = model.ProfileID,
Profile = model.Profile,
Description = model.Description,
Status = model.Status
};
data = new RepositoryProfile().Insert(data);
model.ProfileID = data.ProfileID;
new BusinessPermission().Set(model.ProfileID, null);
return(model);
}
public void Should_return_two_parameters_for_id_and_value()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasProperty <TestEntity, int>(x => x.IntValue)
.ThatIsPrivateKey();
var elements = new List <TestEntity>
{
new TestEntity {
Id = 10, RecordId = "rec-01", SensorId = "sens-02", IntValue = 12
}
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
Assert.NotNull(commandResult.SqlParameters);
Assert.AreEqual(0, commandResult.SqlParameters.Count);
}
public void Should_match_constraint_name_in_on_conflict_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasPropertyAsPartOfUniqueConstraint <TestEntity, string>(x => x.RecordId);
entityProfile.HasUniqueConstraint("business_identity");
entityProfile.HasProperty <TestEntity, string>(x => x.SensorId);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
var onConflictClausePattern = "on\\s+conflict\\s+(\\(\\s*\"\\w+\"\\s*\\)|on\\s+constraint\\s+\"\\w+\")";
Assert.IsTrue(Regex.IsMatch(commandResult.Command, onConflictClausePattern, RegexOptions.IgnoreCase));
}
public void Should_return_true_given_double_member()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
var propInfo = entityProfile.HasProperty <TestEntity, double>(entity => entity.DoubleValue);
Assert.IsFalse(propInfo.IsDynamicallyInvoked());
}
public void Should_return_true_given_string_member()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
var propInfo = entityProfile.HasProperty <TestEntity, string>(entity => entity.RecordId);
Assert.IsTrue(propInfo.IsDynamicallyInvoked());
}
public void Should_return_true_given_date_member()
{
var entityProfile = new EntityProfile(typeof(EntityWithDateTime));
var propInfo = entityProfile.HasProperty <EntityWithDateTime, Date>("date", entity => entity.Date);
Assert.IsTrue(propInfo.IsDynamicallyInvoked());
}
public void Should_return_true_given_simple_enum_member()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
var propInfo = entityProfile.HasProperty <TestEntity, SomeEnum>(entity => entity.Enumeration);
Assert.IsFalse(propInfo.IsDynamicallyInvoked());
}
public void Should_return_true_given_converted_enum()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
var propInfo = entityProfile.HasProperty <TestEntity, int?>(entity => (int?)entity.Enumeration);
Assert.IsTrue(propInfo.IsDynamicallyInvoked());
}
public void Should_match_delete_cmd_without_returning_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasProperty <TestEntity, string>(x => x.RecordId);
entityProfile.HasProperty <TestEntity, string>(x => x.SensorId);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
Assert.IsTrue(Regex.IsMatch(commandResult.Command, DELETE_PATTERN, RegexOptions.IgnoreCase));
}
public void HasProperty_should_pass_nullable_properties()
{
var entityProfile = new EntityProfile(typeof(EntityWithNullableProperty));
Assert.DoesNotThrow(() => entityProfile.HasProperty <EntityWithNullableProperty, bool?>
("value", x => x.NullableBool));
}
public void Should_put_all_private_keys_into_where_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasProperty <TestEntity, string>(x => x.RecordId)
.ThatIsPrivateKey();
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sen-0"
}
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
// pattern should match "id" whatever builder put the "id" column in any order where "id" = @param1; or where ""value"=@param1, "id"=@param2;
var pattern = "where\\s+(\"id\"\\s*=\\s*\\d+|\\s*\"record_id\"\\s*=\\s*@param_record_id_\\d+)\\s*(and\\s*\"id\"\\s*=\\s*\\d+|\\s+and\\s*\"record_id\"\\s*=\\s*@param_record_id_\\d+)";
Assert.IsTrue(Regex.IsMatch(commandResult.Command, pattern, RegexOptions.IgnoreCase));
}
public void Should_not_include_after_insert_columns_into_update_returning_clause()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey()
.MustBeUpdatedAfterInsert();
var elements = new List <TestEntity>
{
new TestEntity {
RecordId = "rec-01"
}
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
// pattern should match "id" whatever builder put the "id" column returning "id"; or returning ""value", "id";
var pattern = @"returning\s+(""\w+""\s*,\s*)*""id""";
Assert.IsFalse(Regex.IsMatch(commandResult.Command, pattern, RegexOptions.IgnoreCase));
}
public void Should_not_put_column_that_was_not_mapped()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id)
.ThatIsPrivateKey();
entityProfile.HasProperty <TestEntity, string>(x => x.RecordId);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>
{
new TestEntity {
Id = 12, RecordId = "rec-01", SensorId = "sens-01", IntValue = 127
},
};
var commands = _testService.Generate(elements, entityProfile, CancellationToken.None);
Assert.NotNull(commands);
Assert.AreEqual(1, commands.Count);
var commandResult = commands.First();
Assert.NotNull(commandResult.Command);
Assert.IsFalse(commandResult.Command.Contains("sensor_id"));
}
public void HasProperty_should_not_pass_duplicates()
{
var i = Math.Round((decimal)5 / 2, MidpointRounding.ToPositiveInfinity);
var entityProfile = new EntityProfile(typeof(TestEntity));
Assert.DoesNotThrow(() => entityProfile.HasProperty <TestEntity, int>(x => x.Id));
Assert.Throws <TypeMappingException>(() => entityProfile.HasProperty <TestEntity, int>(x => x.Id));
}
public void Should_throw_exception_for_empty_elements()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id).ThatIsPrivateKey();
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>();
Assert.Throws <ArgumentException>(() => _testService.Generate(elements, entityProfile, CancellationToken.None));
}
public void Upsert_should_not_pass_entities_without_unique_constraint()
{
var entityProfile = new EntityProfile(typeof(TestEntity));
entityProfile.HasProperty <TestEntity, int>(x => x.Id);
entityProfile.ToTable("test_entity", "custom");
var elements = new List <TestEntity>();
Assert.Throws <ArgumentException>(() => _testService.Generate(elements, entityProfile, CancellationToken.None));
}
