public void SubmitChanges_PersonInserted_SetsNewId()
{
var person = new Person {
Id = -1
};
var entry = new ChangeTrackerEntry
{
Item = person,
State = ChangeTrackerEntry.States.Inserted
};
var mockDriver = new Mock <IDatabaseDriver>();
mockDriver.Setup(x => x.RunInsertStatement(It.IsAny <string>())).Returns(1);
var mockSqlBuilder = new Mock <ISqlStatementBuilder>();
var mockChangeTracker = new Mock <IChangeTracker>();
mockChangeTracker.Setup(x => x.GetEntry(person)).Returns(entry);
mockChangeTracker.Setup(x => x.InsertedObjects).Returns(new List <object> {
person
});
var orm = new MyOrm(mockDriver.Object, mockSqlBuilder.Object, mockChangeTracker.Object);
orm.SubmitChanges();
person.Id.ShouldBe(1);
}
/// <summary>
/// Used by the query provider to materialize database objects
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="builder"></param>
/// <returns></returns>
public List <T> GetObjectsFromDb <T>(ISqlStatementBuilder builder)
{
var selectResults = _dbDriver.RunSelectStatement(builder.SelectStatement);
var objects = new List <T>();
foreach (var result in selectResults)
{
var myObject = MaterializeObject <T>(result);
var id = GetId(myObject);
var possiblyExistingObject = ChangeTracker.GetEntry(id, typeof(T))?.Item;
var objectIsNew = possiblyExistingObject == null;
if (!objectIsNew)
{
objects.Add((T)possiblyExistingObject);
continue;
}
var changeTrackerEntry = new ChangeTrackerEntry
{
State = ChangeTrackerEntry.States.Unmodified,
Item = myObject,
};
changeTrackerEntry.UpdateOriginals(myObject);
ChangeTracker.AddEntry(changeTrackerEntry);
objects.Add(myObject);
}
return(objects);
}
public void AddEntry_NoItem_ThrowsException()
{
var entry = new ChangeTrackerEntry();
IChangeTracker changeTracker = new ChangeTracker();
Should.Throw <Exception>(() => changeTracker.AddEntry(entry));
}
/// <inheritdoc />
public void AddEntry(ChangeTrackerEntry entry)
{
if (entry.Item == null)
{
throw new Exception("Item is null");
}
_entries.Add(entry.Item, entry);
}
/// <summary>
/// Used to add objects to the ORM
/// </summary>
/// <param name="objectToInsert"></param>
public void Insert(object objectToInsert)
{
SetId(objectToInsert, --_insertionId);
var changeTrackerEntry = new ChangeTrackerEntry
{
State = ChangeTrackerEntry.States.Inserted,
Item = objectToInsert,
};
changeTrackerEntry.UpdateOriginals(objectToInsert);
ChangeTracker.AddEntry(changeTrackerEntry);
}
public void ModifiedObjects_HaveBeenAdded_ReturnEntries()
{
var myObject = new object();
var entry = new ChangeTrackerEntry
{
Item = myObject,
State = ChangeTrackerEntry.States.Modified
};
IChangeTracker changeTracker = new ChangeTracker();
changeTracker.AddEntry(entry);
changeTracker.ModifiedObjects.Single().ShouldBe(myObject);
}
public void AddEntry_HasItem_ContainsEntry()
{
var myObject = new object();
var entry = new ChangeTrackerEntry
{
Item = myObject
};
IChangeTracker changeTracker = new ChangeTracker();
changeTracker.AddEntry(entry);
changeTracker.Count.ShouldBe(1);
changeTracker.Entries.Single().Item.ShouldBe(myObject);
}
public void GetEntryByObject_EntryExists_CorrectEntry()
{
var myObject = new object();
var entry = new ChangeTrackerEntry
{
Item = myObject
};
IChangeTracker changeTracker = new ChangeTracker();
changeTracker.AddEntry(entry);
var retrievedEntry = changeTracker.GetEntry(myObject);
retrievedEntry.ShouldBe(entry);
retrievedEntry.Item.ShouldBe(myObject);
}
public void ComputeState_SetState_StateModified()
{
//Arrange
Photographer p = GetPhotographer();
ChangeTrackerEntry cte = new ChangeTrackerEntry(p);
//Act
p.BirthDate = p.BirthDate.AddDays(2);
cte.ComputeState();
//Assert
Assert.NotNull(cte.Item);
Assert.Equal(p, cte.Item);
Assert.NotNull(cte.Originals);
Assert.Equal(ChangeTrackerEntry.States.Modified, cte.State);
Assert.Equal(p.GetType().GetProperties().Length, cte.Originals.Count);
}
public void ComputeState_NoChange_StateDeleted()
{
//Arrange
Photographer p = GetPhotographer();
ChangeTrackerEntry cte = new ChangeTrackerEntry(p, ChangeTrackerEntry.States.Deleted);
//Act
p.Name = "othername";
cte.ComputeState();
//Assert
Assert.NotNull(cte.Item);
Assert.Equal(p, cte.Item);
Assert.NotNull(cte.Originals);
Assert.Equal(ChangeTrackerEntry.States.Deleted, cte.State);
Assert.Equal(p.GetType().GetProperties().Length, cte.Originals.Count);
}
public void Constructor_SetsValues()
{
//Arrange
Photographer p = GetPhotographer();
//Act
ChangeTrackerEntry cte = new ChangeTrackerEntry(p);
//Assert
Assert.NotNull(cte.Item);
Assert.Equal(p, cte.Item);
Assert.NotNull(cte.Originals);
Assert.Equal(ChangeTrackerEntry.States.Unmodified, cte.State);
Assert.Equal(p.GetType().GetProperties().Length, cte.Originals.Count);
foreach (var pair in cte.Originals)
{
Assert.Equal(pair.Item1.GetValue(p), pair.Item2);
}
}
public void Delete_GetsChangeTrackerEntry_SetsDeleted()
{
var person = new Person();
var entry = new ChangeTrackerEntry
{
Item = person,
State = ChangeTrackerEntry.States.Unmodified
};
var mockDriver = new Mock <IDatabaseDriver>();
var mockSqlBuilder = new Mock <ISqlStatementBuilder>();
var mockChangeTracker = new Mock <IChangeTracker>();
mockChangeTracker.Setup(x => x.GetEntry(person)).Returns(entry);
var orm = new MyOrm(mockDriver.Object, mockSqlBuilder.Object, mockChangeTracker.Object);
orm.Delete(person);
mockChangeTracker.Verify(x => x.GetEntry(person), Times.Once);
entry.State.ShouldBe(ChangeTrackerEntry.States.Deleted);
}
public void SubmitChanges_PersonInserted_SetsStateUnmodified()
{
var person = new Person();
var entry = new ChangeTrackerEntry
{
Item = person,
State = ChangeTrackerEntry.States.Inserted
};
var mockDriver = new Mock <IDatabaseDriver>();
var mockSqlBuilder = new Mock <ISqlStatementBuilder>();
var mockChangeTracker = new Mock <IChangeTracker>();
mockChangeTracker.Setup(x => x.GetEntry(person)).Returns(entry);
mockChangeTracker.Setup(x => x.InsertedObjects).Returns(new List <object> {
person
});
var orm = new MyOrm(mockDriver.Object, mockSqlBuilder.Object, mockChangeTracker.Object);
orm.SubmitChanges();
entry.State.ShouldBe(ChangeTrackerEntry.States.Unmodified);
}
public void SubmitChanges_PersonInserted_InvokesDriverRunInsertStatement()
{
var person = new Person();
var entry = new ChangeTrackerEntry
{
Item = person,
State = ChangeTrackerEntry.States.Inserted
};
var mockDriver = new Mock <IDatabaseDriver>();
var mockSqlBuilder = new Mock <ISqlStatementBuilder>();
var mockChangeTracker = new Mock <IChangeTracker>();
mockChangeTracker.Setup(x => x.GetEntry(person)).Returns(entry);
mockChangeTracker.Setup(x => x.InsertedObjects).Returns(new List <object> {
person
});
var orm = new MyOrm(mockDriver.Object, mockSqlBuilder.Object, mockChangeTracker.Object);
orm.SubmitChanges();
mockDriver.Verify(x => x.RunInsertStatement(It.IsAny <string>()), Times.AtLeastOnce());
}
public void GetObjectsFromDb_ObjectExists_UsesSameObject()
{
var id = new Random().Next(1, int.MaxValue);
var person = new Person
{
Id = id,
FirstName = "Mike",
LastName = "Rosoft",
Age = 1337
};
var entry = new ChangeTrackerEntry
{
Item = person,
State = ChangeTrackerEntry.States.Unmodified
};
var props = new List <IDictionary <string, object> >
{
new Dictionary <string, object>
{
{ "Id", id },
{ "FirstName", "Mike" },
{ "LastName", "Rosoft" },
{ "Age", 1337 }
}
};
var mockDriver = new Mock <IDatabaseDriver>();
mockDriver.Setup(x => x.RunSelectStatement(It.IsAny <string>()))
.Returns(props);
var mockSqlBuilder = new Mock <ISqlStatementBuilder>();
var mockChangeTracker = new Mock <IChangeTracker>();
mockChangeTracker.Setup(x => x.GetEntry(id, typeof(Person))).Returns(entry);
var orm = new MyOrm(mockDriver.Object, mockSqlBuilder.Object, mockChangeTracker.Object);
var result = orm.GetObjectsFromDb <Person>(mockSqlBuilder.Object);
result.Single().ShouldBe(person);
}
public void SetUnmodified_SetsStateToUnmodified_FromModified()
{
//Arrange
Photographer p = GetPhotographer();
ChangeTrackerEntry cte = new ChangeTrackerEntry(p);
p.BirthDate = p.BirthDate.AddDays(2);
cte.ComputeState();
//Act
cte.SetUnmodified();
//Assert
Assert.NotNull(cte.Item);
Assert.Equal(p, cte.Item);
Assert.NotNull(cte.Originals);
Assert.Equal(ChangeTrackerEntry.States.Unmodified, cte.State);
Assert.Equal(p.GetType().GetProperties().Length, cte.Originals.Count);
foreach (var pair in cte.Originals)
{
Assert.Equal(pair.Item1.GetValue(p), pair.Item2);
}
}
