public void ReadWrite()
{
DateTime val = DateTime.UtcNow;
DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Local);
DateTimeClass basic = new DateTimeClass();
basic.Id = 1;
basic.LocalDateTimeValue = val;
ISession s = OpenSession();
s.Save(basic);
s.Flush();
s.Close();
s = OpenSession();
basic = (DateTimeClass)s.Load(typeof(DateTimeClass), 1);
Assert.AreEqual(DateTimeKind.Local, basic.LocalDateTimeValue.Value.Kind);
Assert.AreEqual(expected, basic.LocalDateTimeValue.Value);
s.Delete(basic);
s.Flush();
s.Close();
}
public virtual void SaveUseExpectedSqlType()
{
var driver = (ClientDriverWithParamsStats)Sfi.ConnectionProvider.Driver;
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var d = new DateTimeClass
{
Id = 2,
Value = Now,
NullableValue = Now
};
driver.ClearStats();
s.Save(d);
t.Commit();
}
var expected = 3;
// GenericBatchingBatcher uses IDriver.GenerateCommand method to create the batching command,
// so the expected result will be doubled as GenerateCommand calls IDriver.GenerateParameter
// for each parameter.
if (Sfi.Settings.BatcherFactory is GenericBatchingBatcherFactory)
{
expected *= 2;
}
// 2 properties + revision
AssertSqlType(driver, expected, true);
}
public async Task ReadWriteAsync()
{
DateTime val = DateTime.UtcNow;
DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Utc);
DateTimeClass basic = new DateTimeClass();
basic.Id = 1;
basic.UtcDateTimeValue = val;
ISession s = OpenSession();
await(s.SaveAsync(basic));
await(s.FlushAsync());
s.Close();
s = OpenSession();
basic = (DateTimeClass)await(s.LoadAsync(typeof(DateTimeClass), 1));
Assert.AreEqual(DateTimeKind.Utc, basic.UtcDateTimeValue.Value.Kind);
Assert.AreEqual(expected, basic.UtcDateTimeValue.Value);
await(s.DeleteAsync(basic));
await(s.FlushAsync());
s.Close();
}
public void LowerDigitsAreIgnored()
{
if (!Dialect.SupportsDateTimeScale)
{
Assert.Ignore("Lower digits cannot be ignored when dialect does not support scale");
}
var baseDate = new DateTime(2017, 10, 01, 17, 55, 24, 548, GetTypeKind());
var entity = new DateTimeClass
{
Id = AdditionalDateId,
Value = baseDate.AddTicks(TimeSpan.TicksPerMillisecond / 3)
};
Assert.That(entity.Value, Is.Not.EqualTo(baseDate));
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
s.Save(entity);
t.Commit();
}
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var retrieved = s.Load <DateTimeClass>(AdditionalDateId);
Assert.That(retrieved.Value, Is.EqualTo(baseDate));
t.Commit();
}
}
protected override void OnSetUp()
{
base.OnSetUp();
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var d = new DateTimeClass
{
Id = DateId,
Value = Now
};
s.Save(d);
t.Commit();
}
}
private async Task ReadWriteAsync(DateTime expected, CancellationToken cancellationToken = default(CancellationToken))
{
// Add an hour to check it is correctly ignored once read back from db.
var basic = new DateTimeClass {
Id = AdditionalDateId, Value = expected.AddHours(1)
};
using (var s = OpenSession())
{
await(s.SaveAsync(basic, cancellationToken));
await(s.FlushAsync(cancellationToken));
}
using (var s = OpenSession())
{
basic = await(s.GetAsync <DateTimeClass>(AdditionalDateId, cancellationToken));
Assert.That(basic.Value, Is.EqualTo(expected));
await(s.DeleteAsync(basic, cancellationToken));
await(s.FlushAsync(cancellationToken));
}
}
private void ReadWrite(DateTime expected)
{
// Add an hour to check it is correctly ignored once read back from db.
var basic = new DateTimeClass {
Id = AdditionalDateId, Value = expected.AddHours(1)
};
using (var s = OpenSession())
{
s.Save(basic);
s.Flush();
}
using (var s = OpenSession())
{
basic = s.Get <DateTimeClass>(AdditionalDateId);
Assert.That(basic.Value, Is.EqualTo(expected));
s.Delete(basic);
s.Flush();
}
}
public virtual async Task SaveUseExpectedSqlTypeAsync()
{
var driver = (ClientDriverWithParamsStats)Sfi.ConnectionProvider.Driver;
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var d = new DateTimeClass
{
Id = 2,
Value = Now,
NullableValue = Now
};
driver.ClearStats();
await(s.SaveAsync(d));
await(t.CommitAsync());
}
// 2 properties + revision
AssertSqlType(driver, 3, true);
}
public void ReadWrite()
{
DateTime val = DateTime.UtcNow;
DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Utc);
DateTimeClass basic = new DateTimeClass();
basic.Id = 1;
basic.UtcDateTimeValue = val;
ISession s = OpenSession();
s.Save(basic);
s.Flush();
s.Close();
s = OpenSession();
basic = (DateTimeClass) s.Load(typeof (DateTimeClass), 1);
Assert.AreEqual(DateTimeKind.Utc, basic.UtcDateTimeValue.Value.Kind);
Assert.AreEqual(expected, basic.UtcDateTimeValue.Value);
s.Delete(basic);
s.Flush();
s.Close();
}
public void ReadWrite(DateTimeKind kind)
{
var entity = new DateTimeClass
{
Id = AdditionalDateId,
Value = GetTestDate(kind)
};
var typeKind = GetTypeKind();
// Now must be acquired before transaction because some db freezes current_timestamp at transaction start,
// like PostgreSQL. https://www.postgresql.org/docs/7.2/static/functions-datetime.html#AEN6700
// This then wrecks tests with DbTimestampType if the always out of tran Now is called for fetching
// beforeNow only after transaction start.
// And account db accuracy
var beforeNow = Now.AddTicks(-DateAccuracyInTicks);
// Save
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
s.Save(entity);
if (kind != typeKind && typeKind != DateTimeKind.Unspecified)
{
Assert.That(() => t.Commit(), Throws.TypeOf <PropertyValueException>());
return;
}
t.Commit();
}
var afterNow = Now.AddTicks(DateAccuracyInTicks);
if (RevisionCheck)
{
Assert.That(entity.Revision, Is.GreaterThan(beforeNow).And.LessThan(afterNow), "Revision not correctly seeded.");
if (typeKind != DateTimeKind.Unspecified)
{
Assert.That(entity.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly seeded.");
}
Assert.That(entity.NullableValue, Is.Null, "NullableValue unexpectedly seeded.");
}
// Retrieve, compare then update
DateTimeClass retrieved;
using (var s = OpenSession())
{
using (var t = s.BeginTransaction())
{
retrieved = s.Get <DateTimeClass>(AdditionalDateId);
Assert.That(retrieved, Is.Not.Null, "Entity not saved or cannot be retrieved by its key.");
Assert.That(retrieved.Value, Is.EqualTo(GetExpectedValue(entity.Value)), "Unexpected value.");
if (RevisionCheck)
{
Assert.That(retrieved.Revision, Is.EqualTo(entity.Revision), "Revision should be the same.");
}
Assert.That(retrieved.NullableValue, Is.EqualTo(entity.NullableValue), "NullableValue should be the same.");
if (typeKind != DateTimeKind.Unspecified)
{
Assert.That(retrieved.Value.Kind, Is.EqualTo(typeKind), "Value kind not correctly retrieved.");
if (RevisionCheck)
{
Assert.That(retrieved.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly retrieved.");
}
}
t.Commit();
}
beforeNow = Now.AddTicks(-DateAccuracyInTicks);
using (var t = s.BeginTransaction())
{
retrieved.NullableValue = GetTestDate(kind);
retrieved.Value = GetTestDate(kind).AddMonths(-1);
t.Commit();
}
afterNow = Now.AddTicks(DateAccuracyInTicks);
}
if (RevisionCheck)
{
Assert.That(
retrieved.Revision,
Is.GreaterThan(beforeNow).And.LessThan(afterNow).And.GreaterThanOrEqualTo(entity.Revision),
"Revision not correctly incremented.");
if (typeKind != DateTimeKind.Unspecified)
{
Assert.That(retrieved.Revision.Kind, Is.EqualTo(typeKind), "Revision kind incorrectly changed.");
}
}
// Retrieve and compare again
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var retrievedAgain = s.Get <DateTimeClass>(AdditionalDateId);
Assert.That(retrievedAgain, Is.Not.Null, "Entity deleted or cannot be retrieved again by its key.");
Assert.That(
retrievedAgain.Value,
Is.EqualTo(GetExpectedValue(retrieved.Value)),
"Unexpected value at second compare.");
if (RevisionCheck)
{
Assert.That(retrievedAgain.Revision, Is.EqualTo(retrieved.Revision), "Revision should be the same again.");
}
Assert.That(
retrievedAgain.NullableValue,
Is.EqualTo(GetExpectedValue(retrieved.NullableValue.Value)),
"Unexpected NullableValue at second compare.");
if (typeKind != DateTimeKind.Unspecified)
{
Assert.That(retrievedAgain.Value.Kind, Is.EqualTo(typeKind), "Value kind not correctly retrieved again.");
if (RevisionCheck)
{
Assert.That(retrievedAgain.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly retrieved again.");
}
Assert.That(
retrievedAgain.NullableValue.Value.Kind,
Is.EqualTo(typeKind),
"NullableValue kind not correctly retrieved again.");
}
t.Commit();
}
}
