def __init__(self, file_path): """ Generates a new environment in which to run Integration tests. `testdata_dir` refers to the base testdata directory, which individual tests will then use to load their test-specific configurations. """ # We also need a sandbox to play in. self.sandbox = FakeFilesystem(root = tempfile.mkdtemp()) # Need a dummy Steam installation for Ice to work with # We'll put it in the `Steam` directory of our sandbox self.steam_fixture = SteamFixture(os.path.join(self.sandbox.root, "Steam")) # Create a list of user fixtures that consumers can populate self.user_fixtures = [] # The testdata directory should be in the same directory as the tests # themselves. self.testdata_dir = os.path.join(os.path.dirname(file_path), "testdata") assert os.path.exists(self.testdata_dir) self.loaded_data = None self.extra_args = []
def __init__(self, file_path): """ Generates a new environment in which to run Integration tests. `testdata_dir` refers to the base testdata directory, which individual tests will then use to load their test-specific configurations. """ # We also need a sandbox to play in. self.sandbox = FakeFilesystem(root=tempfile.mkdtemp()) # Need a dummy Steam installation for Ice to work with # We'll put it in the `Steam` directory of our sandbox self.steam_fixture = SteamFixture(os.path.join(self.sandbox.root, "Steam")) # Create a list of user fixtures that consumers can populate self.user_fixtures = [] # The testdata directory should be in the same directory as the tests # themselves. self.testdata_dir = os.path.join(os.path.dirname(file_path), "testdata") assert os.path.exists(self.testdata_dir) self.loaded_data = None self.extra_args = []
class FakeEnvironment(object): def __init__(self, file_path): """ Generates a new environment in which to run Integration tests. `testdata_dir` refers to the base testdata directory, which individual tests will then use to load their test-specific configurations. """ # We also need a sandbox to play in. self.sandbox = FakeFilesystem(root=tempfile.mkdtemp()) # Need a dummy Steam installation for Ice to work with # We'll put it in the `Steam` directory of our sandbox self.steam_fixture = SteamFixture( os.path.join(self.sandbox.root, "Steam")) # Create a list of user fixtures that consumers can populate self.user_fixtures = [] # The testdata directory should be in the same directory as the tests # themselves. self.testdata_dir = os.path.join(os.path.dirname(file_path), "testdata") assert (os.path.exists(self.testdata_dir)) self.loaded_data = None self.extra_args = [] def clean(self): for user_fixture in self.user_fixtures: user_fixture.tearDown() self.steam_fixture.tearDown() shutil.rmtree(self.sandbox.root) def _use_config_file(self, file, location): assert (os.path.exists(location)) self.extra_args.append('--%s' % file) self.extra_args.append(location) def _test_config_path(self, directory, file): return os.path.join(directory, '%s.txt' % file) def _load_config_file_overrides(self, directory): file_basenames = ['config', 'consoles', 'emulators'] filenames = map(lambda f: '%s.txt' % f, file_basenames) for f in file_basenames: self._use_config_file(f, self._test_config_path(directory, f)) def _load_roms_for_test(self, directory): """Takes the ROMs located in `directory/ROMs` and moves them into the ROMs directory specified in the provided config.txt file.""" # TODO: This is extremely non-kosher. The fact that I have to do this # suggests that something is very wrong with my Configuration object. # # Knowing that object I'm tempted to agree. c = Configuration( ConfigFileBackingStore(self._test_config_path(directory, 'config')), None, None, None, ) target_roms_directory = self.sandbox.adjusted_path(c.roms_directory()) source_roms_directory = os.path.join(directory, 'ROMs') shutil.copytree(source_roms_directory, target_roms_directory) def _override_backups_directory(self, data_directory): # TODO: Figure out a way to actually override this, so I can test that # backups get made correctly. pass def _adjust_json_path(self, path): return path.replace("%sb", self.sandbox.root) def _adjust_shortcut_exe(self, shortcut): return model.Shortcut( name=shortcut.name, exe=self._adjust_json_path(shortcut.exe), startdir=shortcut.startdir, icon=shortcut.icon, tags=shortcut.tags, ) def load_test_data(self, testdata): """ Reads the config.txt, consoles.txt, emulators.txt, shortcuts.vdf, and ROMs folder from the provided testdata subdirectory and places it in the sandbox such that it will be used by Ice the next time its run. """ assert (self.loaded_data is None, "Can't load test data twice in a single test") self.loaded_data = testdata data_directory = os.path.join(self.testdata_dir, testdata) assert (os.path.exists(data_directory), "Can't load test data from a missing directory") self._load_config_file_overrides(data_directory) self._load_roms_for_test(data_directory) self._override_backups_directory(data_directory) def create_fake_user(self, uid=None): fixture = UserFixture(self.steam_fixture, uid) self.user_fixtures.append(fixture) return fixture.uid def load_shortcuts_from_json(self, filename): expectations_path = os.path.join(self.testdata_dir, self.loaded_data, filename) with open(expectations_path) as f: expected_shortcuts_json = json.load(f) return map(json_to_shortcut, expected_shortcuts_json) def expected_shortcuts(self, filename="shortcuts-expected.json"): """Returns the shortcuts which the test expects will exist after executing""" expected_shortcuts = self.load_shortcuts_from_json(filename) return map(self._adjust_shortcut_exe, expected_shortcuts) def set_user_shortcuts(self, uid, new_shortcuts): context = model.LocalUserContext(self.steam_fixture.get_steam(), uid) return shortcuts.set_shortcuts(context, new_shortcuts) def user_shortcuts(self, uid): context = model.LocalUserContext(self.steam_fixture.get_steam(), uid) return shortcuts.get_shortcuts(context) def run_command(self, *args): """" Runs the command specified by `args`, where doing run_command("list", "consoles", "--json") is equivalent to running the command ./ice.py list consoles --json """ # Turn `args` into a list, like `sys.argv` represents them args = list(args) # Add the 'ice.py' at the beginning of the list, which `run` will then # promptly ignore args.insert(0, "ice.py") args.extend(self.extra_args) # Run the command try: runner = CommandLineRunner(self.steam_fixture.get_steam(), self.sandbox) runner.run(args) success = True except Exception as e: success = False print e
class FakeEnvironment(object): def __init__(self, file_path): """ Generates a new environment in which to run Integration tests. `testdata_dir` refers to the base testdata directory, which individual tests will then use to load their test-specific configurations. """ # We also need a sandbox to play in. self.sandbox = FakeFilesystem(root=tempfile.mkdtemp()) # Need a dummy Steam installation for Ice to work with # We'll put it in the `Steam` directory of our sandbox self.steam_fixture = SteamFixture(os.path.join(self.sandbox.root, "Steam")) # Create a list of user fixtures that consumers can populate self.user_fixtures = [] # The testdata directory should be in the same directory as the tests # themselves. self.testdata_dir = os.path.join(os.path.dirname(file_path), "testdata") assert os.path.exists(self.testdata_dir) self.loaded_data = None self.extra_args = [] def clean(self): for user_fixture in self.user_fixtures: user_fixture.tearDown() self.steam_fixture.tearDown() shutil.rmtree(self.sandbox.root) def _use_config_file(self, file, location): assert os.path.exists(location) self.extra_args.append("--%s" % file) self.extra_args.append(location) def _test_config_path(self, directory, file): return os.path.join(directory, "%s.txt" % file) def _load_config_file_overrides(self, directory): file_basenames = ["config", "consoles", "emulators"] filenames = map(lambda f: "%s.txt" % f, file_basenames) for f in file_basenames: self._use_config_file(f, self._test_config_path(directory, f)) def _load_roms_for_test(self, directory): """Takes the ROMs located in `directory/ROMs` and moves them into the ROMs directory specified in the provided config.txt file.""" # TODO: This is extremely non-kosher. The fact that I have to do this # suggests that something is very wrong with my Configuration object. # # Knowing that object I'm tempted to agree. c = Configuration(ConfigFileBackingStore(self._test_config_path(directory, "config")), None, None, None, None) target_roms_directory = self.sandbox.adjusted_path(c.roms_directory()) source_roms_directory = os.path.join(directory, "ROMs") shutil.copytree(source_roms_directory, target_roms_directory) def _override_backups_directory(self, data_directory): # TODO: Figure out a way to actually override this, so I can test that # backups get made correctly. pass def _adjust_json_path(self, path): return path.replace("%sb", self.sandbox.root) def _shortcut_from_expectation_json(self, json): for field in ["name", "exe", "startdir", "icon", "tags"]: assert field in json return model.Shortcut( name=json.get("name"), exe=self._adjust_json_path(json.get("exe")), startdir=json.get("startdir"), icon=json.get("icon"), tags=json.get("tags"), ) def load_test_data(self, testdata): """ Reads the config.txt, consoles.txt, emulators.txt, shortcuts.vdf, and ROMs folder from the provided testdata subdirectory and places it in the sandbox such that it will be used by Ice the next time its run. """ assert (self.loaded_data is None, "Can't load test data twice in a single test") self.loaded_data = testdata data_directory = os.path.join(self.testdata_dir, testdata) assert (os.path.exists(data_directory), "Can't load test data from a missing directory") self._load_config_file_overrides(data_directory) self._load_roms_for_test(data_directory) self._override_backups_directory(data_directory) def create_fake_user(self, uid=None): fixture = UserFixture(self.steam_fixture, uid) self.user_fixtures.append(fixture) return fixture.uid def expected_shortcuts(self): """Returns the shortcuts which the test expects will exist after executing""" expectations_path = os.path.join(self.testdata_dir, self.loaded_data, "shortcuts-expected.json") with open(expectations_path) as f: expected_shortcuts_json = json.load(f) expected_shortcuts = map(self._shortcut_from_expectation_json, expected_shortcuts_json) return expected_shortcuts def user_shortcuts(self, uid): context = model.LocalUserContext(self.steam_fixture.get_steam(), uid) return shortcuts.get_shortcuts(context) def run_command(self, *args): """" Runs the command specified by `args`, where doing run_command("list", "consoles", "--json") is equivalent to running the command ./ice.py list consoles --json """ # Turn `args` into a list, like `sys.argv` represents them args = list(args) # Add the 'ice.py' at the beginning of the list, which `run` will then # promptly ignore args.insert(0, "ice.py") args.extend(self.extra_args) # Run the command try: runner = CommandLineRunner(self.steam_fixture.get_steam(), self.sandbox) runner.run(args) success = True except Exception as e: success = False print e