#!/usr/bin/env vpython3 # Copyright (c) 2020 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Smoke tests for gclient.py. Shell out 'gclient' and run git tests. """ import json import logging import os import sys import unittest import gclient_smoketest_base ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, ROOT_DIR) import subprocess2 from testing_support.fake_repos import join, write # TODO: Should fix these warnings. # pylint: disable=line-too-long class GClientSmokeGIT(gclient_smoketest_base.GClientSmokeBase): def setUp(self): super(GClientSmokeGIT, self).setUp() self.env['PATH'] = (os.path.join(ROOT_DIR, 'testing_support') + os.pathsep + self.env['PATH']) self.env['GCLIENT_SUPPRESS_GIT_VERSION_WARNING'] = '1' self.env['GCLIENT_SUPPRESS_SUBMODULE_WARNING'] = '1' self.enabled = self.FAKE_REPOS.set_up_git() if not self.enabled: self.skipTest('git fake repos not available') def testGitmodules_relative(self): self.gclient(['config', self.git_base + 'repo_19', '--name', 'dir'], cwd=self.git_base + 'repo_19') self.gclient(['sync'], cwd=self.git_base + 'repo_19') self.gclient(['gitmodules'], cwd=self.git_base + os.path.join('repo_19', 'dir')) gitmodules = os.path.join(self.git_base, 'repo_19', 'dir', '.gitmodules') with open(gitmodules) as f: contents = f.read().splitlines() self.assertEqual([ '[submodule "some_repo"]', '\tpath = some_repo', '\turl = /repo_2', '\tgclient-condition = not foo_checkout', '[submodule "chicken/dickens"]', '\tpath = chicken/dickens', '\turl = /repo_3' ], contents) def testGitmodules_not_relative(self): self.gclient(['config', self.git_base + 'repo_20', '--name', 'foo'], cwd=self.git_base + 'repo_20') self.gclient(['sync'], cwd=self.git_base + 'repo_20') self.gclient(['gitmodules'], cwd=self.git_base + os.path.join('repo_20', 'foo')) gitmodules = os.path.join(self.git_base, 'repo_20', 'foo', '.gitmodules') with open(gitmodules) as f: contents = f.read().splitlines() self.assertEqual([ '[submodule "some_repo"]', '\tpath = some_repo', '\turl = /repo_2', '\tgclient-condition = not foo_checkout', '[submodule "chicken/dickens"]', '\tpath = chicken/dickens', '\turl = /repo_3' ], contents) def testGitmodules_migration_no_git_suffix(self): self.gclient(['config', self.git_base + 'repo_21', '--name', 'foo'], cwd=self.git_base + 'repo_21') # We are not running gclient sync since dependencies don't exist self.gclient(['gitmodules'], cwd=self.git_base + 'repo_21') gitmodules = os.path.join(self.git_base, 'repo_21', '.gitmodules') with open(gitmodules) as f: contents = f.read().splitlines() self.assertEqual([ '[submodule "bar"]', '\tpath = bar', '\turl = https://example.googlesource.com/repo.git', ], contents) # force migration os.remove(gitmodules) self.gclient(['gitmodules'], cwd=self.git_base + 'repo_21') gitmodules = os.path.join(self.git_base, 'repo_21', '.gitmodules') with open(gitmodules) as f: contents = f.read().splitlines() self.assertEqual([ '[submodule "bar"]', '\tpath = bar', '\turl = https://example.googlesource.com/repo', ], contents) def testGitmodules_not_in_gclient(self): with self.assertRaisesRegex(AssertionError, 'from a gclient workspace'): self.gclient(['gitmodules'], cwd=self.root_dir) def testSync(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) # Test unversioned checkout. self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'], ['running', 'running', 'running']) # TODO(maruel): http://crosbug.com/3582 hooks run even if not matching, # must add sync parsing to get the list of updated files. tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) # Manually remove git_hooked1 before syncing to make sure it's not # recreated. os.remove(join(self.root_dir, 'src', 'git_hooked1')) # Test incremental versioned sync: sync backward. self.parseGclient([ 'sync', '--jobs', '1', '--revision', 'src@' + self.githash('repo_1', 1), '--deps', 'mac', '--delete_unversioned_trees' ], ['deleting']) tree = self.mangle_git_tree( ('repo_1@1', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@1', 'src/repo2/repo3'), ('repo_4@2', 'src/repo4')) tree['src/git_hooked2'] = 'git_hooked2' tree['src/repo2/gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'false_var = false', 'false_str_var = false', 'true_var = true', 'true_str_var = true', 'str_var = "abc"', 'cond_var = false', ]) self.assertTree(tree) # Test incremental sync: delete-unversioned_trees isn't there. self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'], ['running', 'running']) tree = self.mangle_git_tree( ('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@1', 'src/repo2/repo3'), ('repo_3@2', 'src/repo2/repo_renamed'), ('repo_4@2', 'src/repo4')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' tree['src/repo2/gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'false_var = false', 'false_str_var = false', 'true_var = true', 'true_str_var = true', 'str_var = "abc"', 'cond_var = false', ]) self.assertTree(tree) def testSyncJsonOutput(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) output_json = os.path.join(self.root_dir, 'output.json') self.gclient(['sync', '--deps', 'mac', '--output-json', output_json]) with open(output_json) as f: output_json = json.load(f) out = { 'solutions': { 'src/': { 'scm': 'git', 'url': self.git_base + 'repo_1', 'revision': self.githash('repo_1', 2), 'was_processed': True, 'was_synced': True, }, 'src/repo2/': { 'scm': 'git', 'url': self.git_base + 'repo_2@' + self.githash('repo_2', 1)[:7], 'revision': self.githash('repo_2', 1), 'was_processed': True, 'was_synced': True, }, 'src/repo2/repo_renamed/': { 'scm': 'git', 'url': self.git_base + 'repo_3', 'revision': self.githash('repo_3', 2), 'was_processed': True, 'was_synced': True, }, 'src/should_not_process/': { 'scm': None, 'url': self.git_base + 'repo_4', 'revision': None, 'was_processed': False, 'was_synced': True, }, }, } self.assertEqual(out, output_json) def testSyncIgnoredSolutionName(self): """TODO(maruel): This will become an error soon.""" self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.parseGclient( [ 'sync', '--deps', 'mac', '--jobs', '1', '--revision', 'invalid@' + self.githash('repo_1', 1) ], ['running', 'running', 'running'], 'Please fix your script, having invalid --revision flags ' 'will soon be considered an error.\n') tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) def testSyncNoSolutionName(self): # When no solution name is provided, gclient uses the first solution # listed. self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.parseGclient([ 'sync', '--deps', 'mac', '--jobs', '1', '--revision', self.githash('repo_1', 1) ], ['running']) tree = self.mangle_git_tree( ('repo_1@1', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@1', 'src/repo2/repo3'), ('repo_4@2', 'src/repo4')) tree['src/repo2/gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'false_var = false', 'false_str_var = false', 'true_var = true', 'true_str_var = true', 'str_var = "abc"', 'cond_var = false', ]) self.assertTree(tree) def testSyncJobs(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) # Test unversioned checkout. self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'], ['running', 'running', 'running'], untangle=True) # TODO(maruel): http://crosbug.com/3582 hooks run even if not matching, # must add sync parsing to get the list of updated files. tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) # Manually remove git_hooked1 before syncing to make sure it's not # recreated. os.remove(join(self.root_dir, 'src', 'git_hooked1')) # Test incremental versioned sync: sync backward. # Use --jobs 1 otherwise the order is not deterministic. self.parseGclient([ 'sync', '--revision', 'src@' + self.githash('repo_1', 1), '--deps', 'mac', '--delete_unversioned_trees', '--jobs', '1' ], ['deleting'], untangle=True) tree = self.mangle_git_tree( ('repo_1@1', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@1', 'src/repo2/repo3'), ('repo_4@2', 'src/repo4')) tree['src/git_hooked2'] = 'git_hooked2' tree['src/repo2/gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'false_var = false', 'false_str_var = false', 'true_var = true', 'true_str_var = true', 'str_var = "abc"', 'cond_var = false', ]) self.assertTree(tree) # Test incremental sync: delete-unversioned_trees isn't there. self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'], ['running', 'running'], untangle=True) tree = self.mangle_git_tree( ('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@1', 'src/repo2/repo3'), ('repo_3@2', 'src/repo2/repo_renamed'), ('repo_4@2', 'src/repo4')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' tree['src/repo2/gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'false_var = false', 'false_str_var = false', 'true_var = true', 'true_str_var = true', 'str_var = "abc"', 'cond_var = false', ]) self.assertTree(tree) def testSyncFetch(self): self.gclient(['config', self.git_base + 'repo_13', '--name', 'src']) self.gclient([ 'sync', '-v', '-v', '-v', '--revision', self.githash('repo_13', 2) ]) def testSyncFetchUpdate(self): self.gclient(['config', self.git_base + 'repo_13', '--name', 'src']) # Sync to an earlier revision first, one that doesn't refer to # non-standard refs. self.gclient([ 'sync', '-v', '-v', '-v', '--revision', self.githash('repo_13', 1) ]) # Make sure update that pulls a non-standard ref works. self.gclient([ 'sync', '-v', '-v', '-v', '--revision', self.githash('repo_13', 2) ]) def testSyncDirect(self): self.gclient(['config', self.git_base + 'repo_12', '--name', 'src']) self.gclient( ['sync', '-v', '-v', '-v', '--revision', 'refs/changes/1212']) def testSyncUnmanaged(self): self.gclient([ 'config', '--spec', 'solutions=[{"name":"src", "url": %r, "managed": False}]' % (self.git_base + 'repo_5') ]) self.gclient(['sync', '--revision', 'src@' + self.githash('repo_5', 2)]) self.gclient( ['sync', '--revision', 'src/repo1@%s' % self.githash('repo_1', 1)]) # src is unmanaged, so gclient shouldn't have updated it. It should've # stayed synced at @2 tree = self.mangle_git_tree(('repo_5@2', 'src'), ('repo_1@1', 'src/repo1'), ('repo_2@1', 'src/repo2')) tree['src/git_pre_deps_hooked'] = 'git_pre_deps_hooked' self.assertTree(tree) def testSyncUrl(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient([ 'sync', '-v', '-v', '-v', '--revision', 'src/repo2@%s' % self.githash('repo_2', 1), '--revision', '%srepo_2@%s' % (self.git_base, self.githash('repo_2', 2)) ]) # repo_2 should've been synced to @2 instead of @1, since URLs override # paths. tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) def testSyncPatchRef(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient([ 'sync', '-v', '-v', '-v', '--revision', 'src/repo2@%s' % self.githash('repo_2', 1), '--patch-ref', '%srepo_2@refs/heads/main:%s' % (self.git_base, self.githash('repo_2', 2)), ]) # Assert that repo_2 files coincide with revision @2 (the patch ref) tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) # Assert that HEAD revision of repo_2 is @1 (the base we synced to) # since we should have done a soft reset. self.assertEqual( self.githash('repo_2', 1), self.gitrevparse(os.path.join(self.root_dir, 'src/repo2'))) def testSyncPatchRefNoHooks(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient([ 'sync', '-v', '-v', '-v', '--revision', 'src/repo2@%s' % self.githash('repo_2', 1), '--patch-ref', '%srepo_2@refs/heads/main:%s' % (self.git_base, self.githash('repo_2', 2)), '--nohooks', ]) # Assert that repo_2 files coincide with revision @2 (the patch ref) tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@2', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) self.assertTree(tree) # Assert that HEAD revision of repo_2 is @1 (the base we synced to) # since we should have done a soft reset. self.assertEqual( self.githash('repo_2', 1), self.gitrevparse(os.path.join(self.root_dir, 'src/repo2'))) def testInstallHooks_no_existing_hook(self): repo = os.path.join(self.git_base, 'repo_18') self.gclient(['config', repo, '--name', 'src'], cwd=repo) self.gclient(['sync'], cwd=repo) self.gclient(['installhooks'], cwd=repo) hook = os.path.join(repo, 'src', '.git', 'hooks', 'pre-commit') with open(hook) as f: contents = f.read() self.assertIn('python3 "$GCLIENT_PRECOMMIT"', contents) # Later runs should only inform that the hook was already installed. stdout, _, _ = self.gclient(['installhooks'], cwd=repo) self.assertIn(f'{hook} already contains the gclient pre-commit hook.', stdout) def testInstallHooks_existing_hook(self): repo = os.path.join(self.git_base, 'repo_19') self.gclient(['config', repo, '--name', 'src'], cwd=repo) self.gclient(['sync'], cwd=repo) # Create an existing pre-commit hook. hook = os.path.join(repo, 'src', '.git', 'hooks', 'pre-commit') hook_contents = ['#!/bin/sh', 'echo hook'] with open(hook, 'w') as f: f.write('\n'.join(hook_contents)) stdout, _, _ = self.gclient(['installhooks'], cwd=repo) self.assertIn('Please append the following lines to the hook', stdout) # The orignal hook is left unchanged. with open(hook) as f: contents = f.read().splitlines() self.assertEqual(hook_contents, contents) def testRunHooks(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) os.remove(join(self.root_dir, 'src', 'git_hooked1')) os.remove(join(self.root_dir, 'src', 'git_hooked2')) # runhooks runs all hooks even if not matching by design. out = self.parseGclient(['runhooks', '--deps', 'mac'], ['running', 'running']) self.assertEqual(1, len(out[0])) self.assertEqual(1, len(out[1])) tree = self.mangle_git_tree(('repo_1@2', 'src'), ('repo_2@1', 'src/repo2'), ('repo_3@2', 'src/repo2/repo_renamed')) tree['src/git_hooked1'] = 'git_hooked1' tree['src/git_hooked2'] = 'git_hooked2' self.assertTree(tree) def testRunHooksCondition(self): self.gclient(['config', self.git_base + 'repo_7', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) tree = self.mangle_git_tree(('repo_7@1', 'src')) tree['src/should_run'] = 'should_run' self.assertTree(tree) def testPreDepsHooks(self): self.gclient(['config', self.git_base + 'repo_5', '--name', 'src']) expectation = [ ('running', self.root_dir), # git clone ('running', self.root_dir), # pre-deps hook ] out = self.parseGclient([ 'sync', '--deps', 'mac', '--jobs=1', '--revision', 'src@' + self.githash('repo_5', 2) ], expectation) self.assertEqual('Cloning into ', out[0][1][:13]) # parseGClient may produce hook slowness warning, so we expect either 2 # or 3 blocks. self.assertIn(len(out[1]), [2, 3], out[1]) self.assertEqual('pre-deps hook', out[1][1]) tree = self.mangle_git_tree(('repo_5@2', 'src'), ('repo_1@2', 'src/repo1'), ('repo_2@1', 'src/repo2')) tree['src/git_pre_deps_hooked'] = 'git_pre_deps_hooked' self.assertTree(tree) os.remove(join(self.root_dir, 'src', 'git_pre_deps_hooked')) # Pre-DEPS hooks don't run with runhooks. self.gclient(['runhooks', '--deps', 'mac']) tree = self.mangle_git_tree(('repo_5@2', 'src'), ('repo_1@2', 'src/repo1'), ('repo_2@1', 'src/repo2')) self.assertTree(tree) # Pre-DEPS hooks run when syncing with --nohooks. self.gclient([ 'sync', '--deps', 'mac', '--nohooks', '--revision', 'src@' + self.githash('repo_5', 2) ]) tree = self.mangle_git_tree(('repo_5@2', 'src'), ('repo_1@2', 'src/repo1'), ('repo_2@1', 'src/repo2')) tree['src/git_pre_deps_hooked'] = 'git_pre_deps_hooked' self.assertTree(tree) os.remove(join(self.root_dir, 'src', 'git_pre_deps_hooked')) # Pre-DEPS hooks don't run with --noprehooks self.gclient([ 'sync', '--deps', 'mac', '--noprehooks', '--revision', 'src@' + self.githash('repo_5', 2) ]) tree = self.mangle_git_tree(('repo_5@2', 'src'), ('repo_1@2', 'src/repo1'), ('repo_2@1', 'src/repo2')) self.assertTree(tree) def testPreDepsHooksError(self): self.gclient(['config', self.git_base + 'repo_5', '--name', 'src']) expectated_stdout = [ ('running', self.root_dir), # git clone ('running', self.root_dir), # pre-deps hook ('running', self.root_dir), # pre-deps hook (fails) ] expected_stderr = ( "Error: Command 'python3 -c import sys; " "sys.exit(1)' returned non-zero exit status 1 in %s\n" % (self.root_dir)) stdout, stderr, retcode = self.gclient([ 'sync', '--deps', 'mac', '--jobs=1', '--revision', 'src@' + self.githash('repo_5', 3) ], error_ok=True) self.assertEqual(stderr, expected_stderr) self.assertEqual(2, retcode) self.checkBlock(stdout, expectated_stdout) def testRevInfo(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) results = self.gclient(['revinfo', '--deps', 'mac']) out = ('src: %(base)srepo_1\n' 'src/repo2: %(base)srepo_2@%(hash2)s\n' 'src/repo2/repo_renamed: %(base)srepo_3\n' % { 'base': self.git_base, 'hash2': self.githash('repo_2', 1)[:7], }) self.check((out, '', 0), results) def testRevInfoActual(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) results = self.gclient(['revinfo', '--deps', 'mac', '--actual']) out = ('src: %(base)srepo_1@%(hash1)s\n' 'src/repo2: %(base)srepo_2@%(hash2)s\n' 'src/repo2/repo_renamed: %(base)srepo_3@%(hash3)s\n' % { 'base': self.git_base, 'hash1': self.githash('repo_1', 2), 'hash2': self.githash('repo_2', 1), 'hash3': self.githash('repo_3', 2), }) self.check((out, '', 0), results) def testRevInfoFilterPath(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) results = self.gclient(['revinfo', '--deps', 'mac', '--filter', 'src']) out = ('src: %(base)srepo_1\n' % { 'base': self.git_base, }) self.check((out, '', 0), results) def testRevInfoFilterURL(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) results = self.gclient([ 'revinfo', '--deps', 'mac', '--filter', '%srepo_2' % self.git_base ]) out = ('src/repo2: %(base)srepo_2@%(hash2)s\n' % { 'base': self.git_base, 'hash2': self.githash('repo_2', 1)[:7], }) self.check((out, '', 0), results) def testRevInfoFilterURLOrPath(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) results = self.gclient([ 'revinfo', '--deps', 'mac', '--filter', 'src', '--filter', '%srepo_2' % self.git_base ]) out = ('src: %(base)srepo_1\n' 'src/repo2: %(base)srepo_2@%(hash2)s\n' % { 'base': self.git_base, 'hash2': self.githash('repo_2', 1)[:7], }) self.check((out, '', 0), results) def testRevInfoJsonOutput(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) output_json = os.path.join(self.root_dir, 'output.json') self.gclient(['revinfo', '--deps', 'mac', '--output-json', output_json]) with open(output_json) as f: output_json = json.load(f) out = { 'src': { 'url': self.git_base + 'repo_1', 'rev': None, }, 'src/repo2': { 'url': self.git_base + 'repo_2', 'rev': self.githash('repo_2', 1)[:7], }, 'src/repo2/repo_renamed': { 'url': self.git_base + 'repo_3', 'rev': None, }, } self.assertEqual(out, output_json) def testRevInfoJsonOutputSnapshot(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) self.gclient(['sync', '--deps', 'mac']) output_json = os.path.join(self.root_dir, 'output.json') self.gclient([ 'revinfo', '--deps', 'mac', '--snapshot', '--output-json', output_json ]) with open(output_json) as f: output_json = json.load(f) out = [{ 'solution_url': self.git_base + 'repo_1', 'managed': True, 'name': 'src', 'deps_file': 'DEPS', 'custom_deps': { 'src/repo2': '%srepo_2@%s' % (self.git_base, self.githash('repo_2', 1)), 'src/repo2/repo_renamed': '%srepo_3@%s' % (self.git_base, self.githash('repo_3', 2)), 'src/should_not_process': None, }, }] self.assertEqual(out, output_json) def testSetDep(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) fake_deps = os.path.join(self.git_base, 'repo_1', 'DEPS') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@bar_rev",', '}', ])) self.gclient([ 'setdep', '-r', 'foo@new_foo', '-r', 'bar@new_bar', '--var', 'foo_var=new_val', '--deps-file', fake_deps ], cwd=self.git_base + 'repo_1') with open(fake_deps) as f: contents = f.read().splitlines() self.assertEqual([ 'vars = { ', ' "foo_var": "new_val",', ' "foo_rev": "new_foo",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@new_bar",', '}', ], contents) def testSetDep_Submodules(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) with open(os.path.join(self.git_base, '.gclient'), 'w') as f: f.write('') fake_deps = os.path.join(self.git_base, 'repo_1', 'DEPS') gitmodules = os.path.join(self.git_base, 'repo_1', '.gitmodules') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'git_dependencies = "SYNC"', 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', 'deps = { ', ' "repo_1/foo": "https://foo" + Var("foo_rev"),', ' "repo_1/bar": "https://bar@barrev",', '}', ])) with open(gitmodules, 'w') as f: f.write('\n'.join([ '[submodule "foo"]', ' url = https://foo', ' path = foo', '[submodule "bar"]', ' url = https://bar', ' path = bar' ])) subprocess2.call([ 'git', 'update-index', '--add', '--cacheinfo', '160000,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,foo' ], cwd=self.git_base + 'repo_1') subprocess2.call([ 'git', 'update-index', '--add', '--cacheinfo', '160000,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,bar' ], cwd=self.git_base + 'repo_1') self.gclient([ 'setdep', '-r', 'repo_1/foo@new_foo', '--var', 'foo_var=new_val', '-r', 'repo_1/bar@bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', ], cwd=self.git_base + 'repo_1') with open(fake_deps) as f: contents = f.read().splitlines() self.assertEqual([ 'git_dependencies = "SYNC"', 'vars = { ', ' "foo_var": "new_val",', ' "foo_rev": "new_foo",', '}', 'deps = { ', ' "repo_1/foo": "https://foo" + Var("foo_rev"),', ' "repo_1/bar": ' '"https://bar@bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",', '}', ], contents) def testSetDep_Submodules_relative(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) fake_deps = os.path.join(self.git_base, 'repo_1', 'DEPS') gitmodules = os.path.join(self.git_base, 'repo_1', '.gitmodules') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'git_dependencies = "SUBMODULES"', 'use_relative_paths = True', 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', ])) with open(gitmodules, 'w') as f: f.write('\n'.join( ['[submodule "foo"]', ' url = https://foo', ' path = foo'])) subprocess2.call([ 'git', 'update-index', '--add', '--cacheinfo', '160000,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,foo' ], cwd=self.git_base + 'repo_1') self.gclient([ 'setdep', '-r', 'foo@new_foo', '--var', 'foo_var=new_val', '--deps-file', fake_deps ], cwd=self.git_base + 'repo_1') with open(fake_deps) as f: contents = f.read().splitlines() self.assertEqual([ 'git_dependencies = "SUBMODULES"', 'use_relative_paths = True', 'vars = { ', ' "foo_var": "new_val",', ' "foo_rev": "foo_rev",', '}', ], contents) def testSetDep_BuiltinVariables(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'], cwd=self.git_base) fake_deps = os.path.join(self.root_dir, 'DEPS') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@bar_rev",', '}', 'hooks = [{', ' "name": "uses_builtin_var",', ' "pattern": ".",', ' "action": ["python3", "fake.py",', ' "--with-android={checkout_android}"],', '}]', ])) self.gclient([ 'setdep', '-r', 'foo@new_foo', '-r', 'bar@new_bar', '--var', 'foo_var=new_val', '--deps-file', fake_deps ], cwd=self.git_base + 'repo_1') with open(fake_deps) as f: contents = f.read().splitlines() self.assertEqual([ 'vars = { ', ' "foo_var": "new_val",', ' "foo_rev": "new_foo",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@new_bar",', '}', 'hooks = [{', ' "name": "uses_builtin_var",', ' "pattern": ".",', ' "action": ["python3", "fake.py",', ' "--with-android={checkout_android}"],', '}]', ], contents) def testGetDep(self): fake_deps = os.path.join(self.root_dir, 'DEPS.fake') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@bar_rev",', '}', ])) results = self.gclient([ 'getdep', '-r', 'foo', '-r', 'bar', '--var', 'foo_var', '--deps-file', fake_deps ]) self.assertEqual([ 'foo_val', 'foo_rev', 'bar_rev', ], results[0].splitlines()) def testGetDep_Submodule(self): self.gclient(['config', self.git_base + 'repo_20', '--name', 'src']) subprocess2.call([ 'git', 'update-index', '--add', '--cacheinfo', '160000,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,bar' ], cwd=self.git_base + 'repo_20') results = self.gclient([ 'getdep', '-r', 'foo/bar:lemur', '-r', 'bar', '--var', 'foo_checkout' ], cwd=self.git_base + 'repo_20') self.assertEqual([ 'True', 'version:1234', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' ], results[0].splitlines()) def testGetDep_BuiltinVariables(self): self.gclient(['config', self.git_base + 'repo_1', '--name', 'src']) fake_deps = os.path.join(self.root_dir, 'DEPS.fake') with open(fake_deps, 'w') as f: f.write('\n'.join([ 'vars = { ', ' "foo_var": "foo_val",', ' "foo_rev": "foo_rev",', '}', 'deps = {', ' "foo": {', ' "url": "url@{foo_rev}",', ' },', ' "bar": "url@bar_rev",', '}', 'hooks = [{', ' "name": "uses_builtin_var",', ' "pattern": ".",', ' "action": ["python3", "fake.py",', ' "--with-android={checkout_android}"],', '}]', ])) results = self.gclient([ 'getdep', '-r', 'foo', '-r', 'bar', '--var', 'foo_var', '--deps-file', fake_deps ]) self.assertEqual([ 'foo_val', 'foo_rev', 'bar_rev', ], results[0].splitlines()) # TODO(crbug.com/1024683): Enable for windows. @unittest.skipIf(sys.platform == 'win32', 'not yet fixed on win') def testFlatten(self): output_deps = os.path.join(self.root_dir, 'DEPS.flattened') self.assertFalse(os.path.exists(output_deps)) self.gclient([ 'config', self.git_base + 'repo_6', '--name', 'src', # This should be ignored because 'custom_true_var' isn't # defined in the DEPS. '--custom-var', 'custom_true_var=True', # This should override 'true_var=True' from the DEPS. '--custom-var', 'true_var="False"' ]) self.gclient(['sync']) self.gclient( ['flatten', '-v', '-v', '-v', '--output-deps', output_deps]) # Assert we can sync to the flattened DEPS we just wrote. solutions = [{ "url": self.git_base + 'repo_6', 'name': 'src', 'deps_file': output_deps }] self.gclient(['sync', '--spec=solutions=%s' % solutions]) with open(output_deps) as f: deps_contents = f.read() self.assertEqual([ 'gclient_gn_args_file = "src/repo2/gclient.args"', 'gclient_gn_args = [\'false_var\', \'false_str_var\', \'true_var\', ' '\'true_str_var\', \'str_var\', \'cond_var\']', 'allowed_hosts = [', ' "' + self.git_base + '",', ']', '', 'deps = {', ' # "src" -> "src/repo2" -> "foo/bar"', ' "foo/bar": {', ' "url": "' + self.git_base + 'repo_3",', ' "condition": \'(repo2_false_var) and (true_str_var)\',', ' },', '', ' # "src"', ' "src": {', ' "url": "' + self.git_base + 'repo_6",', ' },', '', ' # "src" -> "src/mac_repo"', ' "src/mac_repo": {', ' "url": "' + self.git_base + 'repo_5",', ' "condition": \'checkout_mac\',', ' },', '', ' # "src" -> "src/repo8" -> "src/recursed_os_repo"', ' "src/recursed_os_repo": {', ' "url": "' + self.git_base + 'repo_5",', ' "condition": \'(checkout_linux) or (checkout_mac)\',', ' },', '', ' # "src" -> "src/repo15"', ' "src/repo15": {', ' "url": "' + self.git_base + 'repo_15",', ' },', '', ' # "src" -> "src/repo16"', ' "src/repo16": {', ' "url": "' + self.git_base + 'repo_16",', ' },', '', ' # "src" -> "src/repo2"', ' "src/repo2": {', ' "url": "' + self.git_base + 'repo_2@%s",' % (self.githash('repo_2', 1)[:7]), ' "condition": \'true_str_var\',', ' },', '', ' # "src" -> "src/repo4"', ' "src/repo4": {', ' "url": "' + self.git_base + 'repo_4",', ' "condition": \'False\',', ' },', '', ' # "src" -> "src/repo8"', ' "src/repo8": {', ' "url": "' + self.git_base + 'repo_8",', ' },', '', ' # "src" -> "src/unix_repo"', ' "src/unix_repo": {', ' "url": "' + self.git_base + 'repo_5",', ' "condition": \'checkout_linux\',', ' },', '', ' # "src" -> "src/win_repo"', ' "src/win_repo": {', ' "url": "' + self.git_base + 'repo_5",', ' "condition": \'checkout_win\',', ' },', '', '}', '', 'hooks = [', ' # "src"', ' {', ' "pattern": ".",', ' "condition": \'True\',', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked1\', \'w\')' '.write(\'git_hooked1\')",', ' ]', ' },', '', ' # "src"', ' {', ' "pattern": "nonexistent",', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked2\', \'w\').write(\'git_hooked2\')",', ' ]', ' },', '', ' # "src"', ' {', ' "pattern": ".",', ' "condition": \'checkout_mac\',', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked_mac\', \'w\').write(' '\'git_hooked_mac\')",', ' ]', ' },', '', ' # "src" -> "src/repo15"', ' {', ' "name": "absolute_cwd",', ' "pattern": ".",', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "pass",', ' ]', ' },', '', ' # "src" -> "src/repo16"', ' {', ' "name": "relative_cwd",', ' "pattern": ".",', ' "cwd": "src/repo16",', ' "action": [', ' "python3",', ' "relative.py",', ' ]', ' },', '', ']', '', 'vars = {', ' # "src"', ' "DummyVariable": \'repo\',', '', ' # "src"', ' "cond_var": \'false_str_var and true_var\',', '', ' # "src"', ' "false_str_var": \'False\',', '', ' # "src"', ' "false_var": False,', '', ' # "src"', ' "git_base": \'' + self.git_base + '\',', '', ' # "src"', ' "hook1_contents": \'git_hooked1\',', '', ' # "src" -> "src/repo2"', ' "repo2_false_var": \'False\',', '', ' # "src"', ' "repo5_var": \'/repo_5\',', '', ' # "src"', ' "str_var": \'abc\',', '', ' # "src"', ' "true_str_var": \'True\',', '', ' # "src" [custom_var override]', ' "true_var": \'False\',', '', '}', '', '# ' + self.git_base + 'repo_15, DEPS', '# ' + self.git_base + 'repo_16, DEPS', '# ' + self.git_base + 'repo_2@%s, DEPS' % (self.githash('repo_2', 1)[:7]), '# ' + self.git_base + 'repo_6, DEPS', '# ' + self.git_base + 'repo_8, DEPS', ], deps_contents.splitlines()) # TODO(crbug.com/1024683): Enable for windows. @unittest.skipIf(sys.platform == 'win32', 'not yet fixed on win') def testFlattenPinAllDeps(self): output_deps = os.path.join(self.root_dir, 'DEPS.flattened') self.assertFalse(os.path.exists(output_deps)) self.gclient(['config', self.git_base + 'repo_6', '--name', 'src']) self.gclient(['sync', '--process-all-deps']) self.gclient([ 'flatten', '-v', '-v', '-v', '--output-deps', output_deps, '--pin-all-deps' ]) with open(output_deps) as f: deps_contents = f.read() self.assertEqual([ 'gclient_gn_args_file = "src/repo2/gclient.args"', 'gclient_gn_args = [\'false_var\', \'false_str_var\', \'true_var\', ' '\'true_str_var\', \'str_var\', \'cond_var\']', 'allowed_hosts = [', ' "' + self.git_base + '",', ']', '', 'deps = {', ' # "src" -> "src/repo2" -> "foo/bar"', ' "foo/bar": {', ' "url": "' + self.git_base + 'repo_3@%s",' % (self.githash('repo_3', 2)), ' "condition": \'(repo2_false_var) and (true_str_var)\',', ' },', '', ' # "src"', ' "src": {', ' "url": "' + self.git_base + 'repo_6@%s",' % (self.githash('repo_6', 1)), ' },', '', ' # "src" -> "src/mac_repo"', ' "src/mac_repo": {', ' "url": "' + self.git_base + 'repo_5@%s",' % (self.githash('repo_5', 3)), ' "condition": \'checkout_mac\',', ' },', '', ' # "src" -> "src/repo8" -> "src/recursed_os_repo"', ' "src/recursed_os_repo": {', ' "url": "' + self.git_base + 'repo_5@%s",' % (self.githash('repo_5', 3)), ' "condition": \'(checkout_linux) or (checkout_mac)\',', ' },', '', ' # "src" -> "src/repo15"', ' "src/repo15": {', ' "url": "' + self.git_base + 'repo_15@%s",' % (self.githash('repo_15', 1)), ' },', '', ' # "src" -> "src/repo16"', ' "src/repo16": {', ' "url": "' + self.git_base + 'repo_16@%s",' % (self.githash('repo_16', 1)), ' },', '', ' # "src" -> "src/repo2"', ' "src/repo2": {', ' "url": "' + self.git_base + 'repo_2@%s",' % (self.githash('repo_2', 1)), ' "condition": \'true_str_var\',', ' },', '', ' # "src" -> "src/repo4"', ' "src/repo4": {', ' "url": "' + self.git_base + 'repo_4@%s",' % (self.githash('repo_4', 2)), ' "condition": \'False\',', ' },', '', ' # "src" -> "src/repo8"', ' "src/repo8": {', ' "url": "' + self.git_base + 'repo_8@%s",' % (self.githash('repo_8', 1)), ' },', '', ' # "src" -> "src/unix_repo"', ' "src/unix_repo": {', ' "url": "' + self.git_base + 'repo_5@%s",' % (self.githash('repo_5', 3)), ' "condition": \'checkout_linux\',', ' },', '', ' # "src" -> "src/win_repo"', ' "src/win_repo": {', ' "url": "' + self.git_base + 'repo_5@%s",' % (self.githash('repo_5', 3)), ' "condition": \'checkout_win\',', ' },', '', '}', '', 'hooks = [', ' # "src"', ' {', ' "pattern": ".",', ' "condition": \'True\',', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked1\', \'w\')' '.write(\'git_hooked1\')",', ' ]', ' },', '', ' # "src"', ' {', ' "pattern": "nonexistent",', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked2\', \'w\').write(\'git_hooked2\')",', ' ]', ' },', '', ' # "src"', ' {', ' "pattern": ".",', ' "condition": \'checkout_mac\',', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "open(\'src/git_hooked_mac\', \'w\').write(' '\'git_hooked_mac\')",', ' ]', ' },', '', ' # "src" -> "src/repo15"', ' {', ' "name": "absolute_cwd",', ' "pattern": ".",', ' "cwd": ".",', ' "action": [', ' "python3",', ' "-c",', ' "pass",', ' ]', ' },', '', ' # "src" -> "src/repo16"', ' {', ' "name": "relative_cwd",', ' "pattern": ".",', ' "cwd": "src/repo16",', ' "action": [', ' "python3",', ' "relative.py",', ' ]', ' },', '', ']', '', 'vars = {', ' # "src"', ' "DummyVariable": \'repo\',', '', ' # "src"', ' "cond_var": \'false_str_var and true_var\',', '', ' # "src"', ' "false_str_var": \'False\',', '', ' # "src"', ' "false_var": False,', '', ' # "src"', ' "git_base": \'' + self.git_base + '\',', '', ' # "src"', ' "hook1_contents": \'git_hooked1\',', '', ' # "src" -> "src/repo2"', ' "repo2_false_var": \'False\',', '', ' # "src"', ' "repo5_var": \'/repo_5\',', '', ' # "src"', ' "str_var": \'abc\',', '', ' # "src"', ' "true_str_var": \'True\',', '', ' # "src"', ' "true_var": True,', '', '}', '', '# ' + self.git_base + 'repo_15@%s, DEPS' % (self.githash('repo_15', 1)), '# ' + self.git_base + 'repo_16@%s, DEPS' % (self.githash('repo_16', 1)), '# ' + self.git_base + 'repo_2@%s, DEPS' % (self.githash('repo_2', 1)), '# ' + self.git_base + 'repo_6@%s, DEPS' % (self.githash('repo_6', 1)), '# ' + self.git_base + 'repo_8@%s, DEPS' % (self.githash('repo_8', 1)), ], deps_contents.splitlines()) # TODO(crbug.com/1024683): Enable for windows. @unittest.skipIf(sys.platform == 'win32', 'not yet fixed on win') def testFlattenRecursedeps(self): output_deps = os.path.join(self.root_dir, 'DEPS.flattened') self.assertFalse(os.path.exists(output_deps)) output_deps_files = os.path.join(self.root_dir, 'DEPS.files') self.assertFalse(os.path.exists(output_deps_files)) self.gclient(['config', self.git_base + 'repo_10', '--name', 'src']) self.gclient(['sync', '--process-all-deps']) self.gclient([ 'flatten', '-v', '-v', '-v', '--output-deps', output_deps, '--output-deps-files', output_deps_files ]) with open(output_deps) as f: deps_contents = f.read() self.assertEqual([ 'gclient_gn_args_file = "src/repo8/gclient.args"', "gclient_gn_args = ['str_var']", 'deps = {', ' # "src"', ' "src": {', ' "url": "' + self.git_base + 'repo_10",', ' },', '', ' # "src" -> "src/repo9" -> "src/repo8" -> "src/recursed_os_repo"', ' "src/recursed_os_repo": {', ' "url": "' + self.git_base + 'repo_5",', ' "condition": \'(checkout_linux) or (checkout_mac)\',', ' },', '', ' # "src" -> "src/repo11"', ' "src/repo11": {', ' "url": "' + self.git_base + 'repo_11",', ' "condition": \'(checkout_ios) or (checkout_mac)\',', ' },', '', ' # "src" -> "src/repo11" -> "src/repo12"', ' "src/repo12": {', ' "url": "' + self.git_base + 'repo_12",', ' "condition": \'(checkout_ios) or (checkout_mac)\',', ' },', '', ' # "src" -> "src/repo9" -> "src/repo4"', ' "src/repo4": {', ' "url": "' + self.git_base + 'repo_4",', ' "condition": \'checkout_android\',', ' },', '', ' # "src" -> "src/repo6"', ' "src/repo6": {', ' "url": "' + self.git_base + 'repo_6",', ' },', '', ' # "src" -> "src/repo9" -> "src/repo7"', ' "src/repo7": {', ' "url": "' + self.git_base + 'repo_7",', ' },', '', ' # "src" -> "src/repo9" -> "src/repo8"', ' "src/repo8": {', ' "url": "' + self.git_base + 'repo_8",', ' },', '', ' # "src" -> "src/repo9"', ' "src/repo9": {', ' "url": "' + self.git_base + 'repo_9",', ' },', '', '}', '', 'vars = {', ' # "src" -> "src/repo9"', ' "str_var": \'xyz\',', '', '}', '', '# ' + self.git_base + 'repo_10, DEPS', '# ' + self.git_base + 'repo_11, DEPS', '# ' + self.git_base + 'repo_8, DEPS', '# ' + self.git_base + 'repo_9, DEPS', ], deps_contents.splitlines()) with open(output_deps_files) as f: deps_files_contents = json.load(f) self.assertEqual([ { 'url': self.git_base + 'repo_10', 'deps_file': 'DEPS', 'hierarchy': [['src', self.git_base + 'repo_10']] }, { 'url': self.git_base + 'repo_11', 'deps_file': 'DEPS', 'hierarchy': [['src', self.git_base + 'repo_10'], ['src/repo11', self.git_base + 'repo_11']] }, { 'url': self.git_base + 'repo_8', 'deps_file': 'DEPS', 'hierarchy': [['src', self.git_base + 'repo_10'], ['src/repo9', self.git_base + 'repo_9'], ['src/repo8', self.git_base + 'repo_8']] }, { 'url': self.git_base + 'repo_9', 'deps_file': 'DEPS', 'hierarchy': [['src', self.git_base + 'repo_10'], ['src/repo9', self.git_base + 'repo_9']] }, ], deps_files_contents) # TODO(crbug.com/1024683): Enable for windows. @unittest.skipIf(sys.platform == 'win32', 'not yet fixed on win') def testFlattenCipd(self): output_deps = os.path.join(self.root_dir, 'DEPS.flattened') self.assertFalse(os.path.exists(output_deps)) self.gclient(['config', self.git_base + 'repo_14', '--name', 'src']) self.gclient(['sync']) self.gclient( ['flatten', '-v', '-v', '-v', '--output-deps', output_deps]) with open(output_deps) as f: deps_contents = f.read() self.assertEqual([ 'deps = {', ' # "src"', ' "src": {', ' "url": "' + self.git_base + 'repo_14",', ' },', '', ' # "src" -> src/another_cipd_dep', ' "src/another_cipd_dep": {', ' "packages": [', ' {', ' "package": "package1",', ' "version": "1.1-cr0",', ' },', ' {', ' "package": "package2",', ' "version": "1.13",', ' },', ' ],', ' "dep_type": "cipd",', ' },', '', ' # "src" -> src/cipd_dep', ' "src/cipd_dep": {', ' "packages": [', ' {', ' "package": "package0",', ' "version": "0.1",', ' },', ' ],', ' "dep_type": "cipd",', ' },', '', ' # "src" -> src/cipd_dep_with_cipd_variable', ' "src/cipd_dep_with_cipd_variable": {', ' "packages": [', ' {', ' "package": "package3/${{platform}}",', ' "version": "1.2",', ' },', ' ],', ' "dep_type": "cipd",', ' },', '', '}', '', '# ' + self.git_base + 'repo_14, DEPS', ], deps_contents.splitlines()) def testRelativeGNArgsFile(self): self.gclient(['config', self.git_base + 'repo_17', '--name', 'src']) self.gclient([ 'sync', ]) tree = self.mangle_git_tree(('repo_17@1', 'src')) tree['src/repo17_gclient.args'] = '\n'.join([ '# Generated from \'DEPS\'', 'toto = "tata"', ]) self.assertTree(tree) if __name__ == '__main__': if '-v' in sys.argv: logging.basicConfig(level=logging.DEBUG) unittest.main()