def test_move(self):
        email_1, password_1 = signup_teacher_directly()
        email_2, password_2 = signup_teacher_directly()
        org_name, postcode = create_organisation_directly(email_1)
        join_teacher_to_organisation(email_2, org_name, postcode)
        _, class_name_1, access_code_1 = create_class_directly(email_1)
        _, class_name_2, access_code_2 = create_class_directly(email_2)
        student_name_1, student_password_1, _ = create_school_student_directly(
            access_code_1
        )
        student_name_2, student_password_2, _ = create_school_student_directly(
            access_code_1
        )

        self.selenium.get(self.live_server_url)
        page = HomePage(self.selenium).go_to_login_page().login(email_1, password_1)
        page = page.go_to_class_page()
        assert page.student_exists(student_name_1)
        assert page.student_exists(student_name_2)

        page = page.toggle_select_student()
        page = page.move_students().select_class_by_index(0).move().move()
        assert not page.student_exists(student_name_1)

        page = page.go_to_dashboard()
        page = page.go_to_top().logout().go_to_login_page().login(email_2, password_2)
        page = page.go_to_class_page()
        assert page.student_exists(student_name_1)

    def test_move(self):
        email_1, password_1 = signup_teacher_directly()
        email_2, password_2 = signup_teacher_directly()
        org_name, postcode = create_organisation_directly(email_1)
        join_teacher_to_organisation(email_2, org_name, postcode)
        _, class_name_1, access_code_1 = create_class_directly(email_1)
        _, class_name_2, access_code_2 = create_class_directly(email_2)
        student_name_1, student_password_1, _ = create_school_student_directly(access_code_1)
        student_name_2, student_password_2, _ = create_school_student_directly(access_code_1)

        self.browser.get(self.live_server_url)
        page = HomePage(self.browser).go_to_teach_page().login(email_1, password_1)
        page = page.go_to_classes_page().go_to_class_page(class_name_1)
        assert page.has_students()
        assert page.student_exists(student_name_1)
        assert page.student_exists(student_name_2)

        page = page.toggle_select_student(student_name_1)
        page = move_students(page, 0)
        assert page.has_students()
        assert page.student_does_not_exist(student_name_1)
        assert page.student_exists(student_name_2)

        page = page.logout().go_to_teach_page().login(email_2, password_2)
        page = page.go_to_classes_page().go_to_class_page(class_name_2)
        assert page.has_students()
        assert page.student_exists(student_name_1)
        assert page.student_does_not_exist(student_name_2)

    def test_create_dashboard_non_admin(self):
        email_1, password_1 = signup_teacher_directly()
        email_2, password_2 = signup_teacher_directly()
        name, postcode = create_organisation_directly(email_1)
        klass_1, class_name_1, access_code_1 = create_class_directly(email_1)
        create_school_student_directly(access_code_1)
        join_teacher_to_organisation(email_2, name, postcode)
        klass_2, class_name_2, access_code_2 = create_class_directly(email_2)
        create_school_student_directly(access_code_2)

        page = self.go_to_homepage().go_to_login_page().login(email_2, password_2)

        page, class_name_3 = create_class(page)

        assert is_class_created_message_showing(self.selenium, class_name_3)

    def test_dismiss(self):
        email, password = signup_teacher_directly()
        org_name, postcode = create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name_1, student_password_1, _ = create_school_student_directly(access_code)
        student_name_2, student_password_2, _ = create_school_student_directly(access_code)

        self.browser.get(self.live_server_url)
        page = HomePage(self.browser).go_to_teach_page().login(email, password)
        page = page.go_to_classes_page().go_to_class_page(class_name)
        assert page.has_students()
        assert page.student_exists(student_name_1)
        assert page.student_exists(student_name_2)

        page = page.dismiss_students_none_selected()
        assert self.is_class_page(page)

        page = page.toggle_select_student(student_name_1).dismiss_students()
        assert page.__class__.__name__ == 'TeachDismissStudentsPage'
        page = page.cancel()
        assert page.has_students()
        assert page.student_exists(student_name_1)
        assert page.student_exists(student_name_2)

        page = page.toggle_select_student(student_name_1)
        page, emails = dismiss_students(page)
        assert page.has_students()
        assert page.student_does_not_exist(student_name_1)
        assert page.student_exists(student_name_2)

    def test_preview_user_cannot_create_duplicate_game(self):
        email, password = signup_teacher_directly_as_preview_user()
        create_organisation_directly(email, True)
        klass, name, access_code = create_class_directly(email)
        create_school_student_directly(access_code)

        self.selenium.get(self.live_server_url)
        page = HomePage(self.selenium).go_to_login_page().login(email, password)
        page = page.go_to_aimmo_home_page()

        page.click_create_new_game_button()
        page.input_new_game_name("Test Game")
        page.click_create_game_button()

        self.selenium.get(self.live_server_url)
        page = HomePage(self.selenium).go_to_aimmo_home_page()

        page.click_create_new_game_button()
        page.input_new_game_name("Test Game")
        page.click_create_game_button()

        self.assertEqual(
            page.get_input_game_name_placeholder(),
            "Sorry, a game with this name already exists...",
        )

    def test_dismiss(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name_1, student_password_1, _ = create_school_student_directly(
            access_code
        )
        student_name_2, student_password_2, _ = create_school_student_directly(
            access_code
        )

        self.selenium.get(self.live_server_url)
        page = HomePage(self.selenium).go_to_login_page().login(email, password)
        page = page.go_to_class_page()
        assert page.student_exists(student_name_1)

        page = page.toggle_select_student().dismiss_students()
        assert page.__class__.__name__ == "TeachDismissStudentsPage"
        page = page.cancel()
        assert page.__class__.__name__ == "TeachClassPage"

        page = (
            page.toggle_select_student()
            .dismiss_students()
            .enter_email("[email protected]")
            .dismiss()
        )
        assert not page.student_exists(student_name_1)

    def test_change_password(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name, student_password, _ = create_school_student_directly(access_code)

        self.browser.get(self.live_server_url)
        page = (
            HomePage(self.browser)
            .go_to_play_page()
            .school_login(student_name, access_code, student_password)
            .go_to_account_page()
        )

        new_password = "new " + student_password
        page = page.change_account_details(
            {"password": new_password, "confirm_password": new_password, "current_password": student_password}
        )

        page = page.logout().go_to_play_page().school_login_incorrect(student_name, access_code, student_password)

        assert page.school_login_has_failed()

        page = page.school_login(student_name, access_code, new_password)
        assert self.is_dashboard(page)

    def test_update_password_success(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name, student_password, _ = create_school_student_directly(access_code)

        self.selenium.get(self.live_server_url)
        page = (
            HomePage(self.selenium)
            .go_to_login_page()
            .student_login(student_name, access_code, student_password)
        )
        assert self.is_dashboard(page)

        new_password = "NewPassword"

        page = page.go_to_account_page().update_password_failure(
            new_password, new_password, student_password
        )
        assert is_student_details_updated_message_showing(self.selenium)

        page.logout()
        self.selenium.get(self.live_server_url)
        page = (
            HomePage(self.selenium)
            .go_to_login_page()
            .student_login(student_name, access_code, new_password)
        )
        assert self.is_dashboard(page)

    def test_update_student_password(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        name, password, student = create_school_student_directly(access_code)

        self.selenium.get(self.live_server_url)
        page = (
            HomePage(self.selenium)
            .go_to_login_page()
            .login(email, password)
            .go_to_class_page()
            .go_to_edit_student_page()
        )

        assert page.is_student_name(name)

        new_student_password = "new_password"

        page = page.click_set_password_form_button().type_student_password(
            new_student_password
        )
        time.sleep(1)
        page = page.click_set_password_button()

        assert page.is_student_password(new_student_password)

    def test_update_student_invalid_name(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        name, password, student = create_school_student_directly(access_code)

        self.selenium.get(self.live_server_url)
        page = (
            HomePage(self.selenium)
            .go_to_login_page()
            .login(email, password)
            .go_to_class_page()
            .go_to_edit_student_page()
        )

        assert page.is_student_name(name)

        new_student_name = "new name!"

        page = page.type_student_name(new_student_name)
        page = page.click_update_button()

        assert page.is_student_name(name)
        assert page.was_form_invalid(
            "form-edit-student",
            "Names may only contain letters, numbers, dashes, underscores, and spaces.",
        )

    def test_edit(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)

        page = self.go_to_homepage() \
            .go_to_teach_page() \
            .login(email, password)
        page = page.go_to_classes_page().go_to_class_page(class_name).go_to_class_settings_page()

        new_class_name = 'new ' + class_name
        assert not page.check_class_details({
            'name': new_class_name,
            'classmates_data_viewable': True,
        })

        page = page.change_class_details({
            'name': new_class_name,
            'classmates_data_viewable': True,
        })

        page = page.go_to_class_settings_page()
        new_class_name = 'new ' + class_name
        assert page.check_class_details({
            'name': new_class_name,
            'classmates_data_viewable': True,
        })

    def test_login_empty_class(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name, student_password, _ = create_school_student_directly(access_code)
        _, class_name2, access_code2 = create_class_directly(email)

        self.selenium.get(self.live_server_url)
        page = (
            HomePage(self.selenium)
            .go_to_login_page()
            .student_login_failure(student_name, access_code2, student_password)
        )

        assert page.has_login_failed(
            "form-login-school", "Invalid name, class access code or password"
        )

    def _test_incorrect_teacher_cannot_login(self, view_name):
        email1, _ = signup_teacher_directly()
        email2, pass2 = signup_teacher_directly()
        _, _, access_code = create_class_directly(email1)

        c = Client()
        assert c.login(username=email2, password=pass2)
        page = reverse(view_name, args=[access_code])
        self.assertNotEqual(c.get(page).status_code, 200)

    def test_login(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name, student_password, _ = create_school_student_directly(access_code)

        self.browser.get(self.live_server_url)
        page = HomePage(self.browser).go_to_play_page().school_login(student_name, access_code, student_password)
        assert self.is_dashboard(page)

    def test_create_dashboard(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        klass, name, access_code = create_class_directly(email)
        create_school_student_directly(access_code)

        page = self.go_to_homepage().go_to_login_page().login(email, password)

        page, class_name = create_class(page)

        assert is_class_created_message_showing(self.selenium, class_name)

    def test_login_failure(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)
        student_name, student_password, _ = create_school_student_directly(access_code)

        selenium.get(self.live_server_url)
        page = HomePage(selenium)\
            .go_to_play_page()\
            .school_login_incorrect(student_name, access_code, 'some other password')

        assert page.school_login_has_failed()

    def test_transfer_cancel(self):
        email, password = signup_teacher_directly()
        create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)

        page = self.go_to_homepage().go_to_teach_page().login(email, password)
        page = page.go_to_classes_page().go_to_class_page(class_name).go_to_class_settings_page()

        page = page.transfer_class()
        assert page.get_list_length() == 0
        page = page.cancel()
        assert page.__class__.__name__ == "TeachClassPage"

    def test_create(self):
        email, password = signup_teacher_directly()
        org_name, postcode = create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)

        self.browser.get(self.live_server_url)
        page = HomePage(self.browser).go_to_teach_page().login(email, password)
        page = page.go_to_classes_page().go_to_class_page(class_name)
        assert page.does_not_have_students()

        page, student_name, student_password = create_school_student(page)
        assert page.has_students()
        assert page.student_exists(student_name)

    def test_create_multiple(self):
        email, password = signup_teacher_directly()
        org_name, postcode = create_organisation_directly(email)
        _, class_name, access_code = create_class_directly(email)

        selenium.get(self.live_server_url)
        page = HomePage(selenium).go_to_teach_page().login(email, password)
        page = page.go_to_classes_page().go_to_class_page(class_name)
        assert page.does_not_have_students()

        page, student_names, student_passwords = create_many_school_students(page, 12)

        assert page.has_students()
        for student_name in student_names:
            assert page.student_exists(student_name)

    def _test_incorrect_teacher_no_info_leak(self, view_name):
        email1, _ = signup_teacher_directly()
        email2, pass2 = signup_teacher_directly()
        _, _, access_code = create_class_directly(email1)

        c = Client()
        assert c.login(username=email2, password=pass2)

        invalid_page = reverse(view_name, args=[access_code])
        invalid_login_code = c.get(invalid_page).status_code

        non_existant_page = reverse(view_name, args=["AAAAA"])
        non_existant_code = c.get(non_existant_page).status_code

        self.assertEqual(non_existant_code, invalid_login_code)