def test_hash_md5(self):
        m = mock_open(read_data=b"hello world")

        with patch('openwebvulndb.common.hash.open', m, create=True):
            hasher = Hasher('MD5')
            self.assertEqual('5eb63bbbe01eeed093cb22bb8f5acdc3',
                             hasher.hash("/some/file.txt"))
    def test_raise_value_error_if_file_is_empty(self):
        m = mock_open(read_data=b"")

        with patch('openwebvulndb.common.hash.open', m, create=True):
            hasher = Hasher('SHA256')
            with self.assertRaises(ValueError):
                hasher.hash("/some/file.txt")
    def test_hash_sha256(self):
        m = mock_open(read_data=b"hello world")

        with patch('openwebvulndb.common.hash.open', m, create=True):
            hasher = Hasher('SHA256')
            self.assertEqual(
                'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9',
                hasher.hash("/some/file.txt"))
    def test_callback_applied_to_chunks(self):
        m = mock_open(read_data=b"hello world")

        with patch('openwebvulndb.common.hash.open', m, create=True):
            check_chunk = MagicMock()

            hasher = Hasher('SHA256')
            hasher.hash("/some/file.txt", chunk_cb=check_chunk)

            check_chunk.assert_called_with(b"hello world")
    async def test_collect_for_one_version(self, fake_future):
        with patch("openwebvulndb.common.hash.HashCollector") as HashCollector:
            workspace = MagicMock()
            workspace.workdir = "/my/workspace/path"
            workspace.to_version.return_value = fake_future(None)

            collector = MagicMock()
            collector.collect.return_value = ["Hello"]
            HashCollector.return_value = collector

            hasher = RepositoryHasher(storage=MagicMock(),
                                      hasher=Hasher("SHA256"))
            out = await hasher.collect_for_version(workspace,
                                                   "2.1",
                                                   prefix="test-prefix")

            self.assertEqual(["Hello"], out)

            HashCollector.assert_called_with(path="/my/workspace/path",
                                             hasher=hasher.hasher,
                                             prefix="test-prefix",
                                             lookup_version="2.1")

            collector.collect.assert_called_with()

            workspace.to_version.assert_called_with("2.1")
    async def test_collect_for_workspace_do_not_write_versions_if_empty_signatures(
            self):
        hasher = RepositoryHasher(storage=MagicMock(), hasher=Hasher("SHA256"))
        hasher.collect_for_version = make_mocked_coro(return_value=[])
        hasher.get_version_list = MagicMock(return_value=VersionList(
            key="plugins/plugin-key",
            producer="unittest",
            versions=[VersionDefinition(version="1.0")]))
        workspace = MagicMock()
        workspace.list_versions = make_mocked_coro(return_value=["1.2"])
        hasher.storage.write_versions = MagicMock()

        await hasher.collect_for_workspace("plugins/plugin-key", workspace)

        hasher.collect_for_version.assert_called_once_with(workspace,
                                                           "1.2",
                                                           prefix="")
        hasher.storage.write_versions.assert_not_called()