include.c 7.81 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "futils.h"
3

4 5 6 7
static git_config *cfg;
static git_buf buf;

void test_config_include__initialize(void)
8
{
9 10
	cfg = NULL;
	memset(&buf, 0, sizeof(git_buf));
11
}
12

13 14
void test_config_include__cleanup(void)
{
15 16
	git_config_free(cfg);
	git_buf_dispose(&buf);
17 18 19 20
}

void test_config_include__relative(void)
{
21 22
	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config-include")));

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 28
}

void test_config_include__absolute(void)
{
29 30 31 32 33
	git_str cfgdata = GIT_STR_INIT;
	cl_git_pass(git_str_printf(&cfgdata, "[include]\npath = %s/config-included", cl_fixture("config")));

	cl_git_mkfile("config-include-absolute", cfgdata.ptr);
	git_str_dispose(&cfgdata);
34 35 36

	cl_git_pass(git_config_open_ondisk(&cfg, "config-include-absolute"));

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 44 45 46 47 48 49
}

void test_config_include__homedir(void)
{
	cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, cl_fixture("config")));
	cl_git_mkfile("config-include-homedir",  "[include]\npath = ~/config-included");

	cl_git_pass(git_config_open_ondisk(&cfg, "config-include-homedir"));

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 59 60 61 62 63 64 65 66 67 68
/* We need to pretend that the variables were defined where the file was included */
void test_config_include__ordering(void)
{
	cl_git_mkfile("included", "[foo \"bar\"]\nbaz = hurrah\nfrotz = hiya");
	cl_git_mkfile("including",
		      "[foo \"bar\"]\nfrotz = hello\n"
		      "[include]\npath = included\n"
		      "[foo \"bar\"]\nbaz = huzzah\n");

	cl_git_pass(git_config_open_ondisk(&cfg, "including"));

69
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar.frotz"));
70 71
	cl_assert_equal_s("hiya", buf.ptr);
	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 76

	cl_git_pass(p_unlink("included"));
	cl_git_pass(p_unlink("including"));
77
}
78 79 80 81 82 83 84 85 86

/* We need to pretend that the variables were defined where the file was included */
void test_config_include__depth(void)
{
	cl_git_mkfile("a", "[include]\npath = b");
	cl_git_mkfile("b", "[include]\npath = a");

	cl_git_fail(git_config_open_ondisk(&cfg, "a"));

87 88
	cl_git_pass(p_unlink("a"));
	cl_git_pass(p_unlink("b"));
89
}
90

91 92 93 94 95
void test_config_include__empty_path_sanely_handled(void)
{
	cl_git_mkfile("a", "[include]\npath");
	cl_git_pass(git_config_open_ondisk(&cfg, "a"));
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "include.path"));
96
	cl_assert_equal_s("", buf.ptr);
97 98 99 100

	cl_git_pass(p_unlink("a"));
}

101 102
void test_config_include__missing(void)
{
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 115
}

void test_config_include__missing_homedir(void)
{
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 130 131 132 133 134 135 136 137 138 139

#define replicate10(s) s s s s s s s s s s
void test_config_include__depth2(void)
{
	const char *content = "[include]\n" replicate10(replicate10("path=bottom\n"));

	cl_git_mkfile("top-level", "[include]\npath = middle\n[foo]\nbar = baz");
	cl_git_mkfile("middle", content);
	cl_git_mkfile("bottom", "[foo]\nbar2 = baz2");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));

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 148 149

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("middle"));
	cl_git_pass(p_unlink("bottom"));
150
}
151 152 153 154 155 156 157 158 159

void test_config_include__removing_include_removes_values(void)
{
	cl_git_mkfile("top-level", "[include]\npath = included");
	cl_git_mkfile("included", "[foo]\nbar = value");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_mkfile("top-level", "");
	cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
160 161 162

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
163
}
164 165 166 167 168 169 170 171 172 173 174 175

void test_config_include__rewriting_include_refreshes_values(void)
{
	cl_git_mkfile("top-level", "[include]\npath = first\n[include]\npath = second");
	cl_git_mkfile("first", "[first]\nfoo = bar");
	cl_git_mkfile("second", "[second]\nfoo = bar");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_mkfile("first", "[first]\nother = value");
	cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "first.other"));
	cl_assert_equal_s(buf.ptr, "value");
176 177 178 179

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("first"));
	cl_git_pass(p_unlink("second"));
180
}
181

182 183 184 185 186 187 188 189
void test_config_include__rewriting_include_twice_refreshes_values(void)
{
	cl_git_mkfile("top-level", "[include]\npath = included");
	cl_git_mkfile("included", "[foo]\nbar = first-value");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));

190
	git_buf_dispose(&buf);
191 192 193 194 195
	cl_git_mkfile("included", "[foo]\nother = value2");
	cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar"));
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.other"));
	cl_assert_equal_s(buf.ptr, "value2");

196
	git_buf_dispose(&buf);
197 198 199 200 201 202 203 204 205
	cl_git_mkfile("included", "[foo]\nanother = bar");
	cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.other"));
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.another"));
	cl_assert_equal_s(buf.ptr, "bar");

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
}

206 207 208 209 210 211 212
void test_config_include__included_variables_cannot_be_deleted(void)
{
	cl_git_mkfile("top-level", "[include]\npath = included\n");
	cl_git_mkfile("included", "[foo]\nbar = value");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_fail(git_config_delete_entry(cfg, "foo.bar"));
213 214 215

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
216 217 218 219 220
}

void test_config_include__included_variables_cannot_be_modified(void)
{
	cl_git_mkfile("top-level", "[include]\npath = included\n");
221

222 223 224 225
	cl_git_mkfile("included", "[foo]\nbar = value");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_fail(git_config_set_string(cfg, "foo.bar", "other-value"));
226 227 228

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
229
}
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259

void test_config_include__variables_in_included_override_including(void)
{
	int i;

	cl_git_mkfile("top-level", "[foo]\nbar = 1\n[include]\npath = included");
	cl_git_mkfile("included", "[foo]\nbar = 2");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_pass(git_config_get_int32(&i, cfg, "foo.bar"));
	cl_assert_equal_i(i, 2);

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
}

void test_config_include__variables_in_including_override_included(void)
{
	int i;

	cl_git_mkfile("top-level", "[include]\npath = included\n[foo]\nbar = 1");
	cl_git_mkfile("included", "[foo]\nbar = 2");

	cl_git_pass(git_config_open_ondisk(&cfg, "top-level"));
	cl_git_pass(git_config_get_int32(&i, cfg, "foo.bar"));
	cl_assert_equal_i(i, 1);

	cl_git_pass(p_unlink("top-level"));
	cl_git_pass(p_unlink("included"));
}