def test_invalid_user_count(self):
self.scenario_dict['user_count'] = -1
self.write_scenario_file()
with assert_raises(ValueError):
Scenario(self.stub_scenario_file)
with assert_raises(ValueError):
Scenario(self.stub_scenario_file, user_count=0)
def test_packb_unpackb_with_run_seconds(self):
self.scenario_dict['run_seconds'] = 27
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file, version='0.1.1')
assert_equal(27, scenario.run_seconds)
assert_equal(None, scenario.operation_count)
packed = scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds'
]:
assert_equal(getattr(unpacked, attr), getattr(scenario, attr))
scenario = Scenario(self.stub_scenario_file,
run_seconds=88,
operation_count=99)
assert_equal(88, scenario.run_seconds)
assert_equal(None, scenario.operation_count)
packed = scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds'
]:
assert_equal(getattr(unpacked, attr), getattr(scenario, attr))
def test_containers_custom_policy(self):
self.scenario_dict['policy'] = 'candlestick'
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file)
assert_list_equal(
scenario.containers,
['ssbench_%06d_candlestick' % i for i in xrange(100)])
def test_start_run(self):
# Just instantiating the object shouldn't create anything
assert_false(os.path.exists(self.result_file_path))
self.run_results.start_run(self.scenario)
# start_run opens the file for writing and dumps out the scenario.
assert_equal(len(self.scenario.packb()), self._current_size())
# This is a bit white-box, but that's what we're here for...
assert_greater(self._current_size(), 0)
with open(self.result_file_path, "rb") as f:
unpacker = msgpack.Unpacker(file_like=f)
got_scenario = Scenario.unpackb(unpacker)
for attr in [
"name",
"_scenario_data",
"user_count",
"operation_count",
"run_seconds",
"container_base",
"container_count",
"containers",
"container_concurrency",
"sizes_by_name",
"version",
"bench_size_thresholds",
]:
assert_equal(getattr(got_scenario, attr), getattr(self.scenario, attr))
def test_unpackb_backwards_compat(self):
# Older ssbench didn't have a delete_after key in scenario data; make
# sure we can still load those for reporting
packed = msgpack.packb({
'_scenario_data':
self.scenario._scenario_data,
'name':
self.scenario.name,
'version':
self.scenario.version,
'user_count':
self.scenario.user_count,
'operation_count':
self.scenario.operation_count,
'run_seconds':
self.scenario.run_seconds,
'container_base':
self.scenario.container_base,
'container_count':
self.scenario.container_count,
'container_concurrency':
self.scenario.container_concurrency,
})
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds'
]:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_constructor_overrides(self):
scenario = Scenario(self.stub_scenario_file,
container_count=21,
user_count=37,
operation_count=101)
assert_equal(21, len(scenario.containers))
assert_equal(37, scenario.user_count)
assert_equal(101, scenario.operation_count)
def read_results(self):
if self.results_file_path.endswith('.gz'):
file_like = GzipFile(self.results_file_path, 'rb')
else:
file_like = open(self.results_file_path, 'rb')
unpacker = msgpack.Unpacker(file_like=file_like)
scenario = Scenario.unpackb(unpacker)
return scenario, unpacker
def test_containers_custom(self):
self.scenario_dict['container_base'] = 'iggy'
self.scenario_dict['container_count'] = 77
self.scenario_dict['container_concurrency'] = 13
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file)
assert_list_equal(scenario.containers,
['iggy_%06d_default_policy' % i for i in xrange(77)])
assert_equal(13, scenario.container_concurrency)
def read_results(self):
if self.results_file_path.endswith('.gz'):
file_like = GzipFile(self.results_file_path, 'rb')
else:
file_like = open(self.results_file_path, 'rb')
unpacker = msgpack.Unpacker(file_like=file_like)
scenario = Scenario.unpackb(unpacker)
return scenario, unpacker
def test_packb_unpackb(self):
packed = self.scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in ['name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds']:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_bench_jobs_with_run_seconds(self):
initial_handler = lambda s, f: 17
signal.signal(signal.SIGALRM, initial_handler)
self.scenario_dict['operation_count'] = 1
self.scenario_dict['run_seconds'] = 1
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file)
start_time = time.time()
jobs = list(scenario.bench_jobs())
delta_t = time.time() - start_time
# Count should be greater than 1, for sure...
assert_greater(len(jobs), 1)
# +/- 10ms seems good:
assert_almost_equal(delta_t, scenario.run_seconds, delta=0.01)
restored_handler = signal.signal(signal.SIGALRM, signal.SIG_DFL)
assert_equal(restored_handler, initial_handler)
def test_bench_jobs_with_run_seconds(self):
initial_handler = lambda s, f: 17
signal.signal(signal.SIGALRM, initial_handler)
self.scenario_dict['operation_count'] = 1
self.scenario_dict['run_seconds'] = 1
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file)
start_time = time.time()
jobs = list(scenario.bench_jobs())
delta_t = time.time() - start_time
# Count should be greater than 1, for sure...
assert_greater(len(jobs), 1)
# +/- 10ms seems good:
assert_almost_equal(delta_t, scenario.run_seconds, delta=0.01)
restored_handler = signal.signal(signal.SIGALRM, signal.SIG_DFL)
assert_equal(restored_handler, initial_handler)
def test_unpackb_given_unpacker(self):
packed = self.scenario.packb()
assert_is_instance(packed, bytes)
file_like = StringIO(packed + msgpack.packb({'red': 'herring'}))
unpacker = msgpack.Unpacker(file_like=file_like)
unpacked = Scenario.unpackb(unpacker)
assert_is_instance(unpacked, Scenario)
for attr in ['name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds']:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_packb_unpackb(self):
packed = self.scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds', 'delete_after'
]:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_packb_unpackb_with_run_seconds(self):
self.scenario_dict['run_seconds'] = 27
self.write_scenario_file()
scenario = Scenario(self.stub_scenario_file, version='0.1.1')
assert_equal(27, scenario.run_seconds)
assert_equal(None, scenario.operation_count)
packed = scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in ['name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds']:
assert_equal(getattr(unpacked, attr), getattr(scenario, attr))
scenario = Scenario(self.stub_scenario_file, run_seconds=88,
operation_count=99)
assert_equal(88, scenario.run_seconds)
assert_equal(None, scenario.operation_count)
packed = scenario.packb()
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in ['name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds']:
assert_equal(getattr(unpacked, attr), getattr(scenario, attr))
def test_unpackb_given_unpacker(self):
packed = self.scenario.packb()
assert_is_instance(packed, bytes)
file_like = StringIO(packed + msgpack.packb({'red': 'herring'}))
unpacker = msgpack.Unpacker(file_like=file_like)
unpacked = Scenario.unpackb(unpacker)
assert_is_instance(unpacked, Scenario)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds'
]:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_unpackb_backwards_compat(self):
# Older ssbench didn't have a delete_after key in scenario data; make
# sure we can still load those for reporting
packed = msgpack.packb({
'_scenario_data': self.scenario._scenario_data,
'name': self.scenario.name,
'version': self.scenario.version,
'user_count': self.scenario.user_count,
'operation_count': self.scenario.operation_count,
'run_seconds': self.scenario.run_seconds,
'container_base': self.scenario.container_base,
'container_count': self.scenario.container_count,
'container_concurrency': self.scenario.container_concurrency,
})
assert_is_instance(packed, bytes)
unpacked = Scenario.unpackb(packed)
assert_is_instance(unpacked, Scenario)
for attr in ['name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds']:
assert_equal(getattr(unpacked, attr), getattr(self.scenario, attr))
def test_start_run(self):
# Just instantiating the object shouldn't create anything
assert_false(os.path.exists(self.result_file_path))
self.run_results.start_run(self.scenario)
# start_run opens the file for writing and dumps out the scenario.
assert_equal(len(self.scenario.packb()), self._current_size())
# This is a bit white-box, but that's what we're here for...
assert_greater(self._current_size(), 0)
with open(self.result_file_path, 'rb') as f:
unpacker = msgpack.Unpacker(file_like=f)
got_scenario = Scenario.unpackb(unpacker)
for attr in [
'name', '_scenario_data', 'user_count', 'operation_count',
'run_seconds', 'container_base', 'container_count',
'containers', 'container_concurrency', 'sizes_by_name',
'version', 'bench_size_thresholds'
]:
assert_equal(getattr(got_scenario, attr),
getattr(self.scenario, attr))
def setUp(self):
superclass = super(ScenarioFixture, self)
if hasattr(superclass, 'setUp'):
superclass.setUp()
if not hasattr(self, 'stub_scenario_file'):
self.tmp_file = tempfile.NamedTemporaryFile()
self.stub_scenario_file = self.tmp_file.name
if not getattr(self, 'scenario_dict', None):
self.scenario_dict = dict(
name='Test1 - Happy go lucky',
sizes=[
dict(name='tiny', size_min=99, size_max=100),
dict(name='small',
size_min=199,
size_max=200,
crud_profile=[73, 12, 5, 10]),
dict(name='medium', size_min=299, size_max=300),
dict(name='red herring', size_min=9999, size_max=9999),
dict(name='large',
size_min=399,
size_max=400,
crud_profile=[13, 17, 19, 51])
],
initial_files=dict(tiny=700, small=400, medium=200, large=100),
# From first POC input, all file size percentages can be
# derived directly from the distribution of initial files. So
# we take that shortcut in the definition of scenarios.
operation_count=20000,
# C R U D
crud_profile=[10, 7, 4, 1], # maybe make this a dict?
user_count=1,
)
self.write_scenario_file()
self.scenario = Scenario(self.stub_scenario_file)
self.scenario_noop = ScenarioNoop(self.stub_scenario_file)
def test_open_fails(self):
with assert_raises(IOError):
# It also logs, but I'm too lazy to test that
Scenario('some file which will not be present!')
def test_no_op_count_or_run_seconds(self):
with assert_raises(ValueError):
self.scenario_dict.pop('run_seconds', None)
self.scenario_dict.pop('operation_count', None)
self.write_scenario_file()
Scenario(self.stub_scenario_file)
def test_no_filename_or__scenario_data(self):
with assert_raises(ValueError):
self.write_scenario_file()
Scenario()
def test_basic_instantiation_with_block_size(self):
# very whitebox:
scenario = Scenario(self.stub_scenario_file, block_size=987)
assert_dict_equal(self.scenario_dict, scenario._scenario_data)
assert_equal(ssbench.version, scenario.version)
assert_equal(987, scenario.block_size)
