Modernize project1.2.0

1 files changed, 0 insertions, 398 deletions

diff --git a/lualdap/tests/test.lua b/lualdap/tests/test.lua
deleted file mode 100755
index 2dce95b..0000000
--- a/lualdap/tests/test.lua
+++ /dev/null
@@ -1,398 +0,0 @@
-#!/usr/local/bin/lua5.1
----------------------------------------------------------------------
--- LuaLDAP test file.
--- This test will create a copy of an existing entry on the
--- directory to work on.  This new entry will be modified,
--- renamed and deleted at the end.
---
--- See Copyright Notice in license.html
--- $Id: test.lua,v 1.15 2006-07-24 01:36:51 tomas Exp $
----------------------------------------------------------------------
-
---
-DN_PAT = "^([^,=]+)%=([^,]+)%,?(.*)$"
-
----------------------------------------------------------------------
--- Print attributes.
----------------------------------------------------------------------
-function print_attrs (dn, attrs)
-	if not dn then
-		io.write ("nil\n")
-		return
-	end
-	io.write (string.format ("\t[%s]\n", dn))
-	for name, values in pairs (attrs) do
-		io.write ("["..name.."] : ")
-		local tv = type (values)
-		if tv == "string" then
-			io.write (values)
-		elseif tv == "table" then
-			local n = table.getn (values)
-			for i = 1, n-1 do
-				io.write (values[i]..",")
-			end
-			io.write (values[n])
-		end
-		io.write ("\n")
-	end
-end
-
----------------------------------------------------------------------
--- clone a table.
----------------------------------------------------------------------
-function clone (tab)
-	local new = {}
-	for i, v in pairs (tab) do
-		new[i] = v
-	end
-	return new
-end
-
-
----------------------------------------------------------------------
--- checks for a value and throw an error if it is not the expected.
----------------------------------------------------------------------
-function assert2 (expected, value, msg)
-	if not msg then
-		msg = ''
-	else
-		msg = tostring(msg)..'\n'
-	end
-	local ret = assert (value == expected,
-		msg.."wrong value (["..tostring(value).."] instead of "..
-		tostring(expected)..")")
-	io.write('.')
-	return ret
-end
-
----------------------------------------------------------------------
--- object test.
----------------------------------------------------------------------
-function test_object (obj, objmethods)
-	-- checking object type.
-	assert2 ("userdata", type(obj), "incorrect object type")
-	-- trying to get metatable.
-	assert2 ("LuaLDAP: you're not allowed to get this metatable",
-		getmetatable(obj), "error permitting access to object's metatable")
-	-- trying to set metatable.
-	assert2 (false, pcall (setmetatable, ENV, {}))
-	-- checking existence of object's methods.
-	for i = 1, table.getn (objmethods) do
-		local method = obj[objmethods[i]]
-		assert2 ("function", type(method))
-		assert2 (false, pcall (method), "no 'self' parameter accepted")
-	end
-	return obj
-end
-
-CONN_OK = function (obj, err)
-	if obj == nil then
-		error (err, 2)
-	end
-	return test_object (obj, { "close", "add", "compare", "delete", "modify", "rename", "search", })
-end
-
----------------------------------------------------------------------
--- basic checking test.
----------------------------------------------------------------------
-function basic_test ()
-	local ld = CONN_OK (lualdap.open_simple (HOSTNAME, WHO, PASSWORD))
-	assert2 (1, ld:close(), "couldn't close connection")
-	-- trying to close without a connection.
-	assert2 (false, pcall (ld.close))
-	-- trying to close an invalid connection.
-	assert2 (false, pcall (ld.close, io.output()))
-	-- trying to use a closed connection.
-	local _,_,rdn_name,rdn_value = string.find (BASE, DN_PAT)
-	assert2 (false, pcall (ld.compare, ld, BASE, rdn_name, rdn_value),
-		"permitting the use of a closed connection")
-	-- it is ok to close a closed object, but nil is returned instead of 1.
-	assert2 (nil, ld:close())
-	-- trying to connect to an invalid host.
-	assert2 (nil, lualdap.open_simple ("unknown-server"), "this should be an error")
-	-- reopen the connection.
-	-- first, try using TLS
-	local ok = lualdap.open_simple (HOSTNAME, WHO, PASSWORD, true)
-	if not ok then
-		-- second, try without TLS
-		io.write ("\nWarning!  Couldn't connect with TLS.  Trying again without it.")
-		ok = lualdap.open_simple (HOSTNAME, WHO, PASSWORD, false)
-	end
-	LD = CONN_OK (ok)
-	CLOSED_LD = ld
-	collectgarbage()
-end
-
-
----------------------------------------------------------------------
--- checks return value which should be a function AND also its return value.
----------------------------------------------------------------------
-function check_future (ret, method, ...)
-	local ok, f = pcall (method, unpack (arg))
-	assert (ok, f)
-	assert2 ("function", type(f))
-	assert2 (ret, f())
-	io.write('.')
-end
-
-
----------------------------------------------------------------------
--- checking compare operation.
----------------------------------------------------------------------
-function compare_test ()
-	local _,_,rdn_name,rdn_value = string.find (BASE, DN_PAT)
-	assert (type(rdn_name) == "string", "could not extract RDN name")
-	assert (type(rdn_value) == "string", "could not extract RDN value")
-	-- comparing against the correct value.
-	check_future (true, LD.compare, LD, BASE, rdn_name, rdn_value)
-	-- comparing against a wrong value.
-	check_future (false, LD.compare, LD, BASE, rdn_name, rdn_value..'_')
-	-- comparing against an incorrect attribute name.
-	check_future (nil, LD.compare, LD, BASE, rdn_name..'x', rdn_value)
-	-- comparing on a wrong base.
-	check_future (nil, LD.compare, LD, 'qwerty', rdn_name, rdn_value)
-	-- comparing with a closed connection.
-	assert2 (false, pcall (LD.compare, CLOSED_LD, BASE, rdn_name, rdn_value))
-	-- comparing with an invalid userdata.
-	assert2 (false, pcall (LD.compare, io.output(), BASE, rdn_name, rdn_value))
-end
-
-
----------------------------------------------------------------------
--- checking basic search operation.
----------------------------------------------------------------------
-function search_test_1 ()
-	local _,_,rdn = string.find (WHO, "^([^,]+)%,.*$")
-	local iter = LD:search {
-		base = BASE,
-		scope = "onelevel",
-		sizelimit = 1,
-		filter = "("..rdn..")",
-	}
-	assert2 ("function", type(iter))
-	collectgarbage()
-	CONN_OK (LD)
-	local dn, entry = iter ()
-	assert2 ("string", type(dn))
-	assert2 ("table", type(entry))
-	collectgarbage()
-	assert2 ("function", type(iter))
-	CONN_OK (LD)
-
-	DN, ENTRY = LD:search {
-		base = BASE,
-		scope = "onelevel",
-		sizelimit = 1,
-		filter = "("..rdn..")",
-	}()
-	collectgarbage()
-	assert2 ("string", type(DN))
-	assert2 ("table", type(ENTRY))
-end
-
-
----------------------------------------------------------------------
--- checking add operation.
----------------------------------------------------------------------
-function add_test ()
-	-- clone an entry.
-	NEW = clone (ENTRY)
-	local _,_,rdn_name, rdn_value, parent_dn = string.find (DN, DN_PAT)
-	NEW[rdn_name] = rdn_value.."_copy"
-	NEW_DN = string.format ("%s=%s,%s", rdn_name, NEW[rdn_name], parent_dn)
-	-- trying to insert an entry with a wrong connection.
-	assert2 (false, pcall (LD.add, CLOSED_LD, NEW_DN, NEW))
-	-- trying to insert an entry with an invalid connection.
-	assert2 (false, pcall (LD.add, io.output(), NEW_DN, NEW))
-	-- trying to insert an entry with a wrong DN.
-	local wrong_dn = string.format ("%s_x=%s,%s", rdn_name, NEW_DN, parent_dn)
-	--assert2 (nil, LD:add (wrong_dn, NEW))
-	check_future (nil, LD.add, LD, wrong_dn, NEW)
-	-- trying to insert the clone on the LDAP data base.
-	check_future (true, LD.add, LD, NEW_DN, NEW)
-	-- trying to reinsert the clone entry on the directory.
-	check_future (nil, LD.add, LD, NEW_DN, NEW)
-end
-
-
----------------------------------------------------------------------
--- checking modify operation.
----------------------------------------------------------------------
-function modify_test ()
-	-- modifying without connection.
-	assert2 (false, pcall (LD.modify, nil, NEW_DN, {}))
-	-- modifying with a closed connection.
-	assert2 (false, pcall (LD.modify, CLOSED_LD, NEW_DN, {}))
-	-- modifying with an invalid userdata.
-	assert2 (false, pcall (LD.modify, io.output(), NEW_DN, {}))
-	-- checking invalid DN.
-	assert2 (false, pcall (LD.modify, LD, {}))
-	-- no modification to apply.
-	check_future (true, LD.modify, LD, NEW_DN)
-	-- forgotten operation on modifications table.
-	local a_attr, a_value = next (ENTRY)
-	assert2 (false, pcall (LD.modify, LD, NEW_DN, { [a_attr] = "abc"}))
-	-- modifying an unknown entry.
-	local _,_, rdn_name, rdn_value, parent_dn = string.find (NEW_DN, DN_PAT)
-	local new_rdn = rdn_name..'='..rdn_value..'_'
-	local new_dn = string.format ("%s,%s", new_rdn, parent_dn)
-	check_future (nil, LD.modify, LD, new_dn)
-	-- trying to create an undefined attribute.
-	check_future (nil, LD.modify, LD, NEW_DN, {'+', unknown_attribute = 'a'})
-end
-
-
----------------------------------------------------------------------
-function count (tab)
-	local counter = 0
-	for dn, entry in LD:search (tab) do
-		counter = counter + 1
-	end
-	return counter
-end
-
-
----------------------------------------------------------------------
--- checking advanced search operation.
----------------------------------------------------------------------
-function search_test_2 ()
-	local _,_,rdn = string.find (WHO, "^([^,]+)%,.*$")
-	local iter = LD:search {
-		base = BASE,
-		scope = "onelevel",
-		sizelimit = 1,
-		filter = "("..rdn..")",
-	}
-	assert2 ("function", type(iter))
-	collectgarbage ()
-	assert2 ("function", type(iter))
-	local dn, entry = iter ()
-	assert2 ("string", type(dn))
-	assert2 ("table", type(entry))
-	collectgarbage ()
-	assert2 ("function", type(iter))
-	iter = nil
-	collectgarbage ()
-
-	-- checking no search specification.
-	assert2 (false, pcall (LD.search, LD))
-	-- checking invalid scope.
-	assert2 (false, pcall (LD.search, LD, { scope = 'BASE', base = BASE, }))
-	-- checking invalid base.
-	check_future (nil, LD.search, LD, { base = "invalid", scope = "base", })
-	-- checking filter.
-	local _,_, rdn_name, rdn_value, parent_dn = string.find (NEW_DN, DN_PAT)
-	local filter = string.format ("(%s=%s)", rdn_name, rdn_value)
-	assert (count { base = BASE, scope = "subtree", filter = filter, } == 1)
-	-- checking sizelimit.
-	assert (count { base = BASE, scope = "subtree", sizelimit = 1, } == 1)
-	-- checking attrsonly parameter.
-	for dn, entry in LD:search { base = BASE, scope = "subtree", attrsonly = true, } do
-		for attr, value in pairs (entry) do
-			assert (value == true, "attrsonly failed")
-		end
-	end
-	-- checking reuse of search object.
-	local iter = assert (LD:search { base = BASE, scope = "base", })
-	assert (type(iter) == "function")
-	local dn, e1 = iter()
-	assert (type(dn) == "string")
-	assert (type(e1) == "table")
-	dn, e1 = iter()
-	assert (type(dn) == "nil")
-	assert (type(e1) == "nil")
-	assert2 (false, pcall (iter))
-	iter = nil
-	-- checking collecting search objects.
-	local dn, entry = LD:search { base = BASE, scope = "base" }()
-	collectgarbage()
-end
-
-
----------------------------------------------------------------------
--- checking rename operation.
----------------------------------------------------------------------
-function rename_test ()
-	local _,_, rdn_name, rdn_value, parent_dn = string.find (NEW_DN, DN_PAT)
-	local new_rdn = rdn_name..'='..rdn_value..'_'
-	local new_dn = string.format ("%s,%s", new_rdn, parent_dn)
-	-- trying to rename with no parent.
-	check_future (true, LD.rename, LD, NEW_DN, new_rdn, nil)
-	-- trying to rename an invalid dn.
-	check_future (nil, LD.rename, LD, NEW_DN, new_rdn, nil)
-	-- trying to rename with the same parent.
-	check_future (true, LD.rename, LD, new_dn, rdn_name..'='..rdn_value, parent_dn)
-	-- trying to rename to an inexistent parent.
-	check_future (nil, LD.rename, LD, NEW_DN, new_rdn, new_dn)
-	-- mal-formed DN.
-	assert2 (false, pcall (LD.rename, LD, ""))
-	-- trying to rename with a closed connection.
-	assert2 (false, pcall (LD.rename, CLOSED_LD, NEW_DN, new_rdn, nil))
-	-- trying to rename with an invalid connection.
-	assert2 (false, pcall (LD.rename, io.output(), NEW_DN, new_rdn, nil))
-end
-
-
----------------------------------------------------------------------
--- checking delete operation.
----------------------------------------------------------------------
-function delete_test ()
-	-- trying to delete with a closed connection.
-	assert2 (false, pcall (LD.delete, CLOSED_LD, NEW_DN))
-	-- trying to delete with an invalid connection.
-	assert2 (false, pcall (LD.delete, io.output(), NEW_DN))
-	-- trying to delete new entry.
-	check_future (true, LD.delete, LD, NEW_DN)
-	-- trying to delete an already deleted entry.
-	check_future (nil, LD.delete, LD, NEW_DN)
-	-- mal-formed DN.
-	check_future (nil, LD.delete, LD, "")
-	-- no DN.
-	assert2 (false, pcall (LD.delete, LD))
-end
-
-
----------------------------------------------------------------------
--- checking close operation.
----------------------------------------------------------------------
-function close_test ()
-	assert (LD:close () == 1, "couldn't close connection")
-end
-
-
----------------------------------------------------------------------
-tests = {
-	{ "basic checking", basic_test },
-	{ "checking compare operation", compare_test },
-	{ "checking basic search operation", search_test_1 },
-	{ "checking add operation", add_test },
-	{ "checking modify operation", modify_test },
-	{ "checking advanced search operation", search_test_2 },
-	{ "checking rename operation", rename_test },
-	{ "checking delete operation", delete_test },
-	{ "closing everything", close_test },
-}
-
----------------------------------------------------------------------
--- Main
----------------------------------------------------------------------
-
-if table.getn(arg) < 1 then
-	print (string.format ("Usage %s host[:port] base [who [password]]", arg[0]))
-	os.exit()
-end
-
-HOSTNAME = arg[1]
-BASE = arg[2]
-WHO = arg[3]
-PASSWORD = arg[4]
-
-require"lualdap"
-assert (type(lualdap)=="table", "couldn't load LDAP library")
-
-for i = 1, table.getn (tests) do
-	local t = tests[i]
-	io.write (t[1].." ...")
-	t[2] ()
-	io.write (" OK !\n")
-end