Example #1
0
 def test_with_sheet_not_editable(self, version, registry, mock_sheet):
     """Ingore event if isheet ist not editable."""
     event = create_new_reference_event(version, registry)
     mock_sheet.meta = mock_sheet.meta._replace(editable=False)
     register_sheet(version, mock_sheet, registry)
     self.call_fut(event)
     assert not mock_sheet.set.called
 def test_version_is_last_version(self, item, version, registry, mock_sheet,
                                  mock_versionable_sheet,
                                  mock_get_last_version):
     """If no version created in transaction and version is the items
        last_version create a new version.
     """
     from adhocracy_core.interfaces import IItemVersion
     from adhocracy_core.sheets.versions import IVersionable
     event = create_new_reference_event(version,
                                        registry,
                                        old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     mock_get_last_version.return_value = version
     registry.content.get_sheets_all.return_value = [
         mock_sheet, mock_versionable_sheet
     ]
     self.call_fut(event)
     assert registry.content.create.call_args[0][
         0] == IItemVersion.__identifier__
     assert registry.content.create.call_args[1][
         'root_versions'] == event.root_versions
     assert registry.content.create.call_args[1][
         'registry'] == event.registry
     assert registry.content.create.call_args[1]['creator'] is event.creator
     assert registry.content.create.call_args[1]['parent'] is item
     assert registry.content.create.call_args[1][
         'is_batchmode'] == event.is_batchmode
     assert registry.content.create.call_args[1]['appstructs'] ==\
         {IDummySheetAutoUpdate.__identifier__: {'elements': [1, 3]},
          IVersionable.__identifier__: {'follows': [version]}}
Example #3
0
 def test_version_is_last_version(
         self, item, version, registry, mock_sheet, mock_versionable_sheet,
         mock_get_last_version):
     """If no version created in transaction and version is the items
        last_version create a new version.
     """
     from adhocracy_core.interfaces import IItemVersion
     from adhocracy_core.sheets.versions import IVersionable
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     mock_get_last_version.return_value = version
     registry.content.get_sheets_all.return_value = [mock_sheet,
                                                     mock_versionable_sheet]
     self.call_fut(event)
     assert registry.content.create.call_args[0][0] == IItemVersion.__identifier__
     assert registry.content.create.call_args[1]['root_versions'] == event.root_versions
     assert registry.content.create.call_args[1]['registry'] == event.registry
     assert registry.content.create.call_args[1]['creator'] is event.creator
     assert registry.content.create.call_args[1]['parent'] is item
     assert registry.content.create.call_args[1]['is_batchmode'] == event.is_batchmode
     assert registry.content.create.call_args[1]['appstructs'] ==\
         {IDummySheetAutoUpdate.__identifier__: {'elements': [1, 3]},
          IVersionable.__identifier__: {'follows': [version]}}
 def test_get_roleids_user_exists(self, context, mock_sheet, request_,
                                  inst):
     from adhocracy_core.testing import register_sheet
     user = testing.DummyResource(roles=['role1'])
     register_sheet(user, mock_sheet, request_.registry)
     context['principals']['users']['User1'] = user
     assert inst.get_roleids('/principals/users/User1') == ['role:role1']
 def test_version_is_not_last_version_and_has_not_same_references(
         self, version, registry, mock_sheet, mock_versionable_sheet,
         mock_get_last_version):
     """If no new version is created in transaction and version is not
        items last_version but has same references raise
     """
     from adhocracy_core.exceptions import AutoUpdateNoForkAllowedError
     event = create_new_reference_event(version,
                                        registry,
                                        old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     last = testing.DummyResource()
     register_sheet(last, mock_sheet, registry)
     mock_sheet.get.side_effect = [{
         'elements': [1, 2]
     }, {
         'elements': [11]
     }, {
         'elements': [22]
     }]
     mock_get_last_version.return_value = last
     registry.content.get_sheets_all.return_value = [
         mock_sheet, mock_versionable_sheet
     ]
     with raises(AutoUpdateNoForkAllowedError) as err:
         self.call_fut(event)
     assert err.value.resource is version
     assert err.value.event is event
 def test_with_sheet_not_editable(self, version, registry, mock_sheet):
     """Ingore event if isheet ist not editable."""
     event = create_new_reference_event(version, registry)
     mock_sheet.meta = mock_sheet.meta._replace(editable=False)
     register_sheet(version, mock_sheet, registry)
     self.call_fut(event)
     assert not mock_sheet.set.called
Example #7
0
 def permissions_sheet(self, context, registry, mock_sheet):
     import copy
     from adhocracy_core.sheets.principal import IPermissions
     from adhocracy_core.testing import register_sheet
     mock_sheet = copy.deepcopy(mock_sheet)
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(context, mock_sheet, registry)
     return mock_sheet
Example #8
0
 def permissions_sheet(self, context, registry, mock_sheet):
     import copy
     from adhocracy_core.sheets.principal import IPermissions
     from adhocracy_core.testing import register_sheet
     mock_sheet = copy.deepcopy(mock_sheet)
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(context, mock_sheet, registry)
     return mock_sheet
 def test_tag_name_is_first(self, version, registry, mock_sheet):
     """Don`t update the "first" tag."""
     version.__name__ = 'FIRST'
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3,
                                        isheet_field='elements')
     register_sheet(version, mock_sheet, registry)
     self.call_fut(event)
     assert mock_sheet.set.called is False
Example #10
0
 def test_single_element(self, version, registry, mock_sheet):
     """Update version (sheet field is list) """
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3,
                                        isheet_field='elements')
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
 def test_multiple_elements(self, version, registry, mock_sheet):
     """Update version (sheet field is list) """
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3,
                                        isheet_field='elements')
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
Example #12
0
    def test_call_with_parent_and_empty_name_data(self, resource_meta, pool,
                                                  registry, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName, ))
        appstructs = {'adhocracy_core.sheets.name.IName': {'name': ''}}
        register_sheet(None, mock_sheet, registry, IName)

        with raises(KeyError):
            self.make_one(meta)(parent=pool, appstructs=appstructs)
Example #13
0
 def test_get_groupids_user_exists(self, context, mock_sheet, request_, inst):
     from adhocracy_core.sheets.principal import IPermissions
     from adhocracy_core.testing import register_sheet
     group = testing.DummyResource(__name__='group1')
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     mock_sheet.get.return_value = {'groups': [group]}
     user = testing.DummyResource()
     register_sheet(user, mock_sheet, request_.registry)
     context['principals']['users']['User1'] = user
     assert inst.get_groupids('/principals/users/User1') == ['group:group1']
Example #14
0
 def test_get_groupids_user_exists(self, context, mock_sheet, request_, inst):
     from adhocracy_core.sheets.principal import IPermissions
     from adhocracy_core.testing import register_sheet
     group = testing.DummyResource(__name__='group1')
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     mock_sheet.get.return_value = {'groups': [group]}
     user = testing.DummyResource()
     register_sheet(user, mock_sheet, request_.registry)
     context['principals']['users']['User1'] = user
     assert inst.get_groupids('/principals/users/User1') == ['group:group1']
Example #15
0
    def test_call_with_parent_and_empty_name_data(self, resource_meta, pool,
                                                  registry, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName,))
        appstructs = {'adhocracy_core.sheets.name.IName': {'name': ''}}
        register_sheet(None, mock_sheet, registry, IName)

        with raises(KeyError):
            self.make_one(meta)(parent=pool, appstructs=appstructs)
Example #16
0
    def test_call_with_creatable_appstructs_data(self, resource_meta, registry,
                                                 mock_sheet):
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(ISheetY, ))
        register_sheet(None, mock_sheet, registry, ISheetY)
        appstructs = {ISheetY.__identifier__: {'count': 0}}

        self.make_one(meta)(appstructs=appstructs)

        assert mock_sheet.set.call_args[0] == ({'count': 0}, )
        assert mock_sheet.set.call_args[1]['send_event'] is False
Example #17
0
    def test_call_with_parent_and_non_unique_name_appstruct(
            self, resource_meta, registry, pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName, ))
        appstructs = {IName.__identifier__: {'name': 'name'}}
        register_sheet(None, mock_sheet, registry, IName)
        pool['name'] = testing.DummyResource()

        with raises(KeyError):
            self.make_one(meta)(parent=pool, appstructs=appstructs)
Example #18
0
    def test_call_with_not_creatable_appstructs_data(self, resource_meta,
                                                     registry, mock_sheet):
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(ISheetY, ))
        register_sheet(None, mock_sheet, registry, ISheetY)
        mock_sheet.meta = sheet_meta._replace(creatable=False)
        appstructs = {ISheetY.__identifier__: {'count': 0}}

        self.make_one(meta)(appstructs=appstructs)

        assert not mock_sheet.set.called
Example #19
0
    def test_call_with_parent_and_non_unique_name_appstruct(
            self, resource_meta, registry, pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName,))
        appstructs = {IName.__identifier__: {'name': 'name'}}
        register_sheet(None, mock_sheet, registry, IName)
        pool['name'] = testing.DummyResource()

        with raises(KeyError):
            self.make_one(meta)(parent=pool, appstructs=appstructs)
Example #20
0
 def test_default_group_not_exists(self, registry, principals, event,
                                   mock_sheet):
     from adhocracy_core.sheets.principal import IPermissions
     del principals['groups']['authenticated']
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     self.call_fut(event)
     assert mock_sheet.set.called is False
Example #21
0
    def test_call_with_creatable_appstructs_data(self, resource_meta, registry,
                                                 mock_sheet):
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(ISheetY,))
        register_sheet(None, mock_sheet, registry, ISheetY)
        appstructs = {ISheetY.__identifier__: {'count': 0}}

        self.make_one(meta)(appstructs=appstructs)

        assert mock_sheet.set.call_args[0] == ({'count': 0},)
        assert mock_sheet.set.call_args[1]['send_event'] is False
Example #22
0
 def test_default_group_not_exists(
         self, registry, principals, event, mock_sheet):
     from adhocracy_core.sheets.principal import IPermissions
     del principals['groups']['authenticated']
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     self.call_fut(event)
     assert mock_sheet.set.called is False
Example #23
0
    def test_call_with_not_creatable_appstructs_data(self, resource_meta,
                                                     registry, mock_sheet):
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(ISheetY,))
        register_sheet(None, mock_sheet, registry, ISheetY)
        mock_sheet.meta = sheet_meta._replace(creatable=False)
        appstructs = {ISheetY.__identifier__: {'count': 0}}

        self.make_one(meta)(appstructs=appstructs)

        assert not mock_sheet.set.called
 def test_default_group_exists_and_no_group_set(
         self, registry, principals, event, mock_sheet, mock_user_locator):
     from adhocracy_core.sheets.principal import IPermissions
     default_group = principals['groups']['authenticated']
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     mock_user_locator.get_groups.return_value = []
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'groups': [default_group]}
Example #25
0
 def test_default_group_exists_and_no_group_set(
         self, registry, principals, event, mock_sheet, mock_user_locator):
     from adhocracy_core.sheets.principal import IPermissions
     default_group = principals['groups']['authenticated']
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     mock_user_locator.get_groups.return_value = []
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'groups': [default_group]}
Example #26
0
    def test_call_with_parent_and_name_appstruct(self, resource_meta, registry,
                                                 pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName,))
        appstructs = {IName.__identifier__: {'name': 'name'}}
        register_sheet(None, mock_sheet, registry, IName)
        inst = self.make_one(meta)(parent=pool, appstructs=appstructs)

        assert inst.__parent__ == pool
        assert inst.__name__ in pool
        assert inst.__name__ == 'name'
Example #27
0
 def test_with_root_versions_not_in_subtree(self, version, mock_graph,
                                            registry, mock_sheet):
     """Ingore event if object ist not in root_versions subtree."""
     root_version = testing.DummyResource()
     mock_graph.is_in_subtree.return_value = False
     version.__graph__ = mock_graph
     event = create_new_reference_event(version, registry,
                                        root_versions=[root_version])
     register_sheet(version, mock_sheet, registry)
     self.call_fut(event)
     mock_graph.is_in_subtree.assert_called_once_with(version, [root_version])
     assert not mock_sheet.set.called
Example #28
0
    def test_without_parent_and_resource_implements_imetadata_and_itemversion(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.sheets.metadata import IMetadata
        from adhocracy_core.interfaces import IItemVersion
        meta = resource_meta._replace(iresource=IItemVersion,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)

        self.make_one(meta)()

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['item_creation_date'] == set_appstructs['creation_date']
Example #29
0
    def test_without_parent_and_resource_implements_imetadata_and_itemversion(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.sheets.metadata import IMetadata
        from adhocracy_core.interfaces import IItemVersion
        meta = resource_meta._replace(iresource=IItemVersion,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)

        self.make_one(meta)()

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['item_creation_date'] == set_appstructs['creation_date']
 def test_transation_version_created_single_element(
         self, version, registry, mock_sheet, changelog_meta):
     """Update version created in transaction (sheet field is single)"""
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3,
                                        isheet_field='element')
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'element': 2}
     registry.changelog['/'] = changelog_meta._replace(created=True)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'element': 3}
     assert registry.content.create.called is False
Example #31
0
    def test_call_with_parent_and_name_appstruct(self, resource_meta, registry,
                                                 pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName, ))
        appstructs = {IName.__identifier__: {'name': 'name'}}
        register_sheet(None, mock_sheet, registry, IName)
        inst = self.make_one(meta)(parent=pool, appstructs=appstructs)

        assert inst.__parent__ == pool
        assert inst.__name__ in pool
        assert inst.__name__ == 'name'
 def test_with_root_versions_not_in_subtree(self, version, mock_graph,
                                            registry, mock_sheet):
     """Ingore event if object ist not in root_versions subtree."""
     root_version = testing.DummyResource()
     mock_graph.is_in_subtree.return_value = False
     version.__graph__ = mock_graph
     event = create_new_reference_event(version, registry,
                                        root_versions=[root_version])
     register_sheet(version, mock_sheet, registry)
     self.call_fut(event)
     mock_graph.is_in_subtree.assert_called_once_with(version, [root_version])
     assert not mock_sheet.set.called
Example #33
0
 def test_transation_version_created_single_element(
         self, version, registry, mock_sheet, changelog_meta):
     """Update version created in transaction (sheet field is single)"""
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3,
                                        isheet_field='element')
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'element': 2}
     registry.changelog['/'] = changelog_meta._replace(created=True)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'element': 3}
     assert registry.content.create.called is False
Example #34
0
 def test_transaction_version_followed_by(
         self, version, registry, mock_sheet, changelog_meta):
     """Update followed_by version created in transaction."""
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     followedby = testing.DummyResource()
     register_sheet(followedby, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     registry.changelog['/'] = changelog_meta._replace(followed_by=followedby)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
     assert registry.content.create.called is False
Example #35
0
    def test_call_with_parent_and_appstructs_name_data(
            self, resource_meta, registry, pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName,))
        register_sheet(None, mock_sheet, registry, IName)
        mock_sheet.set.return_value = False
        appstructs = {IName.__identifier__: {'name': 'child'}}

        self.make_one(meta)(parent=pool, appstructs=appstructs)

        assert 'child' in pool
        assert mock_sheet.set.called
 def test_transaction_version_followed_by(
         self, version, registry, mock_sheet, changelog_meta):
     """Update followed_by version created in transaction."""
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     followedby = testing.DummyResource()
     register_sheet(followedby, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     registry.changelog['/'] = changelog_meta._replace(followed_by=followedby)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
     assert registry.content.create.called is False
Example #37
0
    def test_call_with_parent_and_appstructs_name_data(
            self, resource_meta, registry, pool, mock_sheet):
        from adhocracy_core.sheets.name import IName
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IName,))
        register_sheet(None, mock_sheet, registry, IName)
        mock_sheet.set.return_value = False
        appstructs = {IName.__identifier__: {'name': 'child'}}

        self.make_one(meta)(parent=pool, appstructs=appstructs)

        assert 'child' in pool
        assert mock_sheet.set.called
Example #38
0
 def test_default_group_exists_and_group_set(
         self, registry, principals, event, mock_sheet, mock_user_locator):
     from adhocracy_core.interfaces import DEFAULT_USER_GROUP_NAME
     from adhocracy_core.sheets.principal import IPermissions
     default_group = principals['groups'][DEFAULT_USER_GROUP_NAME]
     other_group = testing.DummyResource()
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     mock_user_locator.get_groups.return_value = [other_group]
     self.call_fut(event)
     assert mock_sheet.set.called is False
 def test_default_group_exists_and_group_set(self, registry, principals,
                                             event, mock_sheet,
                                             mock_user_locator):
     from adhocracy_core.interfaces import DEFAULT_USER_GROUP_NAME
     from adhocracy_core.sheets.principal import IPermissions
     default_group = principals['groups'][DEFAULT_USER_GROUP_NAME]
     other_group = testing.DummyResource()
     user = principals['users']['000000']
     event.object = user
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IPermissions)
     register_sheet(event.object, mock_sheet, registry)
     mock_sheet.get.return_value = {'groups': []}
     mock_user_locator.get_groups.return_value = [other_group]
     self.call_fut(event)
     assert mock_sheet.set.called is False
Example #40
0
 def test_with_detail_and_imetadata(self, error, request_, mock_sheet,
                                    registry_with_content):
     from datetime import datetime
     from adhocracy_core.testing import register_sheet
     from adhocracy_core.sheets.metadata import IMetadata
     resource = testing.DummyResource(__provides__=[IMetadata])
     user = testing.DummyResource(__name__='/user')
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IMetadata)
     mock_sheet.get.return_value = {'modification_date': datetime.today(),
                                    'modified_by': user}
     register_sheet(resource, mock_sheet, registry_with_content)
     error.detail = 'hidden'
     request_.context = resource
     inst = self.make_one(error, request_)
     assert inst.json_body['modification_date'].endswith('00:00')
     assert inst.json_body['modified_by'].endswith('user/')
Example #41
0
 def test_with_request(self, context, registry, mock_sheet, monkeypatch):
     from datetime import datetime
     from . import subscriber
     from adhocracy_core.sheets.metadata import IMetadata
     now = datetime.now()
     monkeypatch.setattr(subscriber, 'get_modification_date', lambda x: now)
     register_sheet(context, mock_sheet, registry, isheet=IMetadata)
     request = testing.DummyResource(user=object())
     event = testing.DummyResource(object=context,
                                   registry=registry,
                                   request=request)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'modification_date': now,
                                               'modified_by': request.user}
     assert mock_sheet.set.call_args[1] == {'send_event': False,
                                            'omit_readonly': False}
Example #42
0
    def test_with_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata, ))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = testing.DummyResource()

        resource = self.make_one(meta)(creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == authenticated_user
        assert set_appstructs['modified_by'] == authenticated_user
        userid = resource_path(authenticated_user)
        assert resource.__local_roles__ == {userid: {'role:creator'}}
Example #43
0
    def test_with_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = testing.DummyResource()

        resource = self.make_one(meta)(creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == authenticated_user
        assert set_appstructs['modified_by'] == authenticated_user
        userid = resource_path(authenticated_user)
        assert resource.__local_roles__ == {userid: {'role:creator'}}
 def test_version_is_not_last_version_but_has_same_references(
         self, version, registry, mock_sheet,
         mock_versionable_sheet, mock_get_last_version):
     """If no new version is created in transaction and version is not
        items last_version but has same references ignore
     """
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     last = testing.DummyResource()
     register_sheet(last, mock_sheet, registry)
     mock_get_last_version.return_value = last
     registry.content.get_sheets_all.return_value = [mock_sheet,
                                                     mock_versionable_sheet]
     self.call_fut(event)
     assert registry.content.create.called is False
Example #45
0
    def test_without_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet, mock_mod_date):
        from adhocracy_core.sheets.metadata import IMetadata
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)

        self.make_one(meta)()

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] is None
        assert set_appstructs['modified_by'] is None
        assert set_appstructs['creation_date'] == mock_mod_date
        assert set_appstructs['item_creation_date'] == mock_mod_date
        assert set_appstructs['modification_date'] == mock_mod_date
        set_send_event = mock_sheet.set.call_args[1]['send_event']
        assert set_send_event is False
Example #46
0
    def test_with_creator_and_resource_implements_imetadata_and_iuser(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.resources.principal import IUser
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        meta = resource_meta._replace(iresource=IUser,
                                      basic_sheets=(IMetadata, ))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = object()

        created_user = self.make_one(meta)(creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == created_user
        assert set_appstructs['modified_by'] == created_user
        userid = resource_path(created_user)
        assert created_user.__local_roles__[userid] == {'role:creator'}
Example #47
0
    def test_with_creator_and_resource_implements_imetadata_and_iuser(
            self, resource_meta, registry, mock_sheet):
        from adhocracy_core.resources.principal import IUser
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        meta = resource_meta._replace(iresource=IUser,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = object()

        created_user = self.make_one(meta)(creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == created_user
        assert set_appstructs['modified_by'] == created_user
        userid = resource_path(created_user)
        assert created_user.__local_roles__[userid] == {'role:creator'}
Example #48
0
    def test_without_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet, mock_mod_date):
        from adhocracy_core.sheets.metadata import IMetadata
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata, ))
        register_sheet(None, mock_sheet, registry, IMetadata)

        self.make_one(meta)()

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] is None
        assert set_appstructs['modified_by'] is None
        assert set_appstructs['creation_date'] == mock_mod_date
        assert set_appstructs['item_creation_date'] == mock_mod_date
        assert set_appstructs['modification_date'] == mock_mod_date
        set_send_event = mock_sheet.set.call_args[1]['send_event']
        assert set_send_event is False
Example #49
0
 def test_version_is_not_last_version_but_has_same_references(
         self, version, registry, mock_sheet,
         mock_versionable_sheet, mock_get_last_version):
     """If no new version is created in transaction and version is not
        items last_version but has same references ignore
     """
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     last = testing.DummyResource()
     register_sheet(last, mock_sheet, registry)
     mock_get_last_version.return_value = last
     registry.content.get_sheets_all.return_value = [mock_sheet,
                                                     mock_versionable_sheet]
     self.call_fut(event)
     assert registry.content.create.called is False
Example #50
0
 def test_with_detail_and_imetadata(self, error, request_, mock_sheet,
                                    registry_with_content):
     from datetime import datetime
     from adhocracy_core.testing import register_sheet
     from adhocracy_core.sheets.metadata import IMetadata
     resource = testing.DummyResource(__provides__=[IMetadata])
     user = testing.DummyResource(__name__='/user')
     mock_sheet.meta = mock_sheet.meta._replace(isheet=IMetadata)
     mock_sheet.get.return_value = {
         'modification_date': datetime.today(),
         'modified_by': user
     }
     register_sheet(resource, mock_sheet, registry_with_content)
     error.detail = 'hidden'
     request_.context = resource
     inst = self.make_one(error, request_)
     assert inst.json_body['modification_date'].endswith('00:00')
     assert inst.json_body['modified_by'].endswith('user/')
 def test_with_request(self, context, registry, mock_sheet, monkeypatch):
     from datetime import datetime
     from . import subscriber
     from adhocracy_core.sheets.metadata import IMetadata
     now = datetime.now()
     monkeypatch.setattr(subscriber, 'get_modification_date', lambda x: now)
     user = object()
     monkeypatch.setattr(subscriber, 'get_user', lambda x: user)
     register_sheet(context, mock_sheet, registry, isheet=IMetadata)
     request = testing.DummyResource()
     event = testing.DummyResource(object=context,
                                   registry=registry,
                                   request=request)
     self.call_fut(event)
     assert mock_sheet.set.call_args[0][0] == {'modification_date': now,
                                               'modified_by': user}
     assert mock_sheet.set.call_args[1] ==\
         {'send_event': False,  'omit_readonly': False, 'request': request}
    def test_transaction_version_batchmode(
            self, item, version, registry, mock_sheet, changelog_meta):
        """Update items last_version created in transaction if batchmode.

           We could create forks if we update followedby/created during batch
           request. So we just take the last created item version.
        """
        from pyramid.traversal import resource_path
        event = create_new_reference_event(version, registry, old_version=2,
                                           new_version=3, is_batchmode=True)
        register_sheet(version, mock_sheet, registry)
        last_version = testing.DummyResource()
        register_sheet(last_version, mock_sheet, registry)
        mock_sheet.get.return_value = {'elements': [1, 2]}
        registry.changelog[resource_path(item)] =\
            changelog_meta._replace(last_version=last_version)
        self.call_fut(event)
        assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
        assert registry.content.create.called is False
Example #53
0
    def test_transaction_version_batchmode(
            self, item, version, registry, mock_sheet, changelog_meta):
        """Update items last_version created in transaction if batchmode.

           We could create forks if we update followedby/created during batch
           request. So we just take the last created item version.
        """
        from pyramid.traversal import resource_path
        event = create_new_reference_event(version, registry, old_version=2,
                                           new_version=3, is_batchmode=True)
        register_sheet(version, mock_sheet, registry)
        last_version = testing.DummyResource()
        register_sheet(last_version, mock_sheet, registry)
        mock_sheet.get.return_value = {'elements': [1, 2]}
        registry.changelog[resource_path(item)] =\
            changelog_meta._replace(last_version=last_version)
        self.call_fut(event)
        assert mock_sheet.set.call_args[0][0] == {'elements': [1, 3]}
        assert registry.content.create.called is False
Example #54
0
    def test_with_anonymized_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet, mocker):
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        mock_set_anonymized =\
            mocker.patch('adhocracy_core.resources.set_anonymized_creator')
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata,))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = testing.DummyResource(__name__='userid')
        anonymous_user = testing.DummyResource(__name__='anonymous')

        resource = self.make_one(meta)(creator=anonymous_user,
                                       anonymized_creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == anonymous_user
        assert set_appstructs['modified_by'] == anonymous_user
        assert getattr(resource, '__local_roles__', None) is None
        userid = resource_path(authenticated_user)
        mock_set_anonymized.assert_called_with(resource, userid)
Example #55
0
    def test_with_anonymized_creator_and_resource_implements_imetadata(
            self, resource_meta, registry, mock_sheet, mocker):
        from adhocracy_core.sheets.metadata import IMetadata
        from pyramid.traversal import resource_path
        mock_set_anonymized =\
            mocker.patch('adhocracy_core.resources.set_anonymized_creator')
        meta = resource_meta._replace(iresource=IResource,
                                      basic_sheets=(IMetadata, ))
        register_sheet(None, mock_sheet, registry, IMetadata)
        authenticated_user = testing.DummyResource(__name__='userid')
        anonymous_user = testing.DummyResource(__name__='anonymous')

        resource = self.make_one(meta)(creator=anonymous_user,
                                       anonymized_creator=authenticated_user)

        set_appstructs = mock_sheet.set.call_args[0][0]
        assert set_appstructs['creator'] == anonymous_user
        assert set_appstructs['modified_by'] == anonymous_user
        assert getattr(resource, '__local_roles__', None) is None
        userid = resource_path(authenticated_user)
        mock_set_anonymized.assert_called_with(resource, userid)
Example #56
0
 def test_version_is_not_last_version_and_has_not_same_references(
         self, version, registry, mock_sheet,
         mock_versionable_sheet, mock_get_last_version):
     """If no new version is created in transaction and version is not
        items last_version but has same references raise
     """
     from adhocracy_core.exceptions import AutoUpdateNoForkAllowedError
     event = create_new_reference_event(version, registry, old_version=2,
                                        new_version=3)
     register_sheet(version, mock_sheet, registry)
     mock_sheet.get.return_value = {'elements': [1, 2]}
     last = testing.DummyResource()
     register_sheet(last, mock_sheet, registry)
     mock_sheet.get.side_effect = [{'elements': [1, 2]}, {'elements': [11]},
                                   {'elements': [22]}]
     mock_get_last_version.return_value = last
     registry.content.get_sheets_all.return_value = [mock_sheet,
                                                     mock_versionable_sheet]
     with raises(AutoUpdateNoForkAllowedError) as err:
         self.call_fut(event)
     assert err.value.resource is version
     assert err.value.event is event
Example #57
0
 def mock_tag_sheet(self, tag, mock_sheet, registry_with_content):
     from adhocracy_core.testing import register_sheet
     from .tags import ITag
     mock_sheet.meta = mock_sheet.meta._replace(isheet=ITag)
     register_sheet(tag, mock_sheet, registry_with_content)
     return mock_sheet
Example #58
0
 def test_get_roleids_user_exists(self, context, mock_sheet, request_, inst):
     from adhocracy_core.testing import register_sheet
     user = testing.DummyResource(roles=['role1'])
     register_sheet(user, mock_sheet, request_.registry)
     context['principals']['users']['User1'] = user
     assert inst.get_roleids('/principals/users/User1') == ['role:role1']