repo.c 10.2 KB
Newer Older
1
#include "clar_libgit2.h"
2 3
#include "fileops.h"
#include "git2/attr.h"
4
#include "attr.h"
5

6 7
#include "attr_expect.h"

8 9 10 11
static git_repository *g_repo = NULL;

void test_attr_repo__initialize(void)
{
12
	g_repo = cl_git_sandbox_init("attr");
13 14 15 16
}

void test_attr_repo__cleanup(void)
{
17
	cl_git_sandbox_cleanup();
18 19 20
	g_repo = NULL;
}

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
static struct attr_expected get_one_test_cases[] = {
	{ "root_test1", "repoattr", EXPECT_TRUE, NULL },
	{ "root_test1", "rootattr", EXPECT_TRUE, NULL },
	{ "root_test1", "missingattr", EXPECT_UNDEFINED, NULL },
	{ "root_test1", "subattr", EXPECT_UNDEFINED, NULL },
	{ "root_test1", "negattr", EXPECT_UNDEFINED, NULL },
	{ "root_test2", "repoattr", EXPECT_TRUE, NULL },
	{ "root_test2", "rootattr", EXPECT_FALSE, NULL },
	{ "root_test2", "missingattr", EXPECT_UNDEFINED, NULL },
	{ "root_test2", "multiattr", EXPECT_FALSE, NULL },
	{ "root_test3", "repoattr", EXPECT_TRUE, NULL },
	{ "root_test3", "rootattr", EXPECT_UNDEFINED, NULL },
	{ "root_test3", "multiattr", EXPECT_STRING, "3" },
	{ "root_test3", "multi2", EXPECT_UNDEFINED, NULL },
	{ "sub/subdir_test1", "repoattr", EXPECT_TRUE, NULL },
	{ "sub/subdir_test1", "rootattr", EXPECT_TRUE, NULL },
	{ "sub/subdir_test1", "missingattr", EXPECT_UNDEFINED, NULL },
	{ "sub/subdir_test1", "subattr", EXPECT_STRING, "yes" },
	{ "sub/subdir_test1", "negattr", EXPECT_FALSE, NULL },
	{ "sub/subdir_test1", "another", EXPECT_UNDEFINED, NULL },
	{ "sub/subdir_test2.txt", "repoattr", EXPECT_TRUE, NULL },
	{ "sub/subdir_test2.txt", "rootattr", EXPECT_TRUE, NULL },
	{ "sub/subdir_test2.txt", "missingattr", EXPECT_UNDEFINED, NULL },
	{ "sub/subdir_test2.txt", "subattr", EXPECT_STRING, "yes" },
	{ "sub/subdir_test2.txt", "negattr", EXPECT_FALSE, NULL },
	{ "sub/subdir_test2.txt", "another", EXPECT_STRING, "zero" },
	{ "sub/subdir_test2.txt", "reposub", EXPECT_TRUE, NULL },
	{ "sub/sub/subdir.txt", "another", EXPECT_STRING, "one" },
	{ "sub/sub/subdir.txt", "reposubsub", EXPECT_TRUE, NULL },
	{ "sub/sub/subdir.txt", "reposub", EXPECT_UNDEFINED, NULL },
	{ "does-not-exist", "foo", EXPECT_STRING, "yes" },
	{ "sub/deep/file", "deepdeep", EXPECT_TRUE, NULL },
	{ "sub/sub/d/no", "test", EXPECT_STRING, "a/b/d/*" },
	{ "sub/sub/d/yes", "test", EXPECT_UNDEFINED, NULL },
};

57 58
void test_attr_repo__get_one(void)
{
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
	int i;

	for (i = 0; i < (int)ARRAY_SIZE(get_one_test_cases); ++i) {
		struct attr_expected *scan = &get_one_test_cases[i];
		const char *value;

		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
		attr_check_expected(
			scan->expected, scan->expected_str, scan->attr, value);
	}

	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes"));
	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes"));
	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes"));
}

void test_attr_repo__get_one_start_deep(void)
{
	int i;
81

82 83
	for (i = (int)ARRAY_SIZE(get_one_test_cases) - 1; i >= 0; --i) {
		struct attr_expected *scan = &get_one_test_cases[i];
84
		const char *value;
85

86
		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
87 88
		attr_check_expected(
			scan->expected, scan->expected_str, scan->attr, value);
89
	}
90

91 92 93 94 95 96
	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes"));
	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes"));
	cl_assert(git_attr_cache__is_cached(
		g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes"));
97 98 99 100 101 102 103
}

void test_attr_repo__get_many(void)
{
	const char *names[4] = { "repoattr", "rootattr", "missingattr", "subattr" };
	const char *values[4];

104
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test1", 4, names));
105

106 107 108 109
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_TRUE(values[1]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
110

111
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test2", 4, names));
112

113 114 115 116
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_FALSE(values[1]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
117

118
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "sub/subdir_test1", 4, names));
119

120 121 122
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_TRUE(values[1]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
123
	cl_assert_equal_s("yes", values[3]);
124 125
}

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
void test_attr_repo__get_many_in_place(void)
{
	const char *vals[4] = { "repoattr", "rootattr", "missingattr", "subattr" };

	/* it should be legal to look up values into the same array that has
	 * the attribute names, overwriting each name as the value is found.
	 */

	cl_git_pass(git_attr_get_many(vals, g_repo, 0, "sub/subdir_test1", 4, vals));

	cl_assert(GIT_ATTR_TRUE(vals[0]));
	cl_assert(GIT_ATTR_TRUE(vals[1]));
	cl_assert(GIT_ATTR_UNSPECIFIED(vals[2]));
	cl_assert_equal_s("yes", vals[3]);
}

142
static int count_attrs(
143 144
	const char *name,
	const char *value,
145 146
	void *payload)
{
147 148
	GIT_UNUSED(name);
	GIT_UNUSED(value);
149 150 151

	*((int *)payload) += 1;

152
	return 0;
153 154
}

155 156
#define CANCEL_VALUE 12345

157 158 159 160 161 162 163 164 165 166 167
static int cancel_iteration(
	const char *name,
	const char *value,
	void *payload)
{
	GIT_UNUSED(name);
	GIT_UNUSED(value);

	*((int *)payload) -= 1;

	if (*((int *)payload) < 0)
168
		return CANCEL_VALUE;
169 170 171 172

	return 0;
}

173 174 175 176 177
void test_attr_repo__foreach(void)
{
	int count;

	count = 0;
178 179
	cl_git_pass(git_attr_foreach(
		g_repo, 0, "root_test1", &count_attrs, &count));
180 181 182
	cl_assert(count == 2);

	count = 0;
183
	cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test1",
184 185 186 187
		&count_attrs, &count));
	cl_assert(count == 4); /* repoattr, rootattr, subattr, negattr */

	count = 0;
188
	cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test2.txt",
189
		&count_attrs, &count));
190
	cl_assert(count == 6); /* repoattr, rootattr, subattr, reposub, negattr, another */
191 192 193

	count = 2;
	cl_assert_equal_i(
194
		CANCEL_VALUE, git_attr_foreach(
195 196
			g_repo, 0, "sub/subdir_test1", &cancel_iteration, &count)
	);
197
}
198 199 200 201 202

void test_attr_repo__manpage_example(void)
{
	const char *value;

203
	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "foo"));
204
	cl_assert(GIT_ATTR_TRUE(value));
205

206
	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "bar"));
207
	cl_assert(GIT_ATTR_UNSPECIFIED(value));
208

209
	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "baz"));
210
	cl_assert(GIT_ATTR_FALSE(value));
211

212
	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "merge"));
213
	cl_assert_equal_s("filfre", value);
214

215
	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "frotz"));
216
	cl_assert(GIT_ATTR_UNSPECIFIED(value));
217 218 219 220 221 222
}

void test_attr_repo__macros(void)
{
	const char *names[5] = { "rootattr", "binary", "diff", "crlf", "frotz" };
	const char *names2[5] = { "mymacro", "positive", "negative", "rootattr", "another" };
223
	const char *names3[3] = { "macro2", "multi2", "multi3" };
224 225
	const char *values[5];

226
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "binfile", 5, names));
227

228 229 230 231 232
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_TRUE(values[1]));
	cl_assert(GIT_ATTR_FALSE(values[2]));
	cl_assert(GIT_ATTR_FALSE(values[3]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[4]));
233

234
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 5, names2));
235

236 237 238 239
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_TRUE(values[1]));
	cl_assert(GIT_ATTR_FALSE(values[2]));
	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
240
	cl_assert_equal_s("77", values[4]);
241

242
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 3, names3));
243

244 245
	cl_assert(GIT_ATTR_TRUE(values[0]));
	cl_assert(GIT_ATTR_FALSE(values[1]));
246
	cl_assert_equal_s("answer", values[2]);
247 248 249 250 251 252 253 254
}

void test_attr_repo__bad_macros(void)
{
	const char *names[6] = { "rootattr", "positive", "negative",
		"firstmacro", "secondmacro", "thirdmacro" };
	const char *values[6];

255
	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_bad", 6, names));
256 257

	/* these three just confirm that the "mymacro" rule ran */
258 259 260
	cl_assert(GIT_ATTR_UNSPECIFIED(values[0]));
	cl_assert(GIT_ATTR_TRUE(values[1]));
	cl_assert(GIT_ATTR_FALSE(values[2]));
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283

	/* file contains:
	 *     # let's try some malicious macro defs
	 *     [attr]firstmacro -thirdmacro -secondmacro
	 *     [attr]secondmacro firstmacro -firstmacro
	 *     [attr]thirdmacro secondmacro=hahaha -firstmacro
	 *     macro_bad firstmacro secondmacro thirdmacro
	 *
	 * firstmacro assignment list ends up with:
	 *     -thirdmacro -secondmacro
	 * secondmacro assignment list expands "firstmacro" and ends up with:
	 *     -thirdmacro -secondmacro -firstmacro
	 * thirdmacro assignment don't expand so list ends up with:
	 *     secondmacro="hahaha"
	 *
	 * macro_bad assignment list ends up with:
	 *     -thirdmacro -secondmacro firstmacro &&
	 *     -thirdmacro -secondmacro -firstmacro secondmacro &&
	 *     secondmacro="hahaha" thirdmacro
	 *
	 * so summary results should be:
	 *     -firstmacro secondmacro="hahaha" thirdmacro
	 */
284
	cl_assert(GIT_ATTR_FALSE(values[3]));
285
	cl_assert_equal_s("hahaha", values[4]);
286
	cl_assert(GIT_ATTR_TRUE(values[5]));
287
}
288

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
#define CONTENT "I'm going to be dynamically processed\r\n" \
	"And my line endings...\r\n" \
	"...are going to be\n" \
	"normalized!\r\n"

#define GITATTR "* text=auto\n" \
	"*.txt text\n" \
	"*.data binary\n"

static void add_to_workdir(const char *filename, const char *content)
{
	git_buf buf = GIT_BUF_INIT;

	cl_git_pass(git_buf_joinpath(&buf, "attr", filename));
	cl_git_rewritefile(git_buf_cstr(&buf), content);

	git_buf_free(&buf);
}

static void assert_proper_normalization(git_index *index, const char *filename, const char *expected_sha)
{
310
	size_t index_pos;
Ben Straub committed
311
	const git_index_entry *entry;
312 313

	add_to_workdir(filename, CONTENT);
314
	cl_git_pass(git_index_add_bypath(index, filename));
315

316
	cl_assert(!git_index_find(&index_pos, index, filename));
317

Edward Thomson committed
318
	entry = git_index_get_byindex(index, index_pos);
319
	cl_assert_equal_i(0, git_oid_streq(&entry->id, expected_sha));
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
}

void test_attr_repo__staging_properly_normalizes_line_endings_according_to_gitattributes_directives(void)
{
	git_index* index;

	cl_git_pass(git_repository_index(&index, g_repo));

	add_to_workdir(".gitattributes", GITATTR);

	assert_proper_normalization(index, "text.txt", "22c74203bace3c2e950278c7ab08da0fca9f4e9b");
	assert_proper_normalization(index, "huh.dunno", "22c74203bace3c2e950278c7ab08da0fca9f4e9b");
	assert_proper_normalization(index, "binary.data", "66eeff1fcbacf589e6d70aa70edd3fce5be2b37c");

	git_index_free(index);
}