#
# Copyright (C) 2015 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""Unittests for classes in package.py"""


import unittest

from bsp import package
from bsp import status
from bsp import subpackage
from core import user_config_stub
from core import util_stub
from test import stubs


class PackageTest(unittest.TestCase):

    def setUp(self):
        self.stub_os = stubs.StubOs()
        self.stub_open = stubs.StubOpen(self.stub_os)
        self.stub_hashlib = stubs.StubHashlib()
        self.stub_shutil = stubs.StubShutil(self.stub_os)
        self.stub_subprocess = stubs.StubSubprocess(stub_os=self.stub_os,
                                                    stub_open=self.stub_open)
        self.stub_user_config = user_config_stub.StubUserConfig()
        self.stub_util = util_stub.StubUtil()

        package.os = self.stub_os
        package.open = self.stub_open.open
        package.shutil = self.stub_shutil
        package.hashlib = self.stub_hashlib
        package.tool.subprocess = self.stub_subprocess
        package.user_config = self.stub_user_config
        package.util = self.stub_util

        self.subpackages = {
            'subpackage1': subpackage.Subpackage('subpackage1', 'subdir1',
                                                 ['license1', 'license2']),
            'subpackage2': subpackage.Subpackage('subpackage2', 'sub/dir2',
                                                 ['license2', 'license3'])
        }
        self.pkg = package.Package('name', 'remote', 'version',
                                   self.subpackages)

        # Special packages for downloading
        self.tar_package = package.TarPackage('name', 'remote', 'hash',
                                              self.subpackages)
        self.git_package = package.GitPackage('name', 'remote', 'branch:hash',
                                              self.subpackages)

    # Helpers for subpackage status.
    def setup_missing_subpackage(self):
        # Package dir is there, but subpackage is not.
        self.stub_os.path.should_be_dir.append(self.pkg.directory)

    def setup_installed_subpackage(self, name):
        # Like missing, but subpackage is present.
        self.setup_missing_subpackage()
        subdir_path = self.stub_os.path.join(self.pkg.directory,
                                             self.pkg.subpackages[name].subdir)
        self.stub_os.path.should_be_dir.append(subdir_path)
        self.stub_os.path.should_exist.append(subdir_path)

    def setup_unknown_subpackage(self, name, path):
        # Like installed, but with a file at path.
        self.setup_installed_subpackage(name)
        self.stub_os.path.should_exist.append(path)

    def setup_linked_subpackage(self, name, path):
        # Like unknown, but with a link to the right place.
        self.setup_unknown_subpackage(name, path)
        self.stub_os.path.should_link[path] = self.stub_os.path.join(
            self.pkg.directory, self.pkg.subpackages[name].subdir)

    def setup_broken_link_subpackage(self, name, path):
        # Like missing, but with a link to the missing dir.
        self.setup_missing_subpackage()
        self.stub_os.path.should_exist.append(path)
        self.stub_os.path.should_link[path] = self.stub_os.path.join(
            self.pkg.directory, self.pkg.subpackages[name].subdir)

    def test_from_dict(self):
        package_dict = {
            'package_type': 'git',
            'remote': 'github',
            'version': 'branch:deadbeef',
            'subpackages': {
                'subpackage_1': {
                    'subdir': 'sub1',
                    'licenses': ['license.txt']
                },
                'subpackage_2': {
                    'subdir': 'sub2',
                    'licenses': []
                }
            }
        }
        pkg = package.Package.from_dict(package_dict, 'package_1')
        self.assertIsInstance(pkg, package.Package)
        self.assertEqual(len(pkg.subpackages), 2)
        self.assertTrue('subpackage_1' in pkg.subpackages)
        self.assertEqual(pkg.remote, 'github')
        self.assertEqual(pkg.version, 'branch:deadbeef')

        # Check git vs. tar packages.
        self.assertIsInstance(pkg, package.GitPackage)
        package_dict['package_type'] = 'tar'
        pkg = package.Package.from_dict(package_dict, 'package_1')
        self.assertIsInstance(pkg, package.TarPackage)

    def test_from_dict_invalid(self):
        package_dict = {
            'package_type': 'not_git_or_tar',
            'remote': 'github',
            'version': 'branch:deadbeef',
            'subpackages': {
                'subpackage_1': {
                    'subdir': 'sub1',
                    'licenses': ['license.txt']
                },
                'subpackage_2': {
                    'subdir': 'sub2',
                    'licenses': []
                }
            }
        }
        # Type must be git or tar.
        with self.assertRaises(ValueError):
            package.Package.from_dict(package_dict, 'package_1')

    def test_path(self):
        self.assertEqual(
            self.pkg.directory,
            self.stub_os.path.join(self.stub_user_config.USER_CONFIG.bsp_dir,
                                   self.pkg.name,
                                   'source_versions',
                                   self.pkg.version))
        # If we update the user config, bsp dir should update accordingly;
        # it shouldn't be cached.
        self.stub_user_config.USER_CONFIG.bsp_dir = '/who/knows/where'
        self.assertEqual(
            self.pkg.directory,
            self.stub_os.path.join(self.stub_user_config.USER_CONFIG.bsp_dir,
                                   self.pkg.name,
                                   'source_versions',
                                   self.pkg.version))


    def test_downloaded(self):
        self.stub_os.path.should_be_dir = [self.pkg.directory]
        self.assertTrue(self.pkg.is_downloaded())

    def test_not_downloaded(self):
        self.assertFalse(self.pkg.is_downloaded())

    def test_subpackage_status_nonexistent_subpackage(self):
        # Should get some sort of error about 'not_a_subpackage'
        # not being a real subpackage of pkg.
        with self.assertRaisesRegexp(package.NoSuchSubpackageError,
                                     'not_a_subpackage'):
            self.pkg.subpackage_status('not_a_subpackage', 'path')

    def test_subpackage_status_not_installed(self):
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'path')[0],
                         status.NOT_INSTALLED)
        # Not installed with no path: still not installed.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.NOT_INSTALLED)

    def test_subpackage_status_installed(self):
        self.setup_installed_subpackage('subpackage1')
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'path')[0],
                         status.INSTALLED)
        # Installed with no path: still installed.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.INSTALLED)


    def test_subpackage_status_linked(self):
        self.setup_linked_subpackage('subpackage1', 'link')
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'link')[0],
                         status.LINKED)
        # Linked with no path: just installed.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.INSTALLED)


    def test_subpackage_status_missing(self):
        self.setup_missing_subpackage()
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'path')[0],
                         status.MISSING)
        # Missing with no path: still missing.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.MISSING)

    def test_subpackage_status_broken_link(self):
        self.setup_broken_link_subpackage('subpackage1', 'link')
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'link')[0],
                         status.UNRECOGNIZED)
        # Broken link because missing, with no path: just missing.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.MISSING)

    def test_subpackage_status_unknown(self):
        self.setup_unknown_subpackage('subpackage1', '???')
        self.assertEqual(self.pkg.subpackage_status('subpackage1', '???')[0],
                         status.UNRECOGNIZED)
        # Unknown but installed, with no path: just installed.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.INSTALLED)

    def test_subpackage_status_incorrect_version(self):
        self.setup_installed_subpackage('subpackage1')
        self.pkg.version = 'different_version'
        # Different versions are treated as completely different BSPs for now.
        self.assertEqual(self.pkg.subpackage_status('subpackage1', 'path')[0],
                         status.NOT_INSTALLED)
        # Still not installed with no path.
        self.assertEqual(self.pkg.subpackage_status('subpackage1')[0],
                         status.NOT_INSTALLED)

    def test_tarball_version(self):
        file1 = stubs.StubFile('file1')
        self.stub_os.path.should_exist = ['file1']
        self.stub_open.files = {'file1': file1}
        self.stub_hashlib.should_return = '<hash_of_file1>'
        self.assertEqual(package.TarPackage.get_tarball_version('file1'),
                         '<hash_of_file1>')

    def test_tarball_invalid_version(self):
        self.stub_os.path.should_exist = []
        with self.assertRaises(package.VersionError):
            package.TarPackage.get_tarball_version('file1')

    def test_already_downloaded(self):
        self.stub_os.path.should_be_dir = [self.pkg.directory]
        # Shouldn't do any downloading - no dirs should be made.
        self.stub_os.should_makedirs = []
        self.pkg.download()

    def test_download_exception(self):
        # pkg is the abstract Package class,
        # download isn't fully implemented
        self.stub_os.should_makedirs = [self.pkg.directory]
        with self.assertRaises(NotImplementedError):
            self.pkg.download()
        # downloaded failed, should clean up the download directory.
        self.assertFalse(self.stub_os.path.exists(self.pkg.directory))

    def test_git_download_shallow(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        # Note: we don't test that tmp_dir/.git exists, because that's
        # hard to write cleanly; so we assume it is created and exists
        # as expected by clone/rev-parse.
        ls_remote = self.stub_subprocess.AddCommand(ret_out='hash')
        clone = self.stub_subprocess.AddFileCommand(pos_out=[-1])
        rev_parse = self.stub_subprocess.AddCommand(ret_out='hash')

        self.git_package.download()
        self.assertTrue(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])
        clone.AssertCallContained(['git', 'clone'])
        rev_parse.AssertCallContained(['git', 'rev-parse'])

    def test_git_download_full(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        # Note: we don't test that tmp_dir/.git exists, because that's
        # hard to write cleanly; so we assume it is created and exists
        # as expected by clone/rev-parse.
        ls_remote = self.stub_subprocess.AddCommand(ret_out='wronghash')
        clone = self.stub_subprocess.AddFileCommand(pos_out=[-1])
        reset = self.stub_subprocess.AddCommand()
        rev_parse = self.stub_subprocess.AddCommand(ret_out='hash')

        self.git_package.download()
        self.assertTrue(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])
        clone.AssertCallContained(['git', 'clone'])
        reset.AssertCallContained(['git', 'reset'])
        rev_parse.AssertCallContained(['git', 'rev-parse'])

    def test_git_failed_lsremote(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        ls_remote = self.stub_subprocess.AddCommand(ret_code=-1)

        with self.assertRaises(package.RemoteError):
            self.git_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])

    def test_git_failed_download(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        ls_remote = self.stub_subprocess.AddCommand(ret_out='hash')
        clone = self.stub_subprocess.AddFileCommand(pos_out=[-1],
                                                    ret_code=-1)

        with self.assertRaises(package.DownloadError):
            self.git_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])
        clone.AssertCallContained(['git', 'clone'])

    def test_git_failed_reset(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        # Note: we don't test that tmp_dir/.git exists, because that's
        # hard to write cleanly; so we assume it is created and exists
        # as expected by clone/rev-parse.
        ls_remote = self.stub_subprocess.AddCommand(ret_out='wronghash')
        clone = self.stub_subprocess.AddFileCommand(pos_out=[-1])
        reset = self.stub_subprocess.AddCommand(ret_code=-1)

        with self.assertRaises(package.VersionError):
            self.git_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])
        clone.AssertCallContained(['git', 'clone'])
        reset.AssertCallContained(['git', 'reset'])

    def test_git_wrong_version(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        # Note: we don't test that tmp_dir/.git exists, because that's
        # hard to write cleanly; so we assume it is created and exists
        # as expected by clone/rev-parse.
        ls_remote = self.stub_subprocess.AddCommand(ret_out='hash')
        clone = self.stub_subprocess.AddFileCommand(pos_out=[-1])
        rev_parse = self.stub_subprocess.AddCommand(ret_out='wronghash')

        with self.assertRaises(package.VersionError):
            self.git_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.git_package.directory))
        ls_remote.AssertCallContained(['git', 'ls-remote'])
        clone.AssertCallContained(['git', 'clone'])
        rev_parse.AssertCallContained(['git', 'rev-parse'])

    def test_git_tarball(self):
        self.stub_os.should_makedirs = [self.git_package.directory]
        # Some sort of error about no tarballs for git packages
        with self.assertRaisesRegexp(ValueError, 'tarball'):
            self.git_package.download(tarball='file')
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.git_package.directory))

    def test_tar_download(self):
        self.stub_os.should_makedirs = [self.tar_package.directory]
        curl = self.stub_subprocess.AddFileCommand(out_args=['-o'])
        # Again, side effects of popen are hard to encode, so this doesn't
        # reflect that the '-C' output directory will get populated by tar.
        tar = self.stub_subprocess.AddFileCommand(in_args=['-C', '-xzf'])
        self.stub_hashlib.should_return = self.tar_package.version

        self.tar_package.download()
        self.assertTrue(self.stub_os.path.exists(self.tar_package.directory))
        curl.AssertCallContained(['curl', '-o'])
        tar.AssertCallContained(['tar', '-C', '-xzf'])

    def test_tar_failed_download(self):
        self.stub_os.should_makedirs = [self.tar_package.directory]
        curl = self.stub_subprocess.AddFileCommand(out_args=['-o'], ret_code=-1)
        self.stub_hashlib.should_return = self.tar_package.version

        with self.assertRaises(package.DownloadError):
            self.tar_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.tar_package.directory))
        curl.AssertCallContained(['curl', '-o'])

    def test_tar_wrong_version(self):
        self.stub_os.should_makedirs = [self.tar_package.directory]
        curl = self.stub_subprocess.AddFileCommand(out_args=['-o'])
        self.stub_hashlib.should_return = '0xWRONG'

        with self.assertRaisesRegexp(package.VersionError,
                                     'incorrect version 0xWRONG'):
            self.tar_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.tar_package.directory))
        curl.AssertCallContained(['curl', '-o'])

    def test_tar_bad_unzip(self):
        self.stub_os.should_makedirs = [self.tar_package.directory]
        curl = self.stub_subprocess.AddFileCommand(out_args=['-o'])
        tar = self.stub_subprocess.AddFileCommand(in_args=['-C', '-xzf'],
                                                  ret_code=-1)
        self.stub_hashlib.should_return = self.tar_package.version

        with self.assertRaises(package.UnzipError):
            self.tar_package.download()
        # Leave in a clean state
        self.assertFalse(self.stub_os.path.exists(self.tar_package.directory))
        curl.AssertCallContained(['curl', '-o'])
        tar.AssertCallContained(['tar', '-C', '-xzf'])

    def test_tar_tarball(self):
        self.stub_os.path.should_exist = ['tar_file']
        self.stub_open.files['tar_file'] = stubs.StubFile()
        self.stub_os.should_makedirs = [self.tar_package.directory]
        tar = self.stub_subprocess.AddFileCommand(in_args=['-C', '-xzf'])
        self.stub_hashlib.should_return = self.tar_package.version

        self.tar_package.download('tar_file')
        self.assertTrue(self.stub_os.path.exists(self.tar_package.directory))
        # Make sure the tar file is still where it was.
        self.assertTrue(self.stub_os.path.exists('tar_file'))
        tar.AssertCallContained(['tar', '-C', '-xzf'])

    def test_uninstall(self):
        dirs = [self.pkg.directory,
                self.stub_os.path.join(self.pkg.directory, 'subdir1'),
                self.stub_os.path.join(self.pkg.directory, 'subdir2'),
                self.stub_os.path.join(self.pkg.directory, 'subdir2',
                                       'deeper')]
        self.stub_os.path.should_be_dir.extend(dirs)
        self.stub_os.path.should_exist.extend(dirs)
        files = [self.stub_os.path.join(dirname, 'a_file') for dirname in dirs]
        self.stub_os.path.should_exist.extend(files)

        self.assertTrue(self.pkg.is_downloaded())
        self.pkg.uninstall()
        for f in files:
            self.assertFalse(self.stub_os.path.exists(f))
        for d in dirs:
            self.assertFalse(self.stub_os.path.exists(d))
            self.assertFalse(self.stub_os.path.isdir(d))
        self.assertFalse(self.pkg.is_downloaded())

    def test_get_licenses(self):
        licenses = self.pkg.get_licenses(['subpackage1', 'subpackage2'])
        expected_names = ['name.subpackage1 - license1',
                          'name.subpackage1 - license2',
                          'name.subpackage2 - license2',
                          'name.subpackage2 - license3']

        for l in licenses:
            self.assertTrue(l.name in expected_names)
            expected_names.remove(l.name)
        self.assertEqual(expected_names, [])

    def test_get_some_licenses(self):
        licenses = self.pkg.get_licenses(['subpackage2'])
        expected_names = ['name.subpackage2 - license2',
                          'name.subpackage2 - license3']

        for l in licenses:
            self.assertTrue(l.name in expected_names)
            expected_names.remove(l.name)
        self.assertEqual(expected_names, [])

    def test_get_no_licenses(self):
        licenses = self.pkg.get_licenses([])
        self.assertEqual(licenses, [])

    def test_link_subpackage(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist.append(subpackage_dir)
        self.stub_os.should_create_link = [(subpackage_dir, 'link_origin')]

        self.pkg.link_subpackage('subpackage1', 'link_origin')
        # Correct link should be created.
        self.assertTrue(self.stub_os.path.islink('link_origin'))
        self.assertEqual(self.stub_os.readlink('link_origin'),
                         subpackage_dir)

    def test_link_not_downloaded(self):
        with self.assertRaises(package.NotDownloadedError):
            self.pkg.link_subpackage('subpackage1', 'link_origin')
        # No link should be created.
        self.assertFalse(self.stub_os.path.exists('link_origin'))

    def test_link_missing(self):
        self.stub_os.path.should_be_dir = [self.pkg.directory]

        with self.assertRaises(package.MissingDirectoryError):
            self.pkg.link_subpackage('subpackage1', 'link_origin')
        # No link should be created.
        self.assertFalse(self.stub_os.path.exists('link_origin'))

    def test_link_fail(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist.append(subpackage_dir)

        with self.assertRaises(package.SubpackageLinkError):
            self.pkg.link_subpackage('subpackage1', 'link_origin')
        # No link should be created.
        self.assertFalse(self.stub_os.path.exists('link_origin'))

    def test_link_overwrite(self):
        (_, subpackage_) = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist += [subpackage_dir, 'link_origin']

        # Should still be a link error. The caller needs to check for this.
        with self.assertRaises(package.SubpackageLinkError):
            self.pkg.link_subpackage('subpackage1', 'link_origin')
        # No link should be created, the file should still be there.
        self.assertTrue(self.stub_os.path.exists('link_origin'))
        self.assertFalse(self.stub_os.path.islink('link_origin'))

    def test_unlink(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist += [subpackage_dir, 'link_origin']
        self.stub_os.path.should_link['link_origin'] = subpackage_dir

        self.pkg.unlink_subpackage('subpackage1', 'link_origin')
        # Should be unlinked.
        self.assertFalse(self.stub_os.path.islink('link_origin'))
        self.assertFalse(self.stub_os.path.exists('link_origin'))

    def test_unlink_wrong_link(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist += [subpackage_dir, 'link_origin',
                                           'somewhere_else']
        self.stub_os.path.should_link['link_origin'] = 'somewhere_else'

        with self.assertRaises(package.SubpackageUnlinkError):
            self.pkg.unlink_subpackage('subpackage1', 'link_origin')
        # Original link should be in place.
        self.assertTrue(self.stub_os.path.exists('link_origin'))
        self.assertTrue(self.stub_os.path.islink('link_origin'))
        self.assertEqual(self.stub_os.readlink('link_origin'),
                         'somewhere_else')

    def test_unlink_no_link(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist += [subpackage_dir, 'link_origin']

        with self.assertRaises(package.SubpackageUnlinkError):
            self.pkg.unlink_subpackage('subpackage1', 'link_origin')
        # Original lack of link should be in place.
        self.assertTrue(self.stub_os.path.exists('link_origin'))
        self.assertFalse(self.stub_os.path.islink('link_origin'))

    def test_unlink_dead_link(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        # Dead links don't exist for os.path purposes.
        self.stub_os.path.should_exist += [subpackage_dir]
        self.stub_os.path.should_link['link_origin'] = 'somewhere_else'

        with self.assertRaises(package.SubpackageUnlinkError):
            self.pkg.unlink_subpackage('subpackage1', 'link_origin')
        # Original dead link should be in place.
        self.assertTrue(self.stub_os.path.islink('link_origin'))
        self.assertEqual(self.stub_os.readlink('link_origin'),
                         'somewhere_else')

    def test_unlink_nothing(self):
        _, subpackage_ = self.pkg.subpackages.items()[0]
        subpackage_dir = self.stub_os.path.join(self.pkg.directory,
                                                subpackage_.subdir)
        self.stub_os.path.should_be_dir = [self.pkg.directory, subpackage_dir]
        self.stub_os.path.should_exist += [subpackage_dir]

        with self.assertRaises(package.SubpackageUnlinkError):
            self.pkg.unlink_subpackage('subpackage1', 'link_origin')
        # Should still be nothing.
        self.assertFalse(self.stub_os.path.islink('link_origin'))
        self.assertFalse(self.stub_os.path.exists('link_origin'))