# Copyright 2015 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Tests for the brick library."""

from __future__ import print_function

import os

from chromite.cbuildbot import constants
from chromite.lib import brick_lib
from chromite.lib import cros_test_lib
from chromite.lib import osutils
from chromite.lib import workspace_lib


class BrickLibTest(cros_test_lib.WorkspaceTestCase):
  """Unittest for brick.py"""

  # pylint: disable=protected-access

  def setUp(self):
    self.CreateWorkspace()

  def SetupLegacyBrick(self, brick_dir=None, brick_name='foo'):
    """Sets up a legacy brick layout."""
    if brick_dir is None:
      brick_dir = self.workspace_path
    layout_conf = 'repo-name = %s\n' % brick_name
    osutils.WriteFile(os.path.join(brick_dir, 'metadata', 'layout.conf'),
                      layout_conf, makedirs=True)

  def testLayoutFormat(self):
    """Test that layout.conf is correctly formatted."""
    brick = self.CreateBrick()
    content = {'repo-name': 'hello',
               'bar': 'foo'}
    brick._WriteLayoutConf(content)

    path = os.path.join(brick.OverlayDir(), 'metadata', 'layout.conf')
    layout_conf = osutils.ReadFile(path).split('\n')

    expected_lines = ['repo-name = hello',
                      'bar = foo',
                      'profile-formats = portage-2 profile-default-eapi']
    for line in expected_lines:
      self.assertTrue(line in layout_conf)

  def testConfigurationGenerated(self):
    """Test that portage's files are generated when the config file changes."""
    brick = self.CreateBrick()
    sample_config = {'name': 'hello',
                     'dependencies': []}

    brick.UpdateConfig(sample_config)

    self.assertExists(brick._LayoutConfPath())

  def testFindBrickInPath(self):
    """Test that we can infer the current brick from the current directory."""
    brick = self.CreateBrick()
    os.remove(os.path.join(brick.brick_dir, brick_lib._CONFIG_FILE))
    brick_dir = os.path.join(self.workspace_path, 'foo', 'bar', 'project')
    expected_name = 'hello'
    brick_lib.Brick(brick_dir, initial_config={'name': 'hello'})

    with osutils.ChdirContext(self.workspace_path):
      self.assertEqual(None, brick_lib.FindBrickInPath())

    with osutils.ChdirContext(brick_dir):
      self.assertEqual(expected_name,
                       brick_lib.FindBrickInPath().config['name'])

    subdir = os.path.join(brick_dir, 'sub', 'directory')
    osutils.SafeMakedirs(subdir)
    with osutils.ChdirContext(subdir):
      self.assertEqual(expected_name,
                       brick_lib.FindBrickInPath().config['name'])

  def testBrickCreation(self):
    """Test that brick initialization throws the right errors."""
    brick = self.CreateBrick()
    with self.assertRaises(brick_lib.BrickCreationFailed):
      brick_lib.Brick(brick.brick_dir, initial_config={})

    nonexistingbrick = os.path.join(self.workspace_path, 'foo')
    with self.assertRaises(brick_lib.BrickNotFound):
      brick_lib.Brick(nonexistingbrick)

  def testLoadNonExistingBrickFails(self):
    """Tests that trying to load a non-existing brick fails."""
    self.assertRaises(brick_lib.BrickNotFound, brick_lib.Brick,
                      self.workspace_path)

  def testLoadExistingNormalBrickSucceeds(self):
    """Tests that loading an existing brick works."""
    brick = self.CreateBrick(name='my_brick')
    brick = brick_lib.Brick(brick.brick_dir, allow_legacy=False)
    self.assertEquals('my_brick', brick.config.get('name'))

  def testLoadExistingLegacyBrickFailsIfNotAllowed(self):
    """Tests that loading a legacy brick fails when not allowed."""
    self.SetupLegacyBrick()
    with self.assertRaises(brick_lib.BrickNotFound):
      brick_lib.Brick(self.workspace_path, allow_legacy=False)

  def testLoadExistingLegacyBrickSucceeds(self):
    """Tests that loading a legacy brick fails when not allowed."""
    self.SetupLegacyBrick()
    brick = brick_lib.Brick(self.workspace_path)
    self.assertEquals('foo', brick.config.get('name'))

  def testLegacyBrickUpdateConfigFails(self):
    """Tests that a legacy brick config cannot be updated."""
    self.SetupLegacyBrick()
    brick = brick_lib.Brick(self.workspace_path)
    with self.assertRaises(brick_lib.BrickFeatureNotSupported):
      brick.UpdateConfig({'name': 'bar'})

  def testInherits(self):
    """Tests the containment checking works as intended."""
    saved_root = constants.SOURCE_ROOT

    try:
      # Mock the source root so that we can create fake legacy overlay.
      constants.SOURCE_ROOT = self.workspace_path
      legacy = os.path.join(self.workspace_path, 'src', 'overlays',
                            'overlay-foobar')
      self.SetupLegacyBrick(brick_dir=legacy, brick_name='foobar')

      bar_brick = brick_lib.Brick('//bar', initial_config={'name': 'bar'})
      foo_brick = brick_lib.Brick(
          '//foo', initial_config={'name': 'foo',
                                   'dependencies': ['//bar', 'board:foobar']})

      self.assertTrue(bar_brick.Inherits('bar'))
      self.assertTrue(foo_brick.Inherits('bar'))
      self.assertFalse(bar_brick.Inherits('foo'))
      self.assertTrue(foo_brick.Inherits('foobar'))
      self.assertFalse(foo_brick.Inherits('dontexist'))

    finally:
      constants.SOURCE_ROOT = saved_root

  def testOverlayDir(self):
    """Tests that overlay directory is returned correctly."""
    self.assertExists(self.CreateBrick().OverlayDir())

  def testOpenUsingLocator(self):
    """Tests that we can open a brick given a locator."""
    brick_lib.Brick(os.path.join(self.workspace_path, 'foo'),
                    initial_config={'name': 'foo'})

    brick_lib.Brick('//foo')

    with self.assertRaises(brick_lib.BrickNotFound):
      brick_lib.Brick('//doesnotexist')

  def testCreateUsingLocator(self):
    """Tests that we can create a brick using a locator."""
    brick_lib.Brick('//foobar', initial_config={'name': 'foobar'})
    brick_lib.Brick('//bricks/some/path', initial_config={'name': 'path'})

    brick_lib.Brick('//foobar')
    brick_lib.Brick('//bricks/some/path')

    brick_lib.Brick(os.path.join(self.workspace_path, 'foobar'))
    brick_lib.Brick(os.path.join(self.workspace_path, 'bricks', 'some', 'path'))

  def testFriendlyName(self):
    """Tests that the friendly name generation works."""
    first = brick_lib.Brick('//foo/bar/test', initial_config={'name': 'test'})
    self.assertEqual('foo.bar.test', first.FriendlyName())

    second = brick_lib.Brick(os.path.join(self.workspace_path, 'test', 'foo'),
                             initial_config={'name': 'foo'})
    self.assertEqual('test.foo', second.FriendlyName())

  def testMissingDependency(self):
    """Tests that the brick creation fails when a dependency is missing."""
    with self.assertRaises(brick_lib.BrickCreationFailed):
      brick_lib.Brick('//bar',
                      initial_config={'name':'bar',
                                      'dependencies':['//dont/exist']})

    # If the creation failed, the directory is removed cleanly.
    self.assertFalse(os.path.exists(workspace_lib.LocatorToPath('//bar')))

  def testNormalizedDependencies(self):
    """Tests that dependencies are normalized during brick creation."""
    brick_lib.Brick('//foo/bar', initial_config={'name': 'bar'})
    with osutils.ChdirContext(os.path.join(self.workspace_path, 'foo')):
      brick_lib.Brick('//baz', initial_config={'name': 'baz',
                                               'dependencies': ['bar']})

    deps = brick_lib.Brick('//baz').config['dependencies']
    self.assertEqual(1, len(deps))
    self.assertEqual('//foo/bar', deps[0])

  def testBrickStack(self):
    """Tests that the brick stacking is correct."""
    def brick_dep(name, deps):
      config = {'name': os.path.basename(name),
                'dependencies': deps}
      return brick_lib.Brick(name, initial_config=config)

    brick_dep('//first', [])
    brick_dep('//second', ['//first'])
    third = brick_dep('//third', ['//first', '//second'])
    fourth = brick_dep('//fourth', ['//second', '//first'])

    self.assertEqual(['//first', '//second', '//third'],
                     [b.brick_locator for b in third.BrickStack()])

    self.assertEqual(['//first', '//second', '//fourth'],
                     [b.brick_locator for b in fourth.BrickStack()])