Wrapping gRPC "already exists" with a HappyBase exception.

Fixes #1818.

Author: dhermes

gcloud/bigtable/happybase/connection.py

@@ -18,6 +18,8 @@
 import datetime
 import warnings
 
+from grpc.beta import interfaces
+from grpc.framework.interfaces.face import face
 import six
 
 from gcloud.bigtable.client import Client
@@ -338,7 +340,14 @@ def create_table(self, name, families):
         # Create table instance and then make API calls.
         name = self._table_name(name)
         low_level_table = _LowLevelTable(name, self._cluster)
-        low_level_table.create()
+        try:
+            low_level_table.create()
+        except face.NetworkError as network_err:
+            if network_err.code == interfaces.StatusCode.ALREADY_EXISTS:
+                from happybase.hbase import ttypes
+                raise ttypes.AlreadyExists(name)
+            else:
+                raise
 
         for column_family_name, gc_rule in gc_rule_dict.items():
             column_family = low_level_table.column_family(

gcloud/bigtable/happybase/test_connection.py

@@ -395,6 +395,49 @@ def test_create_table_bad_value(self):
         with self.assertRaises(ValueError):
             connection.create_table(name, families)
 
+    def _create_table_error_helper(self, err_val, err_type):
+        from gcloud._testing import _Monkey
+        from gcloud.bigtable.happybase import connection as MUT
+
+        cluster = _Cluster()  # Avoid implicit environ check.
+        connection = self._makeOne(autoconnect=False, cluster=cluster)
+
+        tables_created = []
+
+        def make_table(*args, **kwargs):
+            kwargs['create_error'] = err_val
+            result = _MockLowLevelTable(*args, **kwargs)
+            tables_created.append(result)
+            return result
+
+        name = 'table-name'
+        families = {'foo': {}}
+        with _Monkey(MUT, _LowLevelTable=make_table):
+            with self.assertRaises(err_type):
+                connection.create_table(name, families)
+
+        self.assertEqual(len(tables_created), 1)
+        self.assertEqual(tables_created[0].create_calls, 1)
+
+    def test_create_table_already_exists(self):
+        from grpc.beta import interfaces
+        from grpc.framework.interfaces.face import face
+        from happybase.hbase import ttypes
+
+        err_val = face.NetworkError(None, None,
+                                    interfaces.StatusCode.ALREADY_EXISTS, None)
+        self._create_table_error_helper(err_val, ttypes.AlreadyExists)
+
+    def test_create_table_connection_error(self):
+        from grpc.beta import interfaces
+        from grpc.framework.interfaces.face import face
+        err_val = face.NetworkError(None, None,
+                                    interfaces.StatusCode.INTERNAL, None)
+        self._create_table_error_helper(err_val, face.NetworkError)
+
+    def test_create_table_other_error(self):
+        self._create_table_error_helper(RuntimeError, RuntimeError)
+
     def _delete_table_helper(self, disable=False):
         from gcloud._testing import _Monkey
         from gcloud.bigtable.happybase import connection as MUT
@@ -612,6 +655,7 @@ class _MockLowLevelTable(object):
     def __init__(self, *args, **kwargs):
         self.args = args
         self.kwargs = kwargs
+        self.create_error = kwargs.get('create_error')
         self.delete_calls = 0
         self.create_calls = 0
         self.col_fam_created = []
@@ -621,6 +665,8 @@ def delete(self):
 
     def create(self):
         self.create_calls += 1
+        if self.create_error:
+            raise self.create_error
 
     def column_family(self, column_family_id, gc_rule=None):
         result = _MockLowLevelColumnFamily(column_family_id, gc_rule=gc_rule)