local unpack = table.unpack;

local server = require "net.server_select";

package.loaded["net.server"] = server;

local st = require "util.stanza";

local function mock_prosody()

	_G.prosody = {

		core_post_stanza = function () end;

		events = require "util.events".new();

		hosts = {};

		paths = {

			data = "./data";

		};

	};

end

local configs = {

	memory = {

		storage = "memory";

	};

	internal = {

		storage = "internal";

	};

	sqlite = {

		storage = "sql";

		sql = { driver = "SQLite3", database = "prosody-tests.sqlite" };

	};

	mysql = {

		storage = "sql";

		sql = { driver = "MySQL",  database = "prosody", username = "prosody", password = "secret", host = "localhost" };

	};

	postgres = {

		storage = "sql";

		sql = { driver = "PostgreSQL", database = "prosody", username = "prosody", password = "secret", host = "localhost" };

	};

};

local test_host = "storage-unit-tests.invalid";

describe("storagemanager", function ()

	for backend, backend_config in pairs(configs) do

		local tagged_name = "#"..backend;

		if backend ~= backend_config.storage then

			tagged_name = tagged_name.." #"..backend_config.storage;

		end

		insulate(tagged_name.." #storage backend", function ()

			mock_prosody();

			local config = require "core.configmanager";

			local sm = require "core.storagemanager";

			local hm = require "core.hostmanager";

			local mm = require "core.modulemanager";

			-- Simple check to ensure insulation is working correctly

			assert.is_nil(config.get(test_host, "storage"));

			for k, v in pairs(backend_config) do

				config.set(test_host, k, v);

			end

			assert(hm.activate(test_host, {}));

			sm.initialize_host(test_host);

			assert(mm.load(test_host, "storage_"..backend_config.storage));

			describe("key-value stores", function ()

				-- These tests rely on being executed in order, disable any order

				-- randomization for this block

				randomize(false);

				local store;

				it("may be opened", function ()

					store = assert(sm.open(test_host, "test"));

				end);

				local simple_data = { foo = "bar" };

				it("may set data for a user", function ()

					assert(store:set("user9999", simple_data));

				end);

				it("may get data for a user", function ()

					assert.same(simple_data, assert(store:get("user9999")));

				end);

				it("may remove data for a user", function ()

					assert(store:set("user9999", nil));

					local ret, err = store:get("user9999");

					assert.is_nil(ret);

					assert.is_nil(err);

				end);

			end);

			describe("map stores", function ()

				-- These tests rely on being executed in order, disable any order

				-- randomization for this block

				randomize(false);

				local store, kv_store;

				it("may be opened", function ()

					store = assert(sm.open(test_host, "test-map", "map"));

				end);

				it("may be opened as a keyval store", function ()

					kv_store = assert(sm.open(test_host, "test-map", "keyval"));

				end);

				it("may set a specific key for a user", function ()

					assert(store:set("user9999", "foo", "bar"));

					assert.same(kv_store:get("user9999"), { foo = "bar" });

				end);

				it("may get a specific key for a user", function ()

					assert.equal("bar", store:get("user9999", "foo"));

				end);

				it("may find all users with a specific key", function ()

					assert.is_function(store.get_all);

					assert(store:set("user9999b", "bar", "bar"));

					assert(store:set("user9999c", "foo", "blah"));

					local ret, err = store:get_all("foo");

					assert.is_nil(err);

					assert.same({ user9999 = "bar", user9999c = "blah" }, ret);

				end);

				it("rejects empty or non-string keys to get_all", function ()

					assert.is_function(store.get_all);

					do

						local ret, err = store:get_all("");

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

					do

						local ret, err = store:get_all(true);

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

				end);

				it("rejects empty or non-string keys to delete_all", function ()

					assert.is_function(store.delete_all);

					do

						local ret, err = store:delete_all("");

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

					do

						local ret, err = store:delete_all(true);

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

				end);

				it("may delete all instances of a specific key", function ()

					assert.is_function(store.delete_all);

					assert(store:set("user9999b", "foo", "hello"));

					assert(store:delete_all("bar"));

					-- Ensure key was deleted

					do

						local ret, err = store:get("user9999b", "bar");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

					-- Ensure other users/keys are intact

					do

						local ret, err = store:get("user9999", "foo");

						assert.equal("bar", ret);

						assert.is_nil(err);

					end

					do

						local ret, err = store:get("user9999b", "foo");

						assert.equal("hello", ret);

						assert.is_nil(err);

					end

					do

						local ret, err = store:get("user9999c", "foo");

						assert.equal("blah", ret);

						assert.is_nil(err);

					end

				end);

				it("may remove data for a specific key for a user", function ()

					assert(store:set("user9999", "foo", nil));

					do

						local ret, err = store:get("user9999", "foo");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

					assert(store:set("user9999b", "foo", nil));

					do

						local ret, err = store:get("user9999b", "foo");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

				end);

			end);

			describe("keyval+ stores", function ()

				-- These tests rely on being executed in order, disable any order

				-- randomization for this block

				randomize(false);

				local store, kv_store, map_store;

				it("may be opened", function ()

					store = assert(sm.open(test_host, "test-kv+", "keyval+"));

				end);

				local simple_data = { foo = "bar" };

				it("may set data for a user", function ()

					assert(store:set("user9999", simple_data));

				end);

				it("may get data for a user", function ()

					assert.same(simple_data, assert(store:get("user9999")));

				end);

				it("may be opened as a keyval store", function ()

					kv_store = assert(sm.open(test_host, "test-kv+", "keyval"));

					assert.same(simple_data, assert(kv_store:get("user9999")));

				end);

				it("may be opened as a map store", function ()

					map_store = assert(sm.open(test_host, "test-kv+", "map"));

					assert.same("bar", assert(map_store:get("user9999", "foo")));

				end);

				it("may remove data for a user", function ()

					assert(store:set("user9999", nil));

					local ret, err = store:get("user9999");

					assert.is_nil(ret);

					assert.is_nil(err);

				end);

				it("may set a specific key for a user", function ()

					assert(store:set_key("user9999", "foo", "bar"));

					assert.same(kv_store:get("user9999"), { foo = "bar" });

				end);

				it("may get a specific key for a user", function ()

					assert.equal("bar", store:get_key("user9999", "foo"));

				end);

				it("may find all users with a specific key", function ()

					assert.is_function(store.get_key_from_all);

					assert(store:set_key("user9999b", "bar", "bar"));

					assert(store:set_key("user9999c", "foo", "blah"));

					local ret, err = store:get_key_from_all("foo");

					assert.is_nil(err);

					assert.same({ user9999 = "bar", user9999c = "blah" }, ret);

				end);

				it("rejects empty or non-string keys to get_all", function ()

					assert.is_function(store.get_key_from_all);

					do

						local ret, err = store:get_key_from_all("");

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

					do

						local ret, err = store:get_key_from_all(true);

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

				end);

				it("rejects empty or non-string keys to delete_all", function ()

					assert.is_function(store.delete_key_from_all);

					do

						local ret, err = store:delete_key_from_all("");

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

					do

						local ret, err = store:delete_key_from_all(true);

						assert.is_nil(ret);

						assert.is_not_nil(err);

					end

				end);

				it("may delete all instances of a specific key", function ()

					assert.is_function(store.delete_key_from_all);

					assert(store:set_key("user9999b", "foo", "hello"));

					assert(store:delete_key_from_all("bar"));

					-- Ensure key was deleted

					do

						local ret, err = store:get_key("user9999b", "bar");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

					-- Ensure other users/keys are intact

					do

						local ret, err = store:get_key("user9999", "foo");

						assert.equal("bar", ret);

						assert.is_nil(err);

					end

					do

						local ret, err = store:get_key("user9999b", "foo");

						assert.equal("hello", ret);

						assert.is_nil(err);

					end

					do

						local ret, err = store:get_key("user9999c", "foo");

						assert.equal("blah", ret);

						assert.is_nil(err);

					end

				end);

				it("may remove data for a specific key for a user", function ()

					assert(store:set_key("user9999", "foo", nil));

					do

						local ret, err = store:get_key("user9999", "foo");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

					assert(store:set_key("user9999b", "foo", nil));

					do

						local ret, err = store:get_key("user9999b", "foo");

						assert.is_nil(ret);

						assert.is_nil(err);

					end

				end);

			end);

			describe("archive stores", function ()

				randomize(false);

				local archive;

				it("can be opened", function ()

					archive = assert(sm.open(test_host, "test-archive", "archive"));

				end);

				local test_stanza = st.stanza("test", { xmlns = "urn:example:foo" })

					:tag("foo"):up()

					:tag("foo"):up()

					:reset();

				local test_time = 1539204123;

				local test_data = {

					{ nil, test_stanza, test_time-1, "contact2@example.com" };

					{ nil, test_stanza, test_time+1, "contact3@example.com" };

				};

				it("can be added to", function ()

					for _, data_item in ipairs(test_data) do

						local id = archive:append("user", unpack(data_item, 1, 4));

						assert.truthy(id);

						data_item[1] = id;

					end

				end);

				describe("can be queried", function ()

					it("for all items", function ()

						-- luacheck: ignore 211/err

						local data, err = archive:find("user", {});

						assert.truthy(data);

						local count = 0;

						for id, item, when in data do

							count = count + 1;

							assert.truthy(id);

							assert(st.is_stanza(item));

							assert.equal("test", item.name);