AD: Rename ad_create_default_options to ad_create_2way_trust_options

Related:
    https://fedorahosted.org/sssd/ticket/2638

Better reflects what's going on in the function. Also adds a unit test.

Reviewed-by: Sumit Bose <sbose@redhat.com>

1 files changed, 129 insertions, 22 deletions

diff --git a/src/tests/cmocka/test_ad_common.c b/src/tests/cmocka/test_ad_common.c
index 1c44bc34b..0013d7833 100644
--- a/src/tests/cmocka/test_ad_common.c
+++ b/src/tests/cmocka/test_ad_common.c
@@ -33,12 +33,24 @@
 #include "providers/ad/ad_common.c"
 
 #include "tests/cmocka/common_mock.h"
+#include "tests/cmocka/common_mock_krb5.h"
 
 #define DOMNAME     "domname"
 #define SUBDOMNAME  "sub."DOMNAME
 #define REALMNAME   DOMNAME
 #define HOST_NAME   "ad."REALMNAME
 
+#define TEST_AUTHID       "host/"HOST_NAME
+#define KEYTAB_TEST_PRINC TEST_AUTHID"@"REALMNAME
+#define KEYTAB_PATH       TEST_DIR"/keytab_test.keytab"
+
+static bool call_real_sasl_options;
+
+krb5_error_code __wrap_krb5_kt_default(krb5_context context, krb5_keytab *id)
+{
+    return krb5_kt_resolve(context, KEYTAB_PATH, id);
+}
+
 struct ad_common_test_ctx {
     struct ad_id_ctx *ad_ctx;
     struct ad_id_ctx *subdom_ad_ctx;
@@ -47,15 +59,9 @@ struct ad_common_test_ctx {
     struct sss_domain_info *subdom;
 };
 
-static int
-ad_common_test_setup(void **state)
+static int test_ad_common_setup(void **state)
 {
     struct ad_common_test_ctx *test_ctx;
-    errno_t ret;
-    struct sdap_domain *sdom;
-    struct ad_id_ctx *ad_ctx;
-    struct ad_id_ctx *subdom_ad_ctx;
-    struct sdap_id_conn_ctx *subdom_ldap_ctx;
 
     assert_true(leak_check_setup());
     check_leaks_push(global_talloc_context);
@@ -72,11 +78,96 @@ ad_common_test_setup(void **state)
     test_ctx->subdom->name = discard_const(SUBDOMNAME);
     test_ctx->subdom->parent = test_ctx->dom;
 
-    ad_ctx = talloc_zero(test_ctx, struct ad_id_ctx);
-    assert_non_null(ad_ctx);
+    test_ctx->ad_ctx = talloc_zero(test_ctx, struct ad_id_ctx);
+    assert_non_null(test_ctx->ad_ctx);
+
+    check_leaks_push(test_ctx);
+    *state = test_ctx;
+    return 0;
+}
+
+static int test_ad_common_teardown(void **state)
+{
+    struct ad_common_test_ctx *test_ctx = talloc_get_type(*state,
+                                                  struct ad_common_test_ctx);
+    assert_non_null(test_ctx);
+
+    assert_true(check_leaks_pop(test_ctx) == true);
+    talloc_free(test_ctx);
+    assert_true(check_leaks_pop(global_talloc_context) == true);
+    assert_true(leak_check_teardown());
+
+    return 0;
+}
 
-    ad_ctx->ad_options = ad_create_default_options(ad_ctx,
-                                                   REALMNAME, HOST_NAME);
+static void test_ad_create_2way_trust_options(void **state)
+{
+    struct ad_common_test_ctx *test_ctx = talloc_get_type(*state,
+                                                  struct ad_common_test_ctx);
+    const char *s;
+
+    call_real_sasl_options = true;
+    mock_keytab_with_contents(test_ctx, KEYTAB_PATH, KEYTAB_TEST_PRINC);
+
+    test_ctx->ad_ctx->ad_options = ad_create_2way_trust_options(
+                                                            test_ctx->ad_ctx,
+                                                            REALMNAME,
+                                                            HOST_NAME);
+    assert_non_null(test_ctx->ad_ctx->ad_options);
+
+    assert_int_equal(test_ctx->ad_ctx->ad_options->id->schema_type,
+                     SDAP_SCHEMA_AD);
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->basic,
+                          AD_KRB5_REALM);
+    assert_non_null(s);
+    assert_string_equal(s, REALMNAME);
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->basic,
+                          AD_HOSTNAME);
+    assert_non_null(s);
+    assert_string_equal(s, HOST_NAME);
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->id->basic,
+                          SDAP_KRB5_KEYTAB);
+    assert_null(s); /* This is the system keytab */
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->id->basic,
+                          SDAP_SASL_REALM);
+    assert_non_null(s);
+    assert_string_equal(s, REALMNAME);
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->id->basic,
+                          SDAP_KRB5_REALM);
+    assert_non_null(s);
+    assert_string_equal(s, REALMNAME);
+
+    s = dp_opt_get_string(test_ctx->ad_ctx->ad_options->id->basic,
+                          SDAP_SASL_AUTHID);
+    assert_non_null(s);
+    assert_string_equal(s, TEST_AUTHID);
+
+    talloc_free(test_ctx->ad_ctx->ad_options);
+}
+
+static int
+test_ldap_conn_setup(void **state)
+{
+    struct ad_common_test_ctx *test_ctx;
+    errno_t ret;
+    struct sdap_domain *sdom;
+    struct ad_id_ctx *ad_ctx;
+    struct ad_id_ctx *subdom_ad_ctx;
+    struct sdap_id_conn_ctx *subdom_ldap_ctx;
+
+    ret = test_ad_common_setup((void **) &test_ctx);
+    assert_int_equal(ret, EOK);
+
+    ad_ctx = test_ctx->ad_ctx;
+
+    ad_ctx->ad_options = ad_create_2way_trust_options(ad_ctx,
+                                                      REALMNAME,
+                                                      HOST_NAME);
     assert_non_null(ad_ctx->ad_options);
 
     ad_ctx->gc_ctx = talloc_zero(ad_ctx, struct sdap_id_conn_ctx);
@@ -107,35 +198,48 @@ ad_common_test_setup(void **state)
     assert_int_equal(ret, EOK);
     sdom->pvt = subdom_ad_ctx;
 
-    test_ctx->ad_ctx = ad_ctx;
     test_ctx->subdom_ad_ctx = subdom_ad_ctx;
 
-    check_leaks_push(test_ctx);
     *state = test_ctx;
     return 0;
 }
 
 static int
-ad_common_test_teardown(void **state)
+test_ldap_conn_teardown(void **state)
 {
     struct ad_common_test_ctx *test_ctx = talloc_get_type(*state,
                                                   struct ad_common_test_ctx);
     assert_non_null(test_ctx);
 
-    assert_true(check_leaks_pop(test_ctx) == true);
-    talloc_free(test_ctx);
-    assert_true(check_leaks_pop(global_talloc_context) == true);
-    assert_true(leak_check_teardown());
+    talloc_free(test_ctx->subdom_ad_ctx);
+    talloc_free(test_ctx->ad_ctx->ad_options);
+    talloc_free(test_ctx->ad_ctx->gc_ctx);
+    talloc_free(test_ctx->ad_ctx->ldap_ctx);
+    talloc_free(test_ctx->ad_ctx->sdap_id_ctx);
+
+    test_ad_common_teardown((void **) &test_ctx);
     return 0;
 }
 
 errno_t
+__real_sdap_set_sasl_options(struct sdap_options *id_opts,
+                             char *default_primary,
+                             char *default_realm,
+                             const char *keytab_path);
+errno_t
 __wrap_sdap_set_sasl_options(struct sdap_options *id_opts,
                              char *default_primary,
                              char *default_realm,
                              const char *keytab_path)
 {
     /* Pretend SASL is fine */
+    if (call_real_sasl_options == true) {
+        return __real_sdap_set_sasl_options(id_opts,
+                                            default_primary,
+                                            default_realm,
+                                            keytab_path);
+    }
+
     return EOK;
 }
 
@@ -214,12 +318,15 @@ int main(int argc, const char *argv[])
     };
 
     const struct CMUnitTest tests[] = {
+        cmocka_unit_test_setup_teardown(test_ad_create_2way_trust_options,
+                                        test_ad_common_setup,
+                                        test_ad_common_teardown),
         cmocka_unit_test_setup_teardown(test_ldap_conn_list,
-                                        ad_common_test_setup,
-                                        ad_common_test_teardown),
+                                        test_ldap_conn_setup,
+                                        test_ldap_conn_teardown),
         cmocka_unit_test_setup_teardown(test_conn_list,
-                                        ad_common_test_setup,
-                                        ad_common_test_teardown),
+                                        test_ldap_conn_setup,
+                                        test_ldap_conn_teardown),
     };
 
     /* Set debug level to invalid value so we can deside if -d 0 was used. */