def __init__(self, config, logger): super().__init__(config, logger) self._volumes = memoize.PersistentDict() self._volumes.make_permanent( self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'volumes') self._volumes.update(self._config.get('SUSHY_EMULATOR_VOLUMES', {}))
def initialize(cls, config, logger, *args, **kwargs): cls._config = config cls._logger = logger cls._devices = memoize.PersistentDict() if hasattr(cls._devices, 'make_permanent'): cls._devices.make_permanent( cls._config.get('SUSHY_EMULATOR_STATE_DIR'), 'vmedia') device_types = cls._config.get('SUSHY_EMULATOR_VMEDIA_DEVICES') if device_types is None: device_types = { u'Cd': { u'Name': u'Virtual CD', u'MediaTypes': [u'CD', u'DVD'] }, u'Floppy': { u'Name': u'Virtual Removable Media', u'MediaTypes': [u'Floppy', u'USBStick'] } } cls._device_types = device_types return cls
def __init__(self, config, logger): super().__init__(config, logger) self._indicators = memoize.PersistentDict() if hasattr(self._indicators, 'make_permanent'): self._indicators.make_permanent( self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'indicators') self._indicators.update( self._config.get('SUSHY_EMULATOR_INDICATOR_LEDS', {}))
def test___delitem__(self, mock_sqlite3, mock_pickle): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_pickle.dumps.return_value = 'pickled-key' mock_connection = mock_sqlite3.connect.return_value mock_cursor = mock_connection.cursor.return_value del pd[1] mock_cursor.execute.assert_called_with('delete from cache where key=?', ('pickled-key', ))
def test___iter__(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() mock_cursor.fetchall.return_value = [[pickle.dumps('pickled-key')]] self.assertEqual(['pickled-key'], list(iter(pd))) mock_cursor.execute.assert_called_once_with('select key from cache')
def initialize(cls, config): cls._config = config cls._volumes = memoize.PersistentDict() if hasattr(cls._volumes, 'make_permanent'): cls._volumes.make_permanent(config.get('SUSHY_EMULATOR_STATE_DIR'), 'volumes') cls._volumes.update(config.get('SUSHY_EMULATOR_VOLUMES', {})) return cls
def test___delitem__(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() del pd[1] mock_cursor.execute.assert_called_once_with( 'delete from cache where key=?', (pickle.dumps(1), ))
def initialize(cls, config): cls._config = config cls._indicators = memoize.PersistentDict() if hasattr(cls._indicators, 'make_permanent'): cls._indicators.make_permanent( config.get('SUSHY_EMULATOR_STATE_DIR'), 'indicators') cls._indicators.update( config.get('SUSHY_EMULATOR_INDICATOR_LEDS', {})) return cls
def test___setitem__(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() pd[1] = 2 mock_cursor.execute.assert_called_once_with( 'insert or replace into cache values (?, ?)', (pickle.dumps(1), pickle.dumps(2)))
def test___len__(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() mock_cursor.fetchone.return_value = [42] self.assertEqual(42, len(pd)) mock_cursor.execute.assert_called_once_with( 'select count(*) from cache')
def test___setitem__(self, mock_sqlite3, mock_pickle): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_pickle.dumps.side_effect = ['pickled-key', 'pickled-value'] mock_connection = mock_sqlite3.connect.return_value mock_cursor = mock_connection.cursor.return_value pd[1] = 2 mock_cursor.execute.assert_called_with( 'insert or replace into cache values (?, ?)', ('pickled-key', 'pickled-value'))
def test___getitem__(self, mock_sqlite3, mock_pickle): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_pickle.dumps.return_value = 'pickled-key' mock_connection = mock_sqlite3.connect.return_value mock_cursor = mock_connection.cursor.return_value mock_cursor.fetchone.return_value = ['pickled-value'] pd[1] mock_cursor.execute.assert_called_with( 'select value from cache where key=?', ('pickled-key', )) mock_pickle.loads.assert_called_once_with('pickled-value')
def test___len__(self, mock_sqlite3, mock_pickle): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_connection = mock_sqlite3.connect.return_value mock_cursor = mock_connection.cursor.return_value expected = 1 mock_cursor.fetchone.return_value = [expected] self.assertEqual(expected, len(pd)) mock_cursor.execute.assert_called_with('select count(*) from cache')
def test___getitem__(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() mock_cursor.fetchone.return_value = [pickle.dumps('pickled-value')] result = pd[1] self.assertEqual('pickled-value', result) mock_cursor.execute.assert_called_with( 'select value from cache where key=?', (pickle.dumps(1), ))
def test___iter__(self, mock_sqlite3, mock_pickle): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_pickle.dumps.return_value = 'pickled-key' mock_connection = mock_sqlite3.connect.return_value mock_cursor = mock_connection.cursor.return_value mock_cursor.fetchall.return_value = [['pickled-key']] for x in pd: x += x mock_cursor.execute.assert_called_with('select key from cache') mock_pickle.loads.assert_called_once_with('pickled-key')
def test___setitem__retries(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_conn = mock_sqlite3.return_value.__enter__.return_value mock_cursor = mock_conn.cursor.return_value mock_cursor.execute.reset_mock() mock_cursor.execute.side_effect = [sqlite3.OperationalError, None] pd[1] = 2 mock_cursor.execute.assert_called_with( 'insert or replace into cache values (?, ?)', (pickle.dumps(1), pickle.dumps(2))) self.assertEqual(2, mock_cursor.execute.call_count)
def __init__(self): super().__init__() self._systems = memoize.PersistentDict() if hasattr(self._systems, 'make_permanent'): self._systems.make_permanent( self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'fakedriver') for system in self._config['SUSHY_EMULATOR_FAKE_SYSTEMS']: # Be careful to reduce racing with other processes if system['uuid'] not in self._systems: self._systems[system['uuid']] = copy.deepcopy(system) self._by_name = { system['name']: uuid for uuid, system in self._systems.items() }
def __init__(self, config, logger): super().__init__(config, logger) self._devices = memoize.PersistentDict() if hasattr(self._devices, 'make_permanent'): self._devices.make_permanent( self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'vmedia') device_types = self._config.get('SUSHY_EMULATOR_VMEDIA_DEVICES') if device_types is None: device_types = { u'Cd': { u'Name': u'Virtual CD', u'MediaTypes': [u'CD', u'DVD'] }, u'Floppy': { u'Name': u'Virtual Removable Media', u'MediaTypes': [u'Floppy', u'USBStick'] } } self._device_types = device_types
def test_decode(self, mock_sqlite3): pd = memoize.PersistentDict() value = pd.decode(pickle.dumps({1: '2'})) self.assertEqual({1: '2'}, value)
def test_make_permanent(self, mock_sqlite3): pd = memoize.PersistentDict() pd.make_permanent('/', 'file') mock_sqlite3.connect.assert_called_with('/file.sqlite')
def test_encode(self, mock_pickle): pd = memoize.PersistentDict() pd.encode({1: '2'}) mock_pickle.dumps.assert_called_once_with({1: '2'})
def test_decode(self, mock_pickle): pd = memoize.PersistentDict() pd.decode('blob') mock_pickle.loads.assert_called_once_with('blob')