def test_add_relationship_classes(self): """Test that adding relationship classes works.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list"): mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]), KeyedTuple([2, "dog"], labels=["id", "name"]), ] self.db_map.add_wide_relationship_classes( { "name": "fish__dog", "object_class_id_list": [1, 2] }, { "name": "fishy_doggy", "object_class_id_list": [1, 2] }, ) relationship_classes = self.db_map.session.query( self.db_map.DiffRelationshipClass).all() self.assertEqual(len(relationship_classes), 4) self.assertEqual(relationship_classes[0].name, "fish__dog") self.assertEqual(relationship_classes[0].object_class_id, 1) self.assertEqual(relationship_classes[1].name, "fish__dog") self.assertEqual(relationship_classes[1].object_class_id, 2) self.assertEqual(relationship_classes[2].name, "fishy_doggy") self.assertEqual(relationship_classes[2].object_class_id, 1) self.assertEqual(relationship_classes[3].name, "fishy_doggy") self.assertEqual(relationship_classes[3].object_class_id, 2)
def test_add_relationship_identical_to_existing_one(self): """Test that adding a relationship with the same class and same objects as an existing one raises an integrity error. """ with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list" ) as mock_wide_rel_cls_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list") as mock_wide_rel_list: mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 20, "pluto"], labels=["id", "class_id", "name"]), ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([1, "10,20", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] mock_wide_rel_list.return_value = [ KeyedTuple([1, 1, "1,2", "nemo__pluto"], labels=["id", "class_id", "object_id_list", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_wide_relationships( { "name": "nemoy__plutoy", "class_id": 1, "object_id_list": [1, 2] }, strict=True)
def test_add_parameter_with_same_name_as_existing_one(self): """Test that adding parameter_definitions with an already taken name raises and integrity error.""" with mock.patch.object( DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list"), mock.patch.object( DiffDatabaseMapping, "parameter_definition_list" ) as mock_parameter_definition_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] mock_parameter_definition_list.return_value = [ KeyedTuple([1, 1, "color", None], labels=[ "id", "object_class_id", "name", "parameter_value_list_id" ]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_parameter_definitions( { "name": "color", "object_class_id": 2 }, strict=True)
def test_add_parameter_definitions_with_same_name(self): """Test that adding two parameter_definitions with the same name adds both of them.""" with mock.patch.object( DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list") as mock_wide_rel_cls_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([10, "1,2", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] self.db_map.add_parameter_definitions( { "name": "color", "object_class_id": 1 }, { "name": "color", "relationship_class_id": 10 }) parameter_definitions = self.db_map.session.query( self.db_map.DiffParameterDefinition).all() self.assertEqual(len(parameter_definitions), 2) self.assertEqual(parameter_definitions[0].name, "color") self.assertEqual(parameter_definitions[0].object_class_id, 1) self.assertIsNone(parameter_definitions[0].relationship_class_id)
def test_add_relationship_with_invalid_object(self): """Test that adding a relationship with an invalid object raises an integrity error. """ with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list" ) as mock_wide_rel_cls_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list"): mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 20, "pluto"], labels=["id", "class_id", "name"]), ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([1, "10,20", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_wide_relationships( { "name": "nemo__pluto", "class_id": 1, "object_id_list": [1, 3] }, strict=True)
def test_add_parameter_with_invalid_class(self): """Test that adding parameter_definitions with an invalid (object or relationship) class raises and integrity error.""" with mock.patch.object( DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list") as mock_wide_rel_cls_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([10, "1,2", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_parameter_definitions( { "name": "color", "object_class_id": 2 }, strict=True) with self.assertRaises(SpineIntegrityError): self.db_map.add_parameter_definitions( { "name": "color", "relationship_class_id": 9 }, strict=True)
def test_add_relationship_classes_with_same_name(self): """Test that adding two relationship classes with the same name only adds one of them.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list"): mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]), KeyedTuple([2, "dog"], labels=["id", "name"]), ] self.db_map.add_wide_relationship_classes( { "name": "dog__fish", "object_class_id_list": [1, 2] }, { "name": "dog__fish", "object_class_id_list": [1, 2] }, ) relationship_classes = self.db_map.session.query( self.db_map.DiffRelationshipClass).all() self.assertEqual(len(relationship_classes), 2) self.assertEqual(relationship_classes[0].name, "dog__fish") self.assertEqual(relationship_classes[0].object_class_id, 1) self.assertEqual(relationship_classes[1].name, "dog__fish") self.assertEqual(relationship_classes[1].object_class_id, 2)
def test_add_parameter_values(self): """Test that adding parameter values works.""" with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list" ) as mock_wide_rel_list, mock.patch.object( DiffDatabaseMapping, "parameter_definition_list" ) as mock_parameter_definition_list: mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 20, "pluto"], labels=["id", "class_id", "name"]), ] mock_wide_rel_list.return_value = [ KeyedTuple([1, 100, "1,2", "nemo__pluto"], labels=["id", "class_id", "object_id_list", "name"]) ] mock_parameter_definition_list.return_value = [ KeyedTuple( [1, 10, None, "color", None], labels=[ "id", "object_class_id", "relationship_class_id", "name", "parameter_value_list_id" ], ), KeyedTuple( [2, None, 100, "rel_speed", None], labels=[ "id", "object_class_id", "relationship_class_id", "name", "parameter_value_list_id" ], ), ] self.db_map.add_parameter_values( { "parameter_definition_id": 1, "object_id": 1, "value": '"orange"' }, { "parameter_definition_id": 2, "relationship_id": 1, "value": "125" }, ) parameter_values = self.db_map.session.query( self.db_map.DiffParameterValue).all() self.assertEqual(len(parameter_values), 2) self.assertEqual(parameter_values[0].parameter_definition_id, 1) self.assertEqual(parameter_values[0].object_id, 1) self.assertIsNone(parameter_values[0].relationship_id) self.assertEqual(parameter_values[0].value, '"orange"') self.assertEqual(parameter_values[1].parameter_definition_id, 2) self.assertIsNone(parameter_values[1].object_id) self.assertEqual(parameter_values[1].relationship_id, 1) self.assertEqual(parameter_values[1].value, "125")
def test_add_parameter_value_with_invalid_object_or_relationship(self): """Test that adding a parameter value with an invalid object or relationship raises an integrity error.""" with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list" ) as mock_wide_rel_list, mock.patch.object( DiffDatabaseMapping, "parameter_definition_list" ) as mock_parameter_definition_list: mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 20, "pluto"], labels=["id", "class_id", "name"]), ] mock_wide_rel_list.return_value = [ KeyedTuple([1, 100, "1,2", "nemo__pluto"], labels=["id", "class_id", "object_id_list", "name"]) ] mock_parameter_definition_list.return_value = [ KeyedTuple( [1, 10, None, "color", None], labels=[ "id", "object_class_id", "relationship_class_id", "name", "parameter_value_list_id" ], ), KeyedTuple( [2, None, 100, "rel_speed", None], labels=[ "id", "object_class_id", "relationship_class_id", "name", "parameter_value_list_id" ], ), ] with self.assertRaises(SpineIntegrityError): self.db_map.add_parameter_values( { "parameter_definition_id": 1, "object_id": 3, "value": "orange" }, strict=True) with self.assertRaises(SpineIntegrityError): self.db_map.add_parameter_values( { "parameter_definition_id": 2, "relationship_id": 2, "value": "125" }, strict=True)
def test_from_json(self): """Tests the jsonable.from_json function""" self.assertEqual(None, jsonable.from_json(None)) self.assertEqual({}, jsonable.from_json({})) self.assertEqual([], jsonable.from_json([])) self.assertEqual({'a': 1}, jsonable.from_json({'a': 1})) self.assertEqual([1], jsonable.from_json([1])) self.assertEqual([1], jsonable.from_json((1, ))) from decimal import Decimal self.assertEqual(1, jsonable.from_json(Decimal(1))) self.assertEqual(1.1, jsonable.from_json(Decimal(1.1))) import datetime obj = datetime.datetime(2014, 5, 5) self.assertEqual( obj, jsonable.from_json({ '__cls__': 'datetime.datetime', 'value': obj.isoformat() })) self.assertEqual( obj, jsonable.from_json({ '__cls__': 'datetime.datetime', 'value': '2014-05-05T00:00:00.000' })) self.assertEqual( obj.date(), jsonable.from_json({ '__cls__': 'datetime.date', 'value': '2014-05-05' })) self.assertEqual( 'a', jsonable.from_json({ '__cls__': 'a.Exception', 'message': 'a' }).message) from sqlalchemy.util import KeyedTuple self.assertEqual( KeyedTuple([1], labels=['a']), jsonable.from_json({ '__cls__': 'sqlalchemy.util.KeyedTuple', '_labels': ['a'], 'a': 1 })) from dbmanagr.dto.node import NameNode self.assertEqual( NameNode('a'), jsonable.from_json({ '__cls__': 'dbmanagr.dto.node.NameNode', 'name': 'a', 'indent': 0 }))
def from_json(d): if type(d) is dict: if '__cls__' in d: classname = d['__cls__'] if (classname.endswith('Exception') or classname.endswith('Error') or classname.endswith('Exit')): return BusinessException(d['message']) if classname == 'sqlalchemy.util.KeyedTuple': from sqlalchemy.util import KeyedTuple return KeyedTuple(map(lambda k: from_json(d[k]), d['_labels']), labels=d['_labels']) if classname == 'datetime.datetime': from datetime import datetime try: return datetime.strptime(d['value'], "%Y-%m-%dT%H:%M:%S") except ValueError: return datetime.strptime(d['value'], "%Y-%m-%dT%H:%M:%S.%f") if classname == 'datetime.date': from datetime import datetime return datetime.strptime(d['value'], "%Y-%m-%d").date() cls = import_class(classname) if hasattr(cls, 'from_json'): return cls.from_json(d) return dict(map(lambda (k, v): (k, from_json(v)), d.iteritems())) if type(d) is list or type(d) is tuple: return map(from_json, d) if type(d) is Decimal: if d % 1 == 0: return int(d) else: return float(d) return d
def test_row_item(self): """Tests the RowItem class""" row = Row( None, KeyedTuple(['', -1, '', '', None, None, '', '', '', '', -1, -1], labels=[ 'database_name', 'pid', 'username', 'client', 'transaction_start', 'query_start', 'state', 'query', 'blocked', 'blocked_by', 'transaction_duration', 'query_duration' ])) item = exporter.RowItem(row, None, None, None) self.assertEqual(item, item) self.assertEqual( item, exporter.RowItem.from_json({ 'row': row, 'include': None, 'exclude': None, 'substitutes': None }))
def member2KeyedTuple(self, member): keys = list(member.__dict__.keys()) values = list(member.__dict__.values()) if '_sa_instance_state' in keys: i = keys.index('_sa_instance_state') del keys[i] del values[i] return KeyedTuple(values, labels=keys)
def test_add_object_with_same_name_as_existing_one(self): """Test that adding an object with an already taken name raises an integrity error.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] mock_object_list.return_value = [ KeyedTuple([1, 1, "nemo"], labels=["id", "class_id", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_objects({ "name": "nemo", "class_id": 1 }, strict=True)
def test_none_entity(self): s, (u1, u2, u3, u4) = self._fixture() User = self.classes.User ua = aliased(User) q = s.query(User, ua) kt = lambda *x: KeyedTuple(x, ['User', 'useralias']) collection = [kt(u1, u2), kt(u1, None), kt(u2, u3)] it = loading.merge_result(q, collection) eq_([(x and x.id or None, y and y.id or None) for x, y in it], [(u1.id, u2.id), (u1.id, None), (u2.id, u3.id)])
def test_entity_col_mix_keyed_tuple(self): s, (u1, u2, u3, u4) = self._fixture() User = self.classes.User q = s.query(User, User.id) kt = lambda *x: KeyedTuple(x, ['User', 'id']) collection = [kt(u1, 1), kt(u2, 2), kt(u3, 7), kt(u4, 8)] it = loading.merge_result(q, collection) it = list(it) eq_([(x.id, y) for x, y in it], [(1, 1), (2, 2), (7, 7), (8, 8)]) eq_(list(it[0].keys()), ['User', 'id'])
def test_add_identical_relationships(self): """Test that adding two relationships with the same class and same objects only adds the first one. """ with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list" ) as mock_wide_rel_cls_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list"): mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 20, "pluto"], labels=["id", "class_id", "name"]), ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([1, "10,20", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] self.db_map.add_wide_relationships( { "name": "nemo__pluto", "class_id": 1, "object_id_list": [1, 2] }, { "name": "nemoy__plutoy", "class_id": 1, "object_id_list": [1, 2] }, ) relationships = self.db_map.session.query( self.db_map.DiffRelationship).all() self.assertEqual(len(relationships), 2) self.assertEqual(relationships[0].name, "nemo__pluto") self.assertEqual(relationships[0].class_id, 1) self.assertEqual(relationships[0].object_id, 1) self.assertEqual(relationships[1].name, "nemo__pluto") self.assertEqual(relationships[1].class_id, 1) self.assertEqual(relationships[1].object_id, 2)
def test_orgs_condition(self): """Test SCMActivityPersons object with an organizations condition""" correct = ActivityList( (KeyedTuple([ 774, u'John Dickinson', datetime.strptime("2013-11-15 15:10:39", datefmt), datetime.strptime("2014-01-24 14:53:17", datefmt) ], labels=rowlabels), KeyedTuple([ 1094, u'Samuel Merritt', datetime.strptime("2013-11-13 12:52:21", datefmt), datetime.strptime("2014-01-31 13:17:00", datefmt) ], labels=rowlabels), KeyedTuple([ 2071, u'Darrell Bishop', datetime.strptime("2013-11-27 00:37:02", datefmt), datetime.strptime("2013-11-27 12:07:42", datefmt) ], labels=rowlabels), KeyedTuple([ 2110, u'Jon Snitow', datetime.strptime("2014-01-29 13:02:54", datefmt), datetime.strptime("2014-01-29 13:02:54", datefmt) ], labels=rowlabels))) period = SCMPeriodCondition(start=self.start, end=self.end) nomerges = SCMNomergesCondition() orgs = SCMOrgsCondition(orgs=("SwiftStack", "Inktank"), actors="authors") data = SCMActivityPersons(datasource=self.session, name="list_authors", conditions=(period, nomerges, orgs)) activity = data.activity() print activity self.assertEqual(data.activity(), correct)
def test_add_relationship_class_with_same_name_as_existing_one(self): """Test that adding a relationship class with an already taken name raises an integrity error.""" with mock.patch.object( DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list") as mock_wide_rel_cls_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]), KeyedTuple([2, "dog"], labels=["id", "name"]), ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([1, "1,2", "fish__dog"], labels=["id", "object_class_id_list", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_wide_relationship_classes( { "name": "fish__dog", "object_class_id_list": [1, 2] }, strict=True)
def test_add_object_with_invalid_class(self): """Test that adding an object with a non existing class raises an integrity error.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list") as mock_object_class_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_objects({ "name": "pluto", "class_id": 2 }, strict=True)
def test_activity_json(self): """Test Period producing JSON""" correct_json = """ [ { "id": 12, "name": "Fulano Larguiño", "period": { "end": "2012-11-01T00:00:00", "start": "2011-12-01T00:00:00" } }, { "id": 3, "name": "Mengana Corta", "period": { "end": "2013-02-03T00:00:00", "start": "2010-02-03T00:00:00" } } ] """ rowlabels = ["person_id", "name", "firstdate", "lastdate"] list = ActivityList((KeyedTuple([ 12, "Fulano Larguiño", datetime(2011, 12, 1), datetime(2012, 11, 1) ], labels=rowlabels), KeyedTuple([ 3, "Mengana Corta", datetime(2010, 2, 3), datetime(2013, 2, 3) ], labels=rowlabels))) activity_json = encode(list, unpicklable=False) self.assertTrue(equal_JSON(activity_json, correct_json))
def unkeyed_tuples(d): class KeyedTuple(object): # I need a class to have self.__dict__ (object() hasn't got it) def __repr__(self): # For debugging purposes z = u"KeyedTuple: " for k, v in self.__dict__.items(): z += u"{}='{}' ".format(k, v) return z # FIXME not really a keyed tuple (it lacks '[]' operator) obj = KeyedTuple() obj.__dict__.update(d) return obj
def jsonable_to_keyed_tuple_sequence(metadata: SQLAMetaData, recursive_set, kts: KeyedTuplesSequence, kt_sequence): keyed_tuples = [] for kt in kt_sequence: typed = [] for i in range(len(kts)): typed.append( jsonable_to_typed_values(metadata, kts._types[i], kt[i], recursive_set)) keyed_tuples.append(KeyedTuple(typed, kts.keys())) return keyed_tuples
def test_add_relationship_class_with_invalid_object_class(self): """Test that adding a relationship class with a non existing object class raises an integrity error.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list" ) as mock_object_class_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list"): mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] with self.assertRaises(SpineIntegrityError): self.db_map.add_wide_relationship_classes( { "name": "fish__dog", "object_class_id_list": [1, 2] }, strict=True)
def list_subscription_rule_states(name=None, account=None): """Returns a list of with the number of rules per state for a subscription. :param name: Name of the subscription :param account: Account identifier :param session: The database session in use. :returns: List with tuple (account, name, state, count) """ if account is not None: account = InternalAccount(account) subs = subscription.list_subscription_rule_states(name, account) for sub in subs: # sub is an immutable KeyedTuple so return new KeyedTuple with edited entries labels = sub._fields d = sub._asdict() d['account'] = d['account'].external yield KeyedTuple([d[l] for l in labels], labels=labels)
def test_add_objects_with_same_name(self): """Test that adding two objects with the same name only adds one of them.""" with mock.patch.object(DiffDatabaseMapping, "object_class_list") as mock_object_class_list: mock_object_class_list.return_value = [ KeyedTuple([1, "fish"], labels=["id", "name"]) ] self.db_map.add_objects({ "name": "nemo", "class_id": 1 }, { "name": "nemo", "class_id": 1 }) objects = self.db_map.session.query(self.db_map.DiffObject).all() self.assertEqual(len(objects), 1) self.assertEqual(objects[0].name, "nemo") self.assertEqual(objects[0].class_id, 1)
def test_add_relationships(self): """Test that adding relationships works.""" with mock.patch.object( DiffDatabaseMapping, "object_list") as mock_object_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_class_list" ) as mock_wide_rel_cls_list, mock.patch.object( DiffDatabaseMapping, "wide_relationship_list"): mock_object_list.return_value = [ KeyedTuple([1, 10, "nemo"], labels=["id", "class_id", "name"]), KeyedTuple([2, 10, "dory"], labels=["id", "class_id", "name"]), KeyedTuple([3, 20, "pluto"], labels=["id", "class_id", "name"]), KeyedTuple([4, 20, "scooby"], labels=["id", "class_id", "name"]), ] mock_wide_rel_cls_list.return_value = [ KeyedTuple([1, "10,20", "fish__dog"], labels=["id", "object_class_id_list", "name"]), KeyedTuple([2, "20,10", "dog__fish"], labels=["id", "object_class_id_list", "name"]), ] self.db_map.add_wide_relationships( { "name": "nemo__pluto", "class_id": 1, "object_id_list": [1, 3] }, { "name": "scooby_dory", "class_id": 2, "object_id_list": [4, 2] }, ) relationships = self.db_map.session.query( self.db_map.DiffRelationship).all() self.assertEqual(len(relationships), 4) self.assertEqual(relationships[0].name, "nemo__pluto") self.assertEqual(relationships[0].class_id, 1) self.assertEqual(relationships[0].object_id, 1) self.assertEqual(relationships[1].name, "nemo__pluto") self.assertEqual(relationships[1].class_id, 1) self.assertEqual(relationships[1].object_id, 3) self.assertEqual(relationships[2].name, "scooby_dory") self.assertEqual(relationships[2].class_id, 2) self.assertEqual(relationships[2].object_id, 4) self.assertEqual(relationships[3].name, "scooby_dory") self.assertEqual(relationships[3].class_id, 2) self.assertEqual(relationships[3].object_id, 2)
def test_as_json(self): """Tests the jsonable.as_json function""" self.assertEqual(None, jsonable.as_json(None)) self.assertEqual({}, jsonable.as_json({})) import datetime obj = datetime.datetime(2014, 5, 5) self.assertEqual( { '__cls__': 'datetime.datetime', 'value': obj.isoformat() }, jsonable.as_json(obj)) from sqlalchemy.util import KeyedTuple self.assertEqual( { '__cls__': 'sqlalchemy.util.KeyedTuple', '_labels': ['a'], 'a': 1 }, jsonable.as_json(KeyedTuple([1], labels=['a']))) from sqlalchemy.sql.sqltypes import NullType self.assertEqual(None, jsonable.as_json(NullType())) self.assertEqual([1], jsonable.as_json([1])) self.assertEqual(u'a', jsonable.as_json('a')) class TestJsonable(jsonable.Jsonable): def __init__(self): self.a = 1 self.b = jsonable.Jsonable() self.assertEqual( { '__cls__': "<class 'tests.test_jsonable.TestJsonable'>", 'a': 1, 'b': { '__cls__': "<class 'dbmanagr.jsonable.Jsonable'>" } }, jsonable.as_json(TestJsonable()))
def test_row_item(self): """Tests the RowItem class""" row = Row( None, KeyedTuple(['', -1, '', '', None, None, '', '', '', '', -1, -1], labels=[ 'database_name', 'pid', 'username', 'client', 'transaction_start', 'query_start', 'state', 'query', 'blocked', 'blocked_by', 'transaction_duration', 'query_duration' ])) item = activity.RowItem(row) self.assertEqual(item, item) self.assertEqual(item, activity.RowItem.from_json({'row': row})) self.assertIsNotNone( activity.writer.StatementActivityWriter( Options()).itemtostring(item))
def poster_developmental_issues(): session = get_session() bid = request_arg('bid', int, default=None) uid = request_arg('uid', int, default=None) if uid is None: username = request_arg('user', str) user = session.query(User).filter(func.lower(User.name) == func.lower(username)).order_by(desc(User.uid)).first() if not user: raise APIError('User not found: %s' % username) else: user = session.query(User).get(uid) if not user: raise APIError('User ID not found: %s' % uid) columns = ['year', 'post_count', 'edit_count', 'threads_created', 'quoted_count', 'quotes_count', 'avg_post_length'] rows = dal.poster_developmental_issues(session, user.uid, bid).all() years = {r.year: r for r in rows} for year in range(min(years), max(years)): if year not in years: years[year] = KeyedTuple([year, 0, 0, 0, 0, 0, 0],labels=columns) rows = sorted(years.values(), key=lambda r: r.year) if 'csv' in request.args: fd = io.StringIO() writer = csv.writer(fd) writer.writerow(columns) for row in rows: writer.writerow(row) response = Response(fd.getvalue(), mimetype='text/csv') response.headers["Content-Disposition"] = "attachment; filename=user-development-%d.csv" % user.uid return response else: return json_response({ 'user': user, 'years': {r.year: r._asdict() for r in rows}, })