def test_push_many_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)
flexmock(Builder)
related2 = 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': 'related2'
}, 'id').and_return(3)
related2.should_receive('new_query').once().and_return(builder)
related2.should_receive('_update_timestamps').once()
related2.name = 'related2'
related2.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_many', Collection([related1, related2]))
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(2, len(model.relation_many))
self.assertEqual([2, 3], model.relation_many.lists('id'))
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_relation_count_query_can_be_built(self):
relation = self._get_relation()
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('select').once()
relation.get_parent().should_receive('get_table').and_return('table')
builder.should_receive('where').once().with_args(
'table.foreign_key', '=', QueryExpression)
parent_query = flexmock(QueryBuilder(None, None, None))
relation.get_query().should_receive('get_query').and_return(
parent_query)
grammar = flexmock()
parent_query.should_receive('get_grammar').once().and_return(grammar)
grammar.should_receive('wrap').once().with_args('table.id')
relation.get_relation_count_query(builder, builder)
def test_timestamps_can_be_retrieved_properly(self):
model1 = OrmBelongsToManyModelStub()
model1.fill(name='john', pivot_user_id=1, pivot_role_id=2)
model2 = OrmBelongsToManyModelStub()
model2.fill(name='jane', pivot_user_id=3, pivot_role_id=4)
models = [model1, model2]
base_builder = flexmock(
Builder(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor())))
relation = self._get_relation().with_timestamps()
relation.get_parent().should_receive('get_connection_name').and_return(
'foo.connection')
relation.get_query().get_query().should_receive('add_select').once()\
.with_args(
'roles.*',
'user_role.user_id AS pivot_user_id',
'user_role.role_id AS pivot_role_id',
'user_role.created_at AS pivot_created_at',
'user_role.updated_at AS pivot_updated_at'
)\
.and_return(relation.get_query())
relation.get_query().should_receive('get_models').once().and_return(
models)
relation.get_query().should_receive(
'eager_load_relations').once().with_args(models).and_return(models)
relation.get_related().should_receive('new_collection').replace_with(
lambda l: Collection(l))
relation.get_query().should_receive('get_query').once().and_return(
base_builder)
results = relation.get()
def _get_relation_arguments(self):
parent = flexmock(Model())
parent.should_receive('get_key').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')
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('roles')
related.should_receive('new_pivot').replace_with(
lambda *args: Pivot(*args))
builder.get_query().should_receive('join').once().with_args(
'user_role', 'roles.id', '=', 'user_role.role_id')
builder.should_receive('where').once().with_args(
'user_role.user_id', '=', 1)
return builder, parent, 'user_role', 'user_id', 'role_id', 'relation_id'
def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('join').once().with_args('users', 'users.id', '=', 'posts.user_id')
builder.should_receive('where').with_args('users.country_id', '=', 1)
country = flexmock(Model())
country.should_receive('get_key').and_return(1)
country.should_receive('get_foreign_key').and_return('country_id')
user = flexmock(Model())
user.should_receive('get_table').and_return('users')
user.should_receive('get_qualified_key_name').and_return('users.id')
post = flexmock(Model())
post.should_receive('get_table').and_return('posts')
builder.should_receive('get_model').and_return(post)
user.should_receive('get_key').and_return(1)
user.should_receive('get_created_at_column').and_return('created_at')
user.should_receive('get_updated_at_column').and_return('updated_at')
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 HasManyThrough(builder, country, user, 'country_id', 'user_id')
def _get_relation_arguments(self):
parent = flexmock(Model())
parent.should_receive('get_morph_class').and_return(
parent.__class__.__name__)
parent.should_receive('get_key').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')
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('tags')
related.should_receive('get_morph_class').and_return(
parent.__class__.__name__)
builder.get_query().should_receive('join').once().with_args(
'taggables', 'tags.id', '=', 'taggables.tag_id')
builder.should_receive('where').once().with_args(
'taggables.taggable_id', '=', 1)
builder.should_receive('where').once().with_args(
'taggables.taggable_type', parent.__class__.__name__)
return builder, parent, 'taggable', 'taggables', 'taggable_id', 'tag_id', 'relation_name', False
def new_query(self):
mock = flexmock(Builder)
mock_query = flexmock(QueryBuilder)
mock_query.should_receive('use_write_connection').once().and_return(
flexmock)
mock.should_receive('find').once().with_args(1).and_return('foo')
return Builder(QueryBuilder(None, None, None))
def new_query(self):
mock = flexmock(Builder)
model = flexmock()
mock_query = flexmock(QueryBuilder)
mock_query.should_receive('where_in').once().with_args(
'id', [1, 2, 3]).and_return(flexmock)
mock.should_receive('get').once().and_return([model])
model.should_receive('delete').once()
return Builder(QueryBuilder(None, None, None))
def test_eager_load_relations_load_top_level_relationships(self):
flexmock(Builder)
builder = Builder(flexmock(QueryBuilder(None, None, None)))
nop1 = lambda: None
nop2 = lambda: None
builder.set_eager_loads({'foo': nop1, 'foo.bar': nop2})
builder.should_receive('_load_relation').with_args(
['models'], 'foo', nop1).and_return(['foo'])
results = builder.eager_load_relations(['models'])
self.assertEqual(['foo'], results)
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 test_insert_process(self):
query = flexmock(Builder)
model = OrmModelStub()
query_builder = flexmock(QueryBuilder)
query_builder.should_receive('insert_get_id').once().with_args(
{
'name': 'john'
}, 'id').and_return(1)
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None)))
model._update_timestamps = mock.MagicMock()
# TODO: events
model.name = 'john'
model.set_exists(False)
self.assertTrue(model.save())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertTrue(model._update_timestamps.called)
model = OrmModelStub()
query_builder.should_receive('insert').once().with_args(
{'name': 'john'})
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None)))
model._update_timestamps = mock.MagicMock()
model.set_incrementing(False)
# TODO: events
model.name = 'john'
model.set_exists(False)
self.assertTrue(model.save())
self.assertFalse(hasattr(model, 'id'))
self.assertTrue(model.exists)
self.assertTrue(model._update_timestamps.called)
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 _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 test_models_are_properly_hydrated(self):
model1 = OrmBelongsToManyModelStub()
model1.fill(name='john', pivot_user_id=1, pivot_role_id=2)
model2 = OrmBelongsToManyModelStub()
model2.fill(name='jane', pivot_user_id=3, pivot_role_id=4)
models = [model1, model2]
base_builder = flexmock(
Builder(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor())))
relation = self._get_relation()
relation.get_parent().should_receive('get_connection_name').and_return(
'foo.connection')
relation.get_query().get_query().should_receive('add_select').once()\
.with_args(*['roles.*', 'user_role.user_id AS pivot_user_id', 'user_role.role_id AS pivot_role_id'])\
.and_return(relation.get_query())
relation.get_query().should_receive('get_models').once().and_return(
models)
relation.get_query().should_receive(
'eager_load_relations').once().with_args(models).and_return(models)
relation.get_related().should_receive('new_collection').replace_with(
lambda l: Collection(l))
relation.get_query().should_receive('get_query').once().and_return(
base_builder)
results = relation.get()
self.assertIsInstance(results, Collection)
# Make sure the foreign keys were set on the pivot models
self.assertEqual('user_id', results[0].pivot.get_foreign_key())
self.assertEqual('role_id', results[0].pivot.get_other_key())
self.assertEqual('john', results[0].name)
self.assertEqual(1, results[0].pivot.user_id)
self.assertEqual(2, results[0].pivot.role_id)
self.assertEqual('foo.connection',
results[0].pivot.get_connection_name())
self.assertEqual('jane', results[1].name)
self.assertEqual(3, results[1].pivot.user_id)
self.assertEqual(4, results[1].pivot.role_id)
self.assertEqual('foo.connection',
results[1].pivot.get_connection_name())
self.assertEqual('user_role', results[0].pivot.get_table())
self.assertTrue(results[0].pivot.exists)
def test_macros_are_called_on_builder(self):
builder = Builder(
QueryBuilder(flexmock(Connection), flexmock(QueryGrammar),
flexmock(QueryProcessor)))
def foo_bar(builder):
builder.foobar = True
return builder
builder.macro('foo_bar', foo_bar)
result = builder.foo_bar()
self.assertEqual(result, builder)
self.assertTrue(builder.foobar)
def test_delete_properly_deletes_model(self):
query = flexmock(Builder)
model = OrmModelStub()
builder = Builder(QueryBuilder(None, None, None))
query.should_receive('where').once().with_args('id',
1).and_return(builder)
query.should_receive('delete').once()
model.new_query = mock.MagicMock(return_value=builder)
model._touch_owners = mock.MagicMock()
model.set_exists(True)
model.id = 1
model.delete()
self.assertTrue(model._touch_owners.called)
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_timestamps_are_not_update_with_timestamps_false_save_option(self):
query = flexmock(Builder)
query.should_receive('where').once().with_args('id', 1)
query.should_receive('update').once().with_args({'name': 'john'})
model = OrmModelStub()
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None)))
model.id = 1
model.sync_original()
model.name = 'john'
model.set_exists(True)
self.assertTrue(model.save({'timestamps': False}))
self.assertFalse(hasattr(model, 'updated_at'))
model.new_query.assert_called_once_with()
def test_push_no_relations(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)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
def test_eager_load_accept_queries(self):
model = OrmBuilderTestModelCloseRelated()
flexmock(Builder)
builder = Builder(flexmock(QueryBuilder(None, None, None)))
nop1 = OrmBuilderTestModelFarRelatedStub.where('id', 5)
builder.set_eager_loads({'foo': nop1})
relation = flexmock()
relation.should_receive('add_eager_constraints').once().with_args(
['models'])
relation.should_receive('init_relation').once().with_args(
['models'], 'foo').and_return(['models'])
relation.should_receive('get_eager').once().and_return(['results'])
relation.should_receive('match').once()\
.with_args(['models'], ['results'], 'foo').and_return(['foo'])
builder.should_receive('get_relation').once().with_args(
'foo').and_return(relation)
relation.should_receive('merge_query').with_args(nop1).and_return(
relation)
results = builder.eager_load_relations(['models'])
self.assertEqual(['foo'], results)
def test_update_process_without_timestamps(self):
query = flexmock(Builder)
query.should_receive('where').once().with_args('id', 1)
query.should_receive('update').once().with_args({'name': 'john'})
model = OrmModelStub()
model.__timestamps__ = False
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None)))
model._update_timestamps = mock.MagicMock()
# TODO: events
model.id = 1
model.sync_original()
model.name = 'john'
model.set_exists(True)
self.assertTrue(model.save())
model.new_query.assert_called_once_with()
self.assertFalse(model._update_timestamps.called)
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_relationship_eager_load_process(self):
proof = flexmock()
flexmock(Builder)
builder = Builder(flexmock(QueryBuilder(None, None, None)))
def callback(q):
proof.foo = q
builder.set_eager_loads({'orders': callback})
relation = flexmock()
relation.should_receive('add_eager_constraints').once().with_args(
['models'])
relation.should_receive('init_relation').once().with_args(
['models'], 'orders').and_return(['models'])
relation.should_receive('get_eager').once().and_return(['results'])
relation.should_receive('match').once()\
.with_args(['models'], ['results'], 'orders').and_return(['models.matched'])
builder.should_receive('get_relation').once().with_args(
'orders').and_return(relation)
results = builder.eager_load_relations(['models'])
self.assertEqual(['models.matched'], results)
self.assertEqual(relation, proof.foo)
def test_update_process_does_not_override_timestamps(self):
query = flexmock(Builder)
query.should_receive('where').once().with_args('id', 1)
query.should_receive('update').once().with_args({
'created_at': 'foo',
'updated_at': 'bar'
})
model = OrmModelStub()
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None)))
model._update_timestamps = mock.MagicMock()
# TODO: events
model.id = 1
model.sync_original()
model.created_at = 'foo'
model.updated_at = 'bar'
model.set_exists(True)
self.assertTrue(model.save())
model.new_query.assert_called_once_with()
self.assertTrue(model._update_timestamps.called)
def new_query(self):
mock = flexmock(Builder)
mock.should_receive('find').once().with_args([1, 2],
['*']).and_return('foo')
return Builder(QueryBuilder(None, None, None))