def test_override(self):
        module_dir = shared.create_dir({'foo': 'bar'})
        self.write_yaml('''\
            cp module foo:
                path: {}

            imports:
                foo: ./
            ''', module_dir)
        override_dir = shared.create_dir({'foo': 'override'})
        # Set the override.
        run_peru_command(['override', 'add', 'foo', override_dir],
                         self.test_dir)
        # Confirm that the override is configured.
        output = run_peru_command(['override'], self.test_dir)
        self.assertEqual(output, 'foo: {}\n'.format(override_dir))
        # Make sure 'override list' gives the same output as 'override'.
        output = run_peru_command(['override', 'list'], self.test_dir)
        self.assertEqual(output, 'foo: {}\n'.format(override_dir))
        # Run the sync and confirm that the override worked.
        self.do_integration_test(['sync'], {'foo': 'override'})
        # Delete the override.
        run_peru_command(['override', 'delete', 'foo'], self.test_dir)
        # Confirm that the override was deleted.
        output = run_peru_command(['override'], self.test_dir)
        self.assertEqual(output, '')
        # Rerun the sync and confirm the original content is back.
        self.do_integration_test(['sync'], {'foo': 'bar'})

    def test_override(self):
        module_dir = shared.create_dir({'foo': 'bar'})
        self.write_yaml('''\
            cp module foo:
                path: {}

            imports:
                foo: ./
            ''', module_dir)
        override_dir = shared.create_dir({'foo': 'override'})
        # Set the override.
        run_peru_command(['override', 'add', 'foo', override_dir],
                         self.test_dir)
        # Confirm that the override is configured.
        output = run_peru_command(['override'], self.test_dir)
        self.assertEqual(output, 'foo: {}\n'.format(override_dir))
        # Make sure 'override list' gives the same output as 'override'.
        output = run_peru_command(['override', 'list'], self.test_dir)
        self.assertEqual(output, 'foo: {}\n'.format(override_dir))
        # Run the sync with --no-overrides and confirm nothing changes. Also
        # check that there's no overrides-related output.
        output = self.do_integration_test(['sync', '--no-overrides'],
                                          {'foo': 'bar'})
        self.assertNotIn('overrides', output)
        # Now run the sync normally and confirm that the override worked. Also
        # confirm that we mentioned the override in output.
        output = self.do_integration_test(['sync'], {'foo': 'override'})
        self.assertIn('overrides', output)
        # Delete the override.
        run_peru_command(['override', 'delete', 'foo'], self.test_dir)
        # Confirm that the override was deleted.
        output = run_peru_command(['override'], self.test_dir)
        self.assertEqual(output, '')
        # Rerun the sync and confirm the original content is back.
        self.do_integration_test(['sync'], {'foo': 'bar'})

 def test_import_with_gitignore(self):
     # Make sure our git imports don't get confused by .gitignore files.
     new_content = {"fee/fi": "fo fum", ".gitignore": "fee/"}
     new_tree = self.cache.import_tree(shared.create_dir(new_content))
     export_dir = shared.create_dir()
     self.cache.export_tree(new_tree, export_dir)
     assert_contents(export_dir, new_content)

 def setUp(self):
     self.cache_dir = shared.create_dir()
     self.cache = cache.Cache(self.cache_dir)
     self.content = {'a': 'foo', 'b/c': 'bar'}
     self.content_dir = shared.create_dir(self.content)
     self.content_tree = self.cache.import_tree(self.content_dir)
     self.entries = self.cache.ls_tree(self.content_tree, recursive=True)

    def test_identical_plugin_cache_fields(self):
        # Plugins that use caching also need to avoid running in parallel, if
        # their cache directories are the same. The noop_cache plugin (created
        # for this test) uses the path field (but not the nonce field) in its
        # plugin cache key. Check that these two modules are not fetched in
        # parallel, even though their module fields aren't exactly the same.
        foo = shared.create_dir()
        peru_yaml = dedent('''\
            imports:
                foo1: ./
                foo2: ./

            noop_cache module foo1:
                path: {}
                # nonce is ignored, but it makes foo1 different from foo2 as
                # far as the module cache is concerned
                nonce: '1'

            noop_cache module foo2:
                path: {}
                nonce: '2'
            '''.format(foo, foo))
        test_dir = shared.create_dir({'peru.yaml': peru_yaml})
        shared.run_peru_command(['sync'], test_dir)
        assert_parallel(1)

 def setUp(self):
     self.cache_dir = shared.create_dir()
     self.cache = yield from cache.Cache(self.cache_dir)
     self.content = {"a": "foo", "b/c": "bar"}
     self.content_dir = shared.create_dir(self.content)
     self.content_tree = yield from self.cache.import_tree(self.content_dir)
     self.entries = yield from self.cache.ls_tree(self.content_tree, recursive=True)

 def test_import_with_gitignore(self):
     # Make sure our git imports don't get confused by .gitignore files.
     new_content = {'fee/fi': 'fo fum', '.gitignore': 'fee/'}
     new_tree = yield from self.cache.import_tree(create_dir(new_content))
     export_dir = create_dir()
     yield from self.cache.export_tree(new_tree, export_dir)
     assert_contents(export_dir, new_content)

 def test_keyval(self):
     root = shared.create_dir()
     tmp_dir = shared.create_dir()
     keyval = KeyVal(root, tmp_dir)
     key = "mykey"
     # keyval should be empty
     self.assertFalse(key in keyval)
     self.assertSetEqual(set(keyval), set())
     # set a key
     keyval[key] = "myval"
     self.assertEqual(keyval[key], "myval")
     self.assertTrue(key in keyval)
     self.assertSetEqual(set(keyval), {key})
     # overwrite the value
     keyval[key] = "anotherval"
     self.assertEqual(keyval[key], "anotherval")
     # instantiate a second keyval on the same dir, should have same content
     another_keyval = KeyVal(root, tmp_dir)
     self.assertTrue(key in another_keyval)
     self.assertEqual(another_keyval[key], "anotherval")
     self.assertSetEqual(set(another_keyval), {key})
     # test deletions
     del keyval[key]
     self.assertFalse(key in keyval)
     self.assertFalse(key in another_keyval)

 def test_flags_override_vars(self):
     flag_cache_dir = shared.create_dir()
     env_cache_dir = shared.create_dir()
     shared.run_peru_command(['--cache-dir', flag_cache_dir, 'sync'],
                             self.cwd,
                             env={'PERU_CACHE_DIR': env_cache_dir})
     self.assert_success(self.project_dir, self.state_dir, flag_cache_dir)

    def test_import_module_defined_in_another_module(self):
        # Project B contains project A
        dir_a = shared.create_dir({'afile': 'stuff'})
        dir_b = shared.create_dir()
        # Create the peru.yaml file for B.
        self.write_yaml('''\
            cp module a:
                path: {}
            ''', dir_a, dir=dir_b)
        # Now create the peru.yaml file in the actual test project.
        self.write_yaml('''\
            imports:
                b.a: a_via_b/

            cp module b:
                path: {}
            ''', dir_b)
        self.do_integration_test(['sync'], {'a_via_b/afile': 'stuff'})
        # Test the error message from an invalid module.
        self.write_yaml('''\
            imports:
                b.missing_module: some_path

            cp module b:
                path: {}
            ''', dir_b)
        try:
            self.do_integration_test(['sync'], {})
        except peru.error.PrintableError as e:
            assert 'b.missing_module' in e.message
        else:
            assert False, 'should throw invalid module error'

    def test_touched_file(self):
        # Bumping the mtime on a file makes it appear dirty to `git
        # diff-files`. However, when the index is refreshed with `git
        # update-index`, the dirtiness should go away. This test guarantees
        # that we do that refresh, both with and without a cached index file.
        # Note that because the index file only has an mtime resolution of 1
        # second, we have to artificially inflate the mtime to guarantee that
        # the file will actually appear dirty.
        export_dir = create_dir()
        a_path = os.path.join(export_dir, 'a')
        t = time.time()

        def bump_mtime_one_minute():
            nonlocal t
            t += 60  # Add a whole minute to the mtime we set.
            os.utime(a_path, (t, t))

        # Do the first export.
        yield from self.cache.export_tree(self.content_tree, export_dir)
        # Touch a and rerun the export with no cached index.
        bump_mtime_one_minute()
        yield from self.cache.export_tree(
            self.content_tree, export_dir, previous_tree=self.content_tree)
        # Create a cached index file.
        index_dir = create_dir()
        index_file = os.path.join(index_dir, 'test_index_file')
        yield from self.cache.export_tree(
            self.content_tree, export_dir, previous_tree=self.content_tree,
            previous_index_file=index_file)
        # Finally, touch a again and rerun the export using the cached index.
        bump_mtime_one_minute()
        yield from self.cache.export_tree(
            self.content_tree, export_dir, previous_tree=self.content_tree,
            previous_index_file=index_file)

    def setUp(self):
        self.cache_dir = create_dir()
        self.cache = Cache(self.cache_dir)

        # These tests use this simple one-file tree as module contents.
        content = {'a': 'a'}
        content_dir = create_dir(content)
        self.content_tree = self.cache.import_tree(content_dir)

 async def setUp(self):
     self.cache_dir = shared.create_dir()
     self.cache = await cache.Cache(self.cache_dir)
     # Include a leading colon to test that we prepend ./ to pathspecs.
     self.content = {'a': 'foo', 'b/c': 'bar', COLON + 'd': 'baz'}
     self.content_dir = shared.create_dir(self.content)
     self.content_tree = await self.cache.import_tree(self.content_dir)
     self.entries = await self.cache.ls_tree(
         self.content_tree, recursive=True)

 def setUp(self):
     self.cache = peru.cache.Cache(shared.create_dir())
     self.content = {
         "a": "foo",
         "b/c": "bar",
         "b/d": "baz",
     }
     self.content_dir = shared.create_dir(self.content)
     self.content_tree = self.cache.import_tree(self.content_dir)

 async def setUp(self):
     self.cache = await peru.cache.Cache(create_dir())
     self.content = {
         'a': 'foo',
         'b/c': 'bar',
         'b/d': 'baz',
     }
     self.content_dir = create_dir(self.content)
     self.content_tree = await self.cache.import_tree(self.content_dir)

 def setUp(self):
     self.cache = yield from peru.cache.Cache(create_dir())
     self.content = {
         'a': 'foo',
         'b/c': 'bar',
         'b/d': 'baz',
     }
     self.content_dir = create_dir(self.content)
     self.content_tree = yield from self.cache.import_tree(self.content_dir)

 def test_setting_all_flags(self):
     cwd = shared.create_dir()
     sync_dir = shared.create_dir()
     state_dir = shared.create_dir()
     cache_dir = shared.create_dir()
     shared.run_peru_command(
         ['--file', self.peru_file, '--sync-dir', sync_dir,
          '--state-dir', state_dir, '--cache-dir', cache_dir, 'sync'],
         cwd)
     self.assert_success(sync_dir, state_dir, cache_dir)

 def test_import_with_files(self):
     all_content = {'foo': '',
                    'bar': '',
                    'baz/bing': ''}
     test_dir = create_dir(all_content)
     tree = self.cache.import_tree(test_dir, picks=['foo', 'baz'])
     expected_content = {'foo': '',
                         'baz/bing': ''}
     out_dir = create_dir()
     self.cache.export_tree(tree, out_dir)
     assert_contents(out_dir, expected_content)

 def test_merge_with_deep_prefix(self):
     '''This test was inspired by a bug on Windows where we would give git a
     backslash-separated merge prefix, even though git demands forward slash
     as a path separator.'''
     content = {'file': 'stuff'}
     content_dir = create_dir(content)
     tree = yield from self.cache.import_tree(content_dir)
     prefixed_tree = yield from self.cache.merge_trees(None, tree, 'a/b/')
     export_dir = create_dir()
     yield from self.cache.export_tree(prefixed_tree, export_dir)
     assert_contents(export_dir, {'a/b/file': 'stuff'})

 def setUp(self):
     self.content = {"some": "stuff", "foo/bar": "baz"}
     self.content_dir = shared.create_dir(self.content)
     self.cache_root = shared.create_dir()
     self.plugin_context = plugin.PluginContext(
         cwd='.',
         plugin_cache_root=self.cache_root,
         plugin_paths=(),
         parallelism_semaphore=asyncio.BoundedSemaphore(
             plugin.DEFAULT_PARALLEL_FETCH_LIMIT),
         plugin_cache_locks=defaultdict(asyncio.Lock))