write.c 11 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "buffer.h"
3 4 5 6

void test_config_write__initialize(void)
{
	cl_fixture_sandbox("config/config9");
7
	cl_fixture_sandbox("config/config15");
8
	cl_fixture_sandbox("config/config17");
9 10 11 12 13
}

void test_config_write__cleanup(void)
{
	cl_fixture_cleanup("config9");
14
	cl_fixture_cleanup("config15");
15
	cl_fixture_cleanup("config17");
16 17 18 19 20 21 22 23 24 25 26 27 28 29
}

void test_config_write__replace_value(void)
{
	git_config *cfg;
	int i;
	int64_t l, expected = +9223372036854775803;

	/* By freeing the config, we make sure we flush the values  */
	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 5));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
30
	cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy"));
31 32 33 34 35 36 37 38 39 40 41 42
	cl_assert(i == 5);
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_int64(cfg, "core.verylong", expected));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
43
	cl_git_pass(git_config_get_int64(&l, cfg, "core.verylong"));
44 45 46 47
	cl_assert(l == expected);
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
48
	cl_must_fail(git_config_get_int32(&i, cfg, "core.verylong"));
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_int64(cfg, "core.verylong", 1));
	git_config_free(cfg);
}

void test_config_write__delete_value(void)
{
	git_config *cfg;
	int32_t i;

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 5));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
Ben Straub committed
66
	cl_git_pass(git_config_delete_entry(cfg, "core.dummy"));
67 68 69
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
70
	cl_assert(git_config_get_int32(&i, cfg, "core.dummy") == GIT_ENOTFOUND);
71 72 73 74
	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
	git_config_free(cfg);
}

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
/*
 * At the beginning of the test:
 *  - config9 has: core.dummy2=42
 *  - config15 has: core.dummy2=7
 */
void test_config_write__delete_value_at_specific_level(void)
{
	git_config *cfg, *cfg_specific;
	int32_t i;

	cl_git_pass(git_config_open_ondisk(&cfg, "config15"));
	cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2"));
	cl_assert(i == 7);
	git_config_free(cfg);

	cl_git_pass(git_config_new(&cfg));
	cl_git_pass(git_config_add_file_ondisk(cfg, "config9",
		GIT_CONFIG_LEVEL_LOCAL, 0));
	cl_git_pass(git_config_add_file_ondisk(cfg, "config15",
		GIT_CONFIG_LEVEL_GLOBAL, 0));

	cl_git_pass(git_config_open_level(&cfg_specific, cfg, GIT_CONFIG_LEVEL_GLOBAL));

Ben Straub committed
98
	cl_git_pass(git_config_delete_entry(cfg_specific, "core.dummy2"));
99 100 101 102 103 104 105 106 107 108
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config15"));
	cl_assert(git_config_get_int32(&i, cfg, "core.dummy2") == GIT_ENOTFOUND);
	cl_git_pass(git_config_set_int32(cfg, "core.dummy2", 7));

	git_config_free(cfg_specific);
	git_config_free(cfg);
}

109 110 111
void test_config_write__write_subsection(void)
{
	git_config *cfg;
112
	git_buf buf = GIT_BUF_INIT;
113 114 115 116 117 118

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_string(cfg, "my.own.var", "works"));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
119 120 121 122
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "my.own.var"));
	cl_assert_equal_s("works", git_buf_cstr(&buf));

	git_buf_free(&buf);
123 124 125
	git_config_free(cfg);
}

126 127 128 129 130
void test_config_write__delete_inexistent(void)
{
	git_config *cfg;

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
Ben Straub committed
131
	cl_assert(git_config_delete_entry(cfg, "core.imaginary") == GIT_ENOTFOUND);
132 133
	git_config_free(cfg);
}
134 135 136 137

void test_config_write__value_containing_quotes(void)
{
	git_config *cfg;
138
	git_buf buf = GIT_BUF_INIT;
139 140 141

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes"));
142 143 144
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this \"has\" quotes", git_buf_cstr(&buf));
	git_buf_clear(&buf);
145 146 147
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
148 149 150
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this \"has\" quotes", git_buf_cstr(&buf));
	git_buf_clear(&buf);
151
	git_config_free(cfg);
152 153 154 155

	/* The code path for values that already exist is different, check that one as well */
	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_string(cfg, "core.somevar", "this also \"has\" quotes"));
156 157 158
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this also \"has\" quotes", git_buf_cstr(&buf));
	git_buf_clear(&buf);
159 160 161
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
162 163 164
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this also \"has\" quotes", git_buf_cstr(&buf));
	git_buf_free(&buf);
165 166 167 168 169 170
	git_config_free(cfg);
}

void test_config_write__escape_value(void)
{
	git_config *cfg;
171
	git_buf buf = GIT_BUF_INIT;
172 173 174

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
	cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes and \t"));
175 176 177
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this \"has\" quotes and \t", git_buf_cstr(&buf));
	git_buf_clear(&buf);
178 179 180
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
181 182 183
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar"));
	cl_assert_equal_s("this \"has\" quotes and \t", git_buf_cstr(&buf));
	git_buf_free(&buf);
184
	git_config_free(cfg);
185
}
186

187 188 189 190 191
void test_config_write__add_value_at_specific_level(void)
{
	git_config *cfg, *cfg_specific;
	int i;
	int64_t l, expected = +9223372036854775803;
192
	git_buf buf = GIT_BUF_INIT;
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218

	// open config15 as global level config file
	cl_git_pass(git_config_new(&cfg));
	cl_git_pass(git_config_add_file_ondisk(cfg, "config9",
		GIT_CONFIG_LEVEL_LOCAL, 0));
	cl_git_pass(git_config_add_file_ondisk(cfg, "config15",
		GIT_CONFIG_LEVEL_GLOBAL, 0));

	cl_git_pass(git_config_open_level(&cfg_specific, cfg, GIT_CONFIG_LEVEL_GLOBAL));

	cl_git_pass(git_config_set_int32(cfg_specific, "core.int32global", 28));
	cl_git_pass(git_config_set_int64(cfg_specific, "core.int64global", expected));
	cl_git_pass(git_config_set_bool(cfg_specific, "core.boolglobal", true));
	cl_git_pass(git_config_set_string(cfg_specific, "core.stringglobal", "I'm a global config value!"));
	git_config_free(cfg_specific);
	git_config_free(cfg);

	// open config15 as local level config file
	cl_git_pass(git_config_open_ondisk(&cfg, "config15"));

	cl_git_pass(git_config_get_int32(&i, cfg, "core.int32global"));
	cl_assert_equal_i(28, i);
	cl_git_pass(git_config_get_int64(&l, cfg, "core.int64global"));
	cl_assert(l == expected);
	cl_git_pass(git_config_get_bool(&i, cfg, "core.boolglobal"));
	cl_assert_equal_b(true, i);
219 220
	cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.stringglobal"));
	cl_assert_equal_s("I'm a global config value!", git_buf_cstr(&buf));
221

222
	git_buf_free(&buf);
223 224 225 226
	git_config_free(cfg);
}

void test_config_write__add_value_at_file_with_no_clrf_at_the_end(void)
227 228 229 230 231 232 233 234 235 236 237 238 239 240
{
	git_config *cfg;
	int i;

	cl_git_pass(git_config_open_ondisk(&cfg, "config17"));
	cl_git_pass(git_config_set_int32(cfg, "core.newline", 7));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config17"));
	cl_git_pass(git_config_get_int32(&i, cfg, "core.newline"));
	cl_assert_equal_i(7, i);

	git_config_free(cfg);
}
241

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
void test_config_write__add_section_at_file_with_no_clrf_at_the_end(void)
{
	git_config *cfg;
	int i;

	cl_git_pass(git_config_open_ondisk(&cfg, "config17"));
	cl_git_pass(git_config_set_int32(cfg, "diff.context", 10));
	git_config_free(cfg);

	cl_git_pass(git_config_open_ondisk(&cfg, "config17"));
	cl_git_pass(git_config_get_int32(&i, cfg, "diff.context"));
	cl_assert_equal_i(10, i);

	git_config_free(cfg);
}

258 259
void test_config_write__add_value_which_needs_quotes(void)
{
260
	git_config *cfg, *base;
261 262 263 264
	const char* str1;
	const char* str2;
	const char* str3;
	const char* str4;
265
	const char* str5;
266 267 268 269 270 271

	cl_git_pass(git_config_open_ondisk(&cfg, "config17"));
	cl_git_pass(git_config_set_string(cfg, "core.startwithspace", " Something"));
	cl_git_pass(git_config_set_string(cfg, "core.endwithspace", "Something "));
	cl_git_pass(git_config_set_string(cfg, "core.containscommentchar1", "some#thing"));
	cl_git_pass(git_config_set_string(cfg, "core.containscommentchar2", "some;thing"));
272
	cl_git_pass(git_config_set_string(cfg, "core.startwhithsapceandcontainsdoublequote", " some\"thing"));
273 274
	git_config_free(cfg);

275 276
	cl_git_pass(git_config_open_ondisk(&base, "config17"));
	cl_git_pass(git_config_snapshot(&cfg, base));
277 278 279 280 281 282 283 284
	cl_git_pass(git_config_get_string(&str1, cfg, "core.startwithspace"));
	cl_assert_equal_s(" Something", str1);
	cl_git_pass(git_config_get_string(&str2, cfg, "core.endwithspace"));
	cl_assert_equal_s("Something ", str2);
	cl_git_pass(git_config_get_string(&str3, cfg, "core.containscommentchar1"));
	cl_assert_equal_s("some#thing", str3);
	cl_git_pass(git_config_get_string(&str4, cfg, "core.containscommentchar2"));
	cl_assert_equal_s("some;thing", str4);
285 286
	cl_git_pass(git_config_get_string(&str5, cfg, "core.startwhithsapceandcontainsdoublequote"));
	cl_assert_equal_s(" some\"thing", str5);
287
	git_config_free(cfg);
288
	git_config_free(base);
289 290
}

291 292 293 294 295 296 297 298 299 300 301 302 303
void test_config_write__can_set_a_value_to_NULL(void)
{
    git_repository *repository;
    git_config *config;

    repository = cl_git_sandbox_init("testrepo.git");

    cl_git_pass(git_repository_config(&config, repository));
    cl_git_fail(git_config_set_string(config, "a.b.c", NULL));
    git_config_free(config);

    cl_git_sandbox_cleanup();
}
304 305 306 307 308

void test_config_write__can_set_an_empty_value(void)
{
	git_repository *repository;
	git_config *config;
309
	git_buf buf = {0};
310 311 312 313 314

	repository = cl_git_sandbox_init("testrepo.git");
	cl_git_pass(git_repository_config(&config, repository));

	cl_git_pass(git_config_set_string(config, "core.somevar", ""));
315 316
	cl_git_pass(git_config_get_string_buf(&buf, config, "core.somevar"));
	cl_assert_equal_s("", buf.ptr);
317

318
	git_buf_free(&buf);
319 320 321
	git_config_free(config);
	cl_git_sandbox_cleanup();
}
322 323 324 325 326 327 328 329 330 331 332 333 334

void test_config_write__updating_a_locked_config_file_returns_ELOCKED(void)
{
	git_config *cfg;

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

	cl_git_mkfile("config9.lock", "[core]\n");

	cl_git_fail_with(git_config_set_string(cfg, "core.dump", "boom"), GIT_ELOCKED);

	git_config_free(cfg);
}
335

336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
void test_config_write__outside_change(void)
{
	int32_t tmp;
	git_config *cfg;
	const char *filename = "config-ext-change";

	cl_git_mkfile(filename, "[old]\nvalue = 5\n");

	cl_git_pass(git_config_open_ondisk(&cfg, filename));

	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));

	/* Change the value on the file itself (simulate external process) */
	cl_git_mkfile(filename, "[old]\nvalue = 6\n");

	cl_git_pass(git_config_set_int32(cfg, "new.value", 7));

	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
354
	cl_assert_equal_i(6, tmp);
355 356 357

	git_config_free(cfg);
}