def test_cant_create_a_load_test_if_not_team_owner_or_team_member(self):
try:
LoadTestFactory.create(
created_by=UserFactory.create(),
team=self.team,
project_name=self.project.name
)
except ValueError:
exc = sys.exc_info()[1]
expect(str(exc)).to_include("Only the owner or members of team %s can create tests for it." % self.team.name)
return
assert False, "Should not have gotten this far"
def test_can_create_commit(self):
load_test = LoadTestFactory.create()
retrieved = LoadTest.objects(id=load_test.id).first()
commit = retrieved.last_commit
expect(commit).not_to_be_null()
expect(commit.hex).to_equal(load_test.last_commit.hex)
def test_load_test_instance(self):
team = TeamFactory.create(owner=self.user)
project = team.add_project("load-test-instace-acc-1", "repo", self.user)
load_test = LoadTestFactory.create(created_by=team.owner, team=team, project_name=project.name)
result1 = TestResultFactory.build()
result2 = TestResultFactory.build()
load_test.results.append(result1)
load_test.results.append(result2)
load_test.save()
result = self.execute("show", load_test.uuid)
expected_text = [
result1.config.title,
result1.cycles[-1].concurrent_users,
result1.cycles[-1].request.successful_requests_per_second,
result1.cycles[-1].request.p95,
result1.cycles[-1].request.failed_requests,
result1.uuid,
result2.config.title,
result2.cycles[-1].concurrent_users,
result2.cycles[-1].request.successful_requests_per_second,
result2.cycles[-1].request.p95,
result2.cycles[-1].request.failed_requests,
result2.uuid,
load_test.uuid,
load_test.status
]
for expected in expected_text:
expect(result).to_include(expected)
def test_can_create_commit(self):
load_test = LoadTestFactory.create()
retrieved = LoadTest.objects(id=load_test.id).first()
commit = retrieved.last_commit
expect(commit).not_to_be_null()
expect(commit.hex).to_equal(load_test.last_commit.hex)
def setUp(self):
super(LoadTestsInstanceTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
self.project = self.team.add_project("schedule-test-project-1", "repo",
self.user)
self.load_test = LoadTestFactory.create(created_by=self.team.owner,
team=self.team,
project_name=self.project.name)
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 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(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_to_dict(self):
load_test = LoadTestFactory.create()
commit = load_test.last_commit
json = commit.to_dict()
expected_committer = {'name': u'Committer Name', 'email': u'Committer Name'}
expected_author = {'name': u'Author Name', 'email': u'*****@*****.**'}
expect(json['message']).to_equal(commit.commit_message)
expect(json['hex']).to_equal('b64df0e7cdd3bcd099c4e43001f6c87efd81d417')
expect(json['author']).to_be_like(expected_author)
expect(json['committer']).to_be_like(expected_committer)
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_create_a_load_test_if_team_owner(self):
test = LoadTestFactory.create(
created_by=self.user,
team=self.team,
project_name=self.project.name
)
retrieveds = LoadTest.objects(id=test.id)
expect(retrieveds.count()).to_equal(1)
retrieved = retrieveds.first()
expect(retrieved.status).to_equal("Scheduled")
expect(retrieved.created_by.email).to_equal(self.user.email)
expect(retrieved.team.name).to_equal(self.team.name)
expect(retrieved.project_name).to_equal(self.project.name)
expect(retrieved.date_created).to_be_like(test.date_created)
expect(retrieved.date_modified).to_be_like(test.date_modified)
def test_to_dict(self):
load_test = LoadTestFactory.create()
commit = load_test.last_commit
json = commit.to_dict()
expected_committer = {
'name': u'Committer Name',
'email': u'Committer Name'
}
expected_author = {
'name': u'Author Name',
'email': u'*****@*****.**'
}
expect(json['message']).to_equal(commit.commit_message)
expect(
json['hex']).to_equal('b64df0e7cdd3bcd099c4e43001f6c87efd81d417')
expect(json['author']).to_be_like(expected_author)
expect(json['committer']).to_be_like(expected_committer)
def test_to_dict(self):
test = LoadTestFactory.create(
created_by=self.user,
team=self.team,
project_name=self.project.name,
base_url="http://some-server.com/some-url"
)
retrieved = LoadTest.objects(id=test.id).first()
expect(retrieved.to_dict()).to_be_like(
{
"baseUrl": "http://some-server.com/some-url",
"uuid": str(test.uuid),
"createdBy": self.user.email,
"team": self.team.name,
"project": self.project.name,
"status": test.status,
"created": test.date_created.isoformat()[:19],
"lastModified": test.date_modified.isoformat()[:19],
"lastCommit": test.last_commit.to_dict(),
"gitBranch": test.git_branch,
"results": []
}
)
def setUp(self):
super(LoadTestsInstanceTest, self).setUp()
self.user = UserFactory.create(with_token=True)
self.team = TeamFactory.create(owner=self.user)
self.project = self.team.add_project("schedule-test-project-1", "repo", self.user)
self.load_test = LoadTestFactory.create(created_by=self.team.owner, team=self.team, project_name=self.project.name)
