public void WriteMembersMultiplePermissions()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria = (db, obj) => obj.ItemCount > 3;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Allow, "ItemCount", goodCriteria);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria2 = (db, obj) => obj.ItemCount < 9;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Allow, "ItemCount", goodCriteria2);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.ItemCount == 8;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Deny, "ItemCount", badCriteria);
obj1.ItemCount = 8;
SecurityTestHelper.FailSaveChanges(dbContextMultiClass);
Assert.AreEqual(0, obj1.DecimalItem);
obj1.ItemCount = 6;
dbContextMultiClass.SaveChanges();
}
}
public void WriteMemberDenyPermission()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.Description == "Not good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Deny, "DecimalItem", badCriteria);
obj1.Description = "Good description";
obj1.DecimalItem = 20;
dbContextMultiClass.SaveChanges();
obj1.Description = "Not good description";
obj1.DecimalItem = 10;
SecurityTestHelper.FailSaveChanges(dbContextMultiClass);
obj1.Description = "Good description";
obj1.DecimalItem = 10;
dbContextMultiClass.SaveChanges();
}
}
public void ReadObjectAllowPermission()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = new DbContextObject1();
obj1.DecimalItem = 10;
obj1.Description = "Good description";
DbContextObject1 obj2 = new DbContextObject1();
obj2.DecimalItem = 20;
obj2.Description = "Not good description";
dbContextMultiClass.Add(obj1);
dbContextMultiClass.Add(obj2);
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
Assert.AreEqual(2, dbContextMultiClass.dbContextDbSet1.Count());
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > criteria = (db, obj) => obj.Description == "Good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Allow, "DecimalItem", criteria);
Assert.AreEqual(1, dbContextMultiClass.dbContextDbSet1.Count());
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
Assert.IsNull(obj1.Description);
Assert.AreEqual(10, obj1.DecimalItem);
}
}
public void IsGrantedMultiplePermissions()
{
foreach (SecurityOperation securityOperation in new SecurityOperation[] { SecurityOperation.Read, SecurityOperation.Write })
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = new DbContextObject1();
Assert.IsTrue(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), SecurityOperation.Write, obj1, null));
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria = (db, obj) => obj.ItemCount > 3;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(securityOperation, OperationState.Allow, "DecimalItem", goodCriteria);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria2 = (db, obj) => obj.ItemCount < 9;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(securityOperation, OperationState.Allow, "DecimalItem", goodCriteria2);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.ItemCount == 8;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(securityOperation, OperationState.Deny, "DecimalItem", badCriteria);
obj1.ItemCount = 8;
Assert.IsFalse(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), securityOperation, obj1, "DecimalItem"));
obj1.ItemCount = 5;
Assert.IsTrue(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), securityOperation, obj1, "DecimalItem"));
}
}
}
private void Zip(Func <DbContextMultiClass> createDbContext)
{
var item1 = new DbContextObject1()
{
ItemName = "Silver Coin", ItemCount = 200
};
var item2 = new DbContextObject1()
{
ItemName = "Gold Coin", ItemCount = 100
};
var item3 = new DbContextObject1()
{
ItemName = "Iron Coin", ItemCount = 300
};
var arrayint = new[] { 1, 2, 3 };
using (var context = createDbContext()) {
context.dbContextDbSet1.AddRange(new[] { item1, item2, item3 });
context.SaveChanges();
}
using (var context = createDbContext()) {
var res = context.dbContextDbSet1.Zip(arrayint, (p, b) => p + " " + b);;
Assert.AreEqual(res.Count(), 3);
}
}
public void ReadMemberAllowPermission()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = new DbContextObject1();
obj1.DecimalItem = 10;
obj1.Description = "Good description";
DbContextObject1 obj2 = new DbContextObject1();
obj2.DecimalItem = 20;
obj2.Description = "Not good description";
dbContextMultiClass.Add(obj1);
dbContextMultiClass.Add(obj2);
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > criteria = (db, obj) => obj.Description != "Good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Deny, "DecimalItem", criteria);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > typeCriteria = (db, obj) => true;
dbContextMultiClass.PermissionsContainer.AddObjectPermission(SecurityOperation.Read, OperationState.Allow, typeCriteria);
var query = from d in dbContextMultiClass.dbContextDbSet1
orderby d.ID
select d.DecimalItem;
Assert.AreEqual(2, query.Count());
Decimal obj1Decimal = query.First();
Assert.AreEqual(10, obj1Decimal);
Decimal obj2Decimal = query.Last();
Assert.AreEqual(0, obj2Decimal); // doesn't work now
}
}
private void Reverse(Func <DbContextMultiClass> createDbContext)
{
using (var context = createDbContext()) {
context.Add(new DbContextObject1()
{
ItemCount = 2
});
context.Add(new DbContextObject1()
{
ItemCount = 3
});
context.Add(new DbContextObject1()
{
ItemCount = 1
});
context.SaveChanges();
}
DbContextObject1 res1 = null;
using (var context = createDbContext()) {
res1 = context.dbContextDbSet1.First();
context.dbContextDbSet1.Reverse();
context.SaveChanges();
}
DbContextObject1 res2 = null;
using (var context = createDbContext()) {
res2 = context.dbContextDbSet1.First();
Assert.AreNotEqual(res2.ItemCount, res1.ItemCount);
}
}
private void Intersect(Func <DbContextMultiClass> createDbContext)
{
var item1 = new DbContextObject1()
{
ItemCount = 1
};
var item2 = new DbContextObject1()
{
ItemCount = 2
};
var item3 = new DbContextObject1()
{
ItemCount = 3
};
var array = new[] { item1, item3 };
var array1 = new[] { item1, item2, item3 };
using (var context = createDbContext()) {
context.dbContextDbSet1.Add(item1);
context.dbContextDbSet1.Add(item2);
context.dbContextDbSet1.Add(item3);
context.SaveChanges();
}
using (var context = createDbContext()) {
var itemres1 = array1.Intersect(array);
var countitem1 = itemres1.Count();
var itemres = context.dbContextDbSet1.Intersect(array);
var countitem = itemres.Count();
}
}
public void WriteTest()
{
int count = 100;
bool firstStart = true;
List <long> times = new List <long>();
List <Func <DbContextMultiClass> > contexts = new List <Func <DbContextMultiClass> >();
for (int i = 0; i < 5; i++)
{
contexts.Add(() => new DbContextMultiClass());
}
foreach (Func <DbContextMultiClass> createContext in contexts)
{
using (IDisposable disposableInterface = (IDisposable)createContext()) {
IDbContextMultiClass contextInterface = (IDbContextMultiClass)disposableInterface;
DbContext context = (DbContext)contextInterface;
context.ResetDatabase();
for (int i = 0; i < count; i++)
{
DbContextObject1 obj = new DbContextObject1();
obj.Description = "Description " + i.ToString();
context.Add(obj);
}
context.SaveChanges();
}
using (DbContextMultiClass context = createContext()) {
List <DbContextObject1> objects = context.dbContextDbSet1.Select(obj => obj).ToList();
Assert.AreEqual(count, objects.Count);
SecurityDbContext securityDbContext = context as SecurityDbContext;
if (securityDbContext != null)
{
PerformanceTestsHelper.AddMultiplePermissions(securityDbContext, SecurityOperation.Write);
}
Stopwatch watch = new Stopwatch();
watch.Start();
foreach (DbContextObject1 obj in objects)
{
context.Security.PermissionProcessor.IsGranted(typeof(DbContextObject1), SecurityOperation.Write, obj);
}
watch.Stop();
if (firstStart)
{
firstStart = false;
}
else
{
times.Add(watch.ElapsedMilliseconds);
}
}
}
Assert.LessOrEqual(times.Average(), 1);
}
public void CreateObjects(TestType testType)
{
int count = 1000;
List <long> memoryUsages = new List <long>();
List <Func <IDbContextMultiClass> > contexts = PerformanceTestsHelper.GetMemoryTestsContextCreators();
foreach (Func <IDbContextMultiClass> createContext in contexts)
{
long initialUsedMemory = 0;
long usedMemory = 0;
initialUsedMemory = PerformanceTestsHelper.GetCurrentUsedMemory();
using (IDisposable disposableContextInterface = (IDisposable)createContext()) {
IDbContextMultiClass contextInterface = (IDbContextMultiClass)disposableContextInterface;
DbContext context = (DbContext)contextInterface;
context.ResetDatabase();
if (testType == TestType.WithOnePermission)
{
SecurityDbContext securityDbContext = context as SecurityDbContext;
if (securityDbContext != null)
{
PerformanceTestsHelper.AddOnePermission(securityDbContext, SecurityOperation.Create);
}
}
if (testType == TestType.WithMultiplePermissions)
{
SecurityDbContext securityDbContext = context as SecurityDbContext;
if (securityDbContext != null)
{
PerformanceTestsHelper.AddMultiplePermissions(securityDbContext, SecurityOperation.Create);
}
}
for (int i = 0; i < count; i++)
{
DbContextObject1 obj = new DbContextObject1();
obj.Description = "Description " + i.ToString();
context.Add(obj);
}
context.SaveChanges();
}
long beforeCollect = GC.GetTotalMemory(true);
usedMemory = PerformanceTestsHelper.GetCurrentUsedMemory();
memoryUsages.Add(usedMemory - initialUsedMemory);
}
double securedContextBytesGrow = PerformanceTestsHelper.GetSecuredContextValue(memoryUsages);
double nativeContextBytesGrow = PerformanceTestsHelper.GetNativeContextValue(memoryUsages);
Assert.IsTrue(false, "our: " + securedContextBytesGrow.ToString() + " bytes, native: " + nativeContextBytesGrow.ToString() + " bytes");
}
public void CreateObjects(TestType testType)
{
int count = 1000;
List <long> times = new List <long>();
List <Func <IDbContextMultiClass> > contexts = PerformanceTestsHelper.GetContextCreators();
foreach (Func <IDbContextMultiClass> createContext in contexts)
{
IDbContextMultiClass contextInterface = createContext();
DbContext context = (DbContext)contextInterface;
context.ResetDatabase();
if (testType == TestType.WithOnePermission)
{
SecurityDbContext securityDbContext = context as SecurityDbContext;
if (securityDbContext != null)
{
PerformanceTestsHelper.AddOnePermission(securityDbContext, SecurityOperation.Create);
}
}
if (testType == TestType.WithMultiplePermissions)
{
SecurityDbContext securityDbContext = context as SecurityDbContext;
if (securityDbContext != null)
{
PerformanceTestsHelper.AddMultiplePermissions(securityDbContext, SecurityOperation.Create);
}
}
Stopwatch watch = new Stopwatch();
watch.Start();
for (int i = 0; i < count; i++)
{
DbContextObject1 obj = new DbContextObject1();
obj.Description = "Description " + i.ToString();
context.Add(obj);
}
context.SaveChanges();
watch.Stop();
times.Add(watch.ElapsedMilliseconds);
}
double securedContextTime = PerformanceTestsHelper.GetSecuredContextValue(times);
double nativeContextTime = PerformanceTestsHelper.GetNativeContextValue(times);
double nominalTimeDifference = GetTimeDifference(testType);
double timeDifference = securedContextTime - nativeContextTime;
Assert.IsTrue(timeDifference <= nominalTimeDifference, GetTimeDifferenceErrorString(timeDifference, nominalTimeDifference));
Debug.WriteLine(GetDebugTimeString(securedContextTime, nativeContextTime));
}
private void Entry(Func <DbContextMultiClass> createDbContext)
{
var itemMold = new DbContextObject1()
{
ItemName = "1"
};
using (DbContextMultiClass context = createDbContext()) {
var item = context.Entry(itemMold);
Assert.AreNotEqual(item, null);
}
}
public void ReadBlockedMembersFromObjectWithMultipleBlockedMembers()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Database.EnsureCreated();
DbContextObject1 obj1 = new DbContextObject1();
obj1.ItemName = "Object 1 name";
obj1.DecimalItem = 10;
obj1.Description = "Good description";
DbContextObject1 obj2 = new DbContextObject1();
obj2.ItemName = "Object 2 name";
obj2.DecimalItem = 20;
obj2.Description = "Not good description";
dbContextMultiClass.Add(obj1);
dbContextMultiClass.Add(obj2);
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
Assert.AreEqual(2, dbContextMultiClass.dbContextDbSet1.Count());
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.Description == "Not good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Deny, "DecimalItem", badCriteria);
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Deny, "ItemName", badCriteria);
Assert.AreEqual(2, dbContextMultiClass.dbContextDbSet1.Count());
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.First(obj => obj.Description == "Good description");
Assert.AreEqual("Good description", obj1.Description);
Assert.AreEqual("Object 1 name", obj1.ItemName);
Assert.AreEqual(10, obj1.DecimalItem);
IList <string> obj1BlockedMembers = dbContextMultiClass.Entry(obj1).GetBlockedMembers();
Assert.IsNotNull(obj1BlockedMembers);
Assert.AreEqual(0, obj1BlockedMembers.Count());
DbContextObject1 obj2 = dbContextMultiClass.dbContextDbSet1.First(obj => obj.Description == "Not good description");
Assert.AreEqual("Not good description", obj2.Description);
Assert.AreEqual(null, obj2.ItemName);
Assert.AreEqual(0, obj2.DecimalItem);
IList <string> obj2BlockedMembers = dbContextMultiClass.Entry(obj2).GetBlockedMembers();
Assert.IsNotNull(obj2BlockedMembers);
Assert.AreEqual(2, obj2BlockedMembers.Count());
Assert.AreEqual("DecimalItem", obj2BlockedMembers.First());
Assert.AreEqual("ItemName", obj2BlockedMembers.Last());
}
}
public void IsGrantedObjectAndMember()
{
using (DbContextMultiClass dbContext = new DbContextMultiClass()) {
DbContextObject1 dbContextObject1_1 = new DbContextObject1();
dbContextObject1_1.ItemName = "1";
dbContext.Add(dbContextObject1_1);
dbContext.SaveChanges();
dbContext.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.AllowAllByDefault);
dbContext.PermissionsContainer.AddObjectPermission <DbContextMultiClass, DbContextObject1>(
SecurityOperation.Read,
OperationState.Deny,
(p, d) => d.ItemName == "1");
Assert.AreEqual(dbContext.dbContextDbSet1.Count(), 0);
}
}
public void RollbackDeletedObjectDatabaseValuesDenyPolicy()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > deleteCriteria = (db, obj) => obj.Description == "Good description";
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > writeCriteria = (db, obj) => true;
dbContextMultiClass.PermissionsContainer.AddObjectPermission(SecurityOperation.Delete, OperationState.Allow, deleteCriteria);
dbContextMultiClass.PermissionsContainer.AddObjectPermission(SecurityOperation.Write, OperationState.Allow, writeCriteria);
dbContextMultiClass.PermissionsContainer.SetTypePermission(typeof(DbContextObject1), SecurityOperation.Read, OperationState.Allow);
obj1.Description = "Not good description";
dbContextMultiClass.SaveChanges();
dbContextMultiClass.Remove(obj1);
SecurityTestHelper.FailSaveChanges(dbContextMultiClass);
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
obj1.Description = "Good description";
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > deleteCriteria = (db, obj) => obj.Description == "Good description";
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > writeCriteria = (db, obj) => true;
dbContextMultiClass.PermissionsContainer.AddObjectPermission(SecurityOperation.Delete, OperationState.Allow, deleteCriteria);
dbContextMultiClass.PermissionsContainer.AddObjectPermission(SecurityOperation.Write, OperationState.Allow, writeCriteria);
dbContextMultiClass.PermissionsContainer.SetTypePermission(typeof(DbContextObject1), SecurityOperation.Read, OperationState.Allow);
dbContextMultiClass.Remove(obj1);
dbContextMultiClass.SaveChanges();
}
}
public void ReadObjectMultiplePermissions()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = new DbContextObject1();
obj1.ItemCount = 5;
obj1.DecimalItem = 10;
DbContextObject1 obj2 = new DbContextObject1();
obj2.ItemCount = 8;
obj2.DecimalItem = 20;
DbContextObject1 obj3 = new DbContextObject1();
obj3.ItemCount = 10;
obj3.DecimalItem = 30;
dbContextMultiClass.Add(obj1);
dbContextMultiClass.SaveChanges();
dbContextMultiClass.Add(obj2);
dbContextMultiClass.SaveChanges();
dbContextMultiClass.Add(obj3);
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
Assert.AreEqual(dbContextMultiClass.dbContextDbSet1.Count(), 3);
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria = (db, obj) => obj.ItemCount > 3;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Allow, "DecimalItem", goodCriteria);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > goodCriteria2 = (db, obj) => obj.ItemCount < 9;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Allow, "DecimalItem", goodCriteria2);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.ItemCount == 8;
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Read, OperationState.Deny, "DecimalItem", badCriteria);
IEnumerable <DbContextObject1> objects = dbContextMultiClass.dbContextDbSet1.OrderBy(p => p.ID).AsEnumerable();
Assert.AreEqual(2, objects.Count());
DbContextObject1 obj1 = objects.ElementAt(0);
Assert.AreEqual(0, obj1.ItemCount);
Assert.AreEqual(10, obj1.DecimalItem);
DbContextObject1 obj2 = objects.ElementAt(1);
Assert.AreEqual(0, obj2.ItemCount);
Assert.AreEqual(30, obj2.DecimalItem);
}
}
public void RollbackMultipleMembersAllowPolicy()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.AllowAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > criteria = (db, obj) => obj.Description != "Good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Deny, "Description", criteria);
// dbContextMultiClass.Security.AddMemberPermission(SecurityOperation.Write, OperationState.Deny, "DecimalItem", criteria);
obj1.Description = "Good description";
obj1.DecimalItem = 10;
Assert.AreEqual(EntityState.Modified, dbContextMultiClass.Entry(obj1).State);
Assert.IsTrue(dbContextMultiClass.Entry(obj1).Property("Description").IsModified);
Assert.IsTrue(dbContextMultiClass.Entry(obj1).Property("DecimalItem").IsModified);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("ItemCount").IsModified);
dbContextMultiClass.SaveChanges();
Assert.AreEqual(EntityState.Unchanged, dbContextMultiClass.Entry(obj1).State);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("Description").IsModified);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("DecimalItem").IsModified);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("ItemCount").IsModified);
obj1.Description = "Not good description";
obj1.DecimalItem = 20;
SecurityTestHelper.FailSaveChanges(dbContextMultiClass);
Assert.AreEqual(EntityState.Unchanged, dbContextMultiClass.Entry(obj1).State);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("Description").IsModified);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("DecimalItem").IsModified);
Assert.IsFalse(dbContextMultiClass.Entry(obj1).Property("ItemCount").IsModified);
Assert.AreEqual("Good description", obj1.Description);
Assert.AreEqual(10, obj1.DecimalItem);
}
}
public void IsGrantedDenyPermission()
{
foreach (SecurityOperation securityOperation in new SecurityOperation[] { SecurityOperation.Read, SecurityOperation.Write })
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = new DbContextObject1();
Assert.IsTrue(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), securityOperation, obj1));
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > badCriteria = (db, obj) => obj.Description == "Not good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(securityOperation, OperationState.Deny, "DecimalItem", badCriteria);
obj1.Description = "Not good description";
Assert.IsFalse(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), securityOperation, obj1, "DecimalItem"));
obj1.Description = "Good description";
Assert.IsTrue(dbContextMultiClass.Security.IsGranted(typeof(DbContextObject1), securityOperation, obj1, "DecimalItem"));
}
}
}
public void DeleteType()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.ResetDatabase();
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.PermissionsContainer.SetTypePermission <DbContextObject1>(SecurityOperation.Delete, OperationState.Deny);
DbContextObject1 dbContextObject1 = dbContextMultiClass.dbContextDbSet1.First();
dbContextMultiClass.Remove(dbContextObject1);
try {
dbContextMultiClass.SaveChanges();
Assert.Fail("Fail");
}
catch (Exception e) {
Assert.AreNotEqual("Fail", e.Message);
}
}
}
public void IntKeyPropertyAutoGenerate(Func <DbContextMultiClass> createDbContext)
{
using (DbContextMultiClass context = createDbContext()) {
DbContextObject1 obj1 = new DbContextObject1()
{
};
context.Add(obj1);
int installID = obj1.ID;
Assert.IsTrue(installID != 0); //with Native test is passed is started only this test but failed when entire fixture is started: Expected: -1 But was: -22
context.SaveChanges();
// TODO: fix?
// Assert.AreEqual(installID, obj1.ID); //what is generated and added to
installID = obj1.ID;
Assert.IsTrue(installID != 0);
}
int installID2;
int installID3;
using (DbContextMultiClass context = createDbContext()) {
DbContextObject1 obj2 = new DbContextObject1();
DbContextObject1 obj3 = new DbContextObject1();
context.Add(obj2);
context.Add(obj3);
installID2 = obj2.ID;
installID3 = obj3.ID;
Assert.IsTrue(installID2 != 0); //with Native test is passed is started only this test but failed when entire fixture is started: Expected: -2 But was: -22
Assert.IsTrue(installID3 != 0); //with Native test is passed is started only this test but failed when entire fixture is started: Expected: -3 But was: -22
context.SaveChanges();
// for sql server
installID2 = obj2.ID;
installID3 = obj3.ID;
Assert.IsTrue(
((obj2.ID == installID2) && (obj3.ID == installID3))
||
((obj2.ID == installID3) && (obj3.ID == installID2)), "obj2.ID=" + installID2.ToString() + ", obj3.ID=" + installID3.ToString());
}
using (DbContextMultiClass context = createDbContext()) {
Assert.IsNotNull(context.dbContextDbSet1.Where(o => o.ID == installID2).Single());
Assert.IsNotNull(context.dbContextDbSet1.Where(o => o.ID == installID3).Single());
}
}
private static void AddObjectsOfDifferentTypesAtOnce(Func <DbContextMultiClass> createDbContext)
{
using (var context = createDbContext()) {
var testValuse = new DbContextObject1();
context.Add(new DbContextObject1());
context.Add(new DbContextObject1());
context.Add(new DbContextObject1());
context.Add(new DbContextObject2());
context.Add(new DbContextObject2());
context.Add(new DbContextObject2());
context.Add(new DbContextObject3());
context.Add(new DbContextObject3());
context.Add(new DbContextObject3());
context.SaveChanges();
}
using (var context = createDbContext()) {
Assert.AreEqual(3, context.dbContextDbSet1.Count());
Assert.AreEqual(3, context.dbContextDbSet2.Count());
Assert.AreEqual(3, context.dbContextDbSet3.Count());
}
}
public void WriteMemberAllowPermission()
{
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
dbContextMultiClass.Add(new DbContextObject1());
dbContextMultiClass.SaveChanges();
}
using (DbContextMultiClass dbContextMultiClass = new DbContextMultiClass()) {
DbContextObject1 obj1 = dbContextMultiClass.dbContextDbSet1.FirstOrDefault();
dbContextMultiClass.PermissionsContainer.SetPermissionPolicy(PermissionPolicy.DenyAllByDefault);
Expression <Func <DbContextMultiClass, DbContextObject1, bool> > criteria = (db, obj) => obj.Description == "Good description";
dbContextMultiClass.PermissionsContainer.AddMemberPermission(SecurityOperation.Write, OperationState.Allow, "Description", criteria);
obj1.Description = "Good description";
dbContextMultiClass.SaveChanges();
obj1.Description = "Not good description";
SecurityTestHelper.FailSaveChanges(dbContextMultiClass);
obj1.Description = "Good description";
dbContextMultiClass.SaveChanges();
}
}
private void SequenceEqual(Func <DbContextMultiClass> createDbContext)
{
var item1 = new DbContextObject1()
{
ItemName = "Silver Coin", ItemCount = 200
};
var item2 = new DbContextObject1()
{
ItemName = "Gold Coin", ItemCount = 100
};
var item3 = new DbContextObject1()
{
ItemName = "Iron Coin", ItemCount = 300
};
var array = new[] { item1, item2, item3 };
using (var context = createDbContext()) {
context.dbContextDbSet1.AddRange(new[] { item1, item2, item3 });
context.SaveChanges();
}
using (var context = createDbContext()) {
var resint = context.dbContextDbSet1.SequenceEqual(array);
}
}
private void Union(Func <DbContextMultiClass> createDbContext)
{
var item1 = new DbContextObject1()
{
ItemName = "Silver Coin", ItemCount = 200
};
var item2 = new DbContextObject1()
{
ItemName = "Gold Coin", ItemCount = 100
};
var item3 = new DbContextObject1()
{
ItemName = "Iron Coin", ItemCount = 300
};
var item5 = new DbContextObject1()
{
ItemName = "Bad Coin", ItemCount = 100
};
var item4 = new DbContextObject1()
{
ItemName = "Good Coin", ItemCount = 500
};
var array = new[] { item4, item5 };
var array1 = new[] { item1, item2, item3 };
using (var context = createDbContext()) {
context.dbContextDbSet1.AddRange(new[] { item1, item2, item3 });
context.SaveChanges();
}
using (var context = createDbContext()) {
var res1 = array1.Union(array);
Assert.AreEqual(5, res1.Count());
var resint = context.dbContextDbSet1.Union(array);
Assert.AreEqual(5, resint.Count());
}
}
