• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env vpython3
2# Copyright 2020 The Chromium Authors
3# Use of this source code is governed by a BSD-style license that can be
4# found in the LICENSE file.
5
6#pylint: disable=protected-access
7
8import json
9import os
10import sys
11import tempfile
12import typing
13import unittest
14
15if sys.version_info[0] == 2:
16  import mock
17else:
18  import unittest.mock as mock
19
20from pyfakefs import fake_filesystem_unittest
21
22from skia_gold_common import skia_gold_properties
23from skia_gold_common import skia_gold_session
24from skia_gold_common import skia_gold_session_manager
25from skia_gold_common import unittest_utils
26
27createSkiaGoldArgs = unittest_utils.createSkiaGoldArgs
28
29
30class SkiaGoldSessionManagerGetSessionTest(fake_filesystem_unittest.TestCase):
31  """Tests the functionality of SkiaGoldSessionManager.GetSkiaGoldSession."""
32
33  def setUp(self) -> None:
34    self.setUpPyfakefs()
35    self._working_dir = tempfile.mkdtemp()
36    self._patcher = mock.patch.object(
37        skia_gold_session_manager.SkiaGoldSessionManager, 'GetSessionClass')
38    self._session_class_mock = self._patcher.start()
39    self._session_class_mock.return_value = skia_gold_session.SkiaGoldSession
40    self.addCleanup(self._patcher.stop)
41
42  def test_ArgsForwardedToSession(self) -> None:
43    args = createSkiaGoldArgs()
44    sgp = skia_gold_properties.SkiaGoldProperties(args)
45    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
46        self._working_dir, sgp)
47    session = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance')
48    self.assertTrue(session._keys_file.startswith(self._working_dir))
49    self.assertEqual(session._corpus, 'corpus')
50    self.assertEqual(session._instance, 'instance')
51    # Make sure the session's working directory is a subdirectory of the
52    # manager's working directory.
53    self.assertEqual(os.path.dirname(session._working_dir), self._working_dir)
54
55  def test_corpusFromJson(self) -> None:
56    args = createSkiaGoldArgs()
57    sgp = skia_gold_properties.SkiaGoldProperties(args)
58    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
59        self._working_dir, sgp)
60    session = sgsm.GetSkiaGoldSession({'source_type': 'foobar'}, None,
61                                      'instance')
62    self.assertTrue(session._keys_file.startswith(self._working_dir))
63    self.assertEqual(session._corpus, 'foobar')
64    self.assertEqual(session._instance, 'instance')
65
66  def test_corpusDefaultsToInstance(self) -> None:
67    args = createSkiaGoldArgs()
68    sgp = skia_gold_properties.SkiaGoldProperties(args)
69    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
70        self._working_dir, sgp)
71    session = sgsm.GetSkiaGoldSession({}, None, 'instance')
72    self.assertTrue(session._keys_file.startswith(self._working_dir))
73    self.assertEqual(session._corpus, 'instance')
74    self.assertEqual(session._instance, 'instance')
75
76  @mock.patch.object(skia_gold_session_manager.SkiaGoldSessionManager,
77                     '_GetDefaultInstance')
78  def test_getDefaultInstance(self,
79                              default_instance_mock: mock.MagicMock) -> None:
80    default_instance_mock.return_value = 'default'
81    args = createSkiaGoldArgs()
82    sgp = skia_gold_properties.SkiaGoldProperties(args)
83    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
84        self._working_dir, sgp)
85    session = sgsm.GetSkiaGoldSession({}, None, None)
86    self.assertTrue(session._keys_file.startswith(self._working_dir))
87    self.assertEqual(session._corpus, 'default')
88    self.assertEqual(session._instance, 'default')
89
90  @mock.patch.object(skia_gold_session.SkiaGoldSession, '__init__')
91  def test_matchingSessionReused(self, session_mock: mock.MagicMock) -> None:
92    session_mock.return_value = None
93    args = createSkiaGoldArgs()
94    sgp = skia_gold_properties.SkiaGoldProperties(args)
95    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
96        self._working_dir, sgp)
97    session1 = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance')
98    session2 = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance')
99    self.assertEqual(session1, session2)
100    # For some reason, session_mock.assert_called_once() always passes,
101    # so check the call count directly.
102    self.assertEqual(session_mock.call_count, 1)
103
104  @mock.patch.object(skia_gold_session.SkiaGoldSession, '__init__')
105  def test_separateSessionsFromKeys(self, session_mock: mock.MagicMock) -> None:
106    session_mock.return_value = None
107    args = createSkiaGoldArgs()
108    sgp = skia_gold_properties.SkiaGoldProperties(args)
109    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
110        self._working_dir, sgp)
111    session1 = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance')
112    session2 = sgsm.GetSkiaGoldSession({'something_different': 1}, 'corpus',
113                                       'instance')
114    self.assertNotEqual(session1, session2)
115    self.assertEqual(session_mock.call_count, 2)
116
117  @mock.patch.object(skia_gold_session.SkiaGoldSession, '__init__')
118  def test_separateSessionsFromCorpus(self,
119                                      session_mock: mock.MagicMock) -> None:
120    session_mock.return_value = None
121    args = createSkiaGoldArgs()
122    sgp = skia_gold_properties.SkiaGoldProperties(args)
123    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
124        self._working_dir, sgp)
125    session1 = sgsm.GetSkiaGoldSession({}, 'corpus1', 'instance')
126    session2 = sgsm.GetSkiaGoldSession({}, 'corpus2', 'instance')
127    self.assertNotEqual(session1, session2)
128    self.assertEqual(session_mock.call_count, 2)
129
130  @mock.patch.object(skia_gold_session.SkiaGoldSession, '__init__')
131  def test_separateSessionsFromInstance(self,
132                                        session_mock: mock.MagicMock) -> None:
133    session_mock.return_value = None
134    args = createSkiaGoldArgs()
135    sgp = skia_gold_properties.SkiaGoldProperties(args)
136    self._working_dir = tempfile.mkdtemp()
137    sgsm = skia_gold_session_manager.SkiaGoldSessionManager(
138        self._working_dir, sgp)
139    session1 = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance1')
140    session2 = sgsm.GetSkiaGoldSession({}, 'corpus', 'instance2')
141    self.assertNotEqual(session1, session2)
142    self.assertEqual(session_mock.call_count, 2)
143
144
145class SkiaGoldSessionManagerKeyConversionTest(fake_filesystem_unittest.TestCase
146                                              ):
147  def setUp(self) -> None:
148    self.setUpPyfakefs()
149    self._working_dir = tempfile.mkdtemp()
150
151  def test_getKeysAsDict(self) -> None:
152    keys_dict = {'foo': 'bar'}
153    keys_file_contents = {'bar': 'baz'}
154    keys_file = tempfile.NamedTemporaryFile(delete=False).name
155    with open(keys_file, 'w') as f:
156      json.dump(keys_file_contents, f)
157
158    self.assertEqual(skia_gold_session_manager._GetKeysAsDict(keys_dict),
159                     keys_dict)
160    self.assertEqual(skia_gold_session_manager._GetKeysAsDict(keys_file),
161                     keys_file_contents)
162    with self.assertRaises(AssertionError):
163      skia_gold_session_manager._GetKeysAsDict(typing.cast(dict, 1))
164
165  def test_getKeysAsJson(self) -> None:
166    keys_dict = {'foo': 'bar'}
167    keys_file_contents = {'bar': 'baz'}
168    keys_file = tempfile.NamedTemporaryFile(delete=False).name
169    with open(keys_file, 'w') as f:
170      json.dump(keys_file_contents, f)
171
172    self.assertEqual(skia_gold_session_manager._GetKeysAsJson(keys_file, ''),
173                     keys_file)
174    keys_dict_as_json = skia_gold_session_manager._GetKeysAsJson(
175        keys_dict, self._working_dir)
176    self.assertTrue(keys_dict_as_json.startswith(self._working_dir))
177    with open(keys_dict_as_json) as f:
178      self.assertEqual(json.load(f), keys_dict)
179    with self.assertRaises(AssertionError):
180      skia_gold_session_manager._GetKeysAsJson(typing.cast(dict, 1), '')
181
182
183if __name__ == '__main__':
184  unittest.main(verbosity=2)
185