#!/usr/bin/env python3
#
# Copyright 2019, 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 generate project file of Eclipse."""

import os
import unittest
from unittest import mock

from aidegen import unittest_constants
from aidegen.lib import common_util
from aidegen.lib import eclipse_project_file_gen
from aidegen.lib import project_info


# pylint: disable=protected-access
class EclipseConfUnittests(unittest.TestCase):
    """Unit tests for generate_project_file.py"""
    _ROOT_PATH = '/android/root'
    _PROJECT_RELPATH = 'module/path'
    _PROJECT_ABSPATH = os.path.join(_ROOT_PATH, _PROJECT_RELPATH)
    _PROJECT_SAMPLE = os.path.join(unittest_constants.TEST_DATA_PATH,
                                   'eclipse.project')

    def setUp(self):
        """Prepare the EclipseConf object."""
        with mock.patch.object(project_info, 'ProjectInfo') as self.proj_info:
            self.proj_info.project_absolute_path = self._PROJECT_ABSPATH
            self.proj_info.project_relative_path = self._PROJECT_RELPATH
            self.proj_info.module_name = 'test'
            self.eclipse = eclipse_project_file_gen.EclipseConf(self.proj_info)

    def tearDown(self):
        """Clear the EclipseConf object."""
        self.eclipse = None

    @mock.patch.object(common_util, 'get_android_root_dir')
    def test_gen_link(self, mock_get_root):
        """Test get_link return a correct link resource config."""
        mock_get_root.return_value = '/a'
        expected_result = ('                <link><name>dependencies/b/c</name>'
                           '<type>2</type><location>/a/b/c</location></link>\n')
        self.assertEqual(self.eclipse._gen_link('b/c'), expected_result)

    @mock.patch('os.path.exists')
    @mock.patch.object(common_util, 'get_android_out_dir')
    @mock.patch.object(common_util, 'get_android_root_dir')
    def test_create_project_content(self, mock_get_root, mock_out_dir,
                                    mock_dir_exists):
        """Test _create_project_content."""
        mock_get_root.return_value = self._ROOT_PATH
        mock_out_dir.return_value = os.path.join(self._ROOT_PATH, 'out')
        mock_dir_exists.return_value = True
        self.eclipse.jar_module_paths = {
            'relative/path/to/file1.jar': self._PROJECT_RELPATH,
            'relative/path/to/file2.jar': 'source/folder/of/jar',
        }
        expected_content = common_util.read_file_content(self._PROJECT_SAMPLE)
        self.eclipse._create_project_content()
        self.assertEqual(self.eclipse.project_content, expected_content)

    @mock.patch.object(common_util, 'exist_android_bp')
    @mock.patch.object(common_util, 'get_android_root_dir')
    def test_gen_src_path_entries(self, mock_get_root, mock_exist_android_bp):
        """Test generate source folders' class path entries."""
        mock_get_root.return_value = self._ROOT_PATH
        self.eclipse.src_paths = {'module/path/src', 'module/path/test',
                                  'out/src'}
        expected_result = [
            '    <classpathentry kind="src" path="dependencies/out/src"/>\n',
            '    <classpathentry kind="src" path="src"/>\n',
            '    <classpathentry kind="src" path="test"/>\n',
        ]
        mock_exist_android_bp.return_value = False
        generated_result = sorted(self.eclipse._gen_src_path_entries())
        self.assertEqual(generated_result, expected_result)

        mock_exist_android_bp.return_value = True
        expected_result = [
            '    <classpathentry excluding="Android.bp" kind="src" '
            'path="dependencies/out/src"/>\n',
            '    <classpathentry excluding="Android.bp" kind="src" '
            'path="src"/>\n',
            '    <classpathentry excluding="Android.bp" kind="src" '
            'path="test"/>\n',
        ]
        generated_result = sorted(self.eclipse._gen_src_path_entries())
        self.assertEqual(generated_result, expected_result)

    @mock.patch.object(common_util, 'get_android_root_dir')
    def test_gen_jar_path_entries(self, mock_get_root):
        """Test generate jar files' class path entries."""
        mock_get_root.return_value = self._ROOT_PATH
        self.eclipse.jar_module_paths = {
            '/abspath/to/the/file.jar': 'relpath/to/the/module',
        }
        expected_result = [
            ('    <classpathentry exported="true" kind="lib" '
             'path="/abspath/to/the/file.jar" '
             'sourcepath="dependencies/relpath/to/the/module"/>\n')
        ]
        self.assertEqual(self.eclipse._gen_jar_path_entries(), expected_result)

    def test_get_other_src_folders(self):
        """Test _get_other_src_folders."""
        self.eclipse.src_paths = {'module/path/src', 'module/path/test',
                                  'out/module/path/src'}
        expected_result = ['out/module/path/src']
        self.assertEqual(self.eclipse._get_other_src_folders(), expected_result)

    @mock.patch('os.makedirs')
    @mock.patch('os.path.exists')
    def test_gen_bin_link(self, mock_exists, mock_mkdir):
        """Test _gen_bin_link."""
        mock_exists.return_value = True
        self.eclipse._gen_bin_link()
        self.assertFalse(mock_mkdir.called)
        mock_exists.return_value = False
        self.eclipse._gen_bin_link()
        self.assertTrue(mock_mkdir.called)

    def test_gen_r_path_entries(self):
        """Test _gen_r_path_entries."""
        self.eclipse.r_java_paths = ['a/b', 'c/d']
        expected_result = [
            '    <classpathentry kind="src" path="dependencies/a/b"/>\n',
            '    <classpathentry kind="src" path="dependencies/c/d"/>\n',
        ]
        self.assertEqual(self.eclipse._gen_r_path_entries(), expected_result)

    def test_gen_bin_dir_entry(self):
        """Test _gen_bin_dir_entry."""
        expected_result = ['    <classpathentry kind="src" path="bin"/>\n']
        self.assertEqual(self.eclipse._gen_bin_dir_entry(), expected_result)

    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_gen_jar_path_entries')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_gen_bin_dir_entry')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_gen_r_path_entries')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_gen_src_path_entries')
    def test_create_classpath_content(self, mock_gen_src, mock_gen_r,
                                      mock_gen_bin, mock_gen_jar):
        """Test _create_classpath_content."""
        self.eclipse._create_classpath_content()
        self.assertTrue(mock_gen_src.called)
        self.assertTrue(mock_gen_r.called)
        self.assertTrue(mock_gen_bin.called)
        self.assertTrue(mock_gen_jar.called)

    @mock.patch.object(common_util, 'file_generate')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_create_project_content')
    def test_generate_project_file(self, mock_gen_content, mock_gen_file):
        """Test generate_project_file."""
        self.eclipse.generate_project_file()
        self.assertTrue(mock_gen_content.called)
        self.assertTrue(mock_gen_file.called)

    @mock.patch.object(common_util, 'file_generate')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       '_create_classpath_content')
    def test_generate_classpath_file(self, mock_gen_content, mock_gen_file):
        """Test generate_classpath_file."""
        self.eclipse.generate_classpath_file()
        self.assertTrue(mock_gen_content.called)
        self.assertTrue(mock_gen_file.called)

    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       'generate_classpath_file')
    @mock.patch.object(eclipse_project_file_gen.EclipseConf,
                       'generate_project_file')
    def test_generate_ide_project_files(self, mock_gen_project,
                                        mock_gen_classpath):
        """Test generate_ide_project_files."""
        self.eclipse.generate_ide_project_files([self.proj_info])
        self.assertTrue(mock_gen_project.called)
        self.assertTrue(mock_gen_classpath.called)


if __name__ == '__main__':
    unittest.main()