diff --git a/c_src/casbin_nif.cpp b/c_src/casbin_nif.cpp index 2c74748..92ab3d7 100644 --- a/c_src/casbin_nif.cpp +++ b/c_src/casbin_nif.cpp @@ -33,11 +33,32 @@ string ListToString(ErlNifEnv* env, ERL_NIF_TERM term) { return string(stringData, res); } +string BinToString(ErlNifEnv* env, ERL_NIF_TERM term) { + ERL_NIF_TERM maybeBin = term; + + unsigned int listLength = 0; + ErlNifBinary term_bin; + if (!enif_inspect_iolist_as_binary(env, term, &term_bin)) + { + // we blame the user if address isn't a string + return string(); + } + + return string(reinterpret_cast(term_bin.data), term_bin.size); +} + ERL_NIF_TERM VectorToList(ErlNifEnv* env, const vector &input) { ERL_NIF_TERM enifList[input.size()]; for(int ii = 0; ii < input.size(); ++ii) { - enifList[ii] = enif_make_string(env, input.at(ii).c_str(), ERL_NIF_LATIN1); + ERL_NIF_TERM component_term; + + const char* inputCharArray = (const char*)input.at(ii).c_str(); + const int inputLength = strlen(inputCharArray); + char *component_term_bin = reinterpret_cast(enif_make_new_binary(env, inputLength, &component_term)); + strncpy(component_term_bin, inputCharArray, inputLength); + + enifList[ii] = component_term; } return enif_make_list_from_array(env, enifList, input.size()); @@ -65,14 +86,14 @@ vector ListToVector(ErlNifEnv* env, ERL_NIF_TERM term) { items = term; while(enif_get_list_cell(env, items, &item, &items)) - resultVector.push_back(ListToString(env, item)); + resultVector.push_back(BinToString(env, item)); return resultVector; } ERL_NIF_TERM CreateEnforcer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { - string modelPath = ListToString(env, argv[0]); - string policyPath = ListToString(env, argv[1]); + string modelPath = BinToString(env, argv[0]); + string policyPath = BinToString(env, argv[1]); try{ @@ -110,12 +131,12 @@ ERL_NIF_TERM DestroyEnforcer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] ERL_NIF_TERM Enforce(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string sub = ListToString(env, argv[0]); - string obj = ListToString(env, argv[1]); - string act = ListToString(env, argv[2]); + string sub = BinToString(env, argv[0]); + string obj = BinToString(env, argv[1]); + string act = BinToString(env, argv[2]); try{ return enforcer->Enforce({sub.c_str(), obj.c_str(), act.c_str()}) @@ -128,12 +149,12 @@ ERL_NIF_TERM Enforce(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM AddPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string sub = ListToString(env, argv[0]); - string obj = ListToString(env, argv[1]); - string act = ListToString(env, argv[2]); + string sub = BinToString(env, argv[0]); + string obj = BinToString(env, argv[1]); + string act = BinToString(env, argv[2]); try{ enforcer->InvalidateCache(); @@ -147,12 +168,12 @@ ERL_NIF_TERM AddPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM RemovePolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string sub = ListToString(env, argv[0]); - string obj = ListToString(env, argv[1]); - string act = ListToString(env, argv[2]); + string sub = BinToString(env, argv[0]); + string obj = BinToString(env, argv[1]); + string act = BinToString(env, argv[2]); try{ enforcer->InvalidateCache(); @@ -166,11 +187,11 @@ ERL_NIF_TERM RemovePolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM AddGroupingPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); - string group = ListToString(env, argv[1]); + string user = BinToString(env, argv[0]); + string group = BinToString(env, argv[1]); try{ enforcer->InvalidateCache(); @@ -184,12 +205,13 @@ ERL_NIF_TERM AddGroupingPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv ERL_NIF_TERM GetUsersForRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string role = ListToString(env, argv[0]); + string role = BinToString(env, argv[0]); try{ - return VectorToList(env, enforcer->GetUsersForRole(role)); + ERL_NIF_TERM list = VectorToList(env, enforcer->GetUsersForRole(role)); + return make_result_tuple( PF_ATOM_OK, list ); } catch(const casbin::CasbinRBACException &e) { return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception")); } catch(...) { @@ -199,12 +221,13 @@ ERL_NIF_TERM GetUsersForRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] ERL_NIF_TERM GetRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); + string user = BinToString(env, argv[0]); try{ - return VectorToList(env, enforcer->GetRolesForUser(user)); + ERL_NIF_TERM list = VectorToList(env, enforcer->GetRolesForUser(user)); + return make_result_tuple( PF_ATOM_OK, list ); } catch(...) { return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Unexpected exception")); } @@ -212,10 +235,10 @@ ERL_NIF_TERM GetRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] ERL_NIF_TERM DeleteRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string role = ListToString(env, argv[0]); + string role = BinToString(env, argv[0]); try{ enforcer->InvalidateCache(); return enforcer->DeleteRole({role}) @@ -230,11 +253,11 @@ ERL_NIF_TERM DeleteRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM AddRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); - string role = ListToString(env, argv[1]); + string user = BinToString(env, argv[0]); + string role = BinToString(env, argv[1]); try{ enforcer->InvalidateCache(); return enforcer->AddRoleForUser(user, role) @@ -249,10 +272,10 @@ ERL_NIF_TERM AddRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) ERL_NIF_TERM AddRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); + string user = BinToString(env, argv[0]); vector roles = ListToVector(env, argv[1]); try{ enforcer->InvalidateCache(); @@ -268,10 +291,10 @@ ERL_NIF_TERM AddRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] ERL_NIF_TERM DeleteRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); + string user = BinToString(env, argv[0]); try{ enforcer->InvalidateCache(); return enforcer->DeleteRolesForUser(user) @@ -287,11 +310,11 @@ ERL_NIF_TERM DeleteRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg ERL_NIF_TERM DeleteRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } - string user = ListToString(env, argv[0]); - string role = ListToString(env, argv[1]); + string user = BinToString(env, argv[0]); + string role = BinToString(env, argv[1]); try{ enforcer->InvalidateCache(); return enforcer->DeleteRoleForUser(user, role) @@ -306,7 +329,7 @@ ERL_NIF_TERM DeleteRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv ERL_NIF_TERM RemoveFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } int fieldIndex = 0; @@ -320,15 +343,17 @@ ERL_NIF_TERM RemoveFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM a return enforcer->RemoveFilteredPolicy(fieldIndex, resourceId) ?PF_ATOM_TRUE :PF_ATOM_FALSE; - } catch(...) { - return PF_ATOM_FALSE; + } catch(const casbin::CasbinRBACException &e) { + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception")); + } catch(std::exception e2) { + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING(e2.what())); } } ERL_NIF_TERM GetFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { if(!enforcer) { - return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first.")); + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first.")); } int fieldIndex = 0; @@ -338,9 +363,12 @@ ERL_NIF_TERM GetFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv vector resourceId = ListToVector(env, argv[1]); try{ - return VectorToList(env, enforcer->GetFilteredPolicy(fieldIndex, resourceId)); - } catch(...) { - return PF_ATOM_FALSE; + ERL_NIF_TERM list = VectorToList(env, enforcer->GetFilteredPolicy(fieldIndex, resourceId)); + return make_result_tuple( PF_ATOM_OK, list ); + } catch(const casbin::CasbinRBACException &e) { + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception") ); + } catch(std::exception e2) { + return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING(e2.what()) ); } } @@ -363,4 +391,4 @@ ErlNifFunc casbinex_nif_funcs[] = {"getFilteredPolicy", 2, GetFilteredPolicy}, }; -ERL_NIF_INIT(Elixir.Casbinex, casbinex_nif_funcs, 0, 0, 0, 0); +ERL_NIF_INIT(Elixir.Casbinex.Base, casbinex_nif_funcs, 0, 0, 0, 0); diff --git a/config/test.exs b/config/test.exs index f4f3249..e792f24 100644 --- a/config/test.exs +++ b/config/test.exs @@ -1,5 +1,5 @@ use Mix.Config config :casbinex, - model_path: 'test/data/rbac_model.conf', - pg_connection: 'test/data/rbac_policy.csv' #postgresql://:@/ + model_path: "test/data/rbac_model.conf", + pg_connection: "test/data/rbac_policy.csv" #postgresql://:@/ diff --git a/lib/casbinex.ex b/lib/casbinex.ex index eb6d20a..cf3f72c 100644 --- a/lib/casbinex.ex +++ b/lib/casbinex.ex @@ -3,71 +3,77 @@ defmodule Casbinex do Documentation for `Casbinex`. """ - @on_load :load_nifs + alias Casbinex.Base - app = Mix.Project.config[:app] - def load_nifs do - path = :filename.join(:code.priv_dir(unquote(app)), 'casbinex_nif') - :ok = :erlang.load_nif(path, 0) + def createEnforcer(modelpath, policypath) do + Base.createEnforcer(modelpath, policypath) end - def createEnforcer(_modelpath, _policypath) do - raise "NIF createEnforcerdd/2 not implemented" + def destroyEnforcer() do + Base.destroyEnforcer() end - def destroyEnforcer() do - raise "NIF destroyEnforcer/0 not implemented" + def enforce(sub, obj, act) do + Base.enforce(sub, obj, act) + end + + def addPolicy(sub, obj, act) do + Base.addPolicy(sub, obj, act) + end + + def removePolicy(sub, obj, act) do + Base.removePolicy(sub, obj, act) end - def enforce(_sub, _obj, _act) do - raise "NIF enforce/3 not implemented" + def addGroupingPolicy(user, group) do + Base.addGroupingPolicy(user, group) end - def addPolicy(_sub, _obj, _act) do - raise "NIF addPolicy/3 not implemented" + def getUsersForRole(role) do + Base.getUsersForRole(role) end - def removePolicy(_sub, _obj, _act) do - raise "NIF removePolicy/3 not implemented" + def getRolesForUser(user) do + Base.getRolesForUser(user) end - def addGroupingPolicy(_user, _group) do - raise "NIF addGroupingPolicy/2 not implemented" + def deleteRole(role) do + Base.deleteRole(role) end - def getUsersForRole(_role) do - raise "NIF getUsersForRole/1 not implemented" + def deleteRoleForUser(user, role) do + Base.deleteRoleForUser(user, role) end - def getRolesForUser(_user) do - raise "NIF getRolesForUser/1 not implemented" + def deleteRolesForUser(user) do + Base.deleteRolesForUser(user) end - def deleteRole(_role) do - raise "NIF deleteRole/1 not implemented" + def addRoleForUser(user, role) do + Base.addRoleForUser(user, role) end - def deleteRoleForUser(_user, _role) do - raise "NIF deleteRoleForUser/2 not implemented" + def addRolesForUser(user, roles) when is_list(roles) do + Base.addRolesForUser(user, roles) end - def deleteRolesForUser(_user) do - raise "NIF deleteRolesForUser/1 not implemented" + def addRolesForUser(user, roles) do + Base.addRoleForUser(user, roles) end - def addRoleForUser(_user, _role) do - raise "NIF addRoleForUser/2 not implemented" + def getFilteredPolicy(fieldindex, fields) when is_list(fields) do + Base.getFilteredPolicy(fieldindex, fields) end - def addRolesForUser(_user, _role) do - raise "NIF addRolesForUser/2 not implemented" + def getFilteredPolicy(fieldindex, field) do + Base.getFilteredPolicy(fieldindex, [field]) end - def getFilteredPolicy(_field_index, _fields) do - raise "NIF getFilteredPolicy/2 not implemented" + def removeFilteredPolicy(fieldindex, fields) when is_list(fields) do + Base.removeFilteredPolicy(fieldindex, fields) end - def removeFilteredPolicy(_field_index, _fields) do - raise "NIF removeFilteredPolicy/2 not implemented" + def removeFilteredPolicy(fieldindex, field) do + Base.removeFilteredPolicy(fieldindex, [field]) end end diff --git a/lib/casbinex/base.ex b/lib/casbinex/base.ex new file mode 100644 index 0000000..b51faba --- /dev/null +++ b/lib/casbinex/base.ex @@ -0,0 +1,73 @@ +defmodule Casbinex.Base do + @moduledoc """ + Documentation for `Casbinex`. + """ + + @on_load :load_nifs + + app = Mix.Project.config[:app] + def load_nifs do + path = :filename.join(:code.priv_dir(unquote(app)), 'casbinex_nif') + :ok = :erlang.load_nif(path, 0) + end + + def createEnforcer(_modelpath, _policypath) do + raise "NIF createEnforcerdd/2 not implemented" + end + + def destroyEnforcer() do + raise "NIF destroyEnforcer/0 not implemented" + end + + def enforce(_sub, _obj, _act) do + raise "NIF enforce/3 not implemented" + end + + def addPolicy(_sub, _obj, _act) do + raise "NIF addPolicy/3 not implemented" + end + + def removePolicy(_sub, _obj, _act) do + raise "NIF removePolicy/3 not implemented" + end + + def addGroupingPolicy(_user, _group) do + raise "NIF addGroupingPolicy/2 not implemented" + end + + def getUsersForRole(_role) do + raise "NIF getUsersForRole/1 not implemented" + end + + def getRolesForUser(_user) do + raise "NIF getRolesForUser/1 not implemented" + end + + def deleteRole(_role) do + raise "NIF deleteRole/1 not implemented" + end + + def deleteRoleForUser(_user, _role) do + raise "NIF deleteRoleForUser/2 not implemented" + end + + def deleteRolesForUser(_user) do + raise "NIF deleteRolesForUser/1 not implemented" + end + + def addRoleForUser(_user, _role) do + raise "NIF addRoleForUser/2 not implemented" + end + + def addRolesForUser(_user, _role) do + raise "NIF addRolesForUser/2 not implemented" + end + + def getFilteredPolicy(_field_index, _fields) do + raise "NIF getFilteredPolicy/2 not implemented" + end + + def removeFilteredPolicy(_field_index, _fields) do + raise "NIF removeFilteredPolicy/2 not implemented" + end +end diff --git a/test/casbinex_test.exs b/test/casbinex_test.exs index 8e2d3d0..d40bacf 100644 --- a/test/casbinex_test.exs +++ b/test/casbinex_test.exs @@ -9,8 +9,8 @@ defmodule CasbinexTest do test "enforces user policies correctly" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.enforce('alice', 'data1', 'read') - assert :false == Casbinex.enforce('attacker', 'data1', 'read') + assert :true == Casbinex.enforce("alice", "data1", "read") + assert :false == Casbinex.enforce("attacker", "data1", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -19,8 +19,8 @@ defmodule CasbinexTest do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) # alice is in the data2_admin group - assert :true == Casbinex.enforce('alice', 'data2', 'write') - assert :false == Casbinex.enforce('attacker', 'data2', 'read') + assert :true == Casbinex.enforce("alice", "data2", "write") + assert :false == Casbinex.enforce("attacker", "data2", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -29,15 +29,15 @@ defmodule CasbinexTest do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) # alice is in the data2_admin group - assert ['alice'] == Casbinex.getUsersForRole('data2_admin') + assert { :ok, ["alice"] } == Casbinex.getUsersForRole("data2_admin") #add bob to the group - assert :true == Casbinex.addGroupingPolicy('bob', 'data2_admin') - assert ['bob', 'alice'] == Casbinex.getUsersForRole('data2_admin') + assert :true == Casbinex.addGroupingPolicy("bob", "data2_admin") + assert { :ok, ["bob", "alice"] } == Casbinex.getUsersForRole("data2_admin") #delete the group - assert :true == Casbinex.deleteRole('data2_admin') - assert {:error, _} = Casbinex.getUsersForRole('data2_admin') + assert :true == Casbinex.deleteRole("data2_admin") + assert {:error, _} = Casbinex.getUsersForRole("data2_admin") assert :ok == Casbinex.destroyEnforcer(); end @@ -45,7 +45,7 @@ defmodule CasbinexTest do test "get a list of roles for the user" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert ['data2_admin'] == Casbinex.getRolesForUser('alice') + assert { :ok, ["data2_admin"] } == Casbinex.getRolesForUser("alice") assert :ok == Casbinex.destroyEnforcer(); end @@ -53,9 +53,9 @@ defmodule CasbinexTest do test "can add new policies" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.addPolicy('bill', 'data1', 'read') - assert :true == Casbinex.enforce('bill', 'data1', 'read') - assert :false == Casbinex.enforce('bill', 'data1', 'write') + assert :true == Casbinex.addPolicy("bill", "data1", "read") + assert :true == Casbinex.enforce("bill", "data1", "read") + assert :false == Casbinex.enforce("bill", "data1", "write") assert :ok == Casbinex.destroyEnforcer(); end @@ -63,9 +63,9 @@ defmodule CasbinexTest do test "can remove policies" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.enforce('alice', 'data1', 'read') - assert :true == Casbinex.removePolicy('alice', 'data1', 'read') - assert :false == Casbinex.enforce('alice', 'data1', 'read') + assert :true == Casbinex.enforce("alice", "data1", "read") + assert :true == Casbinex.removePolicy("alice", "data1", "read") + assert :false == Casbinex.enforce("alice", "data1", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -73,9 +73,9 @@ defmodule CasbinexTest do test "can remove user from all groups" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.enforce('alice', 'data2', 'read') - assert :true == Casbinex.deleteRolesForUser('alice') - assert :false == Casbinex.enforce('alice', 'data2', 'read') + assert :true == Casbinex.enforce("alice", "data2", "read") + assert :true == Casbinex.deleteRolesForUser("alice") + assert :false == Casbinex.enforce("alice", "data2", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -83,9 +83,9 @@ defmodule CasbinexTest do test "can remove role for user" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.enforce('alice', 'data2', 'read') - assert :true == Casbinex.deleteRoleForUser('alice', 'data2_admin') - assert :false == Casbinex.enforce('alice', 'data2', 'read') + assert :true == Casbinex.enforce("alice", "data2", "read") + assert :true == Casbinex.deleteRoleForUser("alice", "data2_admin") + assert :false == Casbinex.enforce("alice", "data2", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -93,11 +93,11 @@ defmodule CasbinexTest do test "can add user to role" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert :true == Casbinex.enforce('alice', 'data2', 'read') - assert :true == Casbinex.deleteRoleForUser('alice', 'data2_admin') - assert :false == Casbinex.enforce('alice', 'data2', 'read') - assert :true == Casbinex.addRoleForUser('alice', 'data2_admin') - assert :true == Casbinex.enforce('alice', 'data2', 'read') + assert :true == Casbinex.enforce("alice", "data2", "read") + assert :true == Casbinex.deleteRoleForUser("alice", "data2_admin") + assert :false == Casbinex.enforce("alice", "data2", "read") + assert :true == Casbinex.addRoleForUser("alice", "data2_admin") + assert :true == Casbinex.enforce("alice", "data2", "read") assert :ok == Casbinex.destroyEnforcer(); end @@ -105,12 +105,12 @@ defmodule CasbinexTest do test "can add user to multiple roles" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - Casbinex.addPolicy('data1_admin', 'data1', 'write') + Casbinex.addPolicy("data1_admin", "data1", "write") - assert :false == Casbinex.enforce('alice', 'data1', 'write') - assert :true == Casbinex.addRolesForUser('alice', ['data1_admin', 'data2_admin']) - assert :true == Casbinex.enforce('alice', 'data2', 'write') - assert :true == Casbinex.enforce('alice', 'data1', 'write') + assert :false == Casbinex.enforce("alice", "data1", "write") + assert :true == Casbinex.addRolesForUser("alice", ["data1_admin", "data2_admin"]) + assert :true == Casbinex.enforce("alice", "data2", "write") + assert :true == Casbinex.enforce("alice", "data1", "write") assert :ok == Casbinex.destroyEnforcer(); end @@ -118,9 +118,9 @@ defmodule CasbinexTest do test "retrieves a filtered list of policies" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert [ - ['bob', 'data2', 'write'], - ['data2_admin', 'data2', 'write']] = Casbinex.getFilteredPolicy(1, ['data2', 'write']) + assert { :ok, [ + ["bob", "data2", "write"], + ["data2_admin", "data2", "write"]] } = Casbinex.getFilteredPolicy(1, ["data2", "write"]) assert :ok == Casbinex.destroyEnforcer(); end @@ -128,13 +128,27 @@ defmodule CasbinexTest do test "removes a filtered list of policies" do assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) - assert [ - ['bob', 'data2', 'write'], - ['data2_admin', 'data2', 'write'] - ] = Casbinex.getFilteredPolicy(1, ['data2', 'write']) + assert { :ok, [ + ["bob", "data2", "write"], + ["data2_admin", "data2", "write"] + ] } = Casbinex.getFilteredPolicy(1, ["data2", "write"]) - Casbinex.removeFilteredPolicy(1, ['data2', 'write']) - assert [] = Casbinex.getFilteredPolicy(1, ['data2', 'write']) + Casbinex.removeFilteredPolicy(1, ["data2", "write"]) + assert { :ok, []} = Casbinex.getFilteredPolicy(1, ["data2", "write"]) + + assert :ok == Casbinex.destroyEnforcer(); + end + + test "removes a filtered list of policies when policy selector is charlist" do + assert { :ok, _ } = Casbinex.createEnforcer(@model_path, @pgconnection) + + assert { :ok, [ + ["bob", "data2", "write"], + ["data2_admin", "data2", "read"], + ["data2_admin", "data2", "write"]] } = Casbinex.getFilteredPolicy(1, "data2") + + Casbinex.removeFilteredPolicy(1, "data2") + assert { :ok, [] } = Casbinex.getFilteredPolicy(1, ["data2", "write"]) assert :ok == Casbinex.destroyEnforcer(); end