public void It_should_properly_store_object_with_oid_in_memory()
{
Assert.That(SubjectUnderTest.GetOid(_object), Is.EqualTo(_oid));
Assert.That(SubjectUnderTest.GetObject(_oid), Is.EqualTo(_object));
Assert.That(SubjectUnderTest.Contains(_object), Is.True);
}
protected override void Given()
{
SubjectUnderTest.Action("transient").Bind(ModifierKeys.Control, Key.F5).To(() => { });
SubjectUnderTest.PermanentAction("permanent").Bind(Key.F5).To(() => { });
_view = new object();
SubjectUnderTest.PlaceInExplorerPane(_view, "Test Header");
}
public void It_should_push_extended_data_set_to_persisted_instance()
{
var newData = new byte[] { 4, 5, 6 };
SubjectUnderTest.AddBytes(newData);
Assert.That(SubjectUnderTest.ToString(), Is.EqualTo("position=3 | bytes=[1 2 3 4 5 6 ] & size=6"));
SubjectUnderTest.PersistMeTo(_fsi);
var savedBytes = ((FileSystemInterfaceFake)_fsi).Bytes;
var position = ByteArrayConverter.ByteArrayToLong(savedBytes);
Assert.That(position, Is.EqualTo(_position));
var size = ByteArrayConverter.ByteArrayToInt(savedBytes, 8);
Assert.That(size, Is.EqualTo(_data.Length + newData.Length));
Assert.That(savedBytes[12], Is.EqualTo(_data[0]));
Assert.That(savedBytes[13], Is.EqualTo(_data[1]));
Assert.That(savedBytes[14], Is.EqualTo(_data[2]));
Assert.That(savedBytes[15], Is.EqualTo(newData[0]));
Assert.That(savedBytes[16], Is.EqualTo(newData[1]));
Assert.That(savedBytes[17], Is.EqualTo(newData[2]));
}
public void It_should_allow_on_inserting_object_header_for_uncommited_object()
{
SubjectUnderTest.RemoveObject(_object);
SubjectUnderTest.AddObjectInfoOfNonCommitedObject(_objectInfo.GetHeader());
Assert.That(SubjectUnderTest.GetObjectInfoHeaderByOid(_oid, false), Is.EqualTo(_objectInfo.GetHeader()));
}
protected override void When()
{
SubjectUnderTest.Publish(new List <object> {
_command
});
SubjectUnderTest.Commit();
}
protected override void Because()
{
SubjectUnderTest.AddDeleteTriggerFor(typeof(object), _fakeDeleteTrigger);
SubjectUnderTest.AddInsertTriggerFor(typeof(Warrior), _fakeInsertTrigger);
SubjectUnderTest.AddUpdateTriggerFor(typeof(Warrior), _fakeUpdateTrigger);
SubjectUnderTest.AddSelectTriggerFor(typeof(Warrior), _fakeSelectTrigger);
}
public void It_should_bubble_the_exception_from_the_establish()
{
var subjectUnderTest = new SubjectUnderTest();
subjectUnderTest.TestFixtureSetUp();
Assert.AreEqual("context", subjectUnderTest.CaughtException.Message);
}
protected override void Because()
{
SubjectUnderTest.SetNbObjects(_numberOfObjects);
SubjectUnderTest.First = _firstOid;
SubjectUnderTest.Last = _secondOid;
}
protected override void When()
{
SubjectUnderTest.Publish(new List <object> {
_event, _otherEvent
});
SubjectUnderTest.Commit();
}
public void It_should_have_all_dictionaries_set_to_null_after_clear_invocation()
{
SubjectUnderTest.Clear();
Assert.That(SubjectUnderTest.MaxPositionInBuffer, Is.Null);
Assert.That(SubjectUnderTest.BufferPositions, Is.Null);
Assert.That(SubjectUnderTest.Buffers, Is.Null);
}
protected override void Because()
{
SubjectUnderTest.AddDeleteTrigger(new FakeDeleteTrigger());
SubjectUnderTest.AddInsertTrigger(new FakeInsertTrigger());
SubjectUnderTest.AddUpdateTrigger(new FakeUpdateTrigger());
SubjectUnderTest.AddSelectTrigger(new FakeSelectTrigger());
}
public void It_should_be_different_than_new_instance_with_different_ids()
{
var secondInstance = new DatabaseId(new[] { 11L, 22L, 33L });
Assert.That(secondInstance, Is.Not.EqualTo(SubjectUnderTest));
Assert.That(secondInstance.GetHashCode(), Is.Not.EqualTo(SubjectUnderTest.GetHashCode()));
}
public void It_should_have_all_buffers_clean_on_start()
{
for (var i = 0; i < 5; i++)
{
Assert.That(SubjectUnderTest.HasBeenUsedForWrite(i), Is.False);
}
}
public void It_should_be_able_to_read_written_byte()
{
SubjectUnderTest.SetPosition(0L);
var value = SubjectUnderTest.Read();
Assert.That(value, Is.EqualTo(_testByte));
}
public void It_should_have_correct_creation_dates()
{
Assert.That(SubjectUnderTest.GetCreationDate(0), Is.EqualTo(_creationDate1));
Assert.That(SubjectUnderTest.GetCreationDate(1), Is.EqualTo(_creationDate2));
Assert.That(SubjectUnderTest.GetCreationDate(2), Is.EqualTo(_creationDate3));
Assert.That(SubjectUnderTest.GetCreationDate(3), Is.EqualTo(_creationDate4));
Assert.That(SubjectUnderTest.GetCreationDate(4), Is.EqualTo(_creationDate5));
}
public void It_should_return_minus_1_when_requested_position_is_out_of_range()
{
const int startOutOfRange = 2000;
var bufferIndex = SubjectUnderTest.GetBufferIndexForPosition(startOutOfRange, 400);
Assert.That(bufferIndex, Is.EqualTo(-1));
}
public void It_returns_string_which_could_be_used_to_create_equal_second_instance()
{
var stringRepresentation = SubjectUnderTest.ToString();
var secondInstance = FromString(stringRepresentation);
Assert.That(secondInstance, Is.EqualTo(SubjectUnderTest));
Assert.That(secondInstance.GetHashCode(), Is.EqualTo(SubjectUnderTest.GetHashCode()));
}
public void It_should_allow_on_changing_property_values()
{
SubjectUnderTest.SetValueOf("Name", "Madzia");
SubjectUnderTest.SetValueOf("Age", 24);
Assert.That(SubjectUnderTest.GetValueOf("Name"), Is.EqualTo("Madzia"));
Assert.That(SubjectUnderTest.GetValueOf("Age"), Is.EqualTo(24));
}
public void It_should_allow_on_reset_of_content()
{
SubjectUnderTest.Reset();
Assert.That(SubjectUnderTest.HasObjects(), Is.False);
Assert.That(SubjectUnderTest.GetNumberbOfObjects(), Is.EqualTo(0));
Assert.That(SubjectUnderTest.First, Is.Null);
Assert.That(SubjectUnderTest.Last, Is.Null);
}
public void It_should_properly_handle_insert_before_trigger()
{
const string value = "insert_before";
SubjectUnderTest.ManageInsertTriggerBefore(typeof(Warrior), value);
Assert.That(value, Is.EqualTo(_fakeInsertTrigger.GetObject()));
Assert.That(_fakeInsertTrigger.GetOid(), Is.Null);
}
public void Test1()
{
var subject = new SubjectUnderTest();
var result = subject.SomeCalculation();
Assert.NotNull(result);
Assert.NotNull(result.Field);
}
public void It_should_allow_you_to_clean_it()
{
Assert.That(SubjectUnderTest.IsEmpty(), Is.False);
SubjectUnderTest.Clear();
Assert.That(SubjectUnderTest.IsEmpty(), Is.True);
Assert.That(SubjectUnderTest.ToString(), Is.EqualTo("position=3 | bytes=null & size=3"));
}
public void It_should_allow_on_cache_cleanup()
{
SubjectUnderTest.Clear(false);
Assert.That(SubjectUnderTest.GetOid(_object), Is.EqualTo(StorageEngineConstant.NullObjectId));
Assert.That(SubjectUnderTest.GetObject(_oid), Is.Null);
Assert.That(SubjectUnderTest.GetObjectInfoHeaderFromObject(_object), Is.Null);
Assert.That(SubjectUnderTest.GetObjectInfoHeaderByOid(_oid, false), Is.Null);
}
protected override void When()
{
var prod_cat_menu = SubjectUnderTest.Register("Product Catalog").ToContainer();
prod_cat_menu.Register("Add Product").ToScreen <TestScreen>();
prod_cat_menu.Register("Add Product Wizard").ToWizard <TestWizard>();
var sub_menu = prod_cat_menu.Register("Sub Menu").ToContainer();
sub_menu.Register("sub Add Product").ToScreen <TestScreen>();
}
public void It_should_properly_handle_select_trigger()
{
const string value = "select";
var oid = OIDFactory.BuildObjectOID(1L);
SubjectUnderTest.ManageSelectTriggerAfter(typeof(Warrior), value, oid);
Assert.That(value, Is.EqualTo(_fakeSelectTrigger.GetObject()));
Assert.That(oid, Is.EqualTo(_fakeSelectTrigger.GetOid()));
}
public void It_should_properly_handle_delete_before_trigger()
{
const string value = "delete_before";
var oid = OIDFactory.BuildObjectOID(1L);
SubjectUnderTest.ManageDeleteTriggerBefore(typeof(Warrior), value, oid);
Assert.That(value, Is.EqualTo(_fakeDeleteTrigger.GetObject()));
Assert.That(oid, Is.EqualTo(_fakeDeleteTrigger.GetOid()));
}
public void It_should_properly_handle_update_after_trigger()
{
const string value = "insert_after";
var oid = OIDFactory.BuildObjectOID(1L);
SubjectUnderTest.ManageUpdateTriggerAfter(typeof(Warrior), null, value, oid);
Assert.That(value, Is.EqualTo(_fakeUpdateTrigger.GetObject()));
Assert.That(oid, Is.EqualTo(_fakeUpdateTrigger.GetOid()));
}
public async Task Assert_That_Can_Add_Product()
{
var addProductCommand = new Fixture().Create <AddProductCommand>();
var response = await SubjectUnderTest.Handle(addProductCommand, CancellationToken.None);
Assert.IsNotNull(response);
Assert.IsNotNull(response.ProductId);
Assert.IsNotEmpty(response.ProductId);
Assert.Greater(response.ProductId.Length, 3);
}
public void It_should_allow_on_removing_already_added_object_by_oid()
{
SubjectUnderTest.RemoveObjectByOid(_oid);
Assert.That(SubjectUnderTest.GetOid(_object), Is.EqualTo(StorageEngineConstant.NullObjectId));
Assert.That(SubjectUnderTest.GetObject(_oid), Is.Null);
Assert.That(SubjectUnderTest.GetObjectInfoHeaderFromObject(_object), Is.Null);
Assert.That(SubjectUnderTest.GetObjectInfoHeaderByOid(_oid, false), Is.Null);
}
public void It_should_be_able_to_write_another_byte_and_read_it()
{
const byte value = 16;
SubjectUnderTest.WriteByte(value);
SubjectUnderTest.SetCurrentReadPosition(StartWritePosition + 5);
var result = SubjectUnderTest.ReadByte();
Assert.That(result, Is.EqualTo(value));
}
