init.c 17.5 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "fileops.h"
3
#include "repository.h"
4
#include "config.h"
5
#include "path.h"
6 7 8 9 10 11

enum repo_mode {
	STANDARD_REPOSITORY = 0,
	BARE_REPOSITORY = 1
};

12
static git_repository *_repo = NULL;
13
static mode_t g_umask = 0;
14 15 16 17

void test_repo_init__initialize(void)
{
	_repo = NULL;
18 19

	/* load umask if not already loaded */
20 21 22
	if (!g_umask) {
		g_umask = p_umask(022);
		(void)p_umask(g_umask);
23
	}
24 25 26 27 28
}

static void cleanup_repository(void *path)
{
	git_repository_free(_repo);
29 30
	_repo = NULL;

31 32 33 34 35 36 37 38 39 40 41
	cl_fixture_cleanup((const char *)path);
}

static void ensure_repository_init(
	const char *working_directory,
	int is_bare,
	const char *expected_path_repository,
	const char *expected_working_directory)
{
	const char *workdir;

42 43
	cl_assert(!git_path_isdir(working_directory));

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
	cl_git_pass(git_repository_init(&_repo, working_directory, is_bare));

	workdir = git_repository_workdir(_repo);
	if (workdir != NULL || expected_working_directory != NULL) {
		cl_assert(
			git__suffixcmp(workdir, expected_working_directory) == 0
		);
	}

	cl_assert(
		git__suffixcmp(git_repository_path(_repo), expected_path_repository) == 0
	);

	cl_assert(git_repository_is_bare(_repo) == is_bare);

#ifdef GIT_WIN32
	if (!is_bare) {
61 62
		DWORD fattrs = GetFileAttributes(git_repository_path(_repo));
		cl_assert((fattrs & FILE_ATTRIBUTE_HIDDEN) != 0);
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
	}
#endif

	cl_assert(git_repository_is_empty(_repo));
}

void test_repo_init__standard_repo(void)
{
	cl_set_cleanup(&cleanup_repository, "testrepo");
	ensure_repository_init("testrepo/", 0, "testrepo/.git/", "testrepo/");
}

void test_repo_init__standard_repo_noslash(void)
{
	cl_set_cleanup(&cleanup_repository, "testrepo");
	ensure_repository_init("testrepo", 0, "testrepo/.git/", "testrepo/");
}

void test_repo_init__bare_repo(void)
{
	cl_set_cleanup(&cleanup_repository, "testrepo.git");
	ensure_repository_init("testrepo.git/", 1, "testrepo.git/", NULL);
}

void test_repo_init__bare_repo_noslash(void)
{
	cl_set_cleanup(&cleanup_repository, "testrepo.git");
	ensure_repository_init("testrepo.git", 1, "testrepo.git/", NULL);
}

93 94
void test_repo_init__bare_repo_escaping_current_workdir(void)
{
95
	git_buf path_repository = GIT_BUF_INIT;
96
	git_buf path_current_workdir = GIT_BUF_INIT;
97

98
	cl_git_pass(git_path_prettify_dir(&path_current_workdir, ".", NULL));
99

100 101
	cl_git_pass(git_buf_joinpath(&path_repository, git_buf_cstr(&path_current_workdir), "a/b/c"));
	cl_git_pass(git_futils_mkdir_r(git_buf_cstr(&path_repository), NULL, GIT_DIR_MODE));
102

103 104
	/* Change the current working directory */
	cl_git_pass(chdir(git_buf_cstr(&path_repository)));
105

106 107 108
	/* Initialize a bare repo with a relative path escaping out of the current working directory */
	cl_git_pass(git_repository_init(&_repo, "../d/e.git", 1));
	cl_git_pass(git__suffixcmp(git_repository_path(_repo), "/a/b/d/e.git/"));
109

110
	git_repository_free(_repo);
111

112 113
	/* Open a bare repo with a relative path escaping out of the current working directory */
	cl_git_pass(git_repository_open(&_repo, "../d/e.git"));
114

115
	cl_git_pass(chdir(git_buf_cstr(&path_current_workdir)));
116

117 118
	git_buf_free(&path_current_workdir);
	git_buf_free(&path_repository);
119

120 121
	cleanup_repository("a");
}
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

void test_repo_init__reinit_bare_repo(void)
{
	cl_set_cleanup(&cleanup_repository, "reinit.git");

	/* Initialize the repository */
	cl_git_pass(git_repository_init(&_repo, "reinit.git", 1));
	git_repository_free(_repo);

	/* Reinitialize the repository */
	cl_git_pass(git_repository_init(&_repo, "reinit.git", 1));
}

void test_repo_init__reinit_too_recent_bare_repo(void)
{
	git_config *config;

	/* Initialize the repository */
	cl_git_pass(git_repository_init(&_repo, "reinit.git", 1));
	git_repository_config(&config, _repo);

	/*
	 * Hack the config of the repository to make it look like it has
	 * been created by a recenter version of git/libgit2
	 */
	cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 42));

	git_config_free(config);
	git_repository_free(_repo);

	/* Try to reinitialize the repository */
	cl_git_fail(git_repository_init(&_repo, "reinit.git", 1));

	cl_fixture_cleanup("reinit.git");
}
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180

void test_repo_init__additional_templates(void)
{
	git_buf path = GIT_BUF_INIT;

	cl_set_cleanup(&cleanup_repository, "tester");

	ensure_repository_init("tester", 0, "tester/.git/", "tester/");

	cl_git_pass(
		git_buf_joinpath(&path, git_repository_path(_repo), "description"));
	cl_assert(git_path_isfile(git_buf_cstr(&path)));

	cl_git_pass(
		git_buf_joinpath(&path, git_repository_path(_repo), "info/exclude"));
	cl_assert(git_path_isfile(git_buf_cstr(&path)));

	cl_git_pass(
		git_buf_joinpath(&path, git_repository_path(_repo), "hooks"));
	cl_assert(git_path_isdir(git_buf_cstr(&path)));
	/* won't confirm specific contents of hooks dir since it may vary */

	git_buf_free(&path);
}
181

182 183
static void assert_config_entry_on_init_bytype(
	const char *config_key, int expected_value, bool is_bare)
184 185
{
	git_config *config;
186 187 188
	int error, current_value;
	const char *repo_path = is_bare ?
		"config_entry/test.bare.git" : "config_entry/test.non.bare.git";
189

190
	cl_set_cleanup(&cleanup_repository, "config_entry");
191

192
	cl_git_pass(git_repository_init(&_repo, repo_path, is_bare));
193

194 195 196
	cl_git_pass(git_repository_config(&config, _repo));
	error = git_config_get_bool(&current_value, config, config_key);
	git_config_free(config);
197

198
	if (expected_value >= 0) {
199
		cl_assert_equal_i(0, error);
200 201 202 203 204
		cl_assert_equal_i(expected_value, current_value);
	} else {
		cl_assert_equal_i(expected_value, error);
	}
}
205

206 207
static void assert_config_entry_on_init(
	const char *config_key, int expected_value)
208 209 210 211 212 213 214
{
	assert_config_entry_on_init_bytype(config_key, expected_value, true);
	git_repository_free(_repo);

	assert_config_entry_on_init_bytype(config_key, expected_value, false);
}

215 216
void test_repo_init__detect_filemode(void)
{
217
	assert_config_entry_on_init("core.filemode", cl_is_chmod_supported());
218
}
219 220 221

void test_repo_init__detect_ignorecase(void)
{
222 223 224 225 226 227 228 229 230
	struct stat st;
	bool found_without_match;

	cl_git_write2file("testCAPS", "whatever\n", 0, O_CREAT | O_WRONLY, 0666);
	found_without_match = (p_stat("Testcaps", &st) == 0);
	cl_must_pass(p_unlink("testCAPS"));

	assert_config_entry_on_init(
		"core.ignorecase", found_without_match ? true : GIT_ENOTFOUND);
231 232
}

233 234
void test_repo_init__detect_precompose_unicode_required(void)
{
235
#ifdef GIT_USE_ICONV
236 237 238 239 240 241 242 243 244
	char *composed = "ḱṷṓn", *decomposed = "ḱṷṓn";
	struct stat st;
	bool found_with_nfd;

	cl_git_write2file(composed, "whatever\n", 0, O_CREAT | O_WRONLY, 0666);
	found_with_nfd = (p_stat(decomposed, &st) == 0);
	cl_must_pass(p_unlink(composed));

	assert_config_entry_on_init("core.precomposeunicode", found_with_nfd);
245 246 247 248 249
#else
	assert_config_entry_on_init("core.precomposeunicode", GIT_ENOTFOUND);
#endif
}

250 251 252 253 254 255
void test_repo_init__reinit_doesnot_overwrite_ignorecase(void)
{
	git_config *config;
	int current_value;

	/* Init a new repo */
256
	cl_set_cleanup(&cleanup_repository, "not.overwrite.git");
257
	cl_git_pass(git_repository_init(&_repo, "not.overwrite.git", 1));
258 259 260 261 262 263

	/* Change the "core.ignorecase" config value to something unlikely */
	git_repository_config(&config, _repo);
	git_config_set_int32(config, "core.ignorecase", 42);
	git_config_free(config);
	git_repository_free(_repo);
264
	_repo = NULL;
265 266

	/* Reinit the repository */
267
	cl_git_pass(git_repository_init(&_repo, "not.overwrite.git", 1));
268 269 270 271 272
	git_repository_config(&config, _repo);

	/* Ensure the "core.ignorecase" config value hasn't been updated */
	cl_git_pass(git_config_get_int32(&current_value, config, "core.ignorecase"));
	cl_assert_equal_i(42, current_value);
273 274 275

	git_config_free(config);
}
276

277 278
void test_repo_init__reinit_overwrites_filemode(void)
{
279
	int expected = cl_is_chmod_supported(), current_value;
280

281 282 283
	/* Init a new repo */
	cl_set_cleanup(&cleanup_repository, "overwrite.git");
	cl_git_pass(git_repository_init(&_repo, "overwrite.git", 1));
284

285
	/* Change the "core.filemode" config value to something unlikely */
286 287
	cl_repo_set_bool(_repo, "core.filemode", !expected);

288 289
	git_repository_free(_repo);
	_repo = NULL;
290

291 292
	/* Reinit the repository */
	cl_git_pass(git_repository_init(&_repo, "overwrite.git", 1));
293

294
	/* Ensure the "core.filemode" config value has been reset */
295
	current_value = cl_repo_get_bool(_repo, "core.filemode");
296
	cl_assert_equal_i(expected, current_value);
297 298
}

299 300 301
void test_repo_init__sets_logAllRefUpdates_according_to_type_of_repository(void)
{
	assert_config_entry_on_init_bytype("core.logallrefupdates", GIT_ENOTFOUND, true);
302
	git_repository_free(_repo);
303 304
	assert_config_entry_on_init_bytype("core.logallrefupdates", true, false);
}
305 306 307

void test_repo_init__extended_0(void)
{
308
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329

	/* without MKDIR this should fail */
	cl_git_fail(git_repository_init_ext(&_repo, "extended", &opts));

	/* make the directory first, then it should succeed */
	cl_git_pass(git_futils_mkdir("extended", NULL, 0775, 0));
	cl_git_pass(git_repository_init_ext(&_repo, "extended", &opts));

	cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/extended/"));
	cl_assert(!git__suffixcmp(git_repository_path(_repo), "/extended/.git/"));
	cl_assert(!git_repository_is_bare(_repo));
	cl_assert(git_repository_is_empty(_repo));

	cleanup_repository("extended");
}

void test_repo_init__extended_1(void)
{
	git_reference *ref;
	git_remote *remote;
	struct stat st;
330
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350

	opts.flags = GIT_REPOSITORY_INIT_MKPATH |
		GIT_REPOSITORY_INIT_NO_DOTGIT_DIR;
	opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP;
	opts.workdir_path = "../c_wd";
	opts.description = "Awesomest test repository evah";
	opts.initial_head = "development";
	opts.origin_url = "https://github.com/libgit2/libgit2.git";

	cl_git_pass(git_repository_init_ext(&_repo, "root/b/c.git", &opts));

	cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/c_wd/"));
	cl_assert(!git__suffixcmp(git_repository_path(_repo), "/c.git/"));
	cl_assert(git_path_isfile("root/b/c_wd/.git"));
	cl_assert(!git_repository_is_bare(_repo));
	/* repo will not be counted as empty because we set head to "development" */
	cl_assert(!git_repository_is_empty(_repo));

	cl_git_pass(git_path_lstat(git_repository_path(_repo), &st));
	cl_assert(S_ISDIR(st.st_mode));
351
	if (cl_is_chmod_supported())
352 353 354
		cl_assert((S_ISGID & st.st_mode) == S_ISGID);
	else
		cl_assert((S_ISGID & st.st_mode) == 0);
355 356 357

	cl_git_pass(git_reference_lookup(&ref, _repo, "HEAD"));
	cl_assert(git_reference_type(ref) == GIT_REF_SYMBOLIC);
358
	cl_assert_equal_s("refs/heads/development", git_reference_symbolic_target(ref));
359 360 361 362 363 364 365 366 367 368 369
	git_reference_free(ref);

	cl_git_pass(git_remote_load(&remote, _repo, "origin"));
	cl_assert_equal_s("origin", git_remote_name(remote));
	cl_assert_equal_s(opts.origin_url, git_remote_url(remote));
	git_remote_free(remote);

	git_repository_free(_repo);
	cl_fixture_cleanup("root");
}

Russell Belfer committed
370 371
#define CLEAR_FOR_CORE_FILEMODE(M) ((M) &= ~0177)

372 373 374 375
static void assert_hooks_match(
	const char *template_dir,
	const char *repo_dir,
	const char *hook_path,
376
	bool core_filemode)
377
{
378 379
	git_buf expected = GIT_BUF_INIT;
	git_buf actual = GIT_BUF_INIT;
380 381 382 383 384 385 386 387
	struct stat expected_st, st;

	cl_git_pass(git_buf_joinpath(&expected, template_dir, hook_path));
	cl_git_pass(git_path_lstat(expected.ptr, &expected_st));

	cl_git_pass(git_buf_joinpath(&actual, repo_dir, hook_path));
	cl_git_pass(git_path_lstat(actual.ptr, &st));

388
	cl_assert(expected_st.st_size == st.st_size);
389

Russell Belfer committed
390 391 392 393
	if (GIT_MODE_TYPE(expected_st.st_mode) != GIT_FILEMODE_LINK) {
		mode_t expected_mode =
			GIT_MODE_TYPE(expected_st.st_mode) |
			(GIT_PERMS_FOR_WRITE(expected_st.st_mode) & ~g_umask);
394

Russell Belfer committed
395 396 397 398
		if (!core_filemode) {
			CLEAR_FOR_CORE_FILEMODE(expected_mode);
			CLEAR_FOR_CORE_FILEMODE(st.st_mode);
		}
399

Russell Belfer committed
400 401
		cl_assert_equal_i_fmt(expected_mode, st.st_mode, "%07o");
	}
402

403 404 405 406
	git_buf_free(&expected);
	git_buf_free(&actual);
}

407 408 409
static void assert_mode_seems_okay(
	const char *base, const char *path,
	git_filemode_t expect_mode, bool expect_setgid, bool core_filemode)
410 411 412 413 414 415 416 417
{
	git_buf full = GIT_BUF_INIT;
	struct stat st;

	cl_git_pass(git_buf_joinpath(&full, base, path));
	cl_git_pass(git_path_lstat(full.ptr, &st));
	git_buf_free(&full);

418
	if (!core_filemode) {
Russell Belfer committed
419 420
		CLEAR_FOR_CORE_FILEMODE(expect_mode);
		CLEAR_FOR_CORE_FILEMODE(st.st_mode);
421 422 423
		expect_setgid = false;
	}

424 425
	if (S_ISGID != 0)
		cl_assert_equal_b(expect_setgid, (st.st_mode & S_ISGID) != 0);
426

Russell Belfer committed
427
	cl_assert_equal_b(
428
		GIT_PERMS_IS_EXEC(expect_mode), GIT_PERMS_IS_EXEC(st.st_mode));
429

Russell Belfer committed
430 431
	cl_assert_equal_i_fmt(
		GIT_MODE_TYPE(expect_mode), GIT_MODE_TYPE(st.st_mode), "%07o");
432 433 434 435 436 437
}

void test_repo_init__extended_with_template(void)
{
	git_buf expected = GIT_BUF_INIT;
	git_buf actual = GIT_BUF_INIT;
438
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
439
	int filemode;
440

441 442 443 444
	cl_set_cleanup(&cleanup_repository, "templated.git");

	opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE |
		GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE;
445 446 447 448 449
	opts.template_path = cl_fixture("template");

	cl_git_pass(git_repository_init_ext(&_repo, "templated.git", &opts));

	cl_assert(git_repository_is_bare(_repo));
450

451 452
	cl_assert(!git__suffixcmp(git_repository_path(_repo), "/templated.git/"));

453 454 455 456 457 458
	cl_git_pass(git_futils_readbuffer(
		&expected, cl_fixture("template/description")));
	cl_git_pass(git_futils_readbuffer(
		&actual, "templated.git/description"));

	cl_assert_equal_s(expected.ptr, actual.ptr);
459

460 461 462
	git_buf_free(&expected);
	git_buf_free(&actual);

463 464
	filemode = cl_repo_get_bool(_repo, "core.filemode");

465 466
	assert_hooks_match(
		cl_fixture("template"), git_repository_path(_repo),
467
		"hooks/update.sample", filemode);
468 469 470

	assert_hooks_match(
		cl_fixture("template"), git_repository_path(_repo),
471
		"hooks/link.sample", filemode);
472 473 474 475 476 477 478
}

void test_repo_init__extended_with_template_and_shared_mode(void)
{
	git_buf expected = GIT_BUF_INIT;
	git_buf actual = GIT_BUF_INIT;
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
479
	int filemode = true;
480
	const char *repo_path = NULL;
481 482 483 484 485 486 487 488 489 490 491 492 493

	cl_set_cleanup(&cleanup_repository, "init_shared_from_tpl");

	opts.flags = GIT_REPOSITORY_INIT_MKPATH |
		GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE;
	opts.template_path = cl_fixture("template");
	opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP;

	cl_git_pass(git_repository_init_ext(&_repo, "init_shared_from_tpl", &opts));

	cl_assert(!git_repository_is_bare(_repo));
	cl_assert(!git__suffixcmp(git_repository_path(_repo), "/init_shared_from_tpl/.git/"));

494
	filemode = cl_repo_get_bool(_repo, "core.filemode");
495

496 497 498 499 500 501
	cl_git_pass(git_futils_readbuffer(
		&expected, cl_fixture("template/description")));
	cl_git_pass(git_futils_readbuffer(
		&actual, "init_shared_from_tpl/.git/description"));

	cl_assert_equal_s(expected.ptr, actual.ptr);
502 503 504 505

	git_buf_free(&expected);
	git_buf_free(&actual);

506 507 508 509 510 511 512
	repo_path = git_repository_path(_repo);
	assert_mode_seems_okay(repo_path, "hooks",
		GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode);
	assert_mode_seems_okay(repo_path, "info",
		GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode);
	assert_mode_seems_okay(repo_path, "description",
		GIT_FILEMODE_BLOB, false, filemode);
513 514 515 516

	/* for a non-symlinked hook, it should have shared permissions now */
	assert_hooks_match(
		cl_fixture("template"), git_repository_path(_repo),
517
		"hooks/update.sample", filemode);
518 519 520 521 522 523

	/* for a symlinked hook, the permissions still should match the
	 * source link, not the GIT_REPOSITORY_INIT_SHARED_GROUP value
	 */
	assert_hooks_match(
		cl_fixture("template"), git_repository_path(_repo),
524
		"hooks/link.sample", filemode);
525
}
526 527 528 529 530

void test_repo_init__can_reinit_an_initialized_repository(void)
{
	git_repository *reinit;

531 532
	cl_set_cleanup(&cleanup_repository, "extended");

533 534 535 536 537 538 539 540 541
	cl_git_pass(git_futils_mkdir("extended", NULL, 0775, 0));
	cl_git_pass(git_repository_init(&_repo, "extended", false));

	cl_git_pass(git_repository_init(&reinit, "extended", false));

	cl_assert_equal_s(git_repository_path(_repo), git_repository_path(reinit));

	git_repository_free(reinit);
}
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570

void test_repo_init__init_with_initial_commit(void)
{
	git_index *index;

	cl_set_cleanup(&cleanup_repository, "committed");

	/* Initialize the repository */
	cl_git_pass(git_repository_init(&_repo, "committed", 0));

	/* Init will be automatically created when requested for a new repo */
	cl_git_pass(git_repository_index(&index, _repo));

	/* Create a file so we can commit it
	 *
	 * If you are writing code outside the test suite, you can create this
	 * file any way that you like, such as:
	 *      FILE *fp = fopen("committed/file.txt", "w");
	 *      fputs("some stuff\n", fp);
	 *      fclose(fp);
	 * We like to use the help functions because they do error detection
	 * in a way that's easily compatible with our test suite.
	 */
	cl_git_mkfile("committed/file.txt", "some stuff\n");

	/* Add file to the index */
	cl_git_pass(git_index_add_bypath(index, "file.txt"));
	cl_git_pass(git_index_write(index));

571 572 573 574 575
	/* Intentionally not using cl_repo_commit_from_index here so this code
	 * can be used as an example of how an initial commit is typically
	 * made to a repository...
	 */

576 577 578 579 580 581 582 583 584 585 586
	/* Make sure we're ready to use git_signature_default :-) */
	{
		git_config *cfg, *local;
		cl_git_pass(git_repository_config(&cfg, _repo));
		cl_git_pass(git_config_open_level(&local, cfg, GIT_CONFIG_LEVEL_LOCAL));
		cl_git_pass(git_config_set_string(local, "user.name", "Test User"));
		cl_git_pass(git_config_set_string(local, "user.email", "t@example.com"));
		git_config_free(local);
		git_config_free(cfg);
	}

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
	/* Create a commit with the new contents of the index */
	{
		git_signature *sig;
		git_oid tree_id, commit_id;
		git_tree *tree;

		cl_git_pass(git_signature_default(&sig, _repo));
		cl_git_pass(git_index_write_tree(&tree_id, index));
		cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id));

		cl_git_pass(git_commit_create_v(
			&commit_id, _repo, "HEAD", sig, sig,
			NULL, "First", tree, 0));

		git_tree_free(tree);
		git_signature_free(sig);
	}

	git_index_free(index);
}