コード例 #1
0
 def test_representation(self):
     workspace = WorkspaceEdit()
     workspace.save()
     workspace_item = workspace.workspace_items.create(
         name="workspace_item")
     # No errors: fine.  As long as we return something.
     self.assertTrue(unicode(workspace_item))
コード例 #2
0
ファイル: tests.py プロジェクト: pombredanne/lizard-map
class WorkspaceItemAdapterTest(TestCase):

    def setUp(self):
        self.workspace = WorkspaceEdit()
        self.workspace.save()
        workspace_item = WorkspaceEditItem(workspace=self.workspace)
        workspace_item.save()
        layer_arguments = {}
        self.adapter = WorkspaceItemAdapter(workspace_item, layer_arguments)

    def test_smoke(self):
        self.assertTrue(self.adapter)

    def test_line_styles(self):
        identifiers = [{str(i): 'b'} for i in range(10)]
        line_styles = self.adapter.line_styles(identifiers)
        self.assertTrue(line_styles)
        self.assertEquals(len(line_styles.keys()), 10)

    def test_value_aggregate_default(self):
        # First, implement values function
        start_date = datetime.datetime(2010, 5, 25)
        end_date = datetime.datetime(2010, 6, 25)
        self.adapter.values = (
            lambda
            identifier, start_date, end_date:
                [{'datetime': start_date, 'value': 5.0, 'unit': 'none'},
                 {'datetime': end_date, 'value': 6.0, 'unit': 'none'}])
        aggregated_values = self.adapter.value_aggregate_default(
            {},
            {'min': None, 'max': None, 'avg': None, 'count_lt': 6,
             'count_gte': 6, 'percentile': 50},
            start_date,
            end_date)
        self.assertEqual(aggregated_values['min'], 5.0)
        self.assertEqual(aggregated_values['max'], 6.0)
        self.assertEqual(aggregated_values['avg'], 5.5)
        self.assertEqual(aggregated_values['count_lt'], 1)
        self.assertEqual(aggregated_values['count_gte'], 1)
        # Percentile value depends on definition...
        self.assertTrue(aggregated_values['percentile'] >= 5.0)
        self.assertTrue(aggregated_values['percentile'] <= 6.0)

    def test_symbol_url(self):
        self.assertTrue(self.adapter.symbol_url())

    def test_html_default_identifiers(self):
        identifiers = {}
        self.assertTrue(self.adapter.html_default(identifiers=identifiers))

    def test_legend_object_default(self):
        self.adapter.legend_object_default('no_name')

    def test_legend_default(self):
        legend_object = self.adapter.legend_object_default('no_name')
        self.adapter.legend_default(legend_object)
コード例 #3
0
 def test_delete_invalid_ws_item_2(self):
     workspace = WorkspaceEdit()
     workspace.save()
     workspace_item = workspace.workspace_items.create(
         adapter_class='adapter_does_not_exist', name='workspace-item')
     workspace_item.save()
     # The workspace item should be deleted after .adapter() got an error.
     self.assertEquals(workspace_item.adapter, None)
     # Make sure the code doesn't hang in the __unicode__ after a deletion.
     self.assertTrue(unicode(workspace_item))
コード例 #4
0
    def test_workspace_item_delete(self):
        workspace = WorkspaceEdit()
        workspace.save()
        workspace_item1 = workspace.workspace_items.create(
            name='test workspaceitem')

        self.request.POST['object_id'] = str(workspace_item1.id)
        lizard_map.views.workspace_item_delete(
            self.request, workspace_edit=workspace)
        self.assertFalse(workspace.workspace_items.all())
コード例 #5
0
 def test_workspace_item_add(self):
     workspace = WorkspaceEdit()
     workspace.save()
     params = {'name': 'test workspace_item',
               'adapter_class': 'test adapter_class',
               'adapter_layer_json': '{"json"}'}
     self.request.POST.update(params)
     lizard_map.views.workspace_item_toggle(
         self.request, workspace_edit=workspace)
     self.assertTrue(workspace.workspace_items.filter())
コード例 #6
0
 def test_delete_invalid_ws_item_1(self):
     workspace = WorkspaceEdit()
     workspace.save()
     workspace_item = workspace.workspace_items.create(
         adapter_class='adapter_dummy', name='reinout')
     workspace_item.save()
     self.assertTrue(isinstance(workspace_item.adapter,
                                lizard_map.layers.AdapterDummy))
     workspace_item.adapter_layer_json = ''
     workspace_item.save()
     workspace_item.adapter_layer_json = '[{"invalid": "non existing"}a]'
     # The workspace item should be deleted after .adapter() got an error.
     self.assertEquals(workspace_item.adapter, None)
     # Make sure the code doesn't hang in the __unicode__ after a deletion.
     self.assertTrue(unicode(workspace_item))
コード例 #7
0
ファイル: tests.py プロジェクト: pombredanne/lizard-map
 def setUp(self):
     self.workspace = WorkspaceEdit()
     self.workspace.save()
     workspace_item = WorkspaceEditItem(workspace=self.workspace)
     workspace_item.save()
     layer_arguments = {}
     self.adapter = WorkspaceItemAdapter(workspace_item, layer_arguments)
コード例 #8
0
 def test_check_workspace_item_adapters(self):
     user = User(username='******')
     workspace = WorkspaceEdit.get_or_create('fake session key', user)
     workspace.workspace_items.create(
         name='fake',
         adapter_class='adapter_class',
         adapter_layer_json='adapter_layer_json')
     workspace.check_workspace_item_adapters()
コード例 #9
0
ファイル: tests.py プロジェクト: pombredanne/lizard-progress
class AdapterTest(TestCase):
    def setUp(self):
        self.workspace = WorkspaceEdit()
        self.workspace.save()
        self.workspace_item = WorkspaceEditItem(workspace=self.workspace)
        self.workspace_item.save()

    def init_adapter(self, layer_arguments, project,
                     contractor, measurement_type):
        # Create adapter with given layer_arguments
        self.adapter = ProgressAdapter(workspace_item=self.workspace_item,
                                       layer_arguments=layer_arguments)

        # Check if project, contractor and measurement_type are as expected
        self.assertEquals(self.adapter.project, project)
        self.assertEquals(self.adapter.contractor, contractor)
        self.assertEquals(self.adapter.measurement_type, measurement_type)

    def test_empty_adapter(self):
        self.init_adapter({}, None, None, None)

    def test_unexisting_adapter(self):
        self.init_adapter({'project_slug': 'wheeeeeee'}, None, None, None)

    def test_weird_adapter_input(self):
        self.assertRaises(
            ValueError, self.init_adapter, None, None, None, None)

    def test_full_adapter(self):
        project = Project(
            slug='test', organization=Organization.objects.create(name="test"))
        project.save()
        contractor = Contractor(slug='contractor')
        contractor.project = project
        contractor.save()
        available_measurement_type = AvailableMeasurementType(slug='mtype')
        available_measurement_type.save()
        measurement_type = MeasurementType(mtype=available_measurement_type)
        measurement_type.project = project
        measurement_type.save()

        self.init_adapter({
                'project_slug': 'test',
                'contractor_slug': 'contractor',
                'measurement_type_slug': 'mtype',
                }, project, contractor, measurement_type)
コード例 #10
0
    def test_workspace_item_reorder(self):
        """Test workspace items reorder

        TODO: this is not a very good test, because indices are given
        in the test. How to fake getlist in your view?
        """
        workspace = WorkspaceEdit()
        workspace.save()
        workspace_item1 = workspace.workspace_items.create()
        workspace_item2 = workspace.workspace_items.create()
        order = {str(workspace_item2.id): 10,
                 str(workspace_item1.id): 20}
        lizard_map.views.workspace_item_reorder(
            self.request, workspace_edit=workspace,
            workspace_items_order=order)

        self.assertEqual(workspace.workspace_items.all()[0], workspace_item2)
        self.assertEqual(workspace.workspace_items.all()[1], workspace_item1)
コード例 #11
0
    def dispatch(self, request, *args, **kwargs):
        """Add in the omnipresent workspace item, then proceed as normal."""

        workspace_edit = WorkspaceEdit.get_or_create(
            request.session.session_key, request.user)

        workspace_edit.add_workspace_item(
            "Neerslagradar", "adapter_neerslagradar", "{}")

        return super(DefaultView, self).dispatch(request, *args, **kwargs)
コード例 #12
0
 def test_is_animatable2(self):
     user = User(username='******')
     workspace = WorkspaceEdit.get_or_create('fake session key', user)
     workspace.workspace_items.create(
         name='fake',
         adapter_class='adapter_class',
         adapter_layer_json='adapter_layer_json')
     workspace.workspace_items.create(
         name='fake2',
         adapter_class='adapter_class',
         adapter_layer_json='adapter_layer_json')
     self.assertFalse(workspace.is_animatable)
コード例 #13
0
    def test_workspace_edit_item(self):
        workspace = WorkspaceEdit(
            session_key=self.request.session.session_key,
            user=self.request.user)
        workspace.save()
        workspace_item1 = workspace.workspace_items.create(
            name='test workspaceitem')

        lizard_map.views.workspace_edit_item(
            self.request, workspace_edit=workspace,
            workspace_item_id=str(workspace_item1.id),
            visible='false')
        self.assertEqual(
            WorkspaceEditItem.objects.get(name='test workspaceitem').visible,
            False)
        lizard_map.views.workspace_edit_item(
            self.request, workspace_edit=workspace,
            workspace_item_id=str(workspace_item1.id),
            visible='true')
        self.assertEqual(
            WorkspaceEditItem.objects.get(name='test workspaceitem').visible,
            True)
コード例 #14
0
ファイル: views.py プロジェクト: nc17/lizard-neerslagradar
    def dispatch(self, request, *args, **kwargs):
        """Add in the omnipresent workspace item, then proceed as normal."""

        workspace_edit = WorkspaceEdit.get_or_create(request.session.session_key, request.user)

        if request.user.is_authenticated():
            layer_json = json.dumps({"userid": request.user.id})
        else:
            layer_json = json.dumps({})

        workspace_edit.add_workspace_item("Neerslagradar", "adapter_neerslagradar", layer_json)

        return super(DefaultView, self).dispatch(request, *args, **kwargs)
コード例 #15
0
    def dispatch(self, request, *args, **kwargs):
        """Add in the omnipresent workspace item, then proceed as normal."""
        # Hack: we need to have a session right away.
        request.session["make_sure_session_is_initialized"] = "hurray"
        # End of the hack.
        if request.session.session_key is None:
            request.session.save()
        workspace_edit = WorkspaceEdit.get_or_create(request.session.session_key, request.user)

        if request.user.is_authenticated():
            layer_json = json.dumps({"userid": request.user.id})
        else:
            layer_json = json.dumps({})

        workspace_edit.add_workspace_item("Neerslagradar", "adapter_neerslagradar", layer_json)

        return super(DefaultView, self).dispatch(request, *args, **kwargs)
コード例 #16
0
    def dispatch(self, request, *args, **kwargs):
        """Add in the omnipresent workspace item, then proceed as normal."""
        # Hack: we need to have a session right away.
        request.session['make_sure_session_is_initialized'] = 'hurray'
        # End of the hack.
        if request.session.session_key is None:
            request.session.save()
        workspace_edit = WorkspaceEdit.get_or_create(
            request.session.session_key, request.user)

        if request.user.is_authenticated():
            layer_json = json.dumps({'userid': request.user.id})
        else:
            layer_json = json.dumps({})

        workspace_edit.add_workspace_item("Neerslagradar",
                                          "adapter_neerslagradar", layer_json)

        return super(DefaultView, self).dispatch(request, *args, **kwargs)
コード例 #17
0
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.workspace_edit = WorkspaceEdit()
        self.workspace_edit.save()

        self.workspace_storage = WorkspaceStorage(
            name='storage', owner=self.user)
        self.workspace_storage.save()

        class Mock(dict):
            def build_absolute_uri(self, arg):
                return "http://example.com" + arg

        self.request = Mock()
        self.request.session = Mock()
        self.request.session.session_key = 'mock-session-key'
        self.request.user = AnonymousUser()
        self.request.META = {}
コード例 #18
0
    def test_loads_stored_workspace(self):
        """WorkspaceEdit's get_or_create should copy an existing
        stored workspace when creating a new one if the relevant
        setting exists."""
        user = AnonymousUser()
        Setting.objects.create(
            key="default_workspace_anonymous_user",
            value="some_secret_slug")

        workspace_storage = WorkspaceStorage(
            name='storage', secret_slug="some_secret_slug")
        workspace_storage.save()
        workspace_storage_item = WorkspaceStorageItem(
            workspace=workspace_storage)
        workspace_storage_item.save()

        session_key = "whee"
        workspace_edit = WorkspaceEdit.get_or_create(session_key, user)

        # Should contain 1 item, copied from the workspace storage
        self.assertEquals(
            len(workspace_edit.workspace_items.all()),
            1)
コード例 #19
0
class ViewsTest(TestCase):
    fixtures = ('lizard_map', )

    def setUp(self):
        self.client = Client()
        self.workspace = WorkspaceEdit(session_key='mock')
        self.workspace.save()

    def test_workspace_edit_wms(self):
        url = reverse('lizard_map_workspace_edit_wms',
                      kwargs={'workspace_item_id': self.workspace.id})
        # ^^^ Check; that's workspace ID instead of workspaceitem ID.
        url += ('?LAYERS=basic&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&'
                'STYLES=&EXCEPTIONS=application%2Fvnd.ogc.se_inimage&'
                'FORMAT=image%2Fjpeg&SRS=EPSG%3A900913&'
                'BBOX=430987.5469813,6803449.8497827,'
                '669012.4530187,6896550.1502173&'
                'WIDTH=1557&HEIGHT=609')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_search_coordinates(self):
        url = reverse('lizard_map.search_coordinates')
        url += ('?x=430987.5469813&y=6817896.448126'
                '&extent_top=6900000&extent_bottom=6800000'
                '&user_workspace_id=%d' % self.workspace.id)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_search_name(self):
        url = reverse('lizard_map.search_name')
        url += ('?x=430987.5469813&y=6817896.448126'
                '&extent_top=6900000&extent_bottom=6800000'
                '&user_workspace_id=%d' % self.workspace.id)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_map_location_save(self):
        """Save map location, see if it doesn't crash
        """
        client = Client()
        url = reverse('lizard_map.map_location_save')
        response = client.post(url, {'left': 100, 'top': 100,
                                     'right': 150, 'bottom': 150,
                                     'base_layer_name': 'Google standard'})
        self.assertEqual(response.status_code, 200)

    def test_map_location_load_default(self):
        """Save map location, then load it back.
        """
        url_load = reverse('lizard_map.map_location_load_default')
        response_load = self.client.get(url_load)
        self.assertEqual(response_load.status_code, 200)
        result = json.loads(response_load.content)
        self.assertEqual(
            result['extent'],
            {'top': '6964942', 'right': '1254790',
             'left': '-14675', 'bottom': '6668977'})

    def test_mixins(self):
        view = lizard_map.views.AppView()

        gtc = view.google_tracking_code()
        if gtc is not None:
            self.assertIsInstance(gtc, str)

        self.assertIsNone(gtc)

    def test_buttons_on(self):
        """This basically tests the settings?"""
        # Refresh AppView, it uses class variables
        reload(lizard_map.views)
        view = lizard_map.views.AppView()
        self.assertFalse(view.map_show_multiselect)
        self.assertTrue(view.map_show_daterange)
        self.assertTrue(view.map_show_default_zoom)
        self.assertTrue(view.map_show_base_layers_menu)
        self.assertTrue(view.map_show_layers_menu)
        self.assertEquals(len(view.content_actions),
                          False + True + True + True + True)

    def test_buttons_off_view(self):
        view = lizard_map.views.AppView()
        view.map_show_multiselect = False
        view.map_show_daterange = False
        view.map_show_default_zoom = False
        view.map_show_base_layers_menu = False
        view.map_show_layers_menu = False
        self.assertEquals(view.content_actions, [])

    @override_settings(LIZARD_MAP_SHOW_MULTISELECT=False,
                       LIZARD_MAP_SHOW_DATERANGE=False,
                       LIZARD_MAP_SHOW_DEFAULT_ZOOM=False,
                       LIZARD_MAP_SHOW_BASE_LAYERS_MENU=False,
                       LIZARD_MAP_SHOW_LAYERS_MENU=False)
    def test_buttons_off_settings(self):
        # Refresh AppView, it uses class variables
        reload(lizard_map.views)

        view = lizard_map.views.AppView()
        self.assertEquals(view.content_actions, [])
コード例 #20
0
ファイル: tests.py プロジェクト: pombredanne/lizard-progress
 def setUp(self):
     self.workspace = WorkspaceEdit()
     self.workspace.save()
     self.workspace_item = WorkspaceEditItem(workspace=self.workspace)
     self.workspace_item.save()
コード例 #21
0
 def test_is_animatable(self):
     user = User(username='******')
     workspace = WorkspaceEdit.get_or_create('fake session key', user)
     self.assertFalse(workspace.is_animatable)
コード例 #22
0
ファイル: tests.py プロジェクト: pombredanne/lizard-map
 def setUp(self):
     self.client = Client()
     self.workspace = WorkspaceEdit(session_key='mock')
     self.workspace.save()
コード例 #23
0
 def test_workspace_edit(self):
     user = User(username='******')
     workspace = WorkspaceEdit.get_or_create('fake session key', user)
     workspace.__unicode__()
コード例 #24
0
ファイル: tests.py プロジェクト: pombredanne/lizard-map
class ViewsTest(TestCase):
    fixtures = ('lizard_map', )

    def setUp(self):
        self.client = Client()
        self.workspace = WorkspaceEdit(session_key='mock')
        self.workspace.save()
        # self.collage = WorkspaceCollage(workspace=self.workspace)
        # self.collage.save()

    # def test_homepage(self):
    #     url = reverse('lizard_map_workspace',
    #                   kwargs={'workspace_id': self.workspace.id})
    #     response = self.client.get(url)
    #     self.assertEqual(response.status_code, 200)

    def test_workspace_edit_wms(self):
        url = reverse('lizard_map_workspace_edit_wms',
                      kwargs={'workspace_item_id': self.workspace.id})
        # ^^^ Check; that's workspace ID instead of workspaceitem ID.
        url += ('?LAYERS=basic&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&'
                'STYLES=&EXCEPTIONS=application%2Fvnd.ogc.se_inimage&'
                'FORMAT=image%2Fjpeg&SRS=EPSG%3A900913&'
                'BBOX=430987.5469813,6803449.8497827,'
                '669012.4530187,6896550.1502173&'
                'WIDTH=1557&HEIGHT=609')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    # def test_collage(self):
    #     url = reverse('lizard_map.collage',
    #                   kwargs={'collage_id': self.collage.id})
    #     response = self.client.get(url)
    #     self.assertEqual(response.status_code, 200)

    # def test_collage_popup(self):
    #     url = reverse('lizard_map.collage_popup',
    #                   kwargs={'collage_id': self.collage.id})
    #     response = self.client.get(url)
    #     self.assertEqual(response.status_code, 200)

    def test_search_coordinates(self):
        url = reverse('lizard_map.search_coordinates')
        url += ('?x=430987.5469813&y=6817896.448126&radius=100&'
                'user_workspace_id=%d' % self.workspace.id)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_search_name(self):
        url = reverse('lizard_map.search_name')
        url += ('?x=430987.5469813&y=6817896.448126&radius=100&'
                'user_workspace_id=%d' % self.workspace.id)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_map_location_save(self):
        """Save map location, see if it doesn't crash
        """
        client = Client()
        url = reverse('lizard_map.map_location_save')
        response = client.post(url, {'left': 100, 'top': 100,
                                     'right': 150, 'bottom': 150,
                                     'base_layer_name': 'Google standard'})
        self.assertEqual(response.status_code, 200)

    def test_map_location_load_default(self):
        """Save map location, then load it back.
        """
        url_load = reverse('lizard_map.map_location_load_default')
        response_load = self.client.get(url_load)
        self.assertEqual(response_load.status_code, 200)
        result = json.loads(response_load.content)
        self.assertEqual(
            result['extent'],
            {'top': '6964942', 'right': '1254790',
             'left': '-14675', 'bottom': '6668977'})

    def test_mixins(self):
        view = lizard_map.views.AppView()

        gtc = view.google_tracking_code()
        if gtc is not None:
            self.assertIsInstance(gtc, str)

        self.assertIsNone(gtc)
コード例 #25
0
 def test_workspace_edit(self):
     user = User(username='******')
     workspace_edit = WorkspaceEdit.get_or_create('fake_key', user)
     mock_request = self.MockRequest()
     context = {'request': mock_request, 'user': user}
     workspaces.workspace_edit(context, workspace_edit)
コード例 #26
0
class WorkspaceLoadSaveTest(TestCase):
    """Loading and saving from WorkspaceEdit to WorkspaceStorage.

    """

    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.workspace_edit = WorkspaceEdit()
        self.workspace_edit.save()

        self.workspace_storage = WorkspaceStorage(
            name='storage', owner=self.user)
        self.workspace_storage.save()

        class Mock(dict):
            def build_absolute_uri(self, arg):
                return "http://example.com" + arg

        self.request = Mock()
        self.request.session = Mock()
        self.request.session.session_key = 'mock-session-key'
        self.request.user = AnonymousUser()
        self.request.META = {}

    def test_item_edit_as_storage(self):
        """WorkspaceEditItem to WorkspaceStorageItem conversion."""
        workspace_item_edit = WorkspaceEditItem(
            workspace=self.workspace_edit)
        workspace_item_edit.save()

        workspace_storage_item = workspace_item_edit.as_storage(
            workspace=self.workspace_storage)
        workspace_storage_item.save()  # Do not crash.

        # This dict does not have _state, _workspace_cache, workspace_id
        edit_dict = workspace_item_edit.__dict__

        storage_dict = workspace_storage_item.__dict__

        # _workspace_cache does not appear in other code... strange?
        del storage_dict['id']
        del storage_dict['_state']
        del storage_dict['_workspace_cache']
        del storage_dict['workspace_id']

        self.assertEquals(edit_dict, storage_dict)

    def test_item_storage_as_edit(self):
        """WorkspaceStorageItem to WorkspaceEditItem conversion."""
        workspace_storage_item = WorkspaceStorageItem(
            workspace=self.workspace_storage)
        workspace_storage_item.save()

        workspace_item_edit = workspace_storage_item.as_edit(
            workspace=self.workspace_edit)
        workspace_item_edit.save()  # Do not crash.

        # This dict does not have _state, _workspace_cache, workspace_id
        storage_dict = workspace_storage_item.__dict__

        edit_dict = workspace_item_edit.__dict__

        # _workspace_cache does not appear in other code... strange?
        del edit_dict['id']
        del edit_dict['_state']
        del edit_dict['_workspace_cache']
        del edit_dict['workspace_id']

        self.assertEquals(edit_dict, storage_dict)

    def test_load(self):
        """Load: copy from storage to edit."""
        # Add some random workspace_items in edit workspace.
        self.workspace_edit.workspace_items.create(name="mock")

        # Add some random workspace_items in storage workspace.
        self.workspace_storage.workspace_items.create(name="saved")

        self.workspace_edit.load_from_storage(self.workspace_storage)

        self.assertEquals(len(self.workspace_edit.workspace_items.all()), 1)
        self.assertEquals(
            self.workspace_edit.workspace_items.all()[0].name, 'saved')

    def test_save(self):
        """Load: copy from storage to edit."""
        # Add some random workspace_items in edit workspace.
        self.workspace_edit.workspace_items.create(name="edit")

        # Add some random workspace_items in storage workspace.
        self.workspace_storage.workspace_items.create(name="saved")

        # The name and owner must correspond.
        self.workspace_edit.save_to_storage(name='storage', owner=self.user)

        self.assertEquals(len(self.workspace_edit.workspace_items.all()), 1)

        # Just copied 'edit' from edit to storage.
        self.assertEquals(
            self.workspace_storage.workspace_items.all()[0].name, 'edit')

        # Item "saved" is deleted.
        self.assertEquals(
            len(WorkspaceStorageItem.objects.filter(name="saved")), 0)

    def test_save2(self):
        """Load: copy from storage to edit in different workspaces."""
        user2 = User(username="******")
        user2.save()
        # Add some random workspace_items in edit workspace.
        self.workspace_edit.workspace_items.create(name="edit")

        # Find existing workspace = 1.
        self.workspace_edit.save_to_storage(name='storage', owner=self.user)
        # Create new workspace = 2.
        self.workspace_edit.save_to_storage(name='new', owner=self.user)
        # Create new workspace = 3.
        self.workspace_edit.save_to_storage(name='storage', owner=user2)
        # Overwrite workspace = 3.
        self.workspace_edit.save_to_storage(name='storage', owner=user2)

        # 3 workspaces, 3 workspace items should exist.
        self.assertEquals(WorkspaceStorage.objects.count(), 3)
        self.assertEquals(WorkspaceStorageItem.objects.count(), 3)