def test_delete_a_project(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
project = team.projects[0]
team.delete_project(project.name)
retrieved = Team.objects.filter(name=team.name).first()
expect(retrieved.projects).to_length(0)
def test_delete_a_project(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
project = team.projects[0]
team.delete_project(project.name)
retrieved = Team.objects.filter(name=team.name).first()
expect(retrieved.projects).to_length(0)
def test_can_run_project(self):
temp_path = mkdtemp()
team = TeamFactory.create(name="teste")
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
project.repository = "git://github.com/heynemann/wight.git"
load_test = LoadTestFactory.add_to_project(1,
user=user,
team=team,
project=project,
base_url=self.base_url)
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(2)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
def test_can_run_simple_project(self):
temp_path = mkdtemp()
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1,
user=user,
team=team,
project=project,
base_url="%s/healthcheck" %
self.base_url,
simple=True)
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(1)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
expect(loaded.results[0].config.module).to_equal("test_simple")
expect(loaded.results[0].config.class_name).to_equal("SimpleTestTest")
expect(loaded.results[0].config.test_name).to_equal("test_simple")
def test_can_run_funkload(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project)
load_test.pressure = "small"
conf = WightConfig.load(join(root_path, 'bench', 'wight.yml'))
test = conf.tests[0]
DEFAULT_CYCLES = {
"small": [10, 20],
"medium": [10, 20, 30],
"large": [30, 75, 100],
}
fl_result = FunkLoadBenchRunner.run(root_path, test, self.base_url, cycles=DEFAULT_CYCLES, duration=5)
expect(fl_result).not_to_be_null()
expect(fl_result.exit_code).to_equal(0)
expect(fl_result.text).to_include("SUCCESSFUL")
expect(fl_result.log).to_be_empty()
expect(fl_result.result).not_to_be_null()
expect(fl_result.config).not_to_be_null()
result = LoadTest.get_data_from_funkload_results(fl_result.config, fl_result.result)
load_test.add_result(result, fl_result.text)
expect(load_test.results).to_length(1)
def test_update_a_project_with_name(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
project = team.projects[0]
team.update_project(project.name, "new-name")
retrieved = Team.objects.filter(name=team.name).first()
expect(retrieved.projects[0].name).to_equal("new-name")
expect(retrieved.projects[0].repository).to_equal(project.repository)
def setUp(self):
super(DeleteTeamProjectTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
TeamFactory.add_members(self.team, 2)
self.project = self.team.projects[0]
def test_update_a_project_with_repository(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
project = team.projects[0]
team.update_project(project.name, new_repository="new-repository")
retrieved = Team.objects.filter(name=team.name).first()
expect(retrieved.projects[0].name).to_equal(project.name)
expect(retrieved.projects[0].repository).to_equal("new-repository")
def setUp(self):
super(DeleteTeamProjectTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
TeamFactory.add_members(self.team, 2)
self.project = self.team.projects[0]
def test_get_last_3_load_tests_for_all_projects_when_owner(self):
LoadTestFactory.add_to_project(4, user=self.user, team=self.team, project=self.project)
LoadTestFactory.add_to_project(4, user=self.user, team=self.team, project=self.team.projects[1])
team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team, 1)
LoadTestFactory.add_to_project(4, user=self.user, team=team, project=team.projects[0])
LoadTestFactory.add_to_project(4, user=UserFactory.create())
loaded_tests = list(LoadTest.get_by_user(self.user))
expect(loaded_tests).to_length(9)
def test_get_project_by_team_should_be_a_equal_to_project_dict(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" % (self.team.name, project.name))
expect(response.code).to_equal(200)
obj = response.body
if isinstance(obj, six.binary_type):
obj = obj.decode('utf-8')
expect(loads(obj)).to_be_like(project.to_dict())
def setUp(self):
super(ShowAuthLoadTestResultTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
self.project = self.team.projects[0]
self.load_test = LoadTestFactory.create(created_by=self.user, team=self.team, project_name=self.project.name)
self.load_test.results.append(TestResultFactory.build())
self.load_test.save()
self.result = self.load_test.results[0]
def test_get_project_by_team_should_be_a_equal_to_project_dict(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" %
(self.team.name, project.name))
expect(response.code).to_equal(200)
obj = response.body
if isinstance(obj, six.binary_type):
obj = obj.decode('utf-8')
expect(loads(obj)).to_be_like(project.to_dict())
def setUp(self):
super(ShowTestResultForTeamProjectAndTestTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 2)
self.project = self.team.projects[0]
self.load_test = LoadTestFactory.create(created_by=self.user, team=self.team, project_name=self.project.name, status="Finished")
self.load_test.save()
self.config = TestConfigurationFactory.build()
self.config2 = TestConfigurationFactory.build()
def setUp(self):
super(ShowLoadLastTestResultTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
self.project = self.team.projects[0]
self.load_test = LoadTestFactory.create(created_by=self.user, team=self.team, project_name=self.project.name, status="Finished")
self.load_test.results.append(TestResultFactory.build())
self.load_test.save()
self.result = self.load_test.results[0]
def test_list_load_tests_by_team_and_project(self):
team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team, 1)
project = team.projects[0]
LoadTestFactory.add_to_project(25, user=self.user, team=team, project=project)
load_tests = LoadTest.get_sliced_by_team_and_project_name(team, project.name, 20)
uuids = _get_print_lines_for_load_tests(load_tests)
result = self.execute("list", team=team.name, project=project.name)
expect(result).to_be_like(BASE_LOAD_TESTS_TABLE_PRINT % (team.name, project.name, "".join(uuids)))
def test_can_git_clone_in_specific_branch(
self, run_config_mock, load_config_mock, validate_mock, save_mock, clone_mock
):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project, branch="test")
runner = BenchRunner()
runner.run_project_tests("some-path-doesnt-matter", str(load_test.uuid), duration=1)
expect(clone_mock.call_args_list[0][1]["branch"]).to_be_like("test")
def test_can_git_clone_in_specific_branch(self, run_config_mock, load_config_mock, validate_mock, save_mock, clone_mock):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project, branch="test")
runner = BenchRunner()
runner.run_project_tests("some-path-doesnt-matter", str(load_test.uuid), duration=1)
expect(clone_mock.call_args_list[0][1]['branch']).to_be_like(
"test"
)
def test_get_project_by_team_should_be_a_json(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" % (self.team.name, project.name))
expect(response.code).to_equal(200)
obj = response.body
if isinstance(obj, six.binary_type):
obj = obj.decode('utf-8')
try:
loads(obj)
assert True
except ValueError:
raise AssertionError("Should be possible to load a json from response")
def setUp(self):
super(ShowTestResultForTeamProjectAndTestTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 2)
self.project = self.team.projects[0]
self.load_test = LoadTestFactory.create(created_by=self.user,
team=self.team,
project_name=self.project.name,
status="Finished")
self.load_test.save()
self.config = TestConfigurationFactory.build()
self.config2 = TestConfigurationFactory.build()
def test_can_schedule_in_specific_branch(self):
team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team, 2)
project_name = team.projects[0].name
result = self.execute("schedule", team=team.name, project=project_name, url="http://www.globo.com", branch="test-branch")
expect(result).to_be_like(
"Scheduled a new load test for project '%s' (branch '%s') in team '%s' at '%s' target." % (
project_name, "test-branch", team.name, self.target
)
)
load_test = LoadTest.objects.filter(team=team, project_name=project_name).first()
expect(load_test).not_to_be_null()
expect(load_test.git_branch).to_equal("test-branch")
def test_get_project_by_team_should_be_a_json(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" %
(self.team.name, project.name))
expect(response.code).to_equal(200)
obj = response.body
if isinstance(obj, six.binary_type):
obj = obj.decode('utf-8')
try:
loads(obj)
assert True
except ValueError:
raise AssertionError(
"Should be possible to load a json from response")
def test_to_dict(self):
team = TeamFactory.create()
TeamFactory.add_members(team, 2)
TeamFactory.add_projects(team, 2)
expect(team.to_dict()).to_be_like({
"name": team.name,
"owner": team.owner.email,
"members": [
team.members[0].email,
team.members[1].email,
],
"projects": [
team.projects[0].to_dict(),
team.projects[1].to_dict(),
]
})
def main(args=None):
if args is None:
args = sys.argv[1:]
parser = argparse.ArgumentParser()
parser.add_argument('--conf', '-c', default=DEFAULT_CONFIG_PATH, help="Path to configuration file.")
options = parser.parse_args(args)
config = Config.load(path=options.conf, conf_name=split(options.conf)[-1], lookup_paths=[
os.curdir,
expanduser('~'),
'/etc/',
])
connect(
config.MONGO_DB,
host=config.MONGO_HOST,
port=config.MONGO_PORT,
username=config.MONGO_USER,
password=config.MONGO_PASS
)
user = UserFactory.create()
team = TeamFactory.create(owner=user)
TeamFactory.add_projects(team, 1)
project = team.projects[0]
config = TestConfigurationFactory.build()
load_test1 = LoadTestFactory.add_to_project(1, user=user, team=team, project=project)
load_test1.results.append(TestResultFactory.build(config=config))
load_test1.save()
print "load test 1: %s" % load_test1.uuid
print "test result for load test 1: %s" % load_test1.results[0].uuid
load_test2 = LoadTestFactory.add_to_project(1, user=user, team=team, project=project)
load_test2.results.append(TestResultFactory.build(config=config))
load_test2.results.append(TestResultFactory.build())
load_test2.save()
load_test3 = LoadTestFactory.add_to_project(1, user=user, team=team, project=project)
load_test3.results.append(TestResultFactory.build(config=config))
load_test3.save()
load_test4 = LoadTestFactory.add_to_project(1, user=user, team=team, project=project)
load_test4.results.append(TestResultFactory.build(config=config))
load_test4.save()
print "load test 2: %s" % load_test2.uuid
print "test result 1 for load test 2: %s" % load_test2.results[0].uuid
print "test result 2 for load test 2: %s" % load_test2.results[1].uuid
print "url for trend: %s/%s/%s/%s/%s/" % (team.name, project.name, config.module, config.class_name, config.test_name)
def test_can_schedule_with_default_project(self):
team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team, 2)
project_name = team.projects[0].name
self.execute("default-set", project=project_name)
result = self.execute("schedule", team=team.name, url="http://www.globo.com")
expect(result).to_be_like(
"Scheduled a new load test for project '%s' in team '%s' at '%s' target." % (
project_name, team.name, self.target
)
)
load_test = LoadTest.objects.filter(team=team, project_name=project_name).first()
expect(load_test).not_to_be_null()
expect(load_test.team.id).to_equal(team.id)
expect(load_test.project_name).to_equal(project_name)
expect(load_test.created_by.id).to_equal(self.user.id)
def test_list_load_tests_by_user_only(self):
team1 = TeamFactory.create(owner=self.user)
team2 = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team1, 2)
TeamFactory.add_projects(team2, 3)
project1 = team1.projects[0]
project2 = team1.projects[1]
project3 = team2.projects[0]
project4 = team2.projects[1]
project5 = team2.projects[2]
LoadTestFactory.add_to_project(4, user=self.user, team=team1, project=project1)
LoadTestFactory.add_to_project(4, user=self.user, team=team1, project=project2)
LoadTestFactory.add_to_project(4, user=self.user, team=team2, project=project3)
LoadTestFactory.add_to_project(4, user=self.user, team=team2, project=project4)
LoadTestFactory.add_to_project(4, user=self.user, team=team2, project=project5)
load_tests1 = LoadTest.get_sliced_by_team_and_project_name(team1, project1.name, 3)
load_tests2 = LoadTest.get_sliced_by_team_and_project_name(team1, project2.name, 3)
load_tests3 = LoadTest.get_sliced_by_team_and_project_name(team2, project3.name, 3)
load_tests4 = LoadTest.get_sliced_by_team_and_project_name(team2, project4.name, 3)
load_tests5 = LoadTest.get_sliced_by_team_and_project_name(team2, project5.name, 3)
uuids1 = _get_print_lines_for_load_tests(load_tests1)
uuids2 = _get_print_lines_for_load_tests(load_tests2)
uuids3 = _get_print_lines_for_load_tests(load_tests3)
uuids4 = _get_print_lines_for_load_tests(load_tests4)
uuids5 = _get_print_lines_for_load_tests(load_tests5)
result = self.execute("list")
expect(result).to_be_like((BASE_LOAD_TESTS_TABLE_PRINT * 5) % (
team1.name, project1.name, "".join(uuids1),
team1.name, project2.name, "".join(uuids2),
team2.name, project3.name, "".join(uuids3),
team2.name, project4.name, "".join(uuids4),
team2.name, project5.name, "".join(uuids5)
))
def test_to_dict(self):
team = TeamFactory.create()
TeamFactory.add_members(team, 2)
TeamFactory.add_projects(team, 2)
expect(team.to_dict()).to_be_like({
"name":
team.name,
"owner":
team.owner.email,
"members": [
team.members[0].email,
team.members[1].email,
],
"projects": [
team.projects[0].to_dict(),
team.projects[1].to_dict(),
]
})
def test_can_run_funkload(self):
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1,
user=user,
team=team,
project=project)
load_test.pressure = "small"
conf = WightConfig.load(join(root_path, 'bench', 'wight.yml'))
test = conf.tests[0]
DEFAULT_CYCLES = {
"small": [10, 20],
"medium": [10, 20, 30],
"large": [30, 75, 100],
}
fl_result = FunkLoadBenchRunner.run(root_path,
test,
self.base_url,
cycles=DEFAULT_CYCLES,
duration=5)
expect(fl_result).not_to_be_null()
expect(fl_result.exit_code).to_equal(0)
expect(fl_result.text).to_include("SUCCESSFUL")
expect(fl_result.log).to_be_empty()
expect(fl_result.result).not_to_be_null()
expect(fl_result.config).not_to_be_null()
result = LoadTest.get_data_from_funkload_results(
fl_result.config, fl_result.result)
load_test.add_result(result, fl_result.text)
expect(load_test.results).to_length(1)
def test_list_load_tests_by_team_only(self):
team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(team, 2)
project1 = team.projects[0]
project2 = team.projects[1]
LoadTestFactory.add_to_project(7, user=self.user, team=team, project=project1)
LoadTestFactory.add_to_project(7, user=self.user, team=team, project=project2)
load_tests1 = LoadTest.get_sliced_by_team_and_project_name(team, project1.name, 5)
load_tests2 = LoadTest.get_sliced_by_team_and_project_name(team, project2.name, 5)
uuids1 = _get_print_lines_for_load_tests(load_tests1)
uuids2 = _get_print_lines_for_load_tests(load_tests2)
result = self.execute("list", team=team.name)
expect(result).to_be_like((BASE_LOAD_TESTS_TABLE_PRINT * 2) % (
team.name, project1.name, "".join(uuids1),
team.name, project2.name, "".join(uuids2)
))
def test_can_run_project(self):
temp_path = mkdtemp()
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
project.repository = "git://github.com/heynemann/wight.git"
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project, base_url=self.base_url)
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(1)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
def test_can_run_simple_project(self):
temp_path = mkdtemp()
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project, base_url="%s/healthcheck" % self.base_url, simple=True)
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(1)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
expect(loaded.results[0].config.module).to_equal("test_simple")
expect(loaded.results[0].config.class_name).to_equal("SimpleTestTest")
expect(loaded.results[0].config.test_name).to_equal("test_simple")
def test_can_run_project_with_two_test(self, build_mock):
simple_test_content = """
import unittest
from funkload.FunkLoadTestCase import FunkLoadTestCase
class SimpleTestTest(FunkLoadTestCase):
def setUp(self):
self.server_url = '%s/healthcheck' % (self.conf_get('main', 'url').rstrip('/'),)
def test_simple(self):
self.get(self.server_url, description='Get url')
if __name__ == '__main__':
unittest.main()
"""
healthcheck_content = """
import unittest
from funkload.FunkLoadTestCase import FunkLoadTestCase
class HealthCheckTest(FunkLoadTestCase):
def setUp(self):
self.server_url = '%s/healthcheck' % (self.conf_get('main', 'url').rstrip('/'),)
def test_healthcheck(self):
self.get(self.server_url, description='Get url')
if __name__ == '__main__':
unittest.main()
"""
cfg_text = """
tests:
-
module: test_healthcheck.py
class: HealthCheckTest
test: test_healthcheck
-
module: test_simple.py
class: SimpleTestTest
test: test_simple
"""
build_mock.return_value = WightConfig(cfg_text)
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1, user=user, team=team, project=project, base_url=self.base_url, simple=True)
temp_path = mkdtemp()
mkdir(join(temp_path, "bench"))
init_file = open(join(temp_path, "bench/__init__.py"), "w")
init_file.close()
wight_file = open(join(temp_path, "bench/wight.yml"), "w")
wight_file.write(cfg_text)
wight_file.close()
simple_file = open(join(temp_path, "bench/test_simple.py"), "w")
simple_file.write(simple_test_content)
simple_file.close()
healthcheck_file = open(join(temp_path, "bench/test_healthcheck.py"), "w")
healthcheck_file.write(healthcheck_content)
healthcheck_file.close()
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(2)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
expect(loaded.results[0].config.module).to_equal("test_healthcheck")
expect(loaded.results[1].log).not_to_be_null()
expect(loaded.results[1].status).to_equal("Successful")
expect(loaded.results[1].config.module).to_equal("test_simple")
def setUp(self):
self.user = UserFactory.create()
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 2)
self.project = self.team.projects[0]
self.load_test = LoadTestFactory.add_to_project(1, user=self.user, team=self.team, project=self.project, status="Finished")
def setUp(self):
super(TestDeleteProject, self).setUp()
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
self.project = self.team.projects[0]
def test_get_project_by_team_and_name_return_200_if_no_errors(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" % (self.team.name, project.name))
expect(response.code).to_equal(200)
def test_get_project_by_team_and_name_return_200_if_no_errors(self):
TeamFactory.add_projects(self.team, 2)
project = self.team.projects[1]
response = self.fetch_with_headers("/teams/%s/projects/%s" %
(self.team.name, project.name))
expect(response.code).to_equal(200)
def setUp(self):
self.user = UserFactory.create()
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 2)
self.project = self.team.projects[0]
def test_can_run_project_with_two_test(self, build_mock):
simple_test_content = """
import unittest
from funkload.FunkLoadTestCase import FunkLoadTestCase
class SimpleTestTest(FunkLoadTestCase):
def setUp(self):
self.server_url = '%s/healthcheck' % (self.conf_get('main', 'url').rstrip('/'),)
def test_simple(self):
self.get(self.server_url, description='Get url')
if __name__ == '__main__':
unittest.main()
"""
healthcheck_content = """
import unittest
from funkload.FunkLoadTestCase import FunkLoadTestCase
class HealthCheckTest(FunkLoadTestCase):
def setUp(self):
self.server_url = '%s/healthcheck' % (self.conf_get('main', 'url').rstrip('/'),)
def test_healthcheck(self):
self.get(self.server_url, description='Get url')
if __name__ == '__main__':
unittest.main()
"""
cfg_text = """
tests:
-
module: test_healthcheck.py
class: HealthCheckTest
test: test_healthcheck
-
module: test_simple.py
class: SimpleTestTest
test: test_simple
"""
build_mock.return_value = WightConfig(cfg_text)
team = TeamFactory.create()
TeamFactory.add_projects(team, 1)
user = team.owner
project = team.projects[0]
load_test = LoadTestFactory.add_to_project(1,
user=user,
team=team,
project=project,
base_url=self.base_url,
simple=True)
temp_path = mkdtemp()
mkdir(join(temp_path, "bench"))
init_file = open(join(temp_path, "bench/__init__.py"), "w")
init_file.close()
wight_file = open(join(temp_path, "bench/wight.yml"), "w")
wight_file.write(cfg_text)
wight_file.close()
simple_file = open(join(temp_path, "bench/test_simple.py"), "w")
simple_file.write(simple_test_content)
simple_file.close()
healthcheck_file = open(join(temp_path, "bench/test_healthcheck.py"),
"w")
healthcheck_file.write(healthcheck_content)
healthcheck_file.close()
runner = BenchRunner()
runner.run_project_tests(temp_path, str(load_test.uuid), duration=1)
loaded = LoadTest.objects(uuid=load_test.uuid).first()
expect(loaded).not_to_be_null()
expect(loaded.status).to_equal("Finished")
expect(loaded.results).to_length(2)
expect(loaded.results[0].log).not_to_be_null()
expect(loaded.results[0].status).to_equal("Successful")
expect(loaded.results[0].config.module).to_equal("test_healthcheck")
expect(loaded.results[1].log).not_to_be_null()
expect(loaded.results[1].status).to_equal("Successful")
expect(loaded.results[1].config.module).to_equal("test_simple")
def setUp(self):
super(TestDeleteProject, self).setUp()
self.team = TeamFactory.create(owner=self.user)
TeamFactory.add_projects(self.team, 1)
self.project = self.team.projects[0]