Exemple #1
0
 def test_check_compatibility__manifest_version_12__exception_raised(
         self, ext_dir):
     manifest = ExtensionManifest('test_extension',
                                  {'required_api_version': '0'}, ext_dir)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.check_compatibility()
     assert e.value.error_name == ErrorName.ExtensionCompatibilityError.value
 def test_validate__prefs_incorrect_type__exception_raised(
         self, valid_manifest):
     valid_manifest['preferences'] = [{'id': 'id', 'type': 'incorrect'}]
     manifest = ExtensionManifest(valid_manifest)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ExtensionError.InvalidManifest.value
Exemple #3
0
    def test_get_preference(self, ext_dir):
        manifest_dict = {
            'preferences': [{
                'id': 'myid',
                'type': 'keyword',
                'default_value': 'mi',
                'name': "Mimimi",
                'icon': 'images/icon.png'
            }, {
                'id': 'newid',
                'type': 'input',
                'default_value': 'ni'
            }]
        }
        manifest = ExtensionManifest('test_extension', manifest_dict, ext_dir)
        assert manifest.get_preference('newid') == {
            'id': 'newid',
            'type': 'input',
            'default_value': 'ni',
        }

        assert manifest.get_preference('myid') == {
            'id': 'myid',
            'type': 'keyword',
            'default_value': 'mi',
            'name': 'Mimimi',
            'icon': 'images/icon.png'
        }
Exemple #4
0
 def test_validate__prefs_empty_id__exception_raised(
         self, ext_dir, valid_manifest):
     valid_manifest['preferences'] = [{}]
     manifest = ExtensionManifest('test_extension', valid_manifest, ext_dir)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ErrorName.InvalidManifestJson.value
 def test_check_compatibility__manifest_version_12__exception_raised(self):
     manifest = ExtensionManifest({
         "name": "Test",
         "required_api_version": "0"
     })
     with pytest.raises(ExtensionManifestError) as e:
         manifest.check_compatibility()
     assert e.value.error_name == ExtensionError.Incompatible.value
Exemple #6
0
 def test_validate__type_kw_empty_name__exception_raised(
         self, ext_dir, valid_manifest):
     valid_manifest['preferences'] = [{
         'id': 'id',
         'type': 'incorrect',
         'keyword': 'kw'
     }]
     manifest = ExtensionManifest('test_extension', valid_manifest, ext_dir)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ErrorName.InvalidManifestJson.value
 def test_validate__raises_error_if_empty_default_value_for_keyword(
         self, valid_manifest):
     valid_manifest['preferences'] = [{
         'id': 'id',
         'type': 'keyword',
         'name': 'My Keyword'
     }]
     manifest = ExtensionManifest(valid_manifest)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ExtensionError.InvalidManifest.value
    def configure(self, extension_id):
        """
        * Adds itself to the controllers dict
        * Validates manifest file.
        * Sends :class:`PreferencesEvent` to extension
        """
        self.extension_id = extension_id
        if not self.extension_id:
            raise RuntimeError("No extension_id provided")

        logger.info('Extension "%s" connected', self.extension_id)

        self.manifest = ExtensionManifest.open(self.extension_id)
        try:
            self.manifest.validate()
        except ExtensionManifestError as e:
            logger.warning("Couldn't connect '%s'. %s: %s", self.extension_id,
                           type(e).__name__, e)
            self.framer.close()
            return

        self.preferences = ExtensionPreferences.create_instance(
            self.extension_id)
        self.controllers[self.extension_id] = self
        self._debounced_send_event = debounce(
            self.manifest.get_option('query_debounce', 0.05))(self._send_event)

        self._send_event(PreferencesEvent(self.preferences.get_dict()))
 def test_validate__doesnt_raise_if_empty_default_value_for_non_keyword(
         self, valid_manifest):
     valid_manifest['preferences'] = [
         {
             'id': 'id',
             'type': 'keyword',
             'name': 'My Keyword',
             'default_value': 'kw'
         },
         {
             'id': 'city',
             'type': 'input',
             'name': 'City'
         },
     ]
     manifest = ExtensionManifest(valid_manifest)
     manifest.validate()
Exemple #10
0
    def run(self, extension_id):
        """
        * Validates manifest
        * Runs extension in a new process
        """
        if self.is_running(extension_id):
            raise ExtensionIsRunningError(f"Extension ID: {extension_id}")

        manifest = ExtensionManifest.open(extension_id)
        manifest.validate()
        manifest.check_compatibility()

        cmd = [
            sys.executable,
            os.path.join(self.extensions_dir, extension_id, 'main.py')
        ]
        env = {}
        env['PYTHONPATH'] = ':'.join(
            filter(
                bool,
                [ULAUNCHER_APP_DIR, os.getenv('PYTHONPATH')]))

        if self.verbose:
            env['VERBOSE'] = '1'

        if self.dont_run_extensions:
            args = [env.get('VERBOSE', ''), env['PYTHONPATH']]
            args.extend(cmd)
            run_cmd = 'VERBOSE={} PYTHONPATH={} {} {}'.format(*args)
            logger.warning('Copy and run the following command to start %s',
                           extension_id)
            logger.warning(run_cmd)
            self.set_extension_error(extension_id,
                                     ExtRunErrorName.NoExtensionsFlag, run_cmd)
            return

        launcher = Gio.SubprocessLauncher.new(Gio.SubprocessFlags.STDERR_PIPE)
        for env_name, env_value in env.items():
            launcher.setenv(env_name, env_value, True)

        t_start = time()
        subproc = launcher.spawnv(cmd)
        error_line_str = Gio.DataInputStream.new(subproc.get_stderr_pipe())
        self.extension_procs[extension_id] = ExtensionProc(
            extension_id=extension_id,
            subprocess=subproc,
            start_time=t_start,
            error_stream=error_line_str,
            recent_errors=deque(maxlen=1))
        logger.debug("Launched %s using Gio.Subprocess", extension_id)

        subproc.wait_async(None, self.handle_wait, extension_id)
        self.read_stderr_line(self.extension_procs[extension_id])
Exemple #11
0
 def test_check_compatibility__required_api_version_1__no_exceptions(
         self, ext_dir):
     manifest = ExtensionManifest('test_extension',
                                  {'required_api_version': '2'}, ext_dir)
     manifest.check_compatibility()
Exemple #12
0
 def create_instance(cls, ext_id):
     return cls(ext_id, ExtensionManifest.open(ext_id))
 def test_validate__prefs_empty_id__exception_raised(self, valid_manifest):
     valid_manifest['preferences'] = [{}]
     manifest = ExtensionManifest(valid_manifest)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ExtensionError.InvalidManifest.value
Exemple #14
0
 def test_get_option__option_exists__value_returned(self, ext_dir):
     manifest_dict = {'options': {'query_debounce': 0.5}}
     manifest = ExtensionManifest('test_extension', manifest_dict, ext_dir)
     assert manifest.get_option('query_debounce') == 0.5
 def test_validate__name_empty__exception_raised(self):
     manifest = ExtensionManifest({"required_api_version": "1"})
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ExtensionError.InvalidManifest.value
 def test_validate__valid_manifest__no_exceptions_raised(
         self, valid_manifest):
     manifest = ExtensionManifest(valid_manifest)
     manifest.validate()
 def test_get_option__option_doesnt_exist__default_returned(self):
     manifest = ExtensionManifest({"options": {}})
     assert manifest.get_option('query_debounce', 0.4) == 0.4
 def test_open__manifest_file__is_read(self):
     ext_dir = os.path.dirname(os.path.abspath(__file__))
     manifest = ExtensionManifest.open('test_extension', ext_dir)
     assert manifest.get_name() == "Test Extension"
 def test_check_compatibility__required_api_version_1__no_exceptions(self):
     manifest = ExtensionManifest({
         "name": "Test",
         "required_api_version": "2"
     })
     manifest.check_compatibility()
 def test_get_option__option_exists__value_returned(self):
     manifest = ExtensionManifest({"options": {"query_debounce": 0.5}})
     assert manifest.get_option("query_debounce") == 0.5
Exemple #21
0
 def test_get_option__option_doesnt_exist__default_returned(self, ext_dir):
     manifest_dict = {'options': {}}
     manifest = ExtensionManifest('test_extension', manifest_dict, ext_dir)
     assert manifest.get_option('query_debounce', 0.4) == 0.4
Exemple #22
0
 def test_open__manifest_file__is_read(self, ext_dir):
     manifest = ExtensionManifest.open('test_extension', ext_dir)
     assert manifest.get_name() == "Test Extension"
Exemple #23
0
 def test_refresh__name__is_reloaded(self, ext_dir):
     manifest = ExtensionManifest('test_extension', {'name': 'Old'},
                                  ext_dir)
     assert manifest.get_name() == 'Old'
     manifest.refresh()
     assert manifest.get_name() == "Test Extension"
Exemple #24
0
 def test_validate__name_empty__exception_raised(self, ext_dir):
     manifest = ExtensionManifest('test_extension',
                                  {'required_api_version': '1'}, ext_dir)
     with pytest.raises(ExtensionManifestError) as e:
         manifest.validate()
     assert e.value.error_name == ErrorName.InvalidManifestJson.value
Exemple #25
0
 def test_validate__valid_manifest__no_exceptions_raised(
         self, ext_dir, valid_manifest):
     manifest = ExtensionManifest('test_extension', valid_manifest, ext_dir)
     manifest.validate()