コード例 #1
0
def test_set_new_password(party_account_fixture):
    fixture = party_account_fixture

    system_account = fixture.system_account
    new_password_request = NewPasswordRequest(system_account=system_account)
    Session.add(new_password_request)
    new_password = system_account.password * 2
    account_management_interface = AccountManagementInterface()
    Session.add(account_management_interface)

    # Case: the key is invalid
    invalid_key = 'in va lid key which is also too long and contains spaces'
    account_management_interface.email = system_account.email
    account_management_interface.secret = invalid_key
    account_management_interface.password = new_password
    with expected(KeyException):
        account_management_interface.choose_new_password()

    # Case: the email is invalid
    invalid_email = 'i am not a valid email'
    account_management_interface.email = invalid_email
    account_management_interface.secret = new_password_request.as_secret_key()
    account_management_interface.password = new_password
    with expected(InvalidEmailException):
        account_management_interface.choose_new_password()

    # Case: the key is valid
    account_management_interface.email = system_account.email
    account_management_interface.secret = new_password_request.as_secret_key()
    account_management_interface.password = new_password
    account_management_interface.choose_new_password()
    system_account.authenticate(new_password)  # Should not raise exception
コード例 #2
0
def test_send_activation_mail(reahl_system_fixture, party_account_fixture):
    fixture = party_account_fixture

    system_account = fixture.new_system_account(email='*****@*****.**',
                                                activated=False)
    activation_request = VerifyEmailRequest(
        email=system_account.email,
        subject_config='accounts.activation_subject',
        email_config='accounts.activation_email')
    Session.add(activation_request)
    activation_action = ActivateAccount(system_account=system_account,
                                        requirements=[activation_request])
    Session.add(activation_action)
    mailer_stub = fixture.mailer
    fixture.account_management_interface.email = system_account.email
    fixture.account_management_interface.password = system_account.password

    # Case: the first send
    fixture.account_management_interface.send_activation_notification()

    assert mailer_stub.mail_recipients == [system_account.email]
    assert mailer_stub.mail_sender == reahl_system_fixture.config.accounts.admin_email
    substitutions = {
        'email': system_account.email,
        'secret_key': activation_request.as_secret_key()
    }
    expected_subject = Template(
        reahl_system_fixture.config.accounts.activation_subject).substitute(
            substitutions)
    assert mailer_stub.mail_subject == expected_subject
    expected_message = Template(
        reahl_system_fixture.config.accounts.activation_email).substitute(
            substitutions)
    assert mailer_stub.mail_message == expected_message
コード例 #3
0
def test_expire_stale_requests(reahl_system_fixture, party_account_fixture):
    fixture = party_account_fixture

    old_email = '*****@*****.**'
    recent_email = '*****@*****.**'
    password = '******'
    mailer_stub = fixture.mailer
    EmailAndPasswordSystemAccount.mailer = mailer_stub
    longago = datetime.now() - timedelta(
        reahl_system_fixture.config.accounts.request_verification_timeout)

    old_account_management_interface = AccountManagementInterface()
    old_account_management_interface.email = old_email
    old_account_management_interface.password = password
    old_account_management_interface.register()
    old_system_account = EmailAndPasswordSystemAccount.by_email(old_email)
    old_activation_request = Session.query(VerifyEmailRequest).one()
    old_activation_request.deferred_actions[0].deadline = longago

    new_account_management_interface = AccountManagementInterface()
    new_account_management_interface.email = recent_email
    new_account_management_interface.password = password
    new_account_management_interface.register()
    recent_system_account = EmailAndPasswordSystemAccount.by_email(
        recent_email)

    ReahlEgg.do_daily_maintenance_for_egg('reahl-domain')
    assert Session.query(EmailAndPasswordSystemAccount).filter_by(
        id=old_system_account.id).count() == 0
    assert Session.query(EmailAndPasswordSystemAccount).filter_by(
        id=recent_system_account.id).count() == 1
コード例 #4
0
 def get_or_create_domain_object(self):
     domain_objects = Session.query(MyDomainObject).all()
     if len(domain_objects) == 0:
         domain_object = MyDomainObject()
         Session.add(domain_object)
         return domain_object
     return domain_objects[0]
コード例 #5
0
ファイル: test_model3.py プロジェクト: dli7428/reahl
def test_reahl_additions():
    ExecutionContext().install()

    try:
        metadata.bind = 'sqlite:///:memory:'
        metadata.create_all()

        address = Address()
        Session.add(address)
        email_field = address.fields.email_address

        # While a programmer would not usually write code like this,
        # it is useful to show how the framework can use Fields and Events
        # to obtain more information about a certain Field/Event:
        assert email_field.label == 'Email'

        # Fields are used (amongst other things) to validate user input:
        with expected(Exception):
            email_field.from_input('invalid email address')

        with expected(NoException):
            assert address.email_address == None
            email_field.from_input('*****@*****.**')
            assert address.email_address == '*****@*****.**'

        # After input was given, the field is set on the object it belongs to:
        # (The value set is a marshalled version of the user input. In this case it is just
        #  a string again, but it could have been, for example an EmailAddress object,
        #  and Integer, or a Date.)
        assert address.email_address == '*****@*****.**'

    finally:
        metadata.bind = None
コード例 #6
0
def test_cascade_removal_of_user_session(sql_alchemy_fixture,
                                         session_scoped_fixture):
    """
        If a user session is deleted, all session scoped objects are deleted as well.
    """

    fixture = session_scoped_fixture

    @session_scoped
    class MySessionScoped(Base):
        __tablename__ = 'my_session_scoped'
        id = Column(Integer, primary_key=True)

    with sql_alchemy_fixture.persistent_test_classes(MySessionScoped):
        user_session = fixture.create_user_session()
        assert Session.query(MySessionScoped).count() == 0

        session_object = MySessionScoped.for_current_session()
        assert Session.query(MySessionScoped).one() is session_object
        assert session_object.user_session is user_session

        if fixture.cascade:
            Session.delete(user_session)
        else:
            Session.delete(session_object)
        Session.flush()

        assert Session.query(MySessionScoped).count() == 0
        assert Session.query(
            UserSession).count() == fixture.expected_user_session_after_delete
コード例 #7
0
ファイル: webdeclarative.py プロジェクト: craig-reahl/reahl
 def save_for(cls, view, form=None, **kwargs):
     assert (not form) or (form.view is view)
     channel_name = form.channel_name if form else None
     web_session = ExecutionContext.get_context().session
     instance = cls(web_session=web_session, view_path=view.full_path, ui_name=view.user_interface.name, channel_name=channel_name, **kwargs)
     Session.add(instance)
     return instance
コード例 #8
0
def test_input_validation_cues_javascript_interaction(web_fixture, sql_alchemy_fixture, javascript_validation_scenario):
    """The visual cues rendered server-side can subsequently be manipulated via javascript."""
    fixture = javascript_validation_scenario

    web_fixture.reahl_server.set_app(web_fixture.new_wsgi_app(child_factory=fixture.Form.factory(), enable_js=False))

    browser = fixture.browser

    with sql_alchemy_fixture.persistent_test_classes(fixture.ModelObject):
        fixture.domain_object = fixture.ModelObject()
        Session.add(fixture.domain_object)
        browser.open('/')
        browser.type(XPath.input_labelled('Some input'), '')
        browser.click(XPath.button_labelled('Submit'))

        assert ['is-invalid'] == fixture.get_form_group_highlight_marks(browser, index=0)
        [error] = fixture.get_form_group_errors(browser, index=0)
        assert error.text == 'Some input is required'

        web_fixture.reahl_server.set_app(web_fixture.new_wsgi_app(child_factory=fixture.Form.factory(), enable_js=True))
        browser.open('/')

        browser.click(XPath.button_labelled('Submit'))

        assert ['is-invalid'] == fixture.get_form_group_highlight_marks(browser, index=0)
        [error] = fixture.get_form_group_errors(browser, index=0)
        assert error.text == 'Some input is required'

        browser.type(XPath.input_labelled('Some input'), 'valid value', trigger_blur=False, wait_for_ajax=False)
        browser.press_tab()

        def form_group_is_marked_success(index):
            return ['is-valid'] == fixture.get_form_group_highlight_marks(browser, index=index)
        assert web_fixture.driver_browser.wait_for(form_group_is_marked_success, 0)
        assert not fixture.get_form_group_errors(browser, index=0)
コード例 #9
0
ファイル: test_form.py プロジェクト: xmonader/reahl
def test_input_validation_cues(sql_alchemy_fixture, validation_scenarios):
    """Visible cues are inserted to indicate the current validation state
       and possible validation error messages to a user. """
    fixture = validation_scenarios

    browser = fixture.browser

    with sql_alchemy_fixture.persistent_test_classes(fixture.ModelObject):
        fixture.domain_object = fixture.ModelObject()
        Session.add(fixture.domain_object)
        browser.open('/')

        assert not fixture.get_form_group_highlight_marks(browser, index=0)
        assert not fixture.get_form_group_errors(browser, index=0)

        browser.type(XPath.input_labelled('Some input'), '')
        browser.click(XPath.button_labelled('Submit'))

        assert ['is-invalid'
                ] == fixture.get_form_group_highlight_marks(browser, index=0)
        [error] = fixture.get_form_group_errors(browser, index=0)
        assert error.text == 'Some input is required'

        browser.type(XPath.input_labelled('Some input'), 'valid value')
        browser.click(XPath.button_labelled('Submit'))

        assert ['is-valid'] == fixture.get_form_group_highlight_marks(browser,
                                                                      index=0)
        assert not fixture.get_form_group_errors(browser, index=0)

        browser.type(XPath.input_labelled('Another input'), 'valid value')
        browser.click(XPath.button_labelled('Submit'))

        assert not fixture.get_form_group_highlight_marks(browser, index=0)
        assert not fixture.get_form_group_errors(browser, index=0)
コード例 #10
0
ファイル: test_account.py プロジェクト: craig-reahl/reahl
def test_verify_from_menu(web_fixture, party_account_fixture,
                          accounts_web_fixture):
    fixture = accounts_web_fixture

    account = party_account_fixture.new_system_account(activated=False)
    activation_request = VerifyEmailRequest(
        email=account.email,
        subject_config='accounts.activation_subject',
        email_config='accounts.activation_email')
    Session.add(activation_request)
    deferred_activation = ActivateAccount(system_account=account,
                                          requirements=[activation_request])
    Session.add(deferred_activation)
    secret_key = activation_request.as_secret_key()

    assert not account.status.is_active()
    fixture.browser.open('/a_ui/verify')

    fixture.browser.type(XPath.input_labelled('Email'), account.email)
    fixture.browser.type(XPath.input_labelled('Secret key'), secret_key)
    fixture.browser.type(XPath.input_labelled('Password'), account.password)
    fixture.browser.click(XPath.button_labelled('Verify'))

    assert fixture.browser.current_url.path == '/a_ui/thanks'
    assert account.status.is_active()
コード例 #11
0
ファイル: test_account.py プロジェクト: craig-reahl/reahl
def test_register_help_pending(web_fixture, party_account_fixture,
                               accounts_web_fixture):
    fixture = accounts_web_fixture

    verification_requests = Session.query(VerifyEmailRequest)
    unactivated_account = party_account_fixture.new_system_account(
        email='*****@*****.**', activated=False)
    activation_request = VerifyEmailRequest(
        email=unactivated_account.email,
        subject_config='accounts.activation_subject',
        email_config='accounts.activation_email')
    Session.add(activation_request)
    deferred_activation = ActivateAccount(system_account=unactivated_account,
                                          requirements=[activation_request])
    Session.add(deferred_activation)

    fixture.browser.open('/a_ui/registerHelp')
    fixture.browser.type(XPath.input_labelled('Email'),
                         unactivated_account.email)
    fixture.browser.click(XPath.button_labelled('Investigate'))

    assert fixture.browser.current_url.path == '/a_ui/registerHelp/pending'
    assert verification_requests.count() == 1
    party_account_fixture.mailer.reset()
    fixture.browser.click(XPath.button_labelled('Send'))

    assert verification_requests.count() == 1
    assert party_account_fixture.mailer.mail_sent
    assert fixture.browser.current_url.path == '/a_ui/registerHelp/pending/sent'
コード例 #12
0
def test_verify_from_menu(web_fixture, party_account_fixture,
                          accounts_web_fixture):
    fixture = accounts_web_fixture

    account = party_account_fixture.new_system_account(activated=False)
    activation_request = VerifyEmailRequest(
        email=account.email,
        subject_config='accounts.activation_subject',
        email_config='accounts.activation_email')
    Session.add(activation_request)
    deferred_activation = ActivateAccount(system_account=account,
                                          requirements=[activation_request])
    Session.add(deferred_activation)
    secret_key = activation_request.as_secret_key()

    assert not account.status.is_active()
    fixture.browser.open('/a_ui/verify')

    fixture.browser.type('//form[@id="verify"]//*[@name="verify-email"]',
                         account.email)
    fixture.browser.type('//form[@id="verify"]//*[@name="verify-secret"]',
                         secret_key)
    fixture.browser.type('//form[@id="verify"]//*[@name="verify-password"]',
                         account.password)
    fixture.browser.click('//form[@id="verify"]//*[@value="Verify"]')

    assert fixture.browser.current_url.path == '/a_ui/thanks'
    assert account.status.is_active()
コード例 #13
0
def test_request_email_change(reahl_system_fixture, party_account_fixture):
    fixture = party_account_fixture

    system_account = fixture.new_system_account(activated=False)
    mailer_stub = fixture.mailer
    new_email = '*****@*****.**'
    account_management_interface = fixture.new_account_management_interface(
        system_account=system_account)

    # Case where the user account has not been activated
    assert isinstance(system_account.status, AccountNotActivated)
    account_management_interface.new_email = new_email
    with expected(AccountNotActiveException):
        account_management_interface.request_email_change()

    system_account.activate()
    system_account.disable()
    # Case where the user account is disabled for another reason
    assert isinstance(system_account.status, AccountDisabled)
    account_management_interface.new_email = new_email
    with expected(AccountNotActiveException):
        account_management_interface.request_email_change()

    system_account.enable()
    # Case where the user account is active and enabled, but a clashing email name is requested
    other_party = Party()
    clashing_new_email = '*****@*****.**'
    clashing_system_account = fixture.new_system_account(
        party=other_party, email=clashing_new_email, activated=True)

    account_management_interface.new_email = clashing_new_email
    with expected(NotUniqueException):
        account_management_interface.request_email_change()

    # Case where the user account is active and enabled, and a new unique email name is requested
    assert Session.query(ChangeAccountEmail).count() == 0
    account_management_interface.new_email = new_email
    account_management_interface.request_email_change()
    new_email_request = Session.query(ChangeAccountEmail).filter_by(
        system_account=system_account).one().verify_email_request

    assert mailer_stub.mail_recipients == [new_email]
    assert mailer_stub.mail_sender == reahl_system_fixture.config.accounts.admin_email
    substitutions = {
        'email': new_email,
        'secret_key': new_email_request.as_secret_key()
    }
    expected_subject = Template(
        reahl_system_fixture.config.accounts.email_change_subject).substitute(
            substitutions)
    assert mailer_stub.mail_subject == expected_subject
    expected_message = Template(
        reahl_system_fixture.config.accounts.email_change_email).substitute(
            substitutions)
    assert mailer_stub.mail_message == expected_message

    # Case where a email name is requested which matches an already pending one
    account_management_interface.new_email = new_email
    with expected(NotUniqueException):
        account_management_interface.request_email_change()
コード例 #14
0
def test_verify_email_change(party_account_fixture):
    fixture = party_account_fixture

    system_account = fixture.system_account
    new_email = '*****@*****.**'
    change_email_action = ChangeAccountEmail(system_account, new_email)
    Session.add(change_email_action)
    request = change_email_action.verify_email_request
    account_management_interface = fixture.account_management_interface

    # Case where there is a password mismatch
    account_management_interface.email = new_email
    account_management_interface.password = '******'
    account_management_interface.secret = request.as_secret_key()
    with expected(InvalidPasswordException, test=assert_is_set_to_commit):
        account_management_interface.verify_email()
    assert system_account.email != new_email

    # Case where there is a key mismatch
    account_management_interface.email = new_email
    account_management_interface.password = system_account.password
    account_management_interface.secret = 'invalid key'
    with expected(KeyException):
        account_management_interface.verify_email()
    assert system_account.email != new_email

    # Case where it works
    assert system_account.email != new_email
    account_management_interface.email = new_email
    account_management_interface.password = system_account.password
    account_management_interface.secret = request.as_secret_key()
    account_management_interface.verify_email()
    assert Session.query(VerifyEmailRequest).filter_by(
        id=request.id).count() == 0
    assert system_account.email == new_email
コード例 #15
0
ファイル: jobsbootstraptests.py プロジェクト: diopib/reahl
    def do_demo_setup(self):
        Session.add(Address(name='John Doe', email_address='*****@*****.**'))
        Session.add(Address(name='Jane Johnson', email_address='*****@*****.**'))
        Session.add(Address(name='Jack Black', email_address='*****@*****.**'))

        Session.flush()
        Session.commit()
コード例 #16
0
def test_clear_form_inputs_on_optimistic_concurrency(web_fixture,
                                                     sql_alchemy_fixture,
                                                     concurrency_fixture,
                                                     scenario):
    """A concurrency error is detected upon submit after an exception.
       When a user resets inputs upon such a concurrency error, previous form exceptions and input data are cleared.
    """
    fixture = concurrency_fixture

    with sql_alchemy_fixture.persistent_test_classes(fixture.ModelObject):
        Session.add(fixture.model_object)

        wsgi_app = web_fixture.new_wsgi_app(
            child_factory=fixture.MyForm.factory())
        web_fixture.reahl_server.set_app(wsgi_app)
        browser = web_fixture.driver_browser
        browser.open('/')

        # Concurrency error is detected on submit after an exception
        scenario.cause_exception_on_submit(browser)
        assert fixture.is_any_error_displayed()
        assert not fixture.is_concurrency_error_displayed()

        fixture.make_concurrent_change_in_backend()

        browser.type(XPath.input_labelled('Some field'), 'valid input')
        browser.click(XPath.button_labelled('Submit'))
        assert fixture.is_concurrency_error_displayed()

        # Previous error and inputs are cleared
        browser.click(XPath.button_labelled('Reset input'))

        assert browser.get_value(
            XPath.input_labelled('Some field')) == 'changed by someone else'
        assert not fixture.is_any_error_displayed()
コード例 #17
0
 def request_new_password(self):
     self.assert_account_live()
     existing_requests = Session.query(NewPasswordRequest).filter_by(
         system_account=self)
     if existing_requests.count() == 0:
         Session.add(NewPasswordRequest(system_account=self))
     self.send_new_password_mail()
コード例 #18
0
 def clear_all_view_data(cls, view):
     web_session = ExecutionContext.get_context().session
     items = Session.query(cls).filter_by(web_session=web_session,
                                          view_path=view.full_path,
                                          ui_name=view.user_interface.name)
     for stale in items:
         Session.delete(stale)
コード例 #19
0
ファイル: fixtures.py プロジェクト: diopib/reahl
 def start_transaction(self):
     if not self.commit:
         # The tests run in a nested transaction inside a real transaction, and both are rolled back
         # This is done because finalise_session (real code) is run as part of the test, and it
         # checks for the nested transaction and behaves differently to make testing possible.
         # Session.begin() - this happens implicitly
         Session.begin_nested()
コード例 #20
0
ファイル: test_workflow.py プロジェクト: dli7428/reahl
 def new_task(self, title=None, queue=None):
     title = title or 'A task'
     queue = queue or self.queue
     task = Task(title=title, queue=queue)
     Session.add(task)
     Session.flush()
     return task
コード例 #21
0
def test_recalculate_on_refresh(web_fixture, query_string_fixture, sql_alchemy_fixture, scenario):
    """You can make a widget recalculate domain values upon refresh by adding an Event to enable_refresh()."""

    fixture = scenario

    with sql_alchemy_fixture.persistent_test_classes(fixture.ModelObject):

        Session.add(fixture.model_object)

        wsgi_app = web_fixture.new_wsgi_app(enable_js=True, child_factory=scenario.MainWidgetWithPersistentModelObject.factory())
        web_fixture.reahl_server.set_app(wsgi_app)
        browser = web_fixture.driver_browser

        browser.open('/')
        assert browser.wait_for(query_string_fixture.is_state_now, 1)
        scenario.check_widget_value(browser, 10)
        browser.type(XPath.input_labelled('Choice'), '2')

        # Case: values are recalculated after ajax
        assert browser.wait_for(query_string_fixture.is_state_now, 2)
        scenario.check_widget_value(browser, 20)

        # Case: values stay recalculated after submit with exception
        browser.click(XPath.button_labelled('submit'))
        assert browser.is_element_present(XPath.paragraph().including_text('An exception happened on submit'))
        scenario.check_widget_value(browser, 20)
コード例 #22
0
def test_login_queries(party_account_fixture, web_fixture):
    """"""
    context = ExecutionContext.get_context()

    config = context.config
    user_session = context.session
    login_session = LoginSession.for_session(context.session)
    system_account = party_account_fixture.system_account

    web_fixture.request.scheme = 'https'
    context.request.cookies[
        config.web.secure_key_name] = user_session.secure_salt
    assert config.web.idle_secure_lifetime < config.web.idle_lifetime
    assert config.web.idle_lifetime < config.web.idle_lifetime_max

    # Case: user logs in
    user_session.last_activity = None
    login_session.set_as_logged_in(system_account, False)
    assert login_session.is_logged_in()
    assert login_session.is_logged_in(secured=True)

    # Case: user logs out
    login_session.log_out()
    assert not login_session.is_logged_in()
    assert not login_session.is_logged_in(secured=True)

    # Case: user activity is older than secure lifetime
    assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
    login_session.set_as_logged_in(system_account, False)
    user_session.last_activity = datetime.now() - timedelta(
        seconds=config.web.idle_secure_lifetime + 50)
    assert login_session.is_logged_in()
    assert not login_session.is_logged_in(secured=True)

    # Case: user activity is older than all lifetimes
    assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
    login_session.set_as_logged_in(system_account, False)
    user_session.last_activity = datetime.now() - timedelta(
        seconds=config.web.idle_lifetime + 50)
    assert not login_session.is_logged_in()
    assert not login_session.is_logged_in(secured=True)

    # Case: user activity is older than non-secure lifetime, but keep_me_logged_in is set
    assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
    assert (config.web.idle_lifetime_max - config.web.idle_lifetime) > 50
    login_session.set_as_logged_in(system_account, True)
    user_session.last_activity = datetime.now() - timedelta(
        seconds=config.web.idle_lifetime + 50)
    assert login_session.is_logged_in()
    assert not login_session.is_logged_in(secured=True)

    # Case: user activity is older than non-secure lifetime max, but keep_me_logged_in is set
    assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
    assert (config.web.idle_lifetime_max - config.web.idle_lifetime) > 50
    login_session.set_as_logged_in(system_account, True)
    Session.flush()
    user_session.last_activity = datetime.now() - timedelta(
        seconds=config.web.idle_lifetime_max + 50)
    assert not login_session.is_logged_in()
    assert not login_session.is_logged_in(secured=True)
コード例 #23
0
ファイル: fixtures.py プロジェクト: diopib/reahl
 def destroy_test_tables(self, *entities):
     #        Session.flush()
     Session.expunge_all()
     for entity in entities:
         if hasattr(entity, '__table__'):
             entity.__table__.metadata.remove(entity.__table__)
             if entity.__name__ in entity._decl_class_registry:
                 del entity._decl_class_registry[entity.__name__]
コード例 #24
0
ファイル: access1bootstraptests.py プロジェクト: diopib/reahl
    def do_demo_setup(self):
        self.address_book
        self.account
        self.other_account
        self.other_address_book

        Session.flush()
        Session.commit()
コード例 #25
0
 def new_account_management_interface(self, system_account=None):
     system_account = system_account or self.system_account
     account_management_interface = AccountManagementInterface()
     account_management_interface.password = system_account.password
     account_management_interface.email = system_account.email
     Session.add(account_management_interface)
     Session.flush()
     return account_management_interface
コード例 #26
0
ファイル: accessbootstraptests.py プロジェクト: diopib/reahl
 def edit_address_in_other_address_book(self):
     address = Address(address_book=self.other_address_book,
                       email_address='*****@*****.**',
                       name='Friend')
     address.save()
     Session.flush()
     self.url = '/edit_address/%s' % address.id
     self.get = True
コード例 #27
0
ファイル: access2bootstraptests.py プロジェクト: diopib/reahl
    def do_demo_setup(self):
        self.address_book
        john = self.account
        jane = self.new_account(email='*****@*****.**')
        jane_book = self.new_address_book(owner=jane)
        someone = self.new_account(email='*****@*****.**')
        someone_book = self.new_address_book(owner=someone)
        someone_else = self.new_account(email='*****@*****.**')
        someone_else_book = self.new_address_book(owner=someone_else)

        jane_book.allow(john, can_add_addresses=True, can_edit_addresses=True)
        someone_book.allow(john,
                           can_add_addresses=False,
                           can_edit_addresses=True)
        someone_else_book.allow(john,
                                can_add_addresses=False,
                                can_edit_addresses=False)

        Address(address_book=jane_book,
                email_address='*****@*****.**',
                name='Friend1').save()
        Address(address_book=jane_book,
                email_address='*****@*****.**',
                name='Friend2').save()
        Address(address_book=jane_book,
                email_address='*****@*****.**',
                name='Friend3').save()
        Address(address_book=jane_book,
                email_address='*****@*****.**',
                name='Friend4').save()

        Address(address_book=someone_book,
                email_address='*****@*****.**',
                name='Friend11').save()
        Address(address_book=someone_book,
                email_address='*****@*****.**',
                name='Friend12').save()
        Address(address_book=someone_book,
                email_address='*****@*****.**',
                name='Friend13').save()
        Address(address_book=someone_book,
                email_address='*****@*****.**',
                name='Friend14').save()

        Address(address_book=someone_else_book,
                email_address='*****@*****.**',
                name='Friend21').save()
        Address(address_book=someone_else_book,
                email_address='*****@*****.**',
                name='Friend22').save()
        Address(address_book=someone_else_book,
                email_address='*****@*****.**',
                name='Friend23').save()
        Address(address_book=someone_else_book,
                email_address='*****@*****.**',
                name='Friend24').save()
        Session.flush()
        Session.commit()
コード例 #28
0
 def new_objects(self):
     objects = [
         self.MyObject(name='B'),
         self.MyObject(name='A'),
         self.MyObject(name='C')
     ]
     for o in objects:
         Session.add(o)
     return objects
コード例 #29
0
ファイル: addressbook2tests.py プロジェクト: diopib/reahl
    def do_demo_setup(self):

        Address(email_address='*****@*****.**', name='Friend1').save()
        Address(email_address='*****@*****.**', name='Friend2').save()
        Address(email_address='*****@*****.**', name='Friend3').save()
        Address(email_address='*****@*****.**', name='Friend4').save()

        Session.flush()
        Session.commit()
コード例 #30
0
ファイル: i18nexamplebootstrap.py プロジェクト: diopib/reahl
    def __init__(self, view):
        super(AddressBookPanel, self).__init__(view)

        self.add_child(H(view, 1, text=_.ngettext('Address', 'Addresses', Session.query(Address).count())))
        
        for address in Session.query(Address).all():
            self.add_child(AddressBox(view, address))

        self.add_child(AddAddressForm(view))