def test_store_values():
class DummyBackend(Backend):
def write(self, item, objs):
return range(len(objs))
blueprint = Blueprint(backend=DummyBackend())
blueprint.add_item({
'name': 'foo',
'table': 'test',
'store_in': {
'foos': '$this'
}
})
blueprint.add_item({
'name': 'bar',
'table': 'test2',
'count': {
'by': 'foo',
'number': 2
},
'store_in': {
'this.foo.bar_ids': '$this.id'
}
})
buffer = Buffer(blueprint)
blueprint.items['foo'].generate(buffer, 10)
buffer.flush()
assert list(foo.id for foo in blueprint.vars['foos']) == list(range(10))
ids = iter(range(20))
for foo in blueprint.vars['foos']:
assert foo.bar_ids == [next(ids), next(ids)]
def test_flush_buffer_with_dependencies(mocker):
class DummyBackend(Backend):
def write(self, item, objs):
return range(len(objs))
blueprint = Blueprint(backend=mocker.Mock(wraps=DummyBackend()))
blueprint.add_item({'name': 'foo', 'table': 'test'})
blueprint.add_item({
'name': 'bar',
'table': 'test',
'count': {
'number': 1,
'by': 'foo'
}
})
blueprint.add_item({
'name': 'lol',
'table': 'test',
'count': {
'number': 1,
'by': 'bar'
}
})
buffer = Buffer(blueprint)
blueprint.items['foo'].generate(buffer, 5)
assert len(buffer.buffers['foo']) == 5
assert len(buffer.buffers['bar']) == 0
assert len(buffer.buffers['lol']) == 0
buffer.flush()
assert len(buffer.buffers['foo']) == 0
assert len(buffer.buffers['bar']) == 0
assert len(buffer.buffers['lol']) == 0
assert blueprint.backend.write.call_count == 3
assert (blueprint.backend.write.call_args_list[0] == mocker.call(
blueprint.items['foo'], ((), (), (), (), ())))
assert (blueprint.backend.write.call_args_list[1] == mocker.call(
blueprint.items['bar'], ((), (), (), (), ())))
assert (blueprint.backend.write.call_args_list[2] == mocker.call(
blueprint.items['lol'], ((), (), (), (), ())))
def test_flush_buffer(mocker):
blueprint = Blueprint(backend=mocker.MagicMock())
blueprint.add_item({'name': 'foo', 'table': 'test'})
blueprint.add_item({'name': 'bar', 'table': 'test'})
buffer = Buffer(blueprint)
blueprint.items['foo'].generate(buffer, 5)
blueprint.items['bar'].generate(buffer, 4)
assert len(buffer.buffers['foo']) == 5
assert len(buffer.buffers['bar']) == 4
buffer.flush()
assert len(buffer.buffers['foo']) == 0
assert len(buffer.buffers['bar']) == 0
assert blueprint.backend.write.call_count == 2
assert (blueprint.backend.write.call_args_list[0] == mocker.call(
blueprint.items['foo'], ((), (), (), (), ())))
assert (blueprint.backend.write.call_args_list[1] == mocker.call(
blueprint.items['bar'], ((), (), (), ())))
def generate(self):
logger.info("Getting existing unique values...")
self.preprocess()
buffer = Buffer(self)
logger.info("Starting generation...")
for item in self.items.values():
if item.count.by:
# we only create the items with no dependency,
# the others will be created on the fly
continue
item.generate(buffer, item.count())
# write everything left in the buffer
buffer.flush()
logger.info("Generation done.")
def test_generate__count_with_var():
class DummyBackend(Backend):
def write(self, item, objs):
return range(len(objs))
blueprint = Blueprint(backend=DummyBackend())
blueprint.add_item({
'name': 'foo',
'table': 'test',
'fields': {
'nb_bars': {
'generator': 'Integer',
'min': 1,
'max': 10
}
},
'store_in': {
'foos': '$this'
}
})
blueprint.add_item({
'name': 'bar',
'table': 'test',
'count': {
'number': '$foo.nb_bars',
'by': 'foo'
},
'store_in': {
'this.foo.bars': '$this'
}
})
buffer = Buffer(blueprint)
blueprint.items['foo'].generate(buffer, 10)
buffer.flush()
assert len(blueprint.vars['foos']) == 10
for foo in blueprint.vars['foos']:
assert 1 <= foo.nb_bars <= 10
assert len(foo.bars) == foo.nb_bars