public void AddToCsvRepoWorksWhenFileDoesNotExist(MockPoco input)
{
// Arrange
var fileName = Path.GetRandomFileName();
var outputFile = new FileInfo(Path.ChangeExtension(fileName, "csv"));
CsvContext <MockPoco> csvContext = null;
CsvRepo <MockPoco> repository = null;
try
{
csvContext = new CsvContext <MockPoco>(outputFile)
{
Culture = CultureInfo.InvariantCulture
};
repository = new CsvRepo <MockPoco>(csvContext);
// Act
repository.Add(input);
csvContext.SaveChanges();
var received = File.ReadAllText(outputFile.FullName);
// Assert
Assert.Contains(input.Value, received);
}
finally
{
repository?.Dispose();
outputFile.Delete();
}
}
public void CreateAndDeleteEntityTest()
{
var dbProvider = ProviderDefaults.AppProvider;
var mp = new MockPoco {
MockStringValue = "xxx"
};
var dew = new DataModel <MockPoco>(mp);
dew.DataProvider = dbProvider;
dew.Save();
var myMockEntityQuery = DataModel <MockPoco>
.NewQuery()
.WhereColumn["string_value"] == "xxx";
var entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNotNull(entity);
Assert.IsNotNull(entity.Entity.ID);
Assert.IsTrue(entity.Entity.ID > 0);
Assert.IsTrue(entity.Entity.MockStringValue == "xxx");
entity.MarkDeleted = true;
entity.Save();
entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNull(entity);
}
public void GetGets(MockPoco input)
{
// Arrange
var fileName = Path.GetRandomFileName();
var outputFile = new FileInfo(Path.ChangeExtension(fileName, "csv"));
CsvContext <MockPoco> csvContext = null;
CsvRepo <MockPoco> repository = null;
try
{
csvContext = new CsvContext <MockPoco>(outputFile)
{
Culture = CultureInfo.InvariantCulture
};
repository = new CsvRepo <MockPoco>(csvContext);
csvContext.Entities.Add(input);
csvContext.SaveChanges();
// Act
var received = repository.Get(input);
// Assert
Assert.Equal(input, received);
}
finally
{
repository?.Dispose();
outputFile.Delete();
}
}
public void ShouldResolveObjectInstance()
{
var instance = new MockPoco();
container.RegisterInstance(typeof(IMock), instance);
Assert.IsNotNull(container.Resolve(typeof(IMock)));
}
public void AddOrUpdateAdds(MockPoco input)
{
// Arrange
var testSettings = new TestProjectSettings();
DbContext testContext = null;
Repository <MockPoco> tested = null;
try
{
testContext = new MockPocoContext(testSettings);
tested = new Repository <MockPoco>(testContext);
testContext.Database.EnsureCreated();
// Act
tested.AddOrUpdate(input);
testContext.SaveChanges();
// Assert
Assert.Equal(input, testContext.Set <MockPoco>().First());
}
finally
{
testContext?.Database.EnsureDeleted();
tested?.Dispose();
testContext?.Dispose();
}
}
public void UpdateUpdates(MockPoco input)
{
// Arrange
const string expected = "newValue1";
var testSettings = new TestProjectSettings();
DbContext testContext = null;
Repository <MockPoco> tested = null;
try
{
testContext = new MockPocoContext(testSettings);
tested = new Repository <MockPoco>(testContext);
testContext.Database.EnsureCreated();
testContext.Add(input);
testContext.SaveChanges();
// Act
input.Value = expected;
testContext.SaveChanges();
// Assert
Assert.Equal(input.Value, testContext.Set <MockPoco>().First().Value);
}
finally
{
testContext?.Database.EnsureDeleted();
tested?.Dispose();
testContext?.Dispose();
}
}
public void ShouldRegisterInstanceGeneric()
{
var instance = new MockPoco();
container.Register <IMock>(instance);
var registered = container.Registry.First(f => f.From == typeof(IMock));
Assert.AreSame(instance, registered.Instance);
}
public void ShouldResolveGeneric()
{
var instance = new MockPoco();
container.Register <IMock>(instance);
var resolved = container.Resolve <IMock>();
Assert.AreSame(instance, resolved);
}
public void ShouldProvideInstance()
{
var container = new MiniCoreContainer();
var instance = new MockPoco();
container.Register(instance);
var provider = new MiniCoreInstanceProvider(container);
var context = new InstanceContext(new MockServiceHost(typeof(MockPoco)));
var actual = provider.GetInstance(context);
Assert.AreSame(instance, actual);
}
public void CreateAndDeleteEntitiesTest()
{
var dbProvider = ProviderDefaults.AppProvider;
var mockPoco1 = new MockPoco {
MockStringValue = "MockPoco1_xxx"
};
var mockPoco1_de = new DataModel <MockPoco>(mockPoco1);
mockPoco1_de.DataProvider = dbProvider;
mockPoco1_de.Save();
var mockPoco2 = new MockPoco {
MockStringValue = "MockPoco2_xxx"
};
var mockPoco2_de = new DataModel <MockPoco>(mockPoco2);
mockPoco2_de.DataProvider = dbProvider;
mockPoco2_de.Save();
var mockPoco3 = new MockPoco {
MockStringValue = "MockPoco3_xxx"
};
var mockPoco3_de = new DataModel <MockPoco>(mockPoco3);
mockPoco3_de.DataProvider = dbProvider;
mockPoco3_de.Save();
var myMockEntityQuery = DataModel <MockPoco>
.NewQuery()
.WhereColumn["string_value"].IsLike("%xxx");
var entities = dbProvider.LoadModels(myMockEntityQuery);
var e = entities.Unwrap <MockPoco>()[0];
entities[0].MarkDeleted = true;
entities[2].MarkDeleted = true;
entities.Save();
var entities2 = dbProvider.LoadModels(myMockEntityQuery);
if (entities2.Count != 1)
{
}
Assert.IsTrue(entities2.Count == 1);
//cleanup
entities[1].MarkDeleted = true;
entities.Save();
}
public void StaticSaveMethodTest()
{
var entity = new MockPoco
{
MockStringValue = "zzz"
};
DataModel <MockPoco> .Save(entity);
var model = DataModel <MockPoco> .LoadMany(DataModel <MockPoco> .NewQuery()).Last();
Assert.IsNotNull(model);
Assert.IsTrue(model.Entity.MockStringValue == "zzz");
model.MarkDeleted = true;
model.Save();
}
public void AddOrUpdateUpdates(MockPoco input)
{
string oldValue = input.Value;
const string newValue = "newValue5";
// Arrange
var fileName = Path.GetRandomFileName();
var outputFile = new FileInfo(Path.ChangeExtension(fileName, "csv"));
using (var streamWriter = outputFile.CreateText())
{
streamWriter.Write($"Id,Value\r\n{input.Id},{input.Value}\r\n");
}
CsvContext <MockPoco> csvContext = null;
CsvRepo <MockPoco> repository = null;
try
{
csvContext = new CsvContext <MockPoco>(outputFile)
{
Culture = CultureInfo.InvariantCulture
};
repository = new CsvRepo <MockPoco>(csvContext);
csvContext.SaveChanges();
// Act
input.Value = newValue;
repository.AddOrUpdate(input);
csvContext.SaveChanges();
var received = File.ReadAllText(outputFile.FullName);
// Assert
Assert.Contains(newValue, received);
Assert.DoesNotContain(oldValue, received);
}
finally
{
repository?.Dispose();
outputFile.Delete();
}
}
public void AddToCsvRepoWorksWhenNonEmptyFileExists(MockPoco input)
{
// Arrange
var fileName = Path.GetRandomFileName();
var outputFile = new FileInfo(Path.ChangeExtension(fileName, "csv"));
using (var streamWriter = outputFile.CreateText())
{
streamWriter.Write("Id,Value\r\n5,test5\r\n");
}
CsvContext <MockPoco> csvContext = null;
CsvRepo <MockPoco> repository = null;
try
{
csvContext = new CsvContext <MockPoco>(outputFile)
{
Culture = CultureInfo.InvariantCulture
};
repository = new CsvRepo <MockPoco>(csvContext);
// Act
repository.Add(input);
csvContext.SaveChanges();
var received = File.ReadAllText(outputFile.FullName);
// Assert
Assert.Contains("test5", received);
Assert.Contains(input.Value, received);
}
finally
{
repository?.Dispose();
outputFile.Delete();
}
}
public void CreateWithoutProcAndDeleteWithProcEntityTest()
{
var dbProvider = ProviderDefaults.AppProvider;
var oldMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
DataModelMap.MapItems.Remove(typeof(MockPoco));
var newMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
newMapping.TableMapping.DeleteProcedure = "sp_mock_table_Delete";
try
{
var mp = new MockPoco {
MockStringValue = "xxx"
};
var dew = new DataModel <MockPoco>(mp);
dew.DataProvider = dbProvider;
dew.Save();
var myMockEntityQuery = DataModel <MockPoco>
.NewQuery()
.WhereColumn["string_value"] == "xxx";
var entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNotNull(entity);
Assert.IsNotNull(entity.Entity.ID);
Assert.IsTrue(entity.Entity.ID > 0);
Assert.IsTrue(entity.Entity.MockStringValue == "xxx");
entity.MarkDeleted = true;
entity.Save();
entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNull(entity);
}
finally
{
DataModelMap.MapItems.Remove(typeof(MockPoco));
DataModelMap.MapItems.Add(typeof(MockPoco), oldMapping);
}
}
public void UpdateUpdatesAfterChangesCommited(MockPoco input)
{
string oldValue = input.Value;
const string newValue = "newValue5";
// Arrange
var fileName = Path.GetRandomFileName();
var outputFile = new FileInfo(Path.ChangeExtension(fileName, "csv"));
CsvContext <MockPoco> csvContext = null;
CsvRepo <MockPoco> repository = null;
try
{
csvContext = new CsvContext <MockPoco>(outputFile)
{
Culture = CultureInfo.InvariantCulture
};
repository = new CsvRepo <MockPoco>(csvContext);
// Act
repository.Add(input);
csvContext.SaveChanges();
input.Value = newValue;
csvContext.SaveChanges();
var received = File.ReadAllText(outputFile.FullName);
// Assert
Assert.Contains(newValue, received);
Assert.DoesNotContain(oldValue, received);
}
finally
{
repository?.Dispose();
outputFile.Delete();
}
}
public void CreateAndDeleteEntityTest2()
{
var dbProvider = ProviderDefaults.AppProvider;
var mp = new MockPoco {
MockStringValue = "xxx"
};
var dew = new DataModel <MockPoco>(mp); // data entity wrapper
dew.DataProvider = dbProvider;
dew.Save(); // auto-synchronizes ID
// or...
//dbProvider.SaveModel(dew);
//dew.SynchronizeFields(SyncTo.ClrMembers); // manually sync ID
// now let's load it and validate that it was saved
var mySampleEntityQuery = DataModel <MockPoco> .NewQuery()
.WhereProperty["ID"] == mp.ID; // mp.ID was inferred as IsIdentity so we auto-returned it on Save()
var data = dbProvider.LoadModel(mySampleEntityQuery);
Assert.IsNotNull(data);
// by the way, you can go back to the POCO type, too
var mp2 = data.Entity;
// precompiler-checked: Assert.IsTrue(mp2 is MockPoco);
Assert.IsTrue(mp2.ID > 0);
Assert.IsTrue(mp2.MockStringValue == "xxx");
// test passed, let's delete the test record
data.MarkDeleted = true;
data.Save();
// ... and make sure that it has been deleted
data = dbProvider.LoadModel(mySampleEntityQuery);
Assert.IsNull(data);
}
public void DefaultDBProviderTest()
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
ProviderDefaults.AppProvider = dbProvider;
var poco = new MockPoco();
poco.MockStringValue = "Provider wuz here";
var pocoModel = new DataModel <MockPoco>(poco);
pocoModel.Save();
var q = DataModel <MockPoco> .NewQuery()
.WhereProperty["MockStringValue"]
.IsEqualTo("Provider wuz here");
pocoModel = dbProvider.LoadModel(q);
Assert.IsNotNull(poco);
Assert.IsTrue(pocoModel.Entity.MockStringValue == "Provider wuz here");
Assert.IsTrue(pocoModel.Entity.ID > 0);
// clean-up
}
