Tools/Scripts/webkitpy/layout_tests/port/config_unittest.py - platform/external/webkit - Git at Google

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #    * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
 # in the documentation and/or other materials provided with the
 # distribution.
 #    * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 import os
 import sys
 import unittest

 from webkitpy.common.system import executive
 from webkitpy.common.system import executive_mock
 from webkitpy.common.system import filesystem
 from webkitpy.common.system import filesystem_mock
 from webkitpy.common.system import outputcapture

 import config


 def mock_run_command(arg_list):
     # Set this to True to test actual output (where possible).
     integration_test = False
     if integration_test:
         return executive.Executive().run_command(arg_list)

     if 'webkit-build-directory' in arg_list[1]:
         return mock_webkit_build_directory(arg_list[2:])
     return 'Error'


 def mock_webkit_build_directory(arg_list):
     if arg_list == ['--top-level']:
         return '/WebKitBuild'
     elif arg_list == ['--configuration', '--debug']:
         return '/WebKitBuild/Debug'
     elif arg_list == ['--configuration', '--release']:
         return '/WebKitBuild/Release'
     return 'Error'


 class ConfigTest(unittest.TestCase):
     def tearDown(self):
         config.clear_cached_configuration()

     def make_config(self, output='', files={}, exit_code=0, exception=None,
                     run_command_fn=None):
         e = executive_mock.MockExecutive2(output=output, exit_code=exit_code,
                                           exception=exception,
                                           run_command_fn=run_command_fn)
         fs = filesystem_mock.MockFileSystem(files)
         return config.Config(e, fs)

     def assert_configuration(self, contents, expected):
         # This tests that a configuration file containing
         # _contents_ ends up being interpreted as _expected_.
         c = self.make_config('foo', {'foo/Configuration': contents})
         self.assertEqual(c.default_configuration(), expected)

     def test_build_directory(self):
         # --top-level
         c = self.make_config(run_command_fn=mock_run_command)
         self.assertTrue(c.build_directory(None).endswith('WebKitBuild'))

         # Test again to check caching
         self.assertTrue(c.build_directory(None).endswith('WebKitBuild'))

         # Test other values
         self.assertTrue(c.build_directory('Release').endswith('/Release'))
         self.assertTrue(c.build_directory('Debug').endswith('/Debug'))
         self.assertRaises(KeyError, c.build_directory, 'Unknown')

     def test_build_dumprendertree__success(self):
         c = self.make_config(exit_code=0)
         self.assertTrue(c.build_dumprendertree("Debug"))
         self.assertTrue(c.build_dumprendertree("Release"))
         self.assertRaises(KeyError, c.build_dumprendertree, "Unknown")

     def test_build_dumprendertree__failure(self):
         c = self.make_config(exit_code=-1)

         # FIXME: Build failures should log errors. However, the message we
         # get depends on how we're being called; as a standalone test,
         # we'll get the "no handlers found" message. As part of
         # test-webkitpy, we get the actual message. Really, we need
         # outputcapture to install its own handler.
         oc = outputcapture.OutputCapture()
         oc.capture_output()
         self.assertFalse(c.build_dumprendertree('Debug'))
         oc.restore_output()

         oc.capture_output()
         self.assertFalse(c.build_dumprendertree('Release'))
         oc.restore_output()

     def test_default_configuration__release(self):
         self.assert_configuration('Release', 'Release')

     def test_default_configuration__debug(self):
         self.assert_configuration('Debug', 'Debug')

     def test_default_configuration__deployment(self):
         self.assert_configuration('Deployment', 'Release')

     def test_default_configuration__development(self):
         self.assert_configuration('Development', 'Debug')

     def test_default_configuration__notfound(self):
         # This tests what happens if the default configuration file
         # doesn't exist.
         c = self.make_config(output='foo', files={'foo/Configuration': None})
         self.assertEqual(c.default_configuration(), "Release")

     def test_default_configuration__unknown(self):
         # Ignore the warning about an unknown configuration value.
         oc = outputcapture.OutputCapture()
         oc.capture_output()
         self.assert_configuration('Unknown', 'Unknown')
         oc.restore_output()

     def test_default_configuration__standalone(self):
         # FIXME: This test runs a standalone python script to test
         # reading the default configuration to work around any possible
         # caching / reset bugs. See https://bugs.webkit.org/show_bug?id=49360
         # for the motivation. We can remove this test when we remove the
         # global configuration cache in config.py.
         e = executive.Executive()
         fs = filesystem.FileSystem()
         c = config.Config(e, fs)
         script = c.path_from_webkit_base('Tools', 'Scripts',
             'webkitpy', 'layout_tests', 'port', 'config_standalone.py')

         # Note: don't use 'Release' here, since that's the normal default.
         expected = 'Debug'

         args = [sys.executable, script, '--mock', expected]
         actual = e.run_command(args).rstrip()
         self.assertEqual(actual, expected)

     def test_default_configuration__no_perl(self):
         # We need perl to run webkit-build-directory to find out where the
         # default configuration file is. See what happens if perl isn't
         # installed. (We should get the default value, 'Release').
         c = self.make_config(exception=OSError)
         actual = c.default_configuration()
         self.assertEqual(actual, 'Release')

     def test_default_configuration__scripterror(self):
         # We run webkit-build-directory to find out where the default
         # configuration file is. See what happens if that script fails.
         # (We should get the default value, 'Release').
         c = self.make_config(exception=executive.ScriptError())
         actual = c.default_configuration()
         self.assertEqual(actual, 'Release')

     def test_path_from_webkit_base(self):
         # FIXME: We use a real filesystem here. Should this move to a
         # mocked one?
         c = config.Config(executive.Executive(), filesystem.FileSystem())
         self.assertTrue(c.path_from_webkit_base('foo'))

     def test_webkit_base_dir(self):
         # FIXME: We use a real filesystem here. Should this move to a
         # mocked one?
         c = config.Config(executive.Executive(), filesystem.FileSystem())
         base_dir = c.webkit_base_dir()
         self.assertTrue(base_dir)
         self.assertNotEqual(base_dir[-1], '/')

         orig_cwd = os.getcwd()
         if sys.platform == 'win32':
             os.chdir(os.environ['USERPROFILE'])
         else:
             os.chdir(os.environ['HOME'])
         c = config.Config(executive.Executive(), filesystem.FileSystem())
         try:
             base_dir_2 = c.webkit_base_dir()
             self.assertEqual(base_dir, base_dir_2)
         finally:
             os.chdir(orig_cwd)


 if __name__ == '__main__':
     unittest.main()
	# Copyright (C) 2010 Google Inc. All rights reserved.
	#
	# Redistribution and use in source and binary forms, with or without
	# modification, are permitted provided that the following conditions are
	# met:
	#
	# * Redistributions of source code must retain the above copyright
	# notice, this list of conditions and the following disclaimer.
	# * Redistributions in binary form must reproduce the above
	# copyright notice, this list of conditions and the following disclaimer
	# in the documentation and/or other materials provided with the
	# distribution.
	# * Neither the name of Google Inc. nor the names of its
	# contributors may be used to endorse or promote products derived from
	# this software without specific prior written permission.
	#
	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	import os
	import sys
	import unittest

	from webkitpy.common.system import executive
	from webkitpy.common.system import executive_mock
	from webkitpy.common.system import filesystem
	from webkitpy.common.system import filesystem_mock
	from webkitpy.common.system import outputcapture

	import config


	def mock_run_command(arg_list):
	# Set this to True to test actual output (where possible).
	integration_test = False
	if integration_test:
	return executive.Executive().run_command(arg_list)

	if 'webkit-build-directory' in arg_list[1]:
	return mock_webkit_build_directory(arg_list[2:])
	return 'Error'


	def mock_webkit_build_directory(arg_list):
	if arg_list == ['--top-level']:
	return '/WebKitBuild'
	elif arg_list == ['--configuration', '--debug']:
	return '/WebKitBuild/Debug'
	elif arg_list == ['--configuration', '--release']:
	return '/WebKitBuild/Release'
	return 'Error'


	class ConfigTest(unittest.TestCase):
	def tearDown(self):
	config.clear_cached_configuration()

	def make_config(self, output='', files={}, exit_code=0, exception=None,
	run_command_fn=None):
	e = executive_mock.MockExecutive2(output=output, exit_code=exit_code,
	exception=exception,
	run_command_fn=run_command_fn)
	fs = filesystem_mock.MockFileSystem(files)
	return config.Config(e, fs)

	def assert_configuration(self, contents, expected):
	# This tests that a configuration file containing
	# _contents_ ends up being interpreted as _expected_.
	c = self.make_config('foo', {'foo/Configuration': contents})
	self.assertEqual(c.default_configuration(), expected)

	def test_build_directory(self):
	# --top-level
	c = self.make_config(run_command_fn=mock_run_command)
	self.assertTrue(c.build_directory(None).endswith('WebKitBuild'))

	# Test again to check caching
	self.assertTrue(c.build_directory(None).endswith('WebKitBuild'))

	# Test other values
	self.assertTrue(c.build_directory('Release').endswith('/Release'))
	self.assertTrue(c.build_directory('Debug').endswith('/Debug'))
	self.assertRaises(KeyError, c.build_directory, 'Unknown')

	def test_build_dumprendertree__success(self):
	c = self.make_config(exit_code=0)
	self.assertTrue(c.build_dumprendertree("Debug"))
	self.assertTrue(c.build_dumprendertree("Release"))
	self.assertRaises(KeyError, c.build_dumprendertree, "Unknown")

	def test_build_dumprendertree__failure(self):
	c = self.make_config(exit_code=-1)

	# FIXME: Build failures should log errors. However, the message we
	# get depends on how we're being called; as a standalone test,
	# we'll get the "no handlers found" message. As part of
	# test-webkitpy, we get the actual message. Really, we need
	# outputcapture to install its own handler.
	oc = outputcapture.OutputCapture()
	oc.capture_output()
	self.assertFalse(c.build_dumprendertree('Debug'))
	oc.restore_output()

	oc.capture_output()
	self.assertFalse(c.build_dumprendertree('Release'))
	oc.restore_output()

	def test_default_configuration__release(self):
	self.assert_configuration('Release', 'Release')

	def test_default_configuration__debug(self):
	self.assert_configuration('Debug', 'Debug')

	def test_default_configuration__deployment(self):
	self.assert_configuration('Deployment', 'Release')

	def test_default_configuration__development(self):
	self.assert_configuration('Development', 'Debug')

	def test_default_configuration__notfound(self):
	# This tests what happens if the default configuration file
	# doesn't exist.
	c = self.make_config(output='foo', files={'foo/Configuration': None})
	self.assertEqual(c.default_configuration(), "Release")

	def test_default_configuration__unknown(self):
	# Ignore the warning about an unknown configuration value.
	oc = outputcapture.OutputCapture()
	oc.capture_output()
	self.assert_configuration('Unknown', 'Unknown')
	oc.restore_output()

	def test_default_configuration__standalone(self):
	# FIXME: This test runs a standalone python script to test
	# reading the default configuration to work around any possible
	# caching / reset bugs. See https://bugs.webkit.org/show_bug?id=49360
	# for the motivation. We can remove this test when we remove the
	# global configuration cache in config.py.
	e = executive.Executive()
	fs = filesystem.FileSystem()
	c = config.Config(e, fs)
	script = c.path_from_webkit_base('Tools', 'Scripts',
	'webkitpy', 'layout_tests', 'port', 'config_standalone.py')

	# Note: don't use 'Release' here, since that's the normal default.
	expected = 'Debug'

	args = [sys.executable, script, '--mock', expected]
	actual = e.run_command(args).rstrip()
	self.assertEqual(actual, expected)

	def test_default_configuration__no_perl(self):
	# We need perl to run webkit-build-directory to find out where the
	# default configuration file is. See what happens if perl isn't
	# installed. (We should get the default value, 'Release').
	c = self.make_config(exception=OSError)
	actual = c.default_configuration()
	self.assertEqual(actual, 'Release')

	def test_default_configuration__scripterror(self):
	# We run webkit-build-directory to find out where the default
	# configuration file is. See what happens if that script fails.
	# (We should get the default value, 'Release').
	c = self.make_config(exception=executive.ScriptError())
	actual = c.default_configuration()
	self.assertEqual(actual, 'Release')

	def test_path_from_webkit_base(self):
	# FIXME: We use a real filesystem here. Should this move to a
	# mocked one?
	c = config.Config(executive.Executive(), filesystem.FileSystem())
	self.assertTrue(c.path_from_webkit_base('foo'))

	def test_webkit_base_dir(self):
	# FIXME: We use a real filesystem here. Should this move to a
	# mocked one?
	c = config.Config(executive.Executive(), filesystem.FileSystem())
	base_dir = c.webkit_base_dir()
	self.assertTrue(base_dir)
	self.assertNotEqual(base_dir[-1], '/')

	orig_cwd = os.getcwd()
	if sys.platform == 'win32':
	os.chdir(os.environ['USERPROFILE'])
	else:
	os.chdir(os.environ['HOME'])
	c = config.Config(executive.Executive(), filesystem.FileSystem())
	try:
	base_dir_2 = c.webkit_base_dir()
	self.assertEqual(base_dir, base_dir_2)
	finally:
	os.chdir(orig_cwd)


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