Making HappyBase enabled/disabled checks into no-ops.

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 <exceptions.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 <exceptions.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 <exceptions.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 <exceptions.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):

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):