diff --git a/gcloud/bigtable/happybase/connection.py b/gcloud/bigtable/happybase/connection.py index ebea84e93998..3780763cd033 100644 --- a/gcloud/bigtable/happybase/connection.py +++ b/gcloud/bigtable/happybase/connection.py @@ -49,9 +49,16 @@ _LEGACY_ARGS = frozenset(('host', 'port', 'compat', 'transport', 'protocol')) _WARN = warnings.warn +_BASE_DISABLE = 'Cloud Bigtable has no concept of enabled / disabled tables.' _DISABLE_DELETE_MSG = ('The disable argument should not be used in ' - 'delete_table(). Cloud Bigtable has no concept ' - 'of enabled / disabled tables.') + 'delete_table(). ') + _BASE_DISABLE +_ENABLE_TMPL = 'Connection.enable_table(%r) was called, but ' + _BASE_DISABLE +_DISABLE_TMPL = 'Connection.disable_table(%r) was called, but ' + _BASE_DISABLE +_IS_ENABLED_TMPL = ('Connection.is_table_enabled(%r) was called, but ' + + _BASE_DISABLE) +_COMPACT_TMPL = ('Connection.compact_table(%r, major=%r) was called, but the ' + 'Cloud Bigtable API handles table compactions automatically ' + 'and does not expose an API for it.') def _get_instance(timeout=None): @@ -378,61 +385,70 @@ def delete_table(self, name, disable=False): name = self._table_name(name) _LowLevelTable(name, self._instance).delete() - def enable_table(self, name): + @staticmethod + def enable_table(name): """Enable the specified table. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this - method does not work. It is provided simply for compatibility. + method does nothing. It is provided simply for compatibility. - :raises: :class:`NotImplementedError ` - always + :type name: str + :param name: The name of the table to be enabled. """ - raise NotImplementedError('The Cloud Bigtable API has no concept of ' - 'enabled or disabled tables.') + _WARN(_ENABLE_TMPL % (name,)) - def disable_table(self, name): + @staticmethod + def disable_table(name): """Disable the specified table. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this - method does not work. It is provided simply for compatibility. + method does nothing. It is provided simply for compatibility. - :raises: :class:`NotImplementedError ` - always + :type name: str + :param name: The name of the table to be disabled. """ - raise NotImplementedError('The Cloud Bigtable API has no concept of ' - 'enabled or disabled tables.') + _WARN(_DISABLE_TMPL % (name,)) - def is_table_enabled(self, name): + @staticmethod + def is_table_enabled(name): """Return whether the specified table is enabled. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this - method does not work. It is provided simply for compatibility. + method always returns :data:`True`. It is provided simply for + compatibility. - :raises: :class:`NotImplementedError ` - always + :type name: str + :param name: The name of the table to check enabled / disabled status. + + :rtype: bool + :returns: The value :data:`True` always. """ - raise NotImplementedError('The Cloud Bigtable API has no concept of ' - 'enabled or disabled tables.') + _WARN(_IS_ENABLED_TMPL % (name,)) + return True - def compact_table(self, name, major=False): + @staticmethod + def compact_table(name, major=False): """Compact the specified table. .. warning:: - Cloud Bigtable does not support compacting a table, so this - method does not work. It is provided simply for compatibility. + Cloud Bigtable supports table compactions, it just doesn't expose + an API for that feature, so this method does nothing. It is + provided simply for compatibility. + + :type name: str + :param name: The name of the table to compact. - :raises: :class:`NotImplementedError ` - always + :type major: bool + :param major: Whether to perform a major compaction. """ - raise NotImplementedError('The Cloud Bigtable API does not support ' - 'compacting a table.') + _WARN(_COMPACT_TMPL % (name, major)) def _parse_family_option(option): diff --git a/gcloud/bigtable/happybase/test_connection.py b/gcloud/bigtable/happybase/test_connection.py index 6236539db71f..f70c69eaaea5 100644 --- a/gcloud/bigtable/happybase/test_connection.py +++ b/gcloud/bigtable/happybase/test_connection.py @@ -488,37 +488,81 @@ def mock_warn(msg): self.assertEqual(warned, [MUT._DISABLE_DELETE_MSG]) def test_enable_table(self): + from gcloud._testing import _Monkey + from gcloud.bigtable.happybase import connection as MUT + instance = _Instance() # Avoid implicit environ check. connection = self._makeOne(autoconnect=False, instance=instance) name = 'table-name' - with self.assertRaises(NotImplementedError): + + warned = [] + + def mock_warn(msg): + warned.append(msg) + + with _Monkey(MUT, _WARN=mock_warn): connection.enable_table(name) + self.assertEqual(warned, [MUT._ENABLE_TMPL % (name,)]) + def test_disable_table(self): + from gcloud._testing import _Monkey + from gcloud.bigtable.happybase import connection as MUT + instance = _Instance() # Avoid implicit environ check. connection = self._makeOne(autoconnect=False, instance=instance) name = 'table-name' - with self.assertRaises(NotImplementedError): + + warned = [] + + def mock_warn(msg): + warned.append(msg) + + with _Monkey(MUT, _WARN=mock_warn): connection.disable_table(name) + self.assertEqual(warned, [MUT._DISABLE_TMPL % (name,)]) + def test_is_table_enabled(self): + from gcloud._testing import _Monkey + from gcloud.bigtable.happybase import connection as MUT + instance = _Instance() # Avoid implicit environ check. connection = self._makeOne(autoconnect=False, instance=instance) name = 'table-name' - with self.assertRaises(NotImplementedError): - connection.is_table_enabled(name) + + warned = [] + + def mock_warn(msg): + warned.append(msg) + + with _Monkey(MUT, _WARN=mock_warn): + result = connection.is_table_enabled(name) + + self.assertTrue(result) + self.assertEqual(warned, [MUT._IS_ENABLED_TMPL % (name,)]) def test_compact_table(self): + from gcloud._testing import _Monkey + from gcloud.bigtable.happybase import connection as MUT + instance = _Instance() # Avoid implicit environ check. connection = self._makeOne(autoconnect=False, instance=instance) name = 'table-name' - major = True - with self.assertRaises(NotImplementedError): - connection.compact_table(name, major=major) + + warned = [] + + def mock_warn(msg): + warned.append(msg) + + with _Monkey(MUT, _WARN=mock_warn): + connection.compact_table(name) + + self.assertEqual(warned, [MUT._COMPACT_TMPL % (name, False)]) class Test__parse_family_option(unittest2.TestCase):