/*
    Authors:
        Jakub Hrozek <jhrozek@redhat.com>

    Copyright (C) 2013 Red Hat

    SSSD tests: Fully Qualified Names Tests

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <popt.h>

#include "db/sysdb_private.h"
#include "tests/cmocka/common_mock.h"

#define NAME        "name"
#define DOMNAME     "domname"
#define FLATNAME    "flatname"
#define SPECIALNAME "[]{}();:'|\",<.>/?!#$%^&*_+~`"
#define PROVIDER    "local"
#define CONNNAME    "conn"

#define DOMNAME2    "domname2"
#define FLATNAME2   "flatname2"

#define SUBDOMNAME    "subdomname"
#define SUBFLATNAME   "subflatname"

static struct sss_domain_info *create_test_domain(TALLOC_CTX *mem_ctx,
                                                  const char *name,
                                                  const char *flatname,
                                                  struct sss_domain_info *parent,
                                                  struct sss_names_ctx *nctx)
{
    struct sss_domain_info *dom;

    dom = talloc_zero(mem_ctx, struct sss_domain_info);
    assert_non_null(dom);

    /* just to make new_subdomain happy */
    dom->sysdb = talloc_zero(dom, struct sysdb_ctx);
    assert_non_null(dom->sysdb);

    dom->name = discard_const(name);
    dom->flat_name = discard_const(flatname);
    dom->parent = parent;
    dom->names = nctx;
    dom->provider = discard_const(PROVIDER);
    dom->conn_name = discard_const(CONNNAME);

    return dom;
}

struct fqdn_test_ctx {
    struct sss_domain_info *dom;

    struct sss_names_ctx *nctx;
};

void fqdn_test_setup(void **state)
{
    struct fqdn_test_ctx *test_ctx;

    assert_true(leak_check_setup());

    test_ctx = talloc_zero(global_talloc_context, struct fqdn_test_ctx);
    assert_non_null(test_ctx);

    test_ctx->dom = create_test_domain(test_ctx, DOMNAME, FLATNAME,
                                       NULL, NULL);

    check_leaks_push(test_ctx);
    *state = test_ctx;
}

void fqdn_test_teardown(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    assert_true(check_leaks_pop(test_ctx) == true);
    talloc_free(test_ctx);
    assert_true(leak_check_teardown());
}

void test_default(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);
    errno_t ret;

    char *fqdn;
    const int fqdn_size = 255;
    char fqdn_s[fqdn_size];

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    ret = sss_names_init_from_args(test_ctx,
                                   "(?P<name>[^@]+)@?(?P<domain>[^@]*$)",
                                   "%1$s@%2$s", &test_ctx->nctx);
    assert_int_equal(ret, EOK);

    fqdn = sss_tc_fqname(test_ctx, test_ctx->nctx, test_ctx->dom, NAME);
    assert_non_null(fqdn);
    assert_string_equal(fqdn, NAME"@"DOMNAME);
    talloc_free(fqdn);

    ret = sss_fqname(fqdn_s, fqdn_size, test_ctx->nctx, test_ctx->dom, NAME);
    assert_int_equal(ret + 1, sizeof(NAME"@"DOMNAME));
    assert_string_equal(fqdn_s, NAME"@"DOMNAME);

    talloc_free(test_ctx->nctx);
}

void test_all(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);
    errno_t ret;

    char *fqdn;
    const int fqdn_size = 255;
    char fqdn_s[fqdn_size];

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    ret = sss_names_init_from_args(test_ctx,
                                   "(?P<name>[^@]+)@?(?P<domain>[^@]*$)",
                                   "%1$s@%2$s@%3$s", &test_ctx->nctx);
    assert_int_equal(ret, EOK);

    fqdn = sss_tc_fqname(test_ctx, test_ctx->nctx, test_ctx->dom, NAME);
    assert_non_null(fqdn);
    assert_string_equal(fqdn, NAME"@"DOMNAME"@"FLATNAME);
    talloc_free(fqdn);

    ret = sss_fqname(fqdn_s, fqdn_size, test_ctx->nctx, test_ctx->dom, NAME);
    assert_int_equal(ret + 1, sizeof(NAME"@"DOMNAME"@"FLATNAME));
    assert_string_equal(fqdn_s, NAME"@"DOMNAME"@"FLATNAME);

    talloc_free(test_ctx->nctx);
}

void test_flat(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);
    errno_t ret;

    char *fqdn;
    const int fqdn_size = 255;
    char fqdn_s[fqdn_size];

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    ret = sss_names_init_from_args(test_ctx,
                                   "(?P<name>[^@]+)@?(?P<domain>[^@]*$)",
                                   "%1$s@%3$s", &test_ctx->nctx);
    assert_int_equal(ret, EOK);

    fqdn = sss_tc_fqname(test_ctx, test_ctx->nctx, test_ctx->dom, NAME);
    assert_non_null(fqdn);
    assert_string_equal(fqdn, NAME"@"FLATNAME);
    talloc_free(fqdn);

    ret = sss_fqname(fqdn_s, fqdn_size, test_ctx->nctx, test_ctx->dom, NAME);
    assert_int_equal(ret + 1, sizeof(NAME"@"FLATNAME));
    assert_string_equal(fqdn_s, NAME"@"FLATNAME);

    talloc_free(test_ctx->nctx);
}

void test_flat_fallback(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);
    errno_t ret;

    char *fqdn;
    const int fqdn_size = 255;
    char fqdn_s[fqdn_size];

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    ret = sss_names_init_from_args(test_ctx,
                                   "(?P<name>[^@]+)@?(?P<domain>[^@]*$)",
                                   "%1$s@%3$s", &test_ctx->nctx);
    assert_int_equal(ret, EOK);

    test_ctx->dom->flat_name = NULL;

    /* If flat name is requested but does not exist, the code falls back to domain
     * name
     */
    fqdn = sss_tc_fqname(test_ctx, test_ctx->nctx, test_ctx->dom, NAME);
    assert_non_null(fqdn);
    assert_string_equal(fqdn, NAME"@"DOMNAME);
    talloc_free(fqdn);

    ret = sss_fqname(fqdn_s, fqdn_size, test_ctx->nctx, test_ctx->dom, NAME);
    assert_int_equal(ret + 1, sizeof(NAME"@"DOMNAME));
    assert_string_equal(fqdn_s, NAME"@"DOMNAME);

    talloc_free(test_ctx->nctx);
}

struct parse_name_test_ctx {
    struct sss_domain_info *dom;
    struct sss_domain_info *subdom;
    struct sss_names_ctx *nctx;
};

void parse_name_check(struct parse_name_test_ctx *test_ctx,
                      const char *full_name,
                      const char *default_domain,
                      const char exp_ret,
                      const char *exp_name,
                      const char *exp_domain)
{
    errno_t ret;
    char *domain = NULL;
    char *name = NULL;

    check_leaks_push(test_ctx);
    ret = sss_parse_name_for_domains(test_ctx, test_ctx->dom, default_domain,
                                     full_name, &domain, &name);
    assert_int_equal(ret, exp_ret);

    if (exp_name) {
        assert_non_null(name);
        assert_string_equal(name, exp_name);
    }

    if (exp_domain) {
        assert_non_null(domain);
        assert_string_equal(domain, exp_domain);
    }

    talloc_free(name);
    talloc_free(domain);
    assert_true(check_leaks_pop(test_ctx) == true);
}

void parse_name_test_setup(void **state)
{
    struct parse_name_test_ctx *test_ctx;
    struct sss_domain_info *dom;
    errno_t ret;

    assert_true(leak_check_setup());

    test_ctx = talloc_zero(global_talloc_context, struct parse_name_test_ctx);
    assert_non_null(test_ctx);

    /* Init with an AD-style regex to be able to test flat name */
    ret = sss_names_init_from_args(test_ctx,
                                   "(((?P<domain>[^\\\\]+)\\\\(?P<name>.+$))|" \
                                   "((?P<name>[^@]+)@(?P<domain>.+$))|" \
                                   "(^(?P<name>[^@\\\\]+)$))",
                                   "%1$s@%2$s", &test_ctx->nctx);
    assert_int_equal(ret, EOK);

    /* The setup is two domains, first one with no subdomains,
     * second one with a single subdomain
     */
    dom = create_test_domain(test_ctx, DOMNAME, FLATNAME,
                                       NULL, test_ctx->nctx);
    assert_non_null(dom);
    DLIST_ADD_END(test_ctx->dom, dom, struct sss_domain_info *);

    dom = create_test_domain(test_ctx, DOMNAME2,
                             FLATNAME2, NULL, test_ctx->nctx);
    assert_non_null(dom);
    DLIST_ADD_END(test_ctx->dom, dom, struct sss_domain_info *);

    /* Create the subdomain, but don't add it yet, we want to be able to
     * test sss_parse_name_for_domains() signaling that domains must be
     * discovered
     */
    test_ctx->subdom = new_subdomain(dom, dom, SUBDOMNAME, NULL, SUBFLATNAME,
                                     NULL, false, false, NULL);
    assert_non_null(test_ctx->subdom);

    check_leaks_push(test_ctx);
    *state = test_ctx;
}

void parse_name_test_teardown(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);

    assert_true(check_leaks_pop(test_ctx) == true);
    talloc_free(test_ctx);
    assert_true(leak_check_teardown());
}

void sss_parse_name_check(struct parse_name_test_ctx *test_ctx,
                          const char *input_name,
                          const char exp_ret,
                          const char *exp_name,
                          const char *exp_domain)
{
    errno_t ret;
    char *domain = NULL;
    char *name = NULL;
    const char *domain_const = NULL;
    const char *name_const = NULL;


    check_leaks_push(test_ctx);
    ret = sss_parse_name(test_ctx, test_ctx->nctx, input_name,
                         &domain, &name);
    assert_int_equal(ret, exp_ret);

    if (exp_name) {
        assert_non_null(name);
        assert_string_equal(name, exp_name);
    }

    if (exp_domain) {
        assert_non_null(domain);
        assert_string_equal(domain, exp_domain);
    }

    talloc_zfree(name);
    talloc_zfree(domain);

    ret = sss_parse_name_const(test_ctx, test_ctx->nctx, input_name,
                               &domain_const, &name_const);
    assert_int_equal(ret, exp_ret);

    if (exp_name) {
        assert_non_null(name_const);
        assert_string_equal(name_const, exp_name);
    }

    if (exp_domain) {
        assert_non_null(domain_const);
        assert_string_equal(domain_const, exp_domain);
    }

    talloc_free(discard_const(name_const));
    talloc_free(discard_const(domain_const));

    assert_true(check_leaks_pop(test_ctx) == true);
}

void parse_name_plain(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);
    int ret;

    parse_name_check(test_ctx, NAME, NULL, EOK, NAME, NULL);

    ret = sss_parse_name(test_ctx, test_ctx->nctx, NAME,
                         NULL, NULL);
    assert_int_equal(ret, EOK);
    ret = sss_parse_name_const(test_ctx, test_ctx->nctx, NAME,
                               NULL, NULL);
    assert_int_equal(ret, EOK);

    sss_parse_name_check(test_ctx, NAME, EOK, NAME, NULL);
    sss_parse_name_check(test_ctx, SPECIALNAME, EOK, SPECIALNAME, NULL);
}

void parse_name_fqdn(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);
    parse_name_check(test_ctx, NAME"@"DOMNAME, NULL, EOK, NAME, DOMNAME);
    parse_name_check(test_ctx, NAME"@"DOMNAME2, NULL, EOK, NAME, DOMNAME2);

    sss_parse_name_check(test_ctx, NAME"@"DOMNAME, EOK, NAME, DOMNAME);
    sss_parse_name_check(test_ctx, NAME"@"DOMNAME2, EOK, NAME, DOMNAME2);
    sss_parse_name_check(test_ctx, DOMNAME"\\"NAME, EOK, NAME, DOMNAME);
    sss_parse_name_check(test_ctx, DOMNAME2"\\"NAME, EOK, NAME, DOMNAME2);
}

void parse_name_sub(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);
    /* The subdomain name is valid, but not known */
    parse_name_check(test_ctx, NAME"@"SUBDOMNAME, NULL, EAGAIN, NULL, NULL);

    /* Link the subdomain (simulating subdom handler) and retry */
    test_ctx->dom->subdomains = test_ctx->subdom;
    parse_name_check(test_ctx, NAME"@"SUBDOMNAME, NULL, EOK, NAME, SUBDOMNAME);
}

void parse_name_flat(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);

    /* Link the subdomain (simulating subdom handler) */
    parse_name_check(test_ctx, FLATNAME"\\"NAME, NULL, EOK, NAME, DOMNAME);
    parse_name_check(test_ctx, FLATNAME2"\\"NAME, NULL, EOK, NAME, DOMNAME2);

    /* The subdomain name is valid, but not known */
    parse_name_check(test_ctx, SUBFLATNAME"\\"NAME, NULL, EAGAIN, NULL, NULL);
    test_ctx->dom->subdomains = test_ctx->subdom;
    parse_name_check(test_ctx, SUBFLATNAME"\\"NAME, NULL, EOK, NAME, SUBDOMNAME);
}

void parse_name_default(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);
    struct sss_domain_info *dom2;

    parse_name_check(test_ctx, NAME, DOMNAME2, EOK, NAME, DOMNAME2);
    dom2 = test_ctx->dom->next;

    /* Simulate uknown default domain */
    DLIST_REMOVE(test_ctx->dom, dom2);
    parse_name_check(test_ctx, NAME, DOMNAME2, EAGAIN, NULL, NULL);
}

void test_init_nouser(void **state)
{
    struct fqdn_test_ctx *test_ctx = talloc_get_type(*state,
                                                     struct fqdn_test_ctx);
    errno_t ret;

    if (test_ctx == NULL) {
        DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
        return;
    }

    ret = sss_names_init_from_args(test_ctx,
                                   "(?P<name>[^@]+)@?(?P<domain>[^@]*$)",
                                   "%2$s@%3$s", &test_ctx->nctx);
    /* Initialization with no user name must fail */
    assert_int_not_equal(ret, EOK);
}

void sss_parse_name_fail(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                           struct parse_name_test_ctx);

    sss_parse_name_check(test_ctx, "", EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, "@", EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, "\\", EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, "\\"NAME, EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, "@"NAME, EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, NAME"@", EINVAL, NULL, NULL);
    sss_parse_name_check(test_ctx, NAME"\\", EINVAL, NULL, NULL);
}

void test_sss_get_domain_name(void **state)
{
    struct parse_name_test_ctx *test_ctx = talloc_get_type(*state,
                                                   struct parse_name_test_ctx);
    struct {
        const char *input;
        struct sss_domain_info *domain;
        const char *expected;
    } data[] = {{"user", test_ctx->dom, "user"},
                {"user", test_ctx->subdom, "user@" SUBDOMNAME},
                {"user@" SUBDOMNAME, test_ctx->subdom, "user@" SUBDOMNAME},
                {NULL, NULL, NULL}};
    char *name;
    int i;

    for (i = 0; data[i].input != NULL; i++) {
        name = sss_get_domain_name(test_ctx, data[i].input, data[i].domain);
        assert_non_null(name);
        assert_string_equal(name, data[i].expected);
        talloc_free(name);
    }
}

int main(int argc, const char *argv[])
{
    poptContext pc;
    int opt;
    struct poptOption long_options[] = {
        POPT_AUTOHELP
        SSSD_DEBUG_OPTS
        POPT_TABLEEND
    };

    const UnitTest tests[] = {
        unit_test_setup_teardown(test_default,
                                 fqdn_test_setup, fqdn_test_teardown),
        unit_test_setup_teardown(test_all,
                                 fqdn_test_setup, fqdn_test_teardown),
        unit_test_setup_teardown(test_flat,
                                 fqdn_test_setup, fqdn_test_teardown),
        unit_test_setup_teardown(test_flat_fallback,
                                 fqdn_test_setup, fqdn_test_teardown),
        unit_test_setup_teardown(test_init_nouser,
                                 fqdn_test_setup, fqdn_test_teardown),

        unit_test_setup_teardown(parse_name_plain,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
        unit_test_setup_teardown(parse_name_fqdn,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
        unit_test_setup_teardown(parse_name_sub,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
        unit_test_setup_teardown(parse_name_flat,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
        unit_test_setup_teardown(parse_name_default,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
        unit_test_setup_teardown(sss_parse_name_fail,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),

        unit_test_setup_teardown(test_sss_get_domain_name,
                                 parse_name_test_setup,
                                 parse_name_test_teardown),
    };

    /* Set debug level to invalid value so we can deside if -d 0 was used. */
    debug_level = SSSDBG_INVALID;

    pc = poptGetContext(argv[0], argc, argv, long_options, 0);
    while((opt = poptGetNextOpt(pc)) != -1) {
        switch(opt) {
        default:
            fprintf(stderr, "\nInvalid option %s: %s\n\n",
                    poptBadOption(pc, 0), poptStrerror(opt));
            poptPrintUsage(pc, stderr, 0);
            return 1;
        }
    }
    poptFreeContext(pc);

    DEBUG_CLI_INIT(debug_level);

    /* Even though normally the tests should clean up after themselves
     * they might not after a failed run. Remove the old db to be sure */
    tests_set_cwd();

    return run_tests(tests);
}