public void DeleteEntry_Subject_Null()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.DeleteEntry("Res", "Action", null));
Assert.Equal("Value cannot be null.\r\nParameter name: subject", ex.Message);
}
public void DeleteEntriesForSubject_RetrieveAllEntries()
{
AclManagerBase manager = MockAclManager();
Assert.IsTrue(manager.StoreEntry("Res", "Action", "U.User", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res", "Action", "G.Group", Value.Deny), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res2", "Action2", "G.Group2", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res2", "Action3", "G.Group2", Value.Deny), "StoreEntry should return true");
Assert.AreEqual(4, manager.TotalEntries, "Wrong entry count");
Assert.IsFalse(manager.DeleteEntriesForSubject("I.Inexistent"), "DeleteEntriesForSubject should return false");
Assert.AreEqual(4, manager.TotalEntries, "Wrong entry count");
Assert.IsTrue(manager.DeleteEntriesForSubject("G.Group2"), "DeleteEntriesForSubject should return true");
Assert.AreEqual(2, manager.TotalEntries, "Wrong entry count");
AclEntry[] allEntries = manager.RetrieveAllEntries();
Assert.AreEqual(2, allEntries.Length, "Wrong entry count");
Array.Sort(allEntries, delegate(AclEntry x, AclEntry y) { return(x.Subject.CompareTo(y.Subject)); });
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "G.Group", Value.Deny), allEntries[0]);
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "U.User", Value.Grant), allEntries[1]);
}
public void RenameResource_NewName_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.RenameResource("Res", ""));
Assert.Equal("New Name cannot be empty.\r\nParameter name: newName", ex.Message);
}
public void StoreEntry_Subject_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.StoreEntry("Res", "Action", "", Value.Grant));
Assert.Equal("Subject cannot be empty.\r\nParameter name: subject", ex.Message);
}
public void StoreEntry_Action_Null()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.StoreEntry("Res", null, "U.User", Value.Grant));
Assert.Equal("Value cannot be null.\r\nParameter name: action", ex.Message);
}
public void RenameResource_NewName_Null()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.RenameResource("Res", null));
Assert.Equal("Value cannot be null.\r\nParameter name: newName", ex.Message);
}
public void InitializeData_NullData()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.InitializeData(null));
Assert.Equal("Value cannot be null.\r\nParameter name: entries", ex.Message);
}
public void StoreEntry_Resource_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.StoreEntry("", "Action", "U.User", Value.Grant));
Assert.Equal("Resource cannot be empty.\r\nParameter name: resource", ex.Message);
}
public void RetrieveEntriesForSubject_Subject_Null()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.RetrieveEntriesForSubject(null));
Assert.Equal("Value cannot be null.\r\nParameter name: subject", ex.Message);
}
public void RetrieveEntriesForSubject_Subject_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.RetrieveEntriesForSubject(""));
Assert.Equal("Subject cannot be empty.\r\nParameter name: subject", ex.Message);
}
public void Event_AclChanged_OverwriteEntry()
{
AclManagerBase manager = MockAclManager();
AclEntry entryOld = new AclEntry("Res", "Action", "U.User", Value.Deny);
AclEntry entryNew = new AclEntry("Res", "Action", "U.User", Value.Grant);
manager.StoreEntry(entryOld.Resource, entryOld.Action, entryOld.Subject, entryOld.Value);
bool invokedStore = false;
bool invokedDelete = false;
manager.AclChanged += delegate(object sender, AclChangedEventArgs e) {
if (e.Change == Change.EntryStored)
{
invokedStore = true;
Assert.AreEqual(1, e.Entries.Length, "Wrong entry count");
AssertAclEntriesAreEqual(entryNew, e.Entries[0]);
Assert.AreEqual(Change.EntryStored, e.Change);
}
else
{
invokedDelete = true;
Assert.AreEqual(1, e.Entries.Length, "Wrong entry count");
AssertAclEntriesAreEqual(entryOld, e.Entries[0]);
Assert.AreEqual(Change.EntryDeleted, e.Change);
}
};
manager.StoreEntry(entryNew.Resource, entryNew.Action, entryNew.Subject, entryNew.Value);
Assert.IsTrue(invokedStore, "Store event not invoked");
Assert.IsTrue(invokedDelete, "Delete event not invoked");
}
public void RetrieveEntriesForResource_Resource_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.RetrieveEntriesForResource(""));
Assert.Equal("Resource cannot be empty.\r\nParameter name: resource", ex.Message);
}
public void DeleteEntriesForResource_Resource_Null()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentNullException>(() => manager.DeleteEntriesForResource(null));
Assert.Equal("Value cannot be null.\r\nParameter name: resource", ex.Message);
}
public void DeleteEntry_Action_Empty()
{
AclManagerBase manager = MockAclManager();
var ex = Assert.Throws <ArgumentException>(() => manager.DeleteEntry("Res", "", "U.User"));
Assert.Equal("Action cannot be empty.\r\nParameter name: action", ex.Message);
}
public void DeleteEntry_InvalidResource_ShouldThrowArgumentException(string r)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.DeleteEntry(r, "Action", "U.User");
});
}
public void DeleteEntry_InvalidSubject_ShouldThrowArgumentNullException(string s)
{
Assert.Throws <ArgumentNullException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.DeleteEntry("Res", "Action", s);
});
}
public void StoreEntry_InvalidSubject_ShouldThrowArgumentException(string s)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.StoreEntry("Res", "Action", s, Value.Grant);
});
}
public void StoreEntry_InvalidAction_ShouldThrowArgumentException(string a)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.StoreEntry("Res", a, "U.User", Value.Grant);
});
}
public void DeleteEntry_InvalidAction_ShouldThrowArgumentNullException(string a)
{
Assert.Throws <ArgumentNullException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.DeleteEntry("Res", a, "U.User");
});
}
public void InitializeData_NullData()
{
Assert.Throws <ArgumentNullException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.InitializeData(null);
});
}
public void StoreEntry_InvalidResource_ShouldThrowArgumentException(string s)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.StoreEntry(s, "Action", "U.User", Value.Grant);
});
}
public void RetrieveEntriesForSubject_InvalidSubject_ShouldThrowArgumentException(string s)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.RetrieveEntriesForSubject(s);
});
}
public void RetrieveEntriesForResource_InvalidResource_ShouldThrowArgumentException(string r)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.RetrieveEntriesForResource(r);
});
}
public void RenameResource_InvalidNewName_ShouldThrowArgumentException(string n)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.RenameResource("res", n);
});
}
public void RenameResource_InvalidResource_ShouldThrowArgumentException(string r)
{
Assert.Throws <ArgumentException>(() =>
{
AclManagerBase manager = MockAclManager();
manager.RenameResource(r, "new_name");
});
}
public void RetrieveEntriesForSubject()
{
AclManagerBase manager = MockAclManager();
Assert.True(manager.StoreEntry("Res", "Action", "U.User", Value.Grant), "StoreEntry should return true");
Assert.True(manager.StoreEntry("Res", "Action", "G.Group", Value.Deny), "StoreEntry should return true");
Assert.True(manager.StoreEntry("Res2", "Action2", "G.Group2", Value.Grant), "StoreEntry should return true");
Assert.True(manager.StoreEntry("Res2", "Action3", "G.Group2", Value.Deny), "StoreEntry should return true");
Assert.Empty(manager.RetrieveEntriesForSubject("I.Inexistent"));
AclEntry[] allEntries = manager.RetrieveEntriesForSubject("G.Group2");
Assert.Equal(2, allEntries.Length);
Array.Sort(allEntries, delegate(AclEntry x, AclEntry y) { return(x.Action.CompareTo(y.Action)); });
AssertAclEntriesAreEqual(new AclEntry("Res2", "Action2", "G.Group2", Value.Grant), allEntries[0]);
AssertAclEntriesAreEqual(new AclEntry("Res2", "Action3", "G.Group2", Value.Deny), allEntries[1]);
}
public void Event_AclChanged_StoreEntry()
{
AclManagerBase manager = MockAclManager();
AclEntry entry = new AclEntry("Res", "Action", "U.User", Value.Grant);
bool invoked = false;
manager.AclChanged += delegate(object sender, AclChangedEventArgs e) {
invoked = true;
Assert.AreEqual(1, e.Entries.Length, "Wrong entry count");
AssertAclEntriesAreEqual(entry, e.Entries[0]);
Assert.AreEqual(Change.EntryStored, e.Change);
};
manager.StoreEntry(entry.Resource, entry.Action, entry.Subject, entry.Value);
Assert.IsTrue(invoked, "Store event not invoked");
}
public void RetrieveEntriesForResource()
{
AclManagerBase manager = MockAclManager();
Assert.IsTrue(manager.StoreEntry("Res", "Action", "U.User", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res", "Action", "G.Group", Value.Deny), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res2", "Action2", "G.Group2", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res2", "Action3", "G.Group2", Value.Deny), "StoreEntry should return true");
Assert.AreEqual(0, manager.RetrieveEntriesForResource("Inexistent").Length, "Wrong result count");
AclEntry[] allEntries = manager.RetrieveEntriesForResource("Res");
Assert.AreEqual(2, allEntries.Length, "Wrong entry count");
Array.Sort(allEntries, delegate(AclEntry x, AclEntry y) { return(x.Subject.CompareTo(y.Subject)); });
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "G.Group", Value.Deny), allEntries[0]);
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "U.User", Value.Grant), allEntries[1]);
}
public void StoreEntry_RetrieveAllEntries()
{
AclManagerBase manager = MockAclManager();
Assert.AreEqual(0, manager.TotalEntries, "Wrong initial entry count");
Assert.AreEqual(0, manager.RetrieveAllEntries().Length, "Wrong initial entry count");
Assert.IsTrue(manager.StoreEntry("Res", "Action", "U.User", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res", "Action", "G.Group", Value.Deny), "StoreEntry should return true");
Assert.AreEqual(2, manager.TotalEntries, "Wrong entry count");
AclEntry[] allEntries = manager.RetrieveAllEntries();
Assert.AreEqual(2, allEntries.Length, "Wrong entry count");
Array.Sort(allEntries, delegate(AclEntry x, AclEntry y) { return(x.Subject.CompareTo(y.Subject)); });
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "G.Group", Value.Deny), allEntries[0]);
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "U.User", Value.Grant), allEntries[1]);
}
public void StoreEntry_Overwrite( )
{
AclManagerBase manager = MockAclManager( );
Assert.IsTrue(manager.StoreEntry("Res", "Action", "U.User", Value.Grant), "StoreEntry should return true");
Assert.IsTrue(manager.StoreEntry("Res", "Action", "G.Group", Value.Grant), "StoreEntry should return true");
// Overwrite with a deny
Assert.IsTrue(manager.StoreEntry("Res", "Action", "U.User", Value.Deny), "StoreEntry should return true");
Assert.AreEqual(2, manager.TotalEntries, "Wrong entry count");
AclEntry[] allEntries = manager.RetrieveAllEntries( );
Assert.AreEqual(2, allEntries.Length, "Wrong entry count");
Array.Sort(allEntries, (x, y) => x.Subject.CompareTo(y.Subject));
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "G.Group", Value.Grant), allEntries[0]);
AssertAclEntriesAreEqual(new AclEntry("Res", "Action", "U.User", Value.Deny), allEntries[1]);
}
