Beispiel #1
0
  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 = []
Beispiel #2
0
    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 = []
Beispiel #3
0
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
Beispiel #4
0
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