def test_get_return_200_if_not_team_owner(self):
     self._add_results()
     user = UserFactory.create(with_token=True)
     TeamFactory.create(owner=user)
     url = "/results/%s/%s/%s/%s/%s" % (self.team.name, self.project.name, self.config.module, self.config.class_name, self.config.test_name)
     response = self.fetch_with_headers(url)
     expect(response.code).to_equal(200)

    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_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_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_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 test_can_create_team_with_members(self):
        team = TeamFactory.create()
        TeamFactory.add_members(team, 1)

        retrieved = Team.objects(id=team.id)
        expect(retrieved.count()).to_equal(1)
        expect(retrieved.first().name).to_equal(team.name)
        expect(retrieved.first().members).to_length(1)
        expect(retrieved.first().members[0].email).to_equal(team.members[0].email)

 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_project_being_a_member(self):
        team = TeamFactory.create()
        TeamFactory.add_members(team, 2)
        team.add_project(name="test-can-create-project-being-a-member", repository="repo", created_by=team.members[0])

        retrieved = Team.objects.filter(name=team.name).first()
        expect(retrieved).not_to_be_null()
        expect(retrieved.projects).to_length(1)
        expect(retrieved.projects[0].name).to_equal(team.projects[0].name)
        expect(retrieved.projects[0].repository).to_equal(team.projects[0].repository)

    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_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_show_memberships(self):
        t1 = TeamFactory.create(owner=self.user)
        t2 = TeamFactory.create(members=[self.user])
        result = self.execute("user-info")

        expected = ("""User: %s
          +--------+--------+
          | team   | role   |
          +--------+--------+
          | %s     | owner  |
          | %s     | member |
          +--------+--------+
        """ % (self.user.email, t1.name, t2.name)).replace('-', '')

        expect(result.replace('-', '')).to_be_like(expected)

    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_add_team_member_twice(self):
        user = UserFactory.create()
        team = TeamFactory.create(owner=self.user, members=[user])

        response = self.patch("/teams/%s/members" % team.name, user=user.email)
        expect(response.code).to_equal(409)
        expect(response.body).to_equal("User already team member")

 def test_try_delete_team_without_auth(self):
     team = TeamFactory.create(owner=self.user)
     self.user = None
     response = self.delete("/teams/anything")
     expect(response.code).to_equal(401)
     team = Team.objects.filter(name=team.name).first()
     expect(team).not_to_be_null()

    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_create_project_with_same_name_in_different_teams(self):
        team = TeamFactory.create()
        team2 = TeamFactory.create()

        team.add_project(name="test-can-create-project", repository="repo", created_by=team.owner)
        team2.add_project(name="test-can-create-project", repository="repo", created_by=team2.owner)

        retrieved = Team.objects.filter(name=team.name).first()
        expect(retrieved).not_to_be_null()
        expect(retrieved.projects).to_length(1)
        expect(retrieved.projects[0].name).to_equal(team.projects[0].name)

        retrieved = Team.objects.filter(name=team2.name).first()
        expect(retrieved).not_to_be_null()
        expect(retrieved.projects).to_length(1)
        expect(retrieved.projects[0].name).to_equal(team2.projects[0].name)

    def test_try_to_delete_a_not_owner_team(self):
        team = TeamFactory.create(owner=UserFactory.create(with_token=True))

        response = self.delete("/teams/%s" % team.name)
        expect(response.code).to_equal(403)

        team = Team.objects.filter(name=team.name).first()
        expect(team).not_to_be_null()