def test_max_age(self):
import datetime
from gcloud.bigtable.column_family import MaxAgeGCRule
orig_rule = MaxAgeGCRule(datetime.timedelta(seconds=1))
gc_rule_pb = orig_rule.to_pb()
result = self._callFUT(gc_rule_pb)
self.assertTrue(isinstance(result, MaxAgeGCRule))
self.assertEqual(result, orig_rule)
def test_max_age(self):
import datetime
from gcloud.bigtable.column_family import MaxAgeGCRule
orig_rule = MaxAgeGCRule(datetime.timedelta(seconds=1))
gc_rule_pb = orig_rule.to_pb()
result = self._callFUT(gc_rule_pb)
self.assertTrue(isinstance(result, MaxAgeGCRule))
self.assertEqual(result, orig_rule)
def test_to_pb_nested(self):
import datetime
from google.protobuf import duration_pb2
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
max_num_versions1 = 42
rule1 = MaxVersionsGCRule(max_num_versions1)
pb_rule1 = _GcRulePB(max_num_versions=max_num_versions1)
max_age = datetime.timedelta(seconds=1)
rule2 = MaxAgeGCRule(max_age)
pb_rule2 = _GcRulePB(max_age=duration_pb2.Duration(seconds=1))
rule3 = self._makeOne(rules=[rule1, rule2])
pb_rule3 = _GcRulePB(intersection=_GcRuleIntersectionPB(
rules=[pb_rule1, pb_rule2]))
max_num_versions2 = 1337
rule4 = MaxVersionsGCRule(max_num_versions2)
pb_rule4 = _GcRulePB(max_num_versions=max_num_versions2)
rule5 = self._makeOne(rules=[rule3, rule4])
pb_rule5 = _GcRulePB(intersection=_GcRuleIntersectionPB(
rules=[pb_rule3, pb_rule4]))
gc_rule_pb = rule5.to_pb()
self.assertEqual(gc_rule_pb, pb_rule5)
def test_to_pb_nested(self):
import datetime
from gcloud.bigtable._generated import (bigtable_table_data_pb2 as
data_pb2)
from gcloud.bigtable._generated import duration_pb2
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
max_num_versions1 = 42
rule1 = MaxVersionsGCRule(max_num_versions1)
pb_rule1 = data_pb2.GcRule(max_num_versions=max_num_versions1)
max_age = datetime.timedelta(seconds=1)
rule2 = MaxAgeGCRule(max_age)
pb_rule2 = data_pb2.GcRule(max_age=duration_pb2.Duration(seconds=1))
rule3 = self._makeOne(rules=[rule1, rule2])
pb_rule3 = data_pb2.GcRule(intersection=data_pb2.GcRule.Intersection(
rules=[pb_rule1, pb_rule2]))
max_num_versions2 = 1337
rule4 = MaxVersionsGCRule(max_num_versions2)
pb_rule4 = data_pb2.GcRule(max_num_versions=max_num_versions2)
rule5 = self._makeOne(rules=[rule3, rule4])
pb_rule5 = data_pb2.GcRule(intersection=data_pb2.GcRule.Intersection(
rules=[pb_rule3, pb_rule4]))
gc_rule_pb = rule5.to_pb()
self.assertEqual(gc_rule_pb, pb_rule5)
def test_with_max_age(self):
import datetime
from gcloud.bigtable.column_family import MaxAgeGCRule
time_to_live = 101
max_age = datetime.timedelta(seconds=time_to_live)
gc_rule = MaxAgeGCRule(max_age)
result = self._callFUT(gc_rule)
expected_result = {'time_to_live': time_to_live}
self.assertEqual(result, expected_result)
def test_dictionary_ttl_key(self):
import datetime
from gcloud.bigtable.column_family import MaxAgeGCRule
time_to_live = 24 * 60 * 60
max_age = datetime.timedelta(days=1)
option = {'time_to_live': time_to_live}
result = self._callFUT(option)
gc_rule = MaxAgeGCRule(max_age)
self.assertEqual(result, gc_rule)
def test_intersection(self):
import datetime
from gcloud.bigtable.column_family import GCRuleIntersection
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
rule1 = MaxVersionsGCRule(1)
rule2 = MaxAgeGCRule(datetime.timedelta(seconds=1))
orig_rule = GCRuleIntersection([rule1, rule2])
gc_rule_pb = orig_rule.to_pb()
result = self._callFUT(gc_rule_pb)
self.assertTrue(isinstance(result, GCRuleIntersection))
self.assertEqual(result, orig_rule)
def _parse_family_option(option):
"""Parses a column family option into a garbage collection rule.
.. note::
If ``option`` is not a dictionary, the type is not checked.
If ``option`` is :data:`None`, there is nothing to do, since this
is the correct output.
:type option: :class:`dict`,
:data:`NoneType <types.NoneType>`,
:class:`.GarbageCollectionRule`
:param option: A column family option passes as a dictionary value in
:meth:`Connection.create_table`.
:rtype: :class:`.GarbageCollectionRule`
:returns: A garbage collection rule parsed from the input.
"""
result = option
if isinstance(result, dict):
if not set(result.keys()) <= set(['max_versions', 'time_to_live']):
all_keys = ', '.join(repr(key) for key in result.keys())
warning_msg = ('Cloud Bigtable only supports max_versions and '
'time_to_live column family settings. '
'Received: %s' % (all_keys,))
_WARN(warning_msg)
max_num_versions = result.get('max_versions')
max_age = None
if 'time_to_live' in result:
max_age = datetime.timedelta(seconds=result['time_to_live'])
versions_rule = age_rule = None
if max_num_versions is not None:
versions_rule = MaxVersionsGCRule(max_num_versions)
if max_age is not None:
age_rule = MaxAgeGCRule(max_age)
if versions_rule is None:
result = age_rule
else:
if age_rule is None:
result = versions_rule
else:
result = GCRuleIntersection(rules=[age_rule, versions_rule])
return result
def test_with_intersection_two_rules(self):
import datetime
from gcloud.bigtable.column_family import GCRuleIntersection
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
time_to_live = 101
max_age = datetime.timedelta(seconds=time_to_live)
rule1 = MaxAgeGCRule(max_age)
max_versions = 2
rule2 = MaxVersionsGCRule(max_versions)
gc_rule = GCRuleIntersection(rules=[rule1, rule2])
result = self._callFUT(gc_rule)
expected_result = {
'max_versions': max_versions,
'time_to_live': time_to_live,
}
self.assertEqual(result, expected_result)
def test_to_pb(self):
import datetime
from google.protobuf import duration_pb2
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
max_num_versions = 42
rule1 = MaxVersionsGCRule(max_num_versions)
pb_rule1 = _GcRulePB(max_num_versions=max_num_versions)
max_age = datetime.timedelta(seconds=1)
rule2 = MaxAgeGCRule(max_age)
pb_rule2 = _GcRulePB(max_age=duration_pb2.Duration(seconds=1))
rule3 = self._makeOne(rules=[rule1, rule2])
pb_rule3 = _GcRulePB(union=_GcRuleUnionPB(rules=[pb_rule1, pb_rule2]))
gc_rule_pb = rule3.to_pb()
self.assertEqual(gc_rule_pb, pb_rule3)
def test_dictionary_both_keys(self):
import datetime
from gcloud.bigtable.column_family import GCRuleIntersection
from gcloud.bigtable.column_family import MaxAgeGCRule
from gcloud.bigtable.column_family import MaxVersionsGCRule
versions = 42
time_to_live = 24 * 60 * 60
option = {
'max_versions': versions,
'time_to_live': time_to_live,
}
result = self._callFUT(option)
max_age = datetime.timedelta(days=1)
# NOTE: This relies on the order of the rules in the method we are
# calling matching this order here.
gc_rule1 = MaxAgeGCRule(max_age)
gc_rule2 = MaxVersionsGCRule(versions)
gc_rule = GCRuleIntersection(rules=[gc_rule1, gc_rule2])
self.assertEqual(result, gc_rule)