class TestAddMarkers(unittest.TestCase):

    def setUp(self):
        self.docker_client = mock.Mock()
        self.log = mock.Mock()
        self.image = "whatever"
        self.squash = Image(self.log, self.docker_client, self.image, None)

    def test_should_not_fail_with_empty_list_of_markers_to_add(self):
        self.squash._add_markers({}, None, None)

    def test_should_add_all_marker_files_to_empty_tar(self):
        tar = mock.Mock()

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')

        markers = {marker_1: 'file'}
        with mock.patch('docker_squash.image.Image._files_in_layers', return_value={}):
            self.squash._add_markers(markers, tar, None)

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file')
        self.assertTrue(tar_info.isfile())

    def test_should_skip_a_marker_file_if_file_is_in_unsquashed_layers(self):
        tar = mock.Mock()

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar, {'1234layerdid': ['some/file', 'marker_1']})

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file2')
        self.assertTrue(tar_info.isfile())

    def test_should_not_add_any_marker_files(self):
        tar = mock.Mock()

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar, {'1234layerdid': ['some/file', 'marker_1', 'marker_2']})

        self.assertTrue(len(tar.addfile.mock_calls) == 0)
class TestAddMarkers(unittest.TestCase):

    def setUp(self):
        self.docker_client = mock.Mock()
        self.log = mock.Mock()
        self.image = "whatever"
        self.squash = Image(self.log, self.docker_client, self.image, None)

    def test_should_not_fail_with_empty_list_of_markers_to_add(self):
        self.squash._add_markers({}, None, None, [])

    def test_should_add_all_marker_files_to_empty_tar(self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')

        markers = {marker_1: 'file'}
        self.squash._add_markers(markers, tar, {}, [])

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file')
        self.assertTrue(tar_info.isfile())

    def test_should_add_all_marker_files_to_empty_tar_besides_what_should_be_skipped(self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar, {'1234layerdid': ['/marker_1', '/marker_2']}, [['/marker_1']])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file2')
        self.assertTrue(tar_info.isfile())

    def test_should_skip_a_marker_file_if_file_is_in_unsquashed_layers(self):
        tar = mock.Mock()
        # List of files in the squashed tar
        tar.getnames.return_value = ['marker_1']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')
        # List of marker files to add back
        markers = {marker_1: 'marker_1', marker_2: 'marker_2'}
        # List of files in all layers to be moved
        files_in_moved_layers = {'1234layerdid': ['/some/file', '/marker_2']}
        self.squash._add_markers(markers, tar, files_in_moved_layers, [])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'marker_2')
        self.assertTrue(tar_info.isfile())

    def test_should_not_add_any_marker_files(self):
        tar = mock.Mock()
        tar.getnames.return_value = ['marker_1', 'marker_2']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar, {'1234layerdid': ['some/file', 'marker_1', 'marker_2']}, [])

        self.assertTrue(len(tar.addfile.mock_calls) == 0)

    # https://github.com/goldmann/docker-squash/issues/108
    def test_should_add_marker_file_when_tar_has_prefixed_entries(self):
        tar = mock.Mock()
        # Files already in tar
        tar.getnames.return_value = ['./abc', './def']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.some/file')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.file2')

        markers = {marker_1: 'filecontent1', marker_2: 'filecontent2'}

        # List of layers to move (and files in these layers), already normalized
        self.squash._add_markers(markers, tar, {'1234layerdid': ['/some/file', '/other/file', '/stuff']}, [])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        # We need to add the marker file because we need to
        # override the already existing file
        self.assertEqual(marker_file, 'filecontent1')
        self.assertTrue(tar_info.isfile())
Exemple #3
0
class TestAddMarkers(unittest.TestCase):
    def setUp(self):
        self.docker_client = mock.Mock()
        self.log = mock.Mock()
        self.image = "whatever"
        self.squash = Image(self.log, self.docker_client, self.image, None)

    def test_should_not_fail_with_empty_list_of_markers_to_add(self):
        self.squash._add_markers({}, None, None)

    def test_should_add_all_marker_files_to_empty_tar(self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')

        markers = {marker_1: 'file'}
        self.squash._add_markers(markers, tar, {})

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file')
        self.assertTrue(tar_info.isfile())

    def test_should_skip_a_marker_file_if_file_is_in_unsquashed_layers(self):
        tar = mock.Mock()
        # List of files in the squashed tar
        tar.getnames.return_value = ['marker_1']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')
        # List of marker files to add back
        markers = {marker_1: 'marker_1', marker_2: 'marker_2'}
        # List of files in all layers to be moved
        files_in_moved_layers = {'1234layerdid': ['some/file', 'marker_2']}
        self.squash._add_markers(markers, tar, files_in_moved_layers)

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'marker_2')
        self.assertTrue(tar_info.isfile())

    def test_should_not_add_any_marker_files(self):
        tar = mock.Mock()
        tar.getnames.return_value = ['marker_1', 'marker_2']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(
            markers, tar,
            {'1234layerdid': ['some/file', 'marker_1', 'marker_2']})

        self.assertTrue(len(tar.addfile.mock_calls) == 0)
Exemple #4
0
class TestAddMarkers(unittest.TestCase):
    def setUp(self):
        self.docker_client = mock.Mock()
        self.log = mock.Mock()
        self.image = "whatever"
        self.squash = Image(self.log, self.docker_client, self.image, None)

    def test_should_not_fail_with_empty_list_of_markers_to_add(self):
        self.squash._add_markers({}, None, None, [])

    def test_should_add_all_marker_files_to_empty_tar(self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')

        markers = {marker_1: 'file'}
        self.squash._add_markers(markers, tar, {}, [])

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file')
        self.assertTrue(tar_info.isfile())

    def test_should_add_all_marker_files_to_empty_tar_besides_what_should_be_skipped(
            self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar,
                                 {'1234layerdid': ['/marker_1', '/marker_2']},
                                 [['/marker_1']])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file2')
        self.assertTrue(tar_info.isfile())

    def test_should_skip_a_marker_file_if_file_is_in_unsquashed_layers(self):
        tar = mock.Mock()
        # List of files in the squashed tar
        tar.getnames.return_value = ['marker_1']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')
        # List of marker files to add back
        markers = {marker_1: 'marker_1', marker_2: 'marker_2'}
        # List of files in all layers to be moved
        files_in_moved_layers = {'1234layerdid': ['/some/file', '/marker_2']}
        self.squash._add_markers(markers, tar, files_in_moved_layers, [])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'marker_2')
        self.assertTrue(tar_info.isfile())

    def test_should_not_add_any_marker_files(self):
        tar = mock.Mock()
        tar.getnames.return_value = ['marker_1', 'marker_2']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(
            markers, tar,
            {'1234layerdid': ['some/file', 'marker_1', 'marker_2']}, [])

        self.assertTrue(len(tar.addfile.mock_calls) == 0)

    # https://github.com/goldmann/docker-squash/issues/108
    def test_should_add_marker_file_when_tar_has_prefixed_entries(self):
        tar = mock.Mock()
        # Files already in tar
        tar.getnames.return_value = ['./abc', './def']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.some/file')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.file2')

        markers = {marker_1: 'filecontent1', marker_2: 'filecontent2'}

        # List of layers to move (and files in these layers), already normalized
        self.squash._add_markers(
            markers, tar,
            {'1234layerdid': ['/some/file', '/other/file', '/stuff']}, [])

        self.assertEqual(len(tar.addfile.mock_calls), 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        # We need to add the marker file because we need to
        # override the already existing file
        self.assertEqual(marker_file, 'filecontent1')
        self.assertTrue(tar_info.isfile())
class TestAddMarkers(unittest.TestCase):

    def setUp(self):
        self.docker_client = mock.Mock()
        self.log = mock.Mock()
        self.image = "whatever"
        self.squash = Image(self.log, self.docker_client, self.image, None)

    def test_should_not_fail_with_empty_list_of_markers_to_add(self):
        self.squash._add_markers({}, None, None)

    def test_should_add_all_marker_files_to_empty_tar(self):
        tar = mock.Mock()
        tar.getnames.return_value = []

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')

        markers = {marker_1: 'file'}
        self.squash._add_markers(markers, tar, {})

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'file')
        self.assertTrue(tar_info.isfile())

    def test_should_skip_a_marker_file_if_file_is_in_unsquashed_layers(self):
        tar = mock.Mock()
        # List of files in the squashed tar
        tar.getnames.return_value = ['marker_1']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')
        # List of marker files to add back
        markers = {marker_1: 'marker_1', marker_2: 'marker_2'}
        # List of files in all layers to be moved
        files_in_moved_layers = {'1234layerdid': ['some/file', 'marker_2']}
        self.squash._add_markers(markers, tar, files_in_moved_layers)

        self.assertTrue(len(tar.addfile.mock_calls) == 1)
        tar_info, marker_file = tar.addfile.call_args[0]
        self.assertIsInstance(tar_info, tarfile.TarInfo)
        self.assertTrue(marker_file == 'marker_2')
        self.assertTrue(tar_info.isfile())

    def test_should_not_add_any_marker_files(self):
        tar = mock.Mock()
        tar.getnames.return_value = ['marker_1', 'marker_2']

        marker_1 = mock.Mock()
        type(marker_1).name = mock.PropertyMock(return_value='.wh.marker_1')
        marker_2 = mock.Mock()
        type(marker_2).name = mock.PropertyMock(return_value='.wh.marker_2')

        markers = {marker_1: 'file1', marker_2: 'file2'}
        self.squash._add_markers(markers, tar, {'1234layerdid': ['some/file', 'marker_1', 'marker_2']})

        self.assertTrue(len(tar.addfile.mock_calls) == 0)