def test_timestamps_are_returned_as_objects_from_timestamps_and_datetime(
self):
model = Model()
model.set_raw_attributes({
'created_at': datetime.datetime.utcnow(),
'updated_at': time.time()
})
self.assertIsInstance(model.created_at, Arrow)
self.assertIsInstance(model.updated_at, Arrow)
def test_models_are_properly_pulled_and_matched(self):
relation = self._get_relation()
one = flexmock(Model())
one.morph_type = 'morph_type_1'
one.foreign_key = 'foreign_key_1'
two = flexmock(Model())
two.morph_type = 'morph_type_1'
two.foreign_key = 'foreign_key_1'
three = flexmock(Model())
three.morph_type = 'morph_type_2'
three.foreign_key = 'foreign_key_2'
relation.add_eager_constraints([one, two, three])
first_query = flexmock(
Builder(flexmock(QueryBuilder(None, QueryGrammar(), None))))
second_query = flexmock(
Builder(flexmock(QueryBuilder(None, QueryGrammar(), None))))
first_model = flexmock(Model())
second_model = flexmock(Model())
relation.should_receive('_create_model_by_type').once().with_args(
'morph_type_1').and_return(first_model)
relation.should_receive('_create_model_by_type').once().with_args(
'morph_type_2').and_return(second_model)
first_model.should_receive('get_key_name').and_return('id')
second_model.should_receive('get_key_name').and_return('id')
first_model.should_receive('new_query').once().and_return(first_query)
second_model.should_receive('new_query').once().and_return(
second_query)
first_query.get_query().should_receive('where_in').once()\
.with_args('id', ['foreign_key_1']).and_return(first_query)
result_one = flexmock()
first_query.should_receive('get').and_return(
Collection.make([result_one]))
result_one.should_receive('get_key').and_return('foreign_key_1')
second_query.get_query().should_receive('where_in').once()\
.with_args('id', ['foreign_key_2']).and_return(second_query)
result_two = flexmock()
second_query.should_receive('get').and_return(
Collection.make([result_two]))
result_two.should_receive('get_key').and_return('foreign_key_2')
one.should_receive('set_relation').once().with_args(
'relation', result_one)
two.should_receive('set_relation').once().with_args(
'relation', result_one)
three.should_receive('set_relation').once().with_args(
'relation', result_two)
relation.get_eager()
def test_to_dict_includes_default_formatted_timestamps(self):
model = Model()
model.set_raw_attributes({
'created_at': '2015-03-24',
'updated_at': '2015-03-25'
})
d = model.to_dict()
self.assertEqual('2015-03-24T00:00:00+00:00', d['created_at'])
self.assertEqual('2015-03-25T00:00:00+00:00', d['updated_at'])
def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.should_receive('where').with_args('table.foreign_key', '=', 1)
related = flexmock(Model())
builder.should_receive('get_model').and_return(related)
parent = flexmock(Model())
parent.should_receive('get_attribute').with_args('id').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
parent.should_receive('new_query').and_return(builder)
return HasOne(builder, parent, 'table.foreign_key', 'id')
def _get_one_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.should_receive('where').with_args('table.morph_id', '=', 1)
related = flexmock(Model())
builder.should_receive('get_model').and_return(related)
parent = flexmock(Model())
parent.should_receive('get_attribute').with_args('id').and_return(1)
parent.should_receive('get_morph_class').and_return(
parent.__class__.__name__)
builder.should_receive('where').once().with_args(
'table.morph_type', parent.__class__.__name__)
return MorphOne(builder, parent, 'table.morph_type', 'table.morph_id',
'id')
def test_relation_is_properly_initialized(self):
relation = self._get_relation()
model = flexmock(Model())
model.should_receive('set_relation').once().with_args('foo', None)
models = relation.init_relation([model], 'foo')
self.assertEqual([model], models)
def test_relation_is_properly_initialized(self):
relation = self._get_relation()
model = flexmock(Model())
relation.get_related().should_receive('new_collection').replace_with(lambda l=None: Collection(l or []))
model.should_receive('set_relation').once().with_args('foo', Collection)
models = relation.init_relation([model], 'foo')
self.assertEqual([model], models)
def test_update_retrieve_model_and_updates(self):
relation = self._get_relation()
mock = flexmock(Model())
mock.should_receive('fill').once().with_args({'foo': 'bar'}).and_return(mock)
mock.should_receive('save').once().and_return(True)
relation.get_query().should_receive('first').once().and_return(mock)
self.assertTrue(relation.update({'foo': 'bar'}))
def test_save_method_set_foreign_key_on_model(self):
relation = self._get_relation()
mock_model = flexmock(Model(), save=lambda: True)
mock_model.should_receive('save').once().and_return(True)
result = relation.save(mock_model)
attributes = result.get_attributes()
self.assertEqual(1, attributes['foreign_key'])
def test_associate_sets_foreign_key_and_type_on_model(self):
parent = flexmock(Model())
parent.should_receive('get_attribute').once().with_args(
'foreign_key').and_return('foreign.value')
relation = self._get_relation_associate(parent)
associate = flexmock(Model())
associate.should_receive('get_key').once().and_return(1)
associate.should_receive('get_morph_class').once().and_return('Model')
parent.should_receive('set_attribute').once().with_args(
'foreign_key', 1)
parent.should_receive('set_attribute').once().with_args(
'morph_type', 'Model')
parent.should_receive('set_relation').once().with_args(
'relation', associate)
relation.associate(associate)
def test_push_one_relation(self):
flexmock(Builder)
related1 = flexmock(Model())
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args(
{
'name': 'related1'
}, 'id').and_return(2)
related1.should_receive('new_query').once().and_return(builder)
related1.should_receive('_update_timestamps').once()
related1.name = 'related1'
related1.set_exists(False)
model = flexmock(Model())
model.should_receive('resolve_connection').and_return(
MockConnection().prepare_mock())
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args(
{
'name': 'john'
}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
model.set_relation('relation_one', related1)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(2, model.relation_one.id)
self.assertTrue(model.relation_one.exists)
self.assertEqual(2, related1.id)
self.assertTrue(related1.exists)
def test_create(self):
relation = self._get_one_relation()
created = flexmock(Model())
created.should_receive('set_attribute').once().with_args('morph_id', 1)
created.should_receive('set_attribute').once()\
.with_args('morph_type', relation.get_parent().__class__.__name__)
relation.get_related().should_receive('new_instance').once().with_args(
{
'name': 'john'
}).and_return(created)
created.should_receive('save').once().and_return(True)
self.assertEqual(created, relation.create(name='john'))
def test_create_properly_creates_new_model(self):
relation = self._get_relation()
created = flexmock(Model(),
save=lambda: True,
set_attribute=lambda: None)
created.should_receive('save').once().and_return(True)
relation.get_related().should_receive('new_instance').once().with_args(
{
'name': 'john'
}).and_return(created)
created.should_receive('set_attribute').with_args('foreign_key', 1)
self.assertEqual(created, relation.create(name='john'))
def _get_relation_associate(self, parent):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.should_receive('where').with_args('relation.id', '=',
'foreign.value')
related = flexmock(Model())
related.should_receive('get_key').and_return(1)
related.should_receive('get_table').and_return('relation')
builder.should_receive('get_model').and_return(related)
return MorphTo(builder, parent, 'foreign_key', 'id', 'morph_type',
'relation')
def _get_relation(self, parent=None):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.should_receive('where').with_args('relation.id', '=', 'foreign.value')
related = flexmock(Model())
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('relation')
builder.should_receive('get_model').and_return(related)
if parent is None:
parent = OrmBelongsToModelStub()
parent.foreign_key = 'foreign.value'
return BelongsTo(builder, parent, 'foreign_key', 'id', 'relation')
def test_timestamps_return_none_if_set_to_none(self):
model = Model()
model.unguard()
timestamps = {
'created_at': datetime.datetime.now(),
'updated_at': datetime.datetime.now()
}
instance = model.new_instance(timestamps)
instance.created_at = None
self.assertIsNone(instance.created_at)
model.reguard()
def test_timestamps_are_returned_as_objects_on_create(self):
model = Model()
model.unguard()
timestamps = {
'created_at': datetime.datetime.now(),
'updated_at': datetime.datetime.now()
}
instance = model.new_instance(timestamps)
self.assertIsInstance(instance.created_at, Arrow)
self.assertIsInstance(instance.updated_at, Arrow)
model.reguard()
def test_morph_many_eager_constraints_are_properly_added(self):
relation = self._get_many_relation()
relation.get_query().get_query().should_receive(
'where_in').once().with_args('table.morph_id', [1, 2])
relation.get_query().should_receive('where').once()\
.with_args('table.morph_type', relation.get_parent().__class__.__name__)
model1 = Model()
model1.id = 1
model2 = Model()
model2.id = 2
relation.add_eager_constraints([model1, model2])
def test_push_empty_many_relation(self):
flexmock(Builder)
model = flexmock(Model())
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args(
{
'name': 'john'
}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
model.set_relation('relation_many', Collection([]))
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(0, len(model.relation_many))
def test_get_relation_properly_sets_nested_relationships(self):
flexmock(Builder)
builder = Builder(flexmock(QueryBuilder(None, None, None)))
model = flexmock(Model())
relation = flexmock()
model.set_relation('orders', relation)
builder.set_model(model)
relation_query = flexmock()
relation.should_receive('get_query').and_return(relation_query)
relation_query.should_receive('with_').once().with_args({
'lines':
None,
'lines.details':
None
})
builder.set_eager_loads({
'orders': None,
'orders.lines': None,
'orders.lines.details': None
})
relation = builder.get_relation('orders')
def test_associate_sets_foreign_key_on_model(self):
parent = Model()
parent.foreign_key = 'foreign.value'
parent.get_attribute = mock.MagicMock(return_value='foreign.value')
parent.set_attribute = mock.MagicMock()
parent.set_relation = mock.MagicMock()
relation = self._get_relation(parent)
associate = flexmock(Model())
associate.should_receive('get_attribute').once().with_args('id').and_return(1)
relation.associate(associate)
parent.get_attribute.assert_has_calls([
mock.call('foreign_key'),
mock.call('foreign_key')
])
parent.set_attribute.assert_has_calls([
mock.call('foreign_key', 1)
])
parent.set_relation.assert_called_once_with('relation', associate)
