tests/libgit2/config/include.c

   1 #include "clar_libgit2.h"
   2 #include "futils.h"
   3
   4 static git_config *cfg;
   5 static git_buf buf;
   6
   7 void test_config_include__initialize(void)
   8 {
   9         cfg = NULL;
  10         memset(&buf, 0, sizeof(git_buf));
  11 }
  12
  13 void test_config_include__cleanup(void)
  14 {
  15         git_config_free(cfg);
  16         git_buf_dispose(&buf);
  17 }
  18
  19 void test_config_include__relative(void)
  20 {
  21         cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config-include")));
  22
  23         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.baz"));
  24         cl_assert_equal_s("huzzah", buf.ptr);
  25 }
  26
  27 void test_config_include__absolute(void)
  28 {
  29         git_str cfgdata = GIT_STR_INIT;
  30         cl_git_pass(git_str_printf(&cfgdata, "[include]\npath = %s/config-included", cl_fixture("config")));
  31
  32         cl_git_mkfile("config-include-absolute", cfgdata.ptr);
  33         git_str_dispose(&cfgdata);
  34
  35         cl_git_pass(git_config_open_ondisk(&cfg, "config-include-absolute"));
  36
  37         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.baz"));
  38         cl_assert_equal_s("huzzah", buf.ptr);
  39
  40         cl_git_pass(p_unlink("config-include-absolute"));
  41 }
  42
  43 void test_config_include__homedir(void)
  44 {
  45         cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, cl_fixture("config")));
  46         cl_git_mkfile("config-include-homedir",  "[include]\npath = ~/config-included");
  47
  48         cl_git_pass(git_config_open_ondisk(&cfg, "config-include-homedir"));
  49
  50         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.baz"));
  51         cl_assert_equal_s("huzzah", buf.ptr);
  52
  53         cl_sandbox_set_search_path_defaults();
  54
  55         cl_git_pass(p_unlink("config-include-homedir"));
  56 }
  57
  58 /* We need to pretend that the variables were defined where the file was included */
  59 void test_config_include__ordering(void)
  60 {
  61         cl_git_mkfile("included", "[foo \"bar\"]\nbaz = hurrah\nfrotz = hiya");
  62         cl_git_mkfile("including",
  63                       "[foo \"bar\"]\nfrotz = hello\n"
  64                       "[include]\npath = included\n"
  65                       "[foo \"bar\"]\nbaz = huzzah\n");
  66
  67         cl_git_pass(git_config_open_ondisk(&cfg, "including"));
  68
  69         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.frotz"));
  70         cl_assert_equal_s("hiya", buf.ptr);
  71         git_buf_dispose(&buf);
  72         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.baz"));
  73         cl_assert_equal_s("huzzah", buf.ptr);
  74
  75         cl_git_pass(p_unlink("included"));
  76         cl_git_pass(p_unlink("including"));
  77 }
  78
  79 /* We need to pretend that the variables were defined where the file was included */
  80 void test_config_include__depth(void)
  81 {
  82         cl_git_mkfile("a", "[include]\npath = b");
  83         cl_git_mkfile("b", "[include]\npath = a");
  84
  85         cl_git_fail(git_config_open_ondisk(&cfg, "a"));
  86
  87         cl_git_pass(p_unlink("a"));
  88         cl_git_pass(p_unlink("b"));
  89 }
  90
  91 void test_config_include__empty_path_sanely_handled(void)
  92 {
  93         cl_git_mkfile("a", "[include]\npath");
  94         cl_git_pass(git_config_open_ondisk(&cfg, "a"));
  95         cl_git_pass(git_config_get_string_buf(&buf, cfg, "include.path"));
  96         cl_assert_equal_s("", buf.ptr);
  97
  98         cl_git_pass(p_unlink("a"));
  99 }
 100
 101 void test_config_include__missing(void)
 102 {
 103         cl_git_mkfile("including", "[include]\npath = nonexistentfile\n[foo]\nbar = baz");
 104
 105         git_error_clear();
 106         cl_git_pass(git_config_open_ondisk(&cfg, "including"));
 107         cl_assert(git_error_last() == NULL);
 108         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 109         cl_assert_equal_s("baz", buf.ptr);
 110
 111         cl_git_pass(p_unlink("including"));
 112 }
 113
 114 void test_config_include__missing_homedir(void)
 115 {
 116         cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, cl_fixture("config")));
 117         cl_git_mkfile("including", "[include]\npath = ~/.nonexistentfile\n[foo]\nbar = baz");
 118
 119         git_error_clear();
 120         cl_git_pass(git_config_open_ondisk(&cfg, "including"));
 121         cl_assert(git_error_last() == NULL);
 122         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 123         cl_assert_equal_s("baz", buf.ptr);
 124
 125         cl_sandbox_set_search_path_defaults();
 126         cl_git_pass(p_unlink("including"));
 127 }
 128
 129 #define replicate10(s) s s s s s s s s s s
 130 void test_config_include__depth2(void)
 131 {
 132         const char *content = "[include]\n" replicate10(replicate10("path=bottom\n"));
 133
 134         cl_git_mkfile("top-level", "[include]\npath = middle\n[foo]\nbar = baz");
 135         cl_git_mkfile("middle", content);
 136         cl_git_mkfile("bottom", "[foo]\nbar2 = baz2");
 137
 138         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 139
 140         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 141         cl_assert_equal_s("baz", buf.ptr);
 142
 143         git_buf_dispose(&buf);
 144         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar2"));
 145         cl_assert_equal_s("baz2", buf.ptr);
 146
 147         cl_git_pass(p_unlink("top-level"));
 148         cl_git_pass(p_unlink("middle"));
 149         cl_git_pass(p_unlink("bottom"));
 150 }
 151
 152 void test_config_include__removing_include_removes_values(void)
 153 {
 154         cl_git_mkfile("top-level", "[include]\npath = included");
 155         cl_git_mkfile("included", "[foo]\nbar = value");
 156
 157         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 158         cl_git_mkfile("top-level", "");
 159         cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 160
 161         cl_git_pass(p_unlink("top-level"));
 162         cl_git_pass(p_unlink("included"));
 163 }
 164
 165 void test_config_include__rewriting_include_refreshes_values(void)
 166 {
 167         cl_git_mkfile("top-level", "[include]\npath = first\n[include]\npath = second");
 168         cl_git_mkfile("first", "[first]\nfoo = bar");
 169         cl_git_mkfile("second", "[second]\nfoo = bar");
 170
 171         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 172         cl_git_mkfile("first", "[first]\nother = value");
 173         cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 174         cl_git_pass(git_config_get_string_buf(&buf, cfg, "first.other"));
 175         cl_assert_equal_s(buf.ptr, "value");
 176
 177         cl_git_pass(p_unlink("top-level"));
 178         cl_git_pass(p_unlink("first"));
 179         cl_git_pass(p_unlink("second"));
 180 }
 181
 182 void test_config_include__rewriting_include_twice_refreshes_values(void)
 183 {
 184         cl_git_mkfile("top-level", "[include]\npath = included");
 185         cl_git_mkfile("included", "[foo]\nbar = first-value");
 186
 187         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 188         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 189
 190         git_buf_dispose(&buf);
 191         cl_git_mkfile("included", "[foo]\nother = value2");
 192         cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
 193         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.other"));
 194         cl_assert_equal_s(buf.ptr, "value2");
 195
 196         git_buf_dispose(&buf);
 197         cl_git_mkfile("included", "[foo]\nanother = bar");
 198         cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.other"));
 199         cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.another"));
 200         cl_assert_equal_s(buf.ptr, "bar");
 201
 202         cl_git_pass(p_unlink("top-level"));
 203         cl_git_pass(p_unlink("included"));
 204 }
 205
 206 void test_config_include__included_variables_cannot_be_deleted(void)
 207 {
 208         cl_git_mkfile("top-level", "[include]\npath = included\n");
 209         cl_git_mkfile("included", "[foo]\nbar = value");
 210
 211         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 212         cl_git_fail(git_config_delete_entry(cfg, "foo.bar"));
 213
 214         cl_git_pass(p_unlink("top-level"));
 215         cl_git_pass(p_unlink("included"));
 216 }
 217
 218 void test_config_include__included_variables_cannot_be_modified(void)
 219 {
 220         cl_git_mkfile("top-level", "[include]\npath = included\n");
 221
 222         cl_git_mkfile("included", "[foo]\nbar = value");
 223
 224         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 225         cl_git_fail(git_config_set_string(cfg, "foo.bar", "other-value"));
 226
 227         cl_git_pass(p_unlink("top-level"));
 228         cl_git_pass(p_unlink("included"));
 229 }
 230
 231 void test_config_include__variables_in_included_override_including(void)
 232 {
 233         int i;
 234
 235         cl_git_mkfile("top-level", "[foo]\nbar = 1\n[include]\npath = included");
 236         cl_git_mkfile("included", "[foo]\nbar = 2");
 237
 238         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 239         cl_git_pass(git_config_get_int32(&i, cfg, "foo.bar"));
 240         cl_assert_equal_i(i, 2);
 241
 242         cl_git_pass(p_unlink("top-level"));
 243         cl_git_pass(p_unlink("included"));
 244 }
 245
 246 void test_config_include__variables_in_including_override_included(void)
 247 {
 248         int i;
 249
 250         cl_git_mkfile("top-level", "[include]\npath = included\n[foo]\nbar = 1");
 251         cl_git_mkfile("included", "[foo]\nbar = 2");
 252
 253         cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
 254         cl_git_pass(git_config_get_int32(&i, cfg, "foo.bar"));
 255         cl_assert_equal_i(i, 1);
 256
 257         cl_git_pass(p_unlink("top-level"));
 258         cl_git_pass(p_unlink("included"));
 259 }