Beispiel #1
0
    def test_after_commit_delete(self, dummy_request):
        from kotti.resources import Document
        from kotti_es.sqla import _after_delete
        from kotti_es.sqla import _after_commit
        document = Document()
        document.request = dummy_request
        _after_delete(None, None, document)

        import mock
        with mock.patch('kotti_es.sqla.get_current_request') as \
                get_current_request:
            get_current_request.return_value = dummy_request
            with mock.patch('kotti_es.sqla.get_client') as \
                    get_client:
                magic = mock.MagicMock()
                get_client.return_value = magic
                session = mock.Mock()
                session.configure_mock(
                    **{
                        'query.return_value.filter_by.'
                        'return_value.one.return_value':
                        document
                    })
                _after_commit(session)
                magic.delete_object.assert_called_with(document,
                                                       immediate=True)
Beispiel #2
0
    def test_multi_rename(self, root):
        from kotti.resources import Document
        from kotti.views.edit.actions import NodeActions

        self.setUp()
        root["child1"] = Document(title="Child 1")
        root["child2"] = Document(title="Child 2")
        request = DummyRequest()
        request.POST = MultiDict()
        id1 = str(root["child1"].id)
        id2 = str(root["child2"].id)
        request.POST.add("children-to-rename", id1)
        request.POST.add("children-to-rename", id2)
        request.POST.add(id1 + "-name", "")
        request.POST.add(id1 + "-title", "Unhappy Child")
        request.POST.add(id2 + "-name", "happy-child")
        request.POST.add(id2 + "-title", "")
        request.POST.add("rename_nodes", "rename_nodes")
        NodeActions(root, request).rename_nodes()
        assert request.session.pop_flash("error") == ["Name and title are required."]

        request.POST.add(id1 + "-name", "unhappy-child")
        request.POST.add(id1 + "-title", "Unhappy Child")
        request.POST.add(id2 + "-name", "happy-child")
        request.POST.add(id2 + "-title", "Happy Child")
        request.POST.add("rename_nodes", "rename_nodes")
        NodeActions(root, request).rename_nodes()
        assert request.session.pop_flash("success") == ["Your changes have been saved."]
Beispiel #3
0
def populate():
    """
    Create the root node (:class:`~kotti.resources.Document`) and the 'about'
    subnode in the nodes tree if there are no nodes yet.
    """
    lrm = LocalizerRequestMixin()
    lrm.registry = get_current_registry()
    # noinspection PyPropertyAccess
    lrm.locale_name = get_settings()["pyramid.default_locale_name"]
    localizer = lrm.localizer

    if DBSession.query(Node.id).count() == 0:
        localized_root_attrs = {
            k: localizer.translate(v)
            for k, v in _ROOT_ATTRS.items()
        }
        root = Document(**localized_root_attrs)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        localized_about_attrs = {
            k: localizer.translate(v)
            for k, v in _ABOUT_ATTRS.items()
        }
        root["about"] = Document(**localized_about_attrs)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, "public")

    populate_users()
Beispiel #4
0
    def test_multi_delete(self, root):
        from kotti.resources import Document
        from kotti.resources import File
        from kotti.views.edit.actions import NodeActions

        root["child1"] = Document(title="Child 1")
        root["child2"] = Document(title="Child 2")
        root["file1"] = File(title="File 1")

        request = DummyRequest()
        request.POST = MultiDict()
        id1 = str(root["child1"].id)
        id2 = str(root["child2"].id)
        id3 = str(root["file1"].id)
        request.POST.add("delete_nodes", "delete_nodes")
        NodeActions(root, request).delete_nodes()
        assert request.session.pop_flash("info") == ["Nothing was deleted."]

        request.POST.add("children-to-delete", id1)
        request.POST.add("children-to-delete", id2)
        request.POST.add("children-to-delete", id3)
        NodeActions(root, request).delete_nodes()
        assert request.session.pop_flash("success") == [
            "${title} was deleted.",
            "${title} was deleted.",
            "${title} was deleted.",
        ]
Beispiel #5
0
def populate():
    """
    Create the root node (:class:`~kotti.resources.Document`) and the 'about'
    subnode in the nodes tree if there are no nodes yet.
    """
    lrm = LocalizerRequestMixin()
    lrm.registry = get_current_registry()
    lrm.locale_name = get_settings()['pyramid.default_locale_name']
    localizer = lrm.localizer

    if DBSession.query(Node).count() == 0:
        localized_root_attrs = dict(
            [(k, localizer.translate(v)) for k, v in _ROOT_ATTRS.iteritems()])
        root = Document(**localized_root_attrs)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        localized_about_attrs = dict(
            [(k, localizer.translate(v)) for k, v in _ABOUT_ATTRS.iteritems()])
        root['about'] = Document(**localized_about_attrs)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #6
0
    def test_multi_rename(self, root):
        from kotti.resources import Document
        from kotti.views.edit.actions import NodeActions
        self.setUp()
        root['child1'] = Document(title="Child 1")
        root['child2'] = Document(title="Child 2")
        request = DummyRequest()
        request.POST = MultiDict()
        id1 = str(root['child1'].id)
        id2 = str(root['child2'].id)
        request.POST.add('children-to-rename', id1)
        request.POST.add('children-to-rename', id2)
        request.POST.add(id1 + '-name', '')
        request.POST.add(id1 + '-title', 'Unhappy Child')
        request.POST.add(id2 + '-name', 'happy-child')
        request.POST.add(id2 + '-title', '')
        request.POST.add('rename_nodes', 'rename_nodes')
        NodeActions(root, request).rename_nodes()
        assert request.session.pop_flash('error') ==\
            ['Name and title are required.']

        request.POST.add(id1 + '-name', 'unhappy-child')
        request.POST.add(id1 + '-title', 'Unhappy Child')
        request.POST.add(id2 + '-name', 'happy-child')
        request.POST.add(id2 + '-title', 'Happy Child')
        request.POST.add('rename_nodes', 'rename_nodes')
        NodeActions(root, request).rename_nodes()
        assert request.session.pop_flash('success') ==\
            ['Your changes have been saved.']
Beispiel #7
0
    def test_set_modification_date(self, root, db_session, events):

        from time import sleep
        from kotti.resources import Document

        # create 2 documents
        d1 = root['d1'] = Document(title='One')
        d2 = root['d2'] = Document(title='Two')
        assert d1.position == 0
        assert d2.position == 1
        db_session.flush()
        md1 = d1.modification_date
        md2 = d2.modification_date

        # changing positions should not update modification_date
        sleep(1)
        d1.position = 1
        d2.position = 0
        db_session.flush()
        assert d1.position == 1
        assert d2.position == 0
        assert d1.modification_date == md1
        assert d2.modification_date == md2

        # changing anything else should update modification_date
        d1.title = 'Eins'
        d2.title = 'Zwei'
        db_session.flush()
        assert d1.modification_date != md1
        assert d2.modification_date != md2
Beispiel #8
0
    def test_multi_delete(self, root):
        from kotti.resources import Document
        from kotti.resources import File
        from kotti.views.edit.actions import NodeActions

        root['child1'] = Document(title="Child 1")
        root['child2'] = Document(title="Child 2")
        root['file1'] = File(title="File 1")

        request = DummyRequest()
        request.POST = MultiDict()
        id1 = str(root['child1'].id)
        id2 = str(root['child2'].id)
        id3 = str(root['file1'].id)
        request.POST.add('delete_nodes', 'delete_nodes')
        NodeActions(root, request).delete_nodes()
        assert request.session.pop_flash('info') ==\
            ['Nothing was deleted.']

        request.POST.add('children-to-delete', id1)
        request.POST.add('children-to-delete', id2)
        request.POST.add('children-to-delete', id3)
        NodeActions(root, request).delete_nodes()
        assert request.session.pop_flash('success') == \
            ['${title} was deleted.',
             '${title} was deleted.',
             '${title} was deleted.']
Beispiel #9
0
def _add_document_from_file(filename, name, parent, title, package='kotti', 
                            directory='populate-content', acl=None):
    body = unicode(resource_string(package, os.path.join(directory, filename)))
    node = Document(name=name, parent=parent, title=title, body=body)
    if acl is not None:
        node.__acl__ = acl
    DBSession.add(node)
    return node
Beispiel #10
0
def test_index_document_without_request(solr):
    doc = Document(title='No request', body=u'There is no request',)
    doc.id = 33
    add_document_handler(event=Mock(object=doc, request=None))
    results = list(solr.query(title='No request'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-33'
    assert results[0]['path'] == '/'
Beispiel #11
0
def populate():
    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

    populate_users()
Beispiel #12
0
 def test_after_delete3(self, dummy_request):
     from kotti.resources import Document
     document1 = Document()
     document1.request = dummy_request
     document2 = Document()
     document2.request = dummy_request
     from kotti_es.sqla import _after_delete
     _after_delete(None, None, document1)
     _after_delete(None, None, document2)
     assert len(getattr(dummy_request, '_index_list')) == 2
Beispiel #13
0
 def test_after_delete2(self, dummy_request):
     from kotti.resources import Document
     document = Document()
     document.id = 1
     document.request = dummy_request
     document.request._index_list = []
     from kotti_es.sqla import _after_delete
     from kotti_es.sqla import DELETE_CODE
     _after_delete(None, None, document)
     assert getattr(document.request,
                    '_index_list') == [(document, document.id, DELETE_CODE)]
Beispiel #14
0
def test_index_document_without_request(solr):
    doc = Document(
        title='No request',
        body=u'There is no request',
    )
    doc.id = 33
    add_document_handler(event=Mock(object=doc, request=None))
    results = list(solr.query(title='No request'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-33'
    assert results[0]['path'] == '/'
Beispiel #15
0
 def test_after_insert(self, dummy_request):
     from kotti.resources import Document
     document = Document()
     document.id = 1
     document.request = dummy_request
     assert hasattr(document.request, '_index_list') is False
     from kotti_es.sqla import _after_insert_update
     from kotti_es.sqla import INSERT_CODE
     _after_insert_update(None, None, document)
     assert getattr(document.request,
                    '_index_list') == [(document, document.id, INSERT_CODE)]
Beispiel #16
0
 def test_after_delete2(self, dummy_request):
     from kotti.resources import Document
     document = Document()
     document.id = 1
     document.request = dummy_request
     document.request._index_list = []
     from kotti_es.sqla import _after_delete
     from kotti_es.sqla import DELETE_CODE
     _after_delete(None, None, document)
     assert getattr(document.request, '_index_list') == [
         (document, document.id, DELETE_CODE)
         ]
Beispiel #17
0
 def test_after_insert(self, dummy_request):
     from kotti.resources import Document
     document = Document()
     document.id = 1
     document.request = dummy_request
     assert hasattr(document.request, '_index_list') is False
     from kotti_es.sqla import _after_insert_update
     from kotti_es.sqla import INSERT_CODE
     _after_insert_update(None, None, document)
     assert getattr(document.request, '_index_list') == [
         (document, document.id, INSERT_CODE)
         ]
Beispiel #18
0
def test_index_document(solr, db_session):
    now = datetime.now()
    doc = Document(title='foo', body=u'bar!', modification_date=now)
    doc.id = 23     # we don't really add the object yet...
    request = Mock(resource_path=lambda _: '/path/')
    add_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='foo'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-23'
    assert results[0]['path'] == '/path/'
    # Solr's date values don't take microseconds into account...
    assert abs(results[0]['modification_date'] - now) < timedelta(milliseconds=1)
Beispiel #19
0
def test_delete_document(solr, db_session):
    doc = Document(title=u'delete-me', description=u'foo!')
    doc.id = 3
    request = Mock(resource_path=lambda _: '/path/')
    add_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='delete-me'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-3'
    assert results[0]['description'] == u'foo!'
    delete_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='delete-me'))
    assert len(results) == 0
Beispiel #20
0
def populate():
    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

    if DBSession.query(Settings).count() == 0:
        settings = Settings(data={'kotti.db_version': get_version()})
        DBSession.add(settings)

    populate_users()
Beispiel #21
0
def test_delete_document(solr, db_session):
    doc = Document(title=u'delete-me', description=u'foo!')
    doc.id = 3
    request = Mock(resource_path=lambda _: '/path/')
    add_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='delete-me'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-3'
    assert results[0]['description'] == u'foo!'
    delete_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='delete-me'))
    assert len(results) == 0
Beispiel #22
0
def populate():
    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

    if DBSession.query(Settings).count() == 0:
        settings = Settings(data={'kotti.db_version': get_version()})
        DBSession.add(settings)

    populate_users()
Beispiel #23
0
def test_index_document(solr, db_session):
    now = datetime.now()
    doc = Document(title='foo', body=u'bar!', modification_date=now)
    doc.id = 23  # we don't really add the object yet...
    request = Mock(resource_path=lambda _: '/path/')
    add_document_handler(event=Mock(object=doc, request=request))
    results = list(solr.query(title='foo'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-23'
    assert results[0]['path'] == '/path/'
    # Solr's date values don't take microseconds into account...
    assert abs(results[0]['modification_date'] -
               now) < timedelta(milliseconds=1)
Beispiel #24
0
def populate():
    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #25
0
    def test_insert_delete(self, es_client, root,
                           dummy_request, db_session):
        import transaction
        from kotti.resources import Document
        document = Document(title=u'mytitle', description=u'mydescription',
                            body=u'<span>mybody</span>')
        document.request = dummy_request
        root[u'mydoc'] = document
        # with body=None no exceptions should be raised (utils/html_to_text)
        transaction.commit()

        es_client.flush()
        assert len(es_client.es.search(q='mytitle')['hits']['hits']) == 1
Beispiel #26
0
    def test_move_up(self, root):
        from kotti.resources import Document
        from kotti.views.edit.actions import NodeActions

        root["child1"] = Document(title="Child 1")
        root["child2"] = Document(title="Child 2")
        assert root["child1"].position < root["child2"].position

        request = DummyRequest()
        request.session["kotti.selected-children"] = [str(root["child2"].id)]
        NodeActions(root, request).up()
        assert request.session.pop_flash("success") == ["${title} was moved."]
        assert root["child1"].position > root["child2"].position
Beispiel #27
0
def populate():
    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #28
0
    def test_move_up(self, root):
        from kotti.resources import Document
        from kotti.views.edit.actions import NodeActions

        root['child1'] = Document(title=u"Child 1")
        root['child2'] = Document(title=u"Child 2")
        assert root['child1'].position < root['child2'].position

        request = DummyRequest()
        request.session['kotti.selected-children'] = [str(root['child2'].id)]
        NodeActions(root, request).up()
        assert request.session.pop_flash('success') ==\
            [u'${title} was moved.']
        assert root['child1'].position > root['child2'].position
def populate_root_document():
    if DBSession.query(Node).count() == 0:
        root = Document(name=u'', title=u'Front Page')
        root.__acl__ = SITE_ACL
        root.default_view = 'front-page'
        DBSession.add(root)
        url = JOB_CONTAINERS['url']
        root[url] = Document(title=u'Job Containers', owner=u'admin')
        set_groups(u'admin', root[url], set([u'role:owner']))

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')
Beispiel #30
0
def test_update_document_triggers_reindexing(solr, db_session, request):
    get_root()['doc'] = Document(title=u'bar', description=u'bar!')
    db_session.flush()
    results = list(solr.query(title='bar'))
    assert len(results) == 1
    assert results[0]['id'] == u'document-2'
    assert results[0]['description'] == 'bar!'
    assert results[0]['path'] == request.resource_path(get_root()['doc'])
    get_root()['doc'].description = u'blah!'
    db_session.flush()
    results = list(solr.query(title='bar'))
    assert len(results) == 1
    assert results[0]['id'] == u'document-2'
    assert results[0]['description'] == 'blah!'
    assert results[0]['path'] == request.resource_path(get_root()['doc'])
Beispiel #31
0
def test_update_document_triggers_reindexing(solr, db_session, request):
    get_root()['doc'] = Document(title=u'bar', description=u'bar!')
    db_session.flush()
    results = list(solr.query(title='bar'))
    assert len(results) == 1
    assert results[0]['id'] == u'document-2'
    assert results[0]['description'] == 'bar!'
    assert results[0]['path'] == request.resource_path(get_root()['doc'])
    get_root()['doc'].description = u'blah!'
    db_session.flush()
    results = list(solr.query(title='bar'))
    assert len(results) == 1
    assert results[0]['id'] == u'document-2'
    assert results[0]['description'] == 'blah!'
    assert results[0]['path'] == request.resource_path(get_root()['doc'])
Beispiel #32
0
    def test_contenttypefactories_with_invalid_add_link(self, config):
        from kotti.resources import Document, File
        from kotti.resources import default_type_info
        from kotti.views.edit import content
        from kotti.views.edit.actions import content_type_factories

        class TestContent:
            type_info = default_type_info.copy(
                name="TestContent",
                title="Test Content",
                add_view=None,
                addable_to=["Document"],
            )

        config.include(content)
        req = DummyRequest()
        root = Document("")

        with patch("kotti.views.edit.actions.get_settings") as gs:
            gs.return_value = {"kotti.available_types": [TestContent, Document, File]}
            res = content_type_factories(root, req)

            assert res["factories"] == [Document, File]

            TestContent.type_info.add_view = "add_document"
            res = content_type_factories(root, req)
            assert res["factories"] == [TestContent, Document, File]
Beispiel #33
0
 def test_verify_adapter(self):
     from pyramid_es.interfaces import IElastic
     from kotti_es.elastic import BaseElasticKottiContent
     from zope.interface.verify import verifyObject
     from kotti.resources import Document
     adapter = BaseElasticKottiContent(Document())
     assert verifyObject(IElastic, adapter)
Beispiel #34
0
    def test_insert(self, es_client, root, dummy_request, db_session):
        import transaction
        from kotti.resources import Document
        document = Document(title=u'mydoc', description=u'mydescription',)
        document.request = dummy_request
        root[u'mydoc'] = document
        # with body=None no exceptions should be raised (utils/html_to_text)
        transaction.commit()

        es_client.flush()
        results = es_client.es.search(q='mydescription')
        _type = results['hits']['hits'][0]['_type']
        assert _type == 'Document'
        from kotti.resources import get_root
        root = get_root()
        assert results['hits']['hits'][0]['_source']['path'] == root[u'mydoc'].path
Beispiel #35
0
    def test_contenttypefactories_with_invalid_add_link(self, config):
        from kotti.resources import Document, File
        from kotti.resources import default_type_info
        from kotti.views.edit import content
        from kotti.views.edit.actions import content_type_factories

        class TestContent(object):
            type_info = default_type_info.copy(
                name='TestContent',
                title='Test Content',
                add_view=None,
                addable_to=['Document'],
            )

        config.include(content)
        req = DummyRequest()
        root = Document('')

        with patch('kotti.views.edit.actions.get_settings') as gs:
            gs.return_value = {'kotti.available_types':
                               [TestContent, Document, File]}
            res = content_type_factories(root, req)

            assert res['factories'] == [Document, File]

            TestContent.type_info.add_view = 'add_document'
            res = content_type_factories(root, req)
            assert res['factories'] == [TestContent, Document, File]
Beispiel #36
0
 def make_document(self, root):
     from kotti.resources import Document
     doc = root['doc'] = Document()
     from kotti import DBSession
     DBSession.flush()
     DBSession.refresh(doc)
     return doc
Beispiel #37
0
    def make_document(self):
        from kotti import DBSession
        from kotti.resources import Document

        content = self.root['document'] = Document()
        DBSession.flush()
        DBSession.refresh(content)
        return content
Beispiel #38
0
    def test_put(self, config):

        config.include("kotti.rest")

        req = self._make_request(config, REQUEST_METHOD="PUT")
        req.body = json.dumps(
            {"data": {"type": "Document", "attributes": {"title": u"Title here", "body": u"Body here"}}}
        )
        doc = Document(name="parent")
        view = self._get_view(doc, req)
        resp = view(doc, req)
        data = resp.json_body["data"]

        assert resp.status == "201 Created"
        assert data["attributes"]["title"] == u"Title here"
        assert data["id"] == "title-here"
        assert doc.keys() == ["title-here"]
Beispiel #39
0
    def make_document(root):
        from kotti import DBSession
        from kotti.resources import Document

        content = root["document"] = Document()
        DBSession.flush()
        DBSession.refresh(content)
        return content
Beispiel #40
0
def test_populate_triggers_indexing(solr, db_session):
    get_root()['bar'] = Document(title=u'bar', description=u'blah!')
    db_session.flush()
    results = list(solr.query(title='bar'))
    assert len(results) == 1
    assert results[0]['id'] == 'document-2'
    assert results[0]['description'] == u'blah!'
    assert results[0]['path'] == u'/bar/'
Beispiel #41
0
    def make_document(self, root):
        from kotti import DBSession
        from kotti.resources import Document

        content = root['doc'] = Document(title=u'MyDocument')
        DBSession.flush()
        DBSession.refresh(content)
        return content
Beispiel #42
0
    def test_delete(self, config, db_session):
        config.include("kotti.rest")

        parent = Document(name="parent")
        child = Document(name="child")
        parent["child"] = child

        req = self._make_request(config, REQUEST_METHOD="DELETE")
        req.body = json.dumps({"data": {"id": "child", "type": "Document"}})

        db_session.add(parent)

        view = self._get_view(child, req)

        assert "child" in parent.keys()
        resp = view(child, req)
        assert resp.status == "204 No Content"
        assert "child" not in parent.keys()
Beispiel #43
0
def populate():
    """
    Create the root node (:class:`~kotti.resources.Document`) and the 'about'
    subnode in the nodes tree if there are no nodes yet.
    """

    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #44
0
    def test_forbidden_view_webtest(self, root, webtest, db_session):
        from kotti.resources import Document
        root[u'doc'] = doc = Document(title=u'document')
        db_session.flush()
        assert doc.state == 'private'

        resp = webtest.get('/doc', headers={'Accept': '*/json'}, status=403)
        assert resp.status_code == 403
        assert 'substancek_cms_theme' in resp.body
Beispiel #45
0
    def test_contenttypefactories_add_links(self, config):
        from kotti.views.edit.actions import content_type_factories
        from kotti.resources import Document, File
        from kotti.views.edit import content

        config.include(content)

        res = content_type_factories(Document(''), DummyRequest())
        assert res['factories'] == [Document, File]
Beispiel #46
0
def populate():
    """
    Create the root node (Document) and the 'about' subnode in the nodes tree
    if there are no nodes yet.
    """

    if DBSession.query(Node).count() == 0:
        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        root['about'] = Document(**_ABOUT_ATTRS)

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #47
0
def populate():
    """
    Create the root node (:class:`~kotti.resources.Document`) and the 'about'
    subnode in the nodes tree if there are no nodes yet.
    """
    lrm = LocalizerRequestMixin()
    lrm.registry = get_current_registry()
    lrm.locale_name = get_settings()['pyramid.default_locale_name']
    localizer = lrm.localizer

    if DBSession.query(Node.id).count() == 0:
        pkgdir = os.path.dirname(__file__)
        pagesdir = os.path.join(pkgdir, 'static/pages')
        #import pdb ; pdb.set_trace()
        root_filename = os.path.join(pagesdir, 'index.md')
        root_atts = make_markdown_attrs('', root_filename,
                                        title='Welcome to XYZZY',
                                        description='Home Page')
        root_atts['body'] = markdown.markdown(root_atts['body'])
        root = Document(**root_atts)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        webatts = make_markdown_attrs('webdesign',
                                      os.path.join(
                                          pagesdir, 'webdesign/index.md'),
                                      title='Web Design',
                                      description='Pages on Web Design')
        root['webdesign'] = MarkDownDocument(**webatts)
        wpages = ['history', 'development', 'stylesheets',
                  'javascript-components']
        for wp in wpages:
            wpfn = os.path.join(pagesdir, 'webdesign/%s.md' % wp)
            wptitle = ' '.join([p.capitalize() for p in wp.split('-')])
            wpatts = make_markdown_attrs(wp, wpfn, title=wptitle)
            root['webdesign'][wp] = MarkDownDocument(**wpatts)
        
        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

    populate_users()
Beispiel #48
0
    def test_put(self, config):
        config.include('kotti.rest')
        req = self._make_request(config, REQUEST_METHOD='PUT')
        req.body = json.dumps({
            'data': {
                'type': 'Document',
                'attributes': {
                    'title': u"Title here",
                    'body': u"Body here"
                }
            }
        })
        doc = Document(name='parent')
        view = self._get_view(doc, req)
        data = view(doc, req).json_body['data']

        assert data['attributes']['title'] == u'Title here'
        assert data['id'] == 'title-here'

        assert doc.keys() == ['title-here']
Beispiel #49
0
    def test_after_commit_delete(self, dummy_request):
        from kotti.resources import Document
        from kotti_es.sqla import _after_delete
        from kotti_es.sqla import _after_commit
        document = Document()
        document.request = dummy_request
        _after_delete(None, None, document)

        import mock
        with mock.patch('kotti_es.sqla.get_current_request') as \
                get_current_request:
            get_current_request.return_value = dummy_request
            with mock.patch('kotti_es.sqla.get_client') as \
                    get_client:
                magic = mock.MagicMock()
                get_client.return_value = magic
                session = mock.Mock()
                session.configure_mock(**{
                    'query.return_value.filter_by.'
                    'return_value.one.return_value': document})
                _after_commit(session)
                magic.delete_object.assert_called_with(document,
                                                       immediate=True)
def populate():

    session = DBSession()

    if session.query(Node).count() == 0:

        root = Document(**_ROOT_ATTRS)
        root.__acl__ = SITE_ACL
        DBSession.add(root)

        root.default_view = u'app'

        wf = get_workflow(root)
        if wf is not None:
            DBSession.flush()  # Initializes workflow
            wf.transition_to_state(root, None, u'public')

        populate_users()

        root_document = \
                session.query(Content).filter(Content.parent_id==None).first()

        fruit_categories_folder = \
                FruitCategoriesFolder(name=u"fruit_categories_folder",
                                      title=u"Fruit Categories Folder",
                                      in_navigation=True,
                                      parent=root_document)

        fruit_categories_folder.__acl__ = SITE_ACL
        session.add(fruit_categories_folder)

        workflow = get_workflow(fruit_categories_folder)
        if workflow:
            DBSession.flush()
            workflow.transition_to_state(fruit_categories_folder, None, u'public')
        else:
            print '################ NO WORKFLOW for ', fruit_categories_folder.title

        folder = \
                session.query(Content).filter_by(
                        name=u"fruit_categories_folder").first()

        fruit_category_instances = {}
        for fruit_category in fruit_categories:
            fruit_category_instances[fruit_category] = \
                FruitCategory(name=fruit_categories[fruit_category]['name'],
                              title=fruit_categories[fruit_category]['name'],
                              parent=folder)

        for key in fruit_category_instances:
            fruit_category_instances[key].__acl__ = SITE_ACL
            session.add(fruit_category_instances[key])

            workflow = get_workflow(fruit_category_instances[key])
            if workflow:
                DBSession.flush()
                workflow.transition_to_state(fruit_category_instances[key], None, u'public')
            else:
                print '################ NO WORKFLOW for ', fruit_category_instances[key].title

        fruit_instances = {}
        for fruit_category in fruit_categories:
            fruit_category_obj = \
                    DBSession.query(FruitCategory).filter_by(
                            title=fruit_category).first()
            for fruit_name in fruit_categories[fruit_category]['fruits']:
                fruit_instances[fruit_name] = \
                    Fruit(**fruit_data_args_dict(fruit_name,
                                                 fruit_category_obj))

        for key in fruit_instances:
            fruit_instances[key].__acl__ = SITE_ACL
            session.add(fruit_instances[key])

            workflow = get_workflow(fruit_instances[key])
            if workflow:
                DBSession.flush()
                workflow.transition_to_state(fruit_instances[key], None, u'public')
            else:
                print '################ NO WORKFLOW for ', fruit_instances[key].title

            # Images have filenames with format: apple.256.jpg. We will use
            # the largest, at 512 pixels, from choices of 32, 64, 128, 256,
            # and 512, and let Kotti handle sizing for thumbnails.
            size = 512
            image_filename = "{0}.{1}.jpg".format(key, size)
            image_path = os.path.join(os.path.dirname(images.__file__),
                                      image_filename)
            image = open(image_path, 'rb').read()
            fruit_instances[key][image_filename] = \
                    Image(image,
                          image_filename,
                          u"image/jpeg",
                          title=image_filename)
            fruit_instances[key][image_filename].__acl__ = SITE_ACL
            session.add(fruit_instances[key][image_filename])


    session.flush()
    transaction.commit()