public void DeleteTest()
{
var session = cache.StartSession();
var penguin1 = new BasePenguin("DeleteTest1");
penguin1 = session.Insert(penguin1);
var penguin2 = new BasePenguin("DeleteTest1");
penguin2.AddRelation(PenguinRelationshipDirection.OUT, "test", penguin1.ID.Value);
penguin2 = session.Insert(penguin2);
Assert.Equal(1, penguin2.Datastore.Relations["test"].Count);
session.Delete(penguin1);
Assert.Throws(typeof(PersistenceException), () => session.GetById(penguin1.ID.Value));
var newPenguin2 = session.GetById(penguin2.ID.Value);
Assert.Equal(0, newPenguin2.Datastore.Relations.Count);
session.Commit();
Assert.Throws(typeof(PersistenceException), () => driver.GetById(penguin1.ID.Value));
var newPenguin3 = driver.GetById(penguin2.ID.Value);
Assert.Equal(0, newPenguin3.Datastore.Relations.Count);
}
public void InsertTest1()
{
var session = cache.StartSession();
var penguin = new BasePenguin("test");
penguin.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin.DirtyDatastore.Attributes.Add("IntProp", 123L);
penguin.DirtyDatastore.Attributes.Add("BoolProp", false);
BasePenguin insertedPenguin = session.Insert(penguin);
Assert.True(insertedPenguin != null);
Assert.True(insertedPenguin.ID.HasValue);
var getPenguin = session.GetById(insertedPenguin.ID.Value);
Assert.Equal("StringValue", insertedPenguin.Datastore.Attributes["StringProp"]);
Assert.Equal("StringValue", getPenguin.Datastore.Attributes["StringProp"]);
Assert.Equal(123L, insertedPenguin.Datastore.Attributes["IntProp"]);
Assert.Equal(123L, (long)getPenguin.Datastore.Attributes["IntProp"]);
Assert.Equal(false, insertedPenguin.Datastore.Attributes["BoolProp"]);
Assert.Equal(false, getPenguin.Datastore.Attributes["BoolProp"]);
Assert.False(insertedPenguin.IsDirty);
Assert.False(getPenguin.IsDirty);
session.Commit();
var getPenguin2 = this.driver.GetById(insertedPenguin.ID.Value);
Assert.Equal(getPenguin, getPenguin2);
}
public void InsertTest1()
{
var penguin = new BasePenguin("test");
penguin.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin.DirtyDatastore.Attributes.Add("IntProp", 123);
penguin.DirtyDatastore.Attributes.Add("BoolProp", false);
BasePenguin insertedPenguin = null;
this.driver.RunTransaction(context =>
{
insertedPenguin = context.Insert(penguin);
});
Assert.True(insertedPenguin != null);
Assert.True(insertedPenguin.ID.HasValue);
var getPenguin = this.driver.GetById(insertedPenguin.ID.Value);
Assert.Equal("StringValue", insertedPenguin.Datastore.Attributes["StringProp"]);
Assert.Equal("StringValue", getPenguin.Datastore.Attributes["StringProp"]);
Assert.Equal(123, insertedPenguin.Datastore.Attributes["IntProp"]);
Assert.Equal(123, (long)getPenguin.Datastore.Attributes["IntProp"]);
Assert.Equal(false, insertedPenguin.Datastore.Attributes["BoolProp"]);
Assert.Equal(false, getPenguin.Datastore.Attributes["BoolProp"]);
Assert.False(insertedPenguin.IsDirty);
Assert.False(getPenguin.IsDirty);
}
public static void AddRelation(this BasePenguin self, PenguinRelationshipDirection direction, string relationName, List <long> id)
{
id.ForEach(i =>
{
var basePenguinRelationship = new BasePenguinRelationship(direction, new RelationDatastore(relationName), i);
self.DirtyDatastore.Relations.CreateOrAddToList(relationName, basePenguinRelationship);
});
}
public void Add(BasePenguin entity)
{
if (entity.ID.HasValue)
{
var item = new CacheItem(entity.Clone() as BasePenguin);
var node = new LinkedListNode <CacheItem>(item);
lru.AddLast(node);
cache.Add(entity.ID.Value, node);
}
}
public void UpdateTest1()
{
var session = this.cache.StartSession();
var penguin1 = new BasePenguin("UpdateTest1");
penguin1.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin1.DirtyDatastore.Attributes.Add("IntProp", 123L);
penguin1.DirtyDatastore.Attributes.Add("BoolProp", false);
var penguin2 = new BasePenguin("UpdateTest1");
penguin2.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin2.DirtyDatastore.Attributes.Add("IntProp", 123L);
penguin2.DirtyDatastore.Attributes.Add("BoolProp", false);
List <BasePenguin> insertedPenguin = null;
insertedPenguin = session.Insert(new List <BasePenguin> {
penguin1, penguin2
});
Assert.False(insertedPenguin[0].IsDirty && insertedPenguin[1].IsDirty);
insertedPenguin[0].DirtyDatastore.Attributes.Add("StringProp", "ModifiedStringValue");
insertedPenguin[1].DirtyDatastore.Attributes.Add("IntProp", 456L);
insertedPenguin[1].DirtyDatastore.Attributes.Add("NewStringProp", "StringValue");
List <BasePenguin> updatedPenguins = null;
updatedPenguins = session.Update(insertedPenguin);
Assert.Equal("ModifiedStringValue", updatedPenguins[0].Datastore.Attributes["StringProp"]);
Assert.Equal(123L, updatedPenguins[0].Datastore.Attributes["IntProp"]);
Assert.Equal(false, updatedPenguins[0].Datastore.Attributes["BoolProp"]);
Assert.Equal("StringValue", updatedPenguins[1].Datastore.Attributes["StringProp"]);
Assert.Equal(456L, updatedPenguins[1].Datastore.Attributes["IntProp"]);
Assert.Equal(false, updatedPenguins[1].Datastore.Attributes["BoolProp"]);
Assert.Equal("StringValue", updatedPenguins[1].Datastore.Attributes["NewStringProp"]);
var getPenguins = session.GetById(new List <long> {
updatedPenguins[0].ID.Value, updatedPenguins[1].ID.Value
});
Assert.Equal(new ComparableHashSet <BasePenguin>(getPenguins), new ComparableHashSet <BasePenguin>(updatedPenguins));
session.Commit();
var getPenguins2 = this.driver.GetById(new List <long> {
updatedPenguins[0].ID.Value, updatedPenguins[1].ID.Value
});
Assert.Equal(getPenguins, getPenguins2);
}
public void UpdateTest1()
{
var penguin1 = new BasePenguin("UpdateTest1");
penguin1.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin1.DirtyDatastore.Attributes.Add("IntProp", 123L);
penguin1.DirtyDatastore.Attributes.Add("BoolProp", false);
var penguin2 = new BasePenguin("UpdateTest1");
penguin2.DirtyDatastore.Attributes.Add("StringProp", "StringValue");
penguin2.DirtyDatastore.Attributes.Add("IntProp", 123L);
penguin2.DirtyDatastore.Attributes.Add("BoolProp", false);
List <BasePenguin> insertedPenguin = null;
this.driver.RunTransaction(context =>
{
insertedPenguin = context.Insert(new List <BasePenguin> {
penguin1, penguin2
});
});
Assert.False(insertedPenguin[0].IsDirty && insertedPenguin[1].IsDirty);
insertedPenguin[0].DirtyDatastore.Attributes.Add("StringProp", "ModifiedStringValue");
insertedPenguin[1].DirtyDatastore.Attributes.Add("IntProp", 456L);
insertedPenguin[1].DirtyDatastore.Attributes.Add("NewStringProp", "StringValue");
List <BasePenguin> updatedPenguins = null;
this.driver.RunTransaction(context =>
{
updatedPenguins = context.Update(insertedPenguin);
});
Assert.Equal("ModifiedStringValue", updatedPenguins[0].Datastore.Attributes["StringProp"]);
Assert.Equal(123L, updatedPenguins[0].Datastore.Attributes["IntProp"]);
Assert.Equal(false, updatedPenguins[0].Datastore.Attributes["BoolProp"]);
Assert.Equal("StringValue", updatedPenguins[1].Datastore.Attributes["StringProp"]);
Assert.Equal(456L, updatedPenguins[1].Datastore.Attributes["IntProp"]);
Assert.Equal(false, updatedPenguins[1].Datastore.Attributes["BoolProp"]);
Assert.Equal("StringValue", updatedPenguins[1].Datastore.Attributes["NewStringProp"]);
var getPenguins = this.driver.GetById(new List <long> {
updatedPenguins[0].ID.Value, updatedPenguins[1].ID.Value
});
Assert.Equal(new ComparableHashSet <BasePenguin>(getPenguins), new ComparableHashSet <BasePenguin>(updatedPenguins));
}
public void Update(BasePenguin entity)
{
if (entity.ID.HasValue)
{
try
{
AcquireLock(entity.ID.Value);
_update(entity);
}
finally
{
ReleaseLock(entity.ID.Value);
}
}
}
public void InsertTest2()
{
var session = cache.StartSession();
var relatedPenguins = new List <BasePenguin> {
new BasePenguin("in"), new BasePenguin("in"), new BasePenguin("out")
};
relatedPenguins = session.Insert(relatedPenguins);
Assert.True(relatedPenguins.All(i => i.ID.HasValue));
var penguin = new BasePenguin("obj");
penguin.AddRelation(PenguinRelationshipDirection.IN, "rel_in", relatedPenguins[0].ID.Value);
penguin.AddRelation(PenguinRelationshipDirection.IN, "rel_in", relatedPenguins[1].ID.Value);
penguin.AddRelation(PenguinRelationshipDirection.OUT, "rel_out", relatedPenguins[2].ID.Value);
BasePenguin insertedPenguin = null;
insertedPenguin = session.Insert(penguin);
Assert.True(insertedPenguin.ID.HasValue);
Assert.True(insertedPenguin.Datastore.Relations.ContainsKey("rel_in") && insertedPenguin.Datastore.Relations["rel_in"].Count == 2);
Assert.True(insertedPenguin.Datastore.Relations.ContainsKey("rel_out") && insertedPenguin.Datastore.Relations["rel_out"].Count == 1);
Assert.Equal(new[] { relatedPenguins[0], relatedPenguins[1] }.Select(i => i.ID.Value).OrderBy(i => i).ToList(), insertedPenguin.Datastore.Relations["rel_in"].Select(i => i.Target.ID.Value).OrderBy(i => i).ToList());
Assert.True(insertedPenguin.Datastore.Relations["rel_out"].First().Target.ID.Value == relatedPenguins[2].ID.Value);
var getPenguin = session.GetById(insertedPenguin.ID.Value);
Assert.True(getPenguin.Datastore.Relations.ContainsKey("rel_in") && getPenguin.Datastore.Relations["rel_in"].Count == 2);
Assert.True(getPenguin.Datastore.Relations.ContainsKey("rel_out") && getPenguin.Datastore.Relations["rel_out"].Count == 1);
Assert.Equal(new[] { relatedPenguins[0], relatedPenguins[1] }.Select(i => i.ID.Value).OrderBy(i => i).ToList(), getPenguin.Datastore.Relations["rel_in"].Select(i => i.Target.ID.Value).OrderBy(i => i).ToList());
Assert.True(getPenguin.Datastore.Relations["rel_out"].First().Target.ID.Value == relatedPenguins[2].ID.Value);
relatedPenguins = session.GetById(relatedPenguins.Select(i => i.ID.Value).ToList());
Assert.True(relatedPenguins[0].Datastore.Relations.ContainsKey("rel_in") && relatedPenguins[0].Datastore.Relations["rel_in"].First().Target.ID.Value == insertedPenguin.ID.Value);
Assert.Equal(PenguinRelationshipDirection.OUT, relatedPenguins[0].Datastore.Relations["rel_in"].First().Direction);
Assert.True(relatedPenguins[1].Datastore.Relations.ContainsKey("rel_in") && relatedPenguins[1].Datastore.Relations["rel_in"].First().Target.ID.Value == insertedPenguin.ID.Value);
Assert.Equal(PenguinRelationshipDirection.OUT, relatedPenguins[1].Datastore.Relations["rel_in"].First().Direction);
Assert.True(relatedPenguins[2].Datastore.Relations.ContainsKey("rel_out") && relatedPenguins[2].Datastore.Relations["rel_out"].First().Target.ID.Value == insertedPenguin.ID.Value);
Assert.Equal(PenguinRelationshipDirection.IN, relatedPenguins[2].Datastore.Relations["rel_out"].First().Direction);
session.Commit();
var getPenguin2 = this.driver.GetById(insertedPenguin.ID.Value);
Assert.Equal(getPenguin, getPenguin2);
}
public void UpdateTest2()
{
var relatedPenguins = new List <BasePenguin> {
new BasePenguin("in"), new BasePenguin("in"), new BasePenguin("out"), new BasePenguin("out")
};
this.driver.RunTransaction(context =>
{
relatedPenguins = context.Insert(relatedPenguins);
});
Assert.True(relatedPenguins.All(i => i.ID.HasValue));
var penguin = new BasePenguin("obj");
penguin.AddRelation(PenguinRelationshipDirection.IN, "rel_in", relatedPenguins[0].ID.Value);
penguin.AddRelation(PenguinRelationshipDirection.IN, "rel_in", relatedPenguins[1].ID.Value);
penguin.AddRelation(PenguinRelationshipDirection.OUT, "rel_out", relatedPenguins[2].ID.Value);
BasePenguin insertedPenguin = null;
this.driver.RunTransaction(context =>
{
insertedPenguin = context.Insert(penguin);
});
insertedPenguin.DirtyDatastore.Relations.CreateOrAddToList("rel_out", insertedPenguin.Datastore.Relations["rel_out"].First());
insertedPenguin.DirtyDatastore.Relations.CreateOrAddToList("rel_out", new BasePenguinRelationship("rel_out", PenguinRelationshipDirection.OUT, relatedPenguins[3].ID.Value));
insertedPenguin.DirtyDatastore.Relations.CreateOrAddToList("rel_in", insertedPenguin.Datastore.Relations["rel_in"].ToList().Find(i => i.Target.ID == relatedPenguins[0].ID.Value));
BasePenguin updatedPenguin = null;
this.driver.RunTransaction(context =>
{
updatedPenguin = context.Update(insertedPenguin);
});
Assert.Equal(1, updatedPenguin.Datastore.Relations["rel_in"].Count);
Assert.Equal(insertedPenguin.DirtyDatastore.Relations["rel_in"].First(), updatedPenguin.Datastore.Relations["rel_in"].First());
Assert.Equal(2, updatedPenguin.Datastore.Relations["rel_out"].Count);
Assert.Equal(insertedPenguin.DirtyDatastore.Relations["rel_out"].Select(i => i.Target.ID.Value).OrderBy(i => i).ToList(), new List <long> {
relatedPenguins[2].ID.Value, relatedPenguins[3].ID.Value
});
var getPenguin = this.driver.GetById(updatedPenguin.ID.Value);
Assert.Equal(updatedPenguin.Datastore, getPenguin.Datastore);
Assert.Equal(updatedPenguin, getPenguin);
}
private void _update(BasePenguin entity)
{
if (entity.ID.HasValue)
{
LinkedListNode <CacheItem> node;
if (cache.TryGetValue(entity.ID.Value, out node))
{
node.Value.Penguin = entity.Clone() as BasePenguin;
node.Value.hit++;
lru.Remove(node);
lru.AddLast(node);
}
else
{
Add(entity);
}
}
}
public void DeleteTest()
{
var penguin1 = new BasePenguin("DeleteTest1");
this.driver.RunTransaction(context => penguin1 = context.Insert(penguin1));
var penguin2 = new BasePenguin("DeleteTest1");
penguin2.AddRelation(PenguinRelationshipDirection.OUT, "test", penguin1.ID.Value);
this.driver.RunTransaction(context => penguin2 = context.Insert(penguin2));
Assert.Equal(1, penguin2.Datastore.Relations["test"].Count);
this.driver.RunTransaction(context => context.Delete(penguin1));
Assert.Throws(typeof(PersistenceException), () => this.driver.GetById(penguin1.ID.Value));
var newPenguin2 = this.driver.GetById(penguin2.ID.Value);
Assert.Equal(0, newPenguin2.Datastore.Relations.Count);
}
public virtual BasePenguin Insert(BasePenguin penguin)
{
return(this.Insert(new List <BasePenguin> {
penguin
})[0]);
}
public virtual void Delete(BasePenguin penguin)
{
this.Delete(new List <BasePenguin> {
penguin
});
}
public virtual BasePenguin Update(BasePenguin penguin)
{
return(this.Update(new List <BasePenguin> {
penguin
})[0]);
}
public void Test1()
{
var outputPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var generatedFile = Path.Combine(new DirectoryInfo(outputPath).Parent.Parent.Parent.FullName, "_test.cs");
var generator = new CodeGenerator(new Options
{
InputFile = Path.Combine(outputPath, "test.penguin-model"),
OutputFile = Path.Combine(outputPath, "_test.cs"),
Namespace = "OnePenguin.Essentials.CodeGenerator.Tests.Test",
Assemblies = new List <string> {
Assembly.GetExecutingAssembly().Location
},
OutputDllFile = Path.Combine(outputPath, "_test.dll"),
});
generator.Generate();
//generator.Compile();
if (!File.Exists(generatedFile) || !CompareFiles(Path.Combine(outputPath, "_test.cs"), generatedFile))
{
File.Copy(Path.Combine(outputPath, "_test.cs"), generatedFile);
Assert.False(true, "Please re-compile the project and run the test.");
}
else
{
var t = Assembly.GetExecutingAssembly().GetType("OnePenguin.Essentials.CodeGenerator.Tests.Test.Test1Penguin");
Assert.NotNull(t);
var props = t.GetProperties().ToList();
var penguin = Activator.CreateInstance(t) as BasePenguin;
Assert.True(props.Exists(i => i.Name == "TestInt"));
props.Find(i => i.Name == "TestInt").SetValue(penguin, 123);
Assert.Equal(123L, penguin.DirtyDatastore.Attributes["TestInt"]);
Assert.Equal(123L, props.Find(i => i.Name == "TestInt").GetValue(penguin));
Assert.True(props.Exists(i => i.Name == "TestInt2"));
props.Find(i => i.Name == "TestInt2").SetValue(penguin, 123);
Assert.Equal(123L, penguin.DirtyDatastore.Attributes["TestInt2"]);
Assert.Equal(123L, props.Find(i => i.Name == "TestInt2").GetValue(penguin));
var dt = DateTime.Now;
Assert.True(props.Exists(i => i.Name == "TestDateTime"));
props.Find(i => i.Name == "TestDateTime").SetValue(penguin, dt);
Assert.Equal(dt, penguin.DirtyDatastore.Attributes["TestDateTime"]);
Assert.Equal(dt, props.Find(i => i.Name == "TestDateTime").GetValue(penguin));
Assert.True(props.Exists(i => i.Name == "TestString"));
props.Find(i => i.Name == "TestString").SetValue(penguin, "123");
Assert.Equal("123", penguin.DirtyDatastore.Attributes["TestString"]);
Assert.Equal("123", props.Find(i => i.Name == "TestString").GetValue(penguin));
var relatedPenguin = new BasePenguin(1, new Datastore("test"));
Assert.True(props.Exists(i => i.Name == "TestRelation"));
props.Find(i => i.Name == "TestRelation").SetValue(penguin, relatedPenguin);
Assert.Equal(new PenguinReference(relatedPenguin.ID.Value), penguin.DirtyDatastore.Relations["TestRelation"].First().Target);
Assert.Equal(new PenguinReference(relatedPenguin.ID.Value), props.Find(i => i.Name == "TestRelation").GetValue(penguin));
Assert.True(props.Exists(i => i.Name == "TestRelation2"));
props.Find(i => i.Name == "TestRelation2").SetValue(penguin, new List <PenguinReference> {
relatedPenguin
});
Assert.Equal(relatedPenguin.ID.Value, penguin.DirtyDatastore.Relations["TestRelation2"].First().Target.ID.Value);
Assert.Equal(new List <PenguinReference> {
relatedPenguin
}, props.Find(i => i.Name == "TestRelation2").GetValue(penguin));
File.Delete(generatedFile);
}
}
public CacheItem(BasePenguin penguin)
{
this.Penguin = penguin;
this.timestamp = DateTime.Now.Ticks;
}
public static void AddRelation(this BasePenguin self, PenguinRelationshipDirection direction, string relationName, long id)
{
self.AddRelation(direction, relationName, new List <long> {
id
});
}
