def test_bossrequest_channel_not_found(self):
        """
        Test initialization of requests with a channel that does not exist

        """
        # create the request
        url = '/' + version + '/meta/col1/exp1/channel2/?key=mkey'
        request = self.rf.get(url)
        force_authenticate(request, user=self.user)
        drfrequest = BossMeta().initialize_request(request)
        drfrequest.version = version

        # Create the request dict
        request_args = {
            "user": self.user,
            "method": request.method,
            "service": "meta",
            "version": version,
            "collection_name": "col1",
            "experiment_name": "exp1",
            "channel_name": "channel2",
            "key": "mkey",
            "value": None
        }

        try:
            BossRequest(drfrequest,request_args)
        except BossError as err:
            assert err.args[0] == 404

    def test_basic_resource_get_downsampled_extent_dims_isotropic(self):
        """Test downsample extent isotropic

        Returns:
            None

        """
        url = '/' + version + '/cutout/col1/exp_iso/channel1/0/0:5/0:6/0:2/'

        # Create the request
        request = self.rf.get(url)
        force_authenticate(request, user=self.user)
        drfrequest = Cutout().initialize_request(request)
        drfrequest.version = version

        request_args = {
            "service": "cutout",
            "collection_name": "col1",
            "experiment_name": "exp_iso",
            "channel_name": "channel1",
            "resolution": 0,
            "x_args": "0:5",
            "y_args": "0:6",
            "z_args": "0:2",
            "time_args": None
        }

        req = BossRequest(drfrequest, request_args)
        resource = BossResourceDjango(req)

        extent_dims = resource.get_downsampled_extent_dims()
        self.assertEqual(len(extent_dims), 8)
        self.assertEqual(extent_dims[0], [2000, 5000, 200])
        self.assertEqual(extent_dims[1], [1000, 2500, 100])
        self.assertEqual(extent_dims[3], [250, 625, 25])

    def get_request(self,method='GET', authed=True):
        request_method=getattr(self.factory,method.lower())
        request=request_method("")
        if authed:
            force_authenticate(request, self.test_user)

        return request

    def test_create_issuer_image_500x300_resizes_to_400x400(self):
        view = IssuerList.as_view()

        with open(os.path.join(os.path.dirname(__file__), 'testfiles',
                               '500x300.png'), 'r') as badge_image:
                issuer_fields_with_image = {
                    'name': 'Awesome Issuer',
                    'description': 'An issuer of awe-inspiring credentials',
                    'url': 'http://example.com',
                    'email': '[email protected]',
                    'image': badge_image,
                }

                request = factory.post('/v1/issuer/issuers',
                                       issuer_fields_with_image,
                                       format='multipart')

                force_authenticate(request,
                                   user=get_user_model().objects.get(pk=1))
                response = view(request)
                self.assertEqual(response.status_code, 201)

                badge_object = response.data.get('json')
                derived_slug = badge_object['id'].split('/')[-1]
                new_issuer = Issuer.objects.get(slug=derived_slug)

                image_width, image_height = \
                    get_image_dimensions(new_issuer.image.file)
                self.assertEqual(image_width, 400)
                self.assertEqual(image_height, 400)

    def test_duplicate_wrong_parameters(self):
        request = factory.post(reverse('resolwe-api:data-duplicate'), format='json')
        force_authenticate(request, self.contributor)
        response = self.duplicate_viewset(request)
        self.assertEqual(response.data['detail'], "`ids` parameter is required")

        request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': 1}, format='json')
        force_authenticate(request, self.contributor)
        response = self.duplicate_viewset(request)
        self.assertEqual(response.data['detail'], "`ids` parameter not a list")

        request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': []}, format='json')
        force_authenticate(request, self.contributor)
        response = self.duplicate_viewset(request)
        self.assertEqual(response.data['detail'], "`ids` parameter is empty")

        request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': ['a']}, format='json')
        force_authenticate(request, self.contributor)
        response = self.duplicate_viewset(request)
        self.assertEqual(response.data['detail'], "`ids` parameter contains non-integers")

        request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': [0]}, format='json')
        force_authenticate(request, self.contributor)
        response = self.duplicate_viewset(request)
        self.assertEqual(response.data['detail'], "Data objects with the following ids not found: 0")

    def setUp(self):
        self.view = ViewSet.as_view({'get': 'retrieve'})
        self.anonymous_user = AnonymousUserFactory()
        self.user = UserFactory.create()
        self.group = GroupFactory.create(name=self.user.username)
        self.leadership = LeadershipFactory.create(
            user=self.user,
            group=self.group
            )
        self.staff_user = UserFactory.create(is_staff=True)

        self.provider = ProviderFactory.create()
        self.identity = IdentityFactory.create(
            provider=self.provider,
            created_by=self.user)
        self.quota = QuotaFactory.create()
        self.allocation = AllocationFactory.create()
        IdentityMembershipFactory.create(
            member=self.group,
            identity=self.identity,
            quota=self.quota
        )

        factory = APIRequestFactory()
        url = reverse('api:v2:identity-detail', args=(self.identity.id,))
        self.request = factory.get(url)
        force_authenticate(self.request, user=self.user)
        self.response = self.view(self.request, pk=self.identity.id)

    def test_request_tile_invalid_orientation(self):
        """
        Test initialization of tile arguments for a invalid tile request. Unrecognized orientation
        :return:
        """
        url = '/' + version + '/tile/col1/exp1/channel1/xe/512/2/0/1/1/1/'

        # Create the request dict
        request_args = {
            "service": "tile",
            "collection_name": "col1",
            "experiment_name": "exp1",
            "channel_name": "channel1",
            "orientation": "xe",
            "tile_size": 512,
            "resolution": 2,
            "x_args": "0",
            "y_args": "0",
            "z_args": "1",
            "time_args": "1"
        }

        # Create the request
        request = self.rf.get(url)
        force_authenticate(request, user=self.user)
        drfrequest = Tile().initialize_request(request)
        drfrequest.version = version

        with self.assertRaises(BossError):
            BossRequest(drfrequest, request_args)

    def post(self, user, data=None):
        if data is None:
            data = {
                'name': 'A test image',
                'description': 'Test image description',
                'file': get_image()
            }

        url = reverse(
            'api:grouping_media',
            kwargs={
                'project_id': self.project.id,
                'grouping_id': self.grouping.id,
                'contribution_id': self.contribution.id
            }
        )

        request = self.factory.post(url, data)
        force_authenticate(request, user)
        view = GroupingContributionsMediaApiView.as_view()
        return view(
            request,
            project_id=self.project.id,
            grouping_id=self.grouping.id,
            contribution_id=self.contribution.id
        ).render()

    def test_remove_lookupvalue_from_not_existing_field(self):
        lookup_value = LookupValueFactory()

        url = reverse(
            'ajax:category_lookupvalues_detail',
            kwargs={
                'project_id': self.project.id,
                'category_id': self.active_type.id,
                'field_id': 45455,
                'value_id': lookup_value.id
            }
        )
        request = self.factory.delete(url)
        force_authenticate(request, user=self.admin)
        view = FieldLookupsUpdate.as_view()

        response = view(
            request,
            project_id=self.project.id,
            category_id=self.active_type.id,
            field_id=45455,
            value_id=lookup_value.id
        ).render()

        self.assertEqual(response.status_code, 404)

    def test_remove_not_exisiting_lookupvalue(self):
        lookup_field = LookupFieldFactory(**{
            'category': self.active_type
        })

        url = reverse(
            'ajax:category_lookupvalues_detail',
            kwargs={
                'project_id': self.project.id,
                'category_id': self.active_type.id,
                'field_id': lookup_field.id,
                'value_id': 65645445444
            }
        )
        request = self.factory.delete(url)
        force_authenticate(request, user=self.admin)
        view = FieldLookupsUpdate.as_view()

        response = view(
            request,
            project_id=self.project.id,
            category_id=self.active_type.id,
            field_id=lookup_field.id,
            value_id=65645445444
        ).render()

        self.assertEqual(response.status_code, 404)

    def test_remove_lookupvalue_with_admin(self):
        lookup_field = LookupFieldFactory(**{
            'category': self.active_type
        })
        lookup_value = LookupValueFactory(**{
            'field': lookup_field
        })

        url = reverse(
            'ajax:category_lookupvalues_detail',
            kwargs={
                'project_id': self.project.id,
                'category_id': self.active_type.id,
                'field_id': lookup_field.id,
                'value_id': lookup_value.id
            }
        )
        request = self.factory.delete(url)
        force_authenticate(request, user=self.admin)
        view = FieldLookupsUpdate.as_view()

        response = view(
            request,
            project_id=self.project.id,
            category_id=self.active_type.id,
            field_id=lookup_field.id,
            value_id=lookup_value.id
        ).render()

        self.assertEqual(response.status_code, 204)
        self.assertEqual(
            len(lookup_field.lookupvalues.filter(status='active')), 0
        )

    def test_add_lookupvalue_with_admin(self):
        lookup_field = LookupFieldFactory(**{
            'category': self.active_type
        })

        url = reverse(
            'ajax:category_lookupvalues',
            kwargs={
                'project_id': self.project.id,
                'category_id': self.active_type.id,
                'field_id': lookup_field.id
            }
        )
        request = self.factory.post(url, {'name': 'Ms. Piggy'})
        force_authenticate(request, user=self.admin)
        view = FieldLookups.as_view()

        response = view(
            request,
            project_id=self.project.id,
            category_id=self.active_type.id,
            field_id=lookup_field.id
        ).render()

        self.assertEqual(response.status_code, 201)
        self.assertEqual(len(lookup_field.lookupvalues.all()), 1)

    def test_reorder_with_false_field(self):
        url = reverse(
            'ajax:category_fields_reorder',
            kwargs={
                'project_id': self.category.project.id,
                'category_id': self.category.id
            }
        )

        data = [
            self.field_4.id, self.field_0.id, self.field_2.id, self.field_1.id,
            655123135135
        ]

        request = self.factory.post(
            url, json.dumps({'order': data}), content_type='application/json')
        force_authenticate(request, user=self.category.project.creator)
        view = FieldsReorderView.as_view()
        response = view(
            request,
            project_id=self.category.project.id,
            category_id=self.category.id
        ).render()

        self.assertEqual(response.status_code, 400)

        fields = self.category.fields.all()

        self.assertTrue(fields.ordered)
        self.assertEqual(fields[0].order, 0)
        self.assertEqual(fields[1].order, 0)
        self.assertEqual(fields[2].order, 0)
        self.assertEqual(fields[3].order, 0)
        self.assertEqual(fields[4].order, 0)

    def test_permissions(self):
        # First user
        request = factory.post('', {}, format='json')
        force_authenticate(request, self.user_1)
        response = self.test_viewset(request)
        response = sorted(response.data, key=lambda obj: obj['name'])

        self.assertEqual(len(response), 2)
        self.assertEqual(response[0]['name'], 'Object name 1')
        self.assertEqual(response[1]['name'], 'Object name 3')

        # Second user
        request = factory.post('', {}, format='json')
        force_authenticate(request, self.user_2)
        response = self.test_viewset(request)
        response = sorted(response.data, key=lambda obj: obj['name'])

        self.assertEqual(len(response), 2)
        self.assertEqual(response[0]['name'], 'Object name 2')
        self.assertEqual(response[1]['name'], 'Object name 3')

        # Public user
        request = factory.post('', {}, format='json')
        response = self.test_viewset(request)

        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]['name'], 'Object name 3')

    def test_get_game_data_player(self):
        """
        Should return game session data for authenticated user upon GET
        request to /play/<session_id>/ag

        Should only return when its that users turn to play.
        """
        test_session = GameSession.objects.get(id=1)
        test_session.set_turn_data(test_json_data_global, "V")

        factory = APIRequestFactory()
        user = User.objects.get(username='john')
        view = GameREST.as_view()
        url = 'play/' + str(test_session.id) + '/ag/'
        request = factory.get(url)
        force_authenticate(request, user=user)
        response = view(request, test_session.id)

        self.assertEqual(response.data['turn_data'], test_json_data_global)
        
        # This test is not the user that should play next
        user2 = User.objects.get(username='ringo')
        request2 = factory.get(url)
        force_authenticate(request2, user=user2)
        response2 = view(request2, test_session.id)
        
        self.assertEqual(response2.data['detail'], 
                         'You do not have permission to perform this action.')

    def test_list_response_contains_expected_fields(self):
        force_authenticate(self.list_request, user=self.user)
        response = self.list_view(self.list_request)
        data = response.data.get('results')
        self.assertTrue(data, "Response contained no results")
        project_data = data[0]

        self.assertEquals(response.status_code, 200)
        self.assertEquals(
            len(project_data), EXPECTED_FIELD_COUNT,
            "Number of fields does not match (%s != %s)" %
            (len(project_data), EXPECTED_FIELD_COUNT)
        )
        self.assertEquals(project_data['id'], self.project.id)
        self.assertIn('url', project_data)
        self.assertEquals(project_data['name'], self.project.name)
        self.assertEquals(project_data['description'], self.project.description)
        self.assertIn('created_by', project_data)
        self.assertIn('owner', project_data)
        self.assertIn('users', project_data)
        self.assertIn('leaders', project_data)
        self.assertIn('uuid', project_data)
        self.assertIn('instances', project_data)
        self.assertIn('volumes', project_data)
        self.assertIn('images', project_data)
        self.assertIn('links', project_data)
        self.assertIn('start_date', project_data)
        self.assertIn('end_date', project_data)

    def test_post_first_turn(self):
        """
        Post output of game return back to django.
        Authenticated user on their turn only.
        Same url as get: /play/<session_id>/ag
        """
        test_session = GameSession.objects.get(id=1)
        test_session.set_turn_data(test_json_data_global, "V")

        factory = APIRequestFactory()
        user = User.objects.get(username='john')
        view = GameREST.as_view()
        url = 'play/' + str(test_session.id) + '/ag/'
        request = factory.post(url, {'virus_player': '{"test": 1}',
                                     'health_player': '{"test2": 2}',
                                     'starting_from': 'india',
                                     'testing': True,
                                     'choice_outcome': '{"test3": 3}',
                                     'virus_tech': '{"dog": 1}',
                                     'health_tech': '{"cat": 2}',
                                     'change': '{"frog": "monkey"}'
                                     }, format='json')
        force_authenticate(request, user=user)

        response = view(request, test_session.id)
        
        # for the tests, reload the session from the DB
        test_session = GameSession.objects.get(id=1)
        self.assertNotEqual(response.data, test_json_data_global)
        self.assertEqual(response.data, 'complete')
        self.assertEqual(test_session.turn_data, '{"dog": "india"}')
        self.assertEqual(test_session.next_to_play, 'H')

    def test_request_tile_init_tileargs_time(self):
        """
        Test initialization of timesample arguments  with a single time
        :return:
        """
        url = '/' + version + '/tile/col1/exp1/channel1/xy/512/2/0/0/1/1/'

        # Create the request dict
        request_args = {
            "service": "tile",
            "collection_name": "col1",
            "experiment_name": "exp1",
            "channel_name": "channel1",
            "orientation": "xy",
            "tile_size": 512,
            "resolution": 2,
            "x_args": "0",
            "y_args": "0",
            "z_args": "1",
            "time_args": "1"
        }

        # Create the request
        request = self.rf.get(url)
        force_authenticate(request, user=self.user)
        drfrequest = Tile().initialize_request(request)
        drfrequest.version = version

        ret = BossRequest(drfrequest, request_args)
        time = ret.get_time()
        self.assertEqual(time, range(1, 2))

    def test_bounding_box_service_invalid_channel_type(self):
        """
        Test initialization of cutout requests for the datamodel
        :return:
        """
        url = '/' + version + '/boundingbox/col1/exp1/channel1/0/10'
        col = 'col1'
        exp = 'exp1'
        channel = 'channel1'

        # Create the request
        request = self.rf.get(url)
        force_authenticate(request, user=self.user)
        drfrequest = Reserve().initialize_request(request)
        drfrequest.version = version

        # Create the request dict
        request_args = {
            "service": "boundingbox",
            "version": version,
            "collection_name": col,
            "experiment_name": exp,
            "channel_name": channel,
            "resolution": 0,
            "id": 10

        }

        with self.assertRaises(BossError):
            ret = BossRequest(drfrequest, request_args)

    def test_create_issuer_authenticated(self):
        view = IssuerList.as_view()

        request = factory.post(
            '/v1/issuer/issuers',
            json.dumps(example_issuer_props),
            content_type='application/json'
        )

        force_authenticate(request, user=get_user_model().objects.get(pk=1))
        response = view(request)
        self.assertEqual(response.status_code, 201)

        # assert that name, description, url, etc are set properly in response badge object
        badge_object = response.data.get('json')
        self.assertEqual(badge_object['url'], example_issuer_props['url'])
        self.assertEqual(badge_object['name'], example_issuer_props['name'])
        self.assertEqual(badge_object['description'], example_issuer_props['description'])
        self.assertEqual(badge_object['email'], example_issuer_props['email'])
        self.assertIsNotNone(badge_object.get('id'))
        self.assertIsNotNone(badge_object.get('@context'))

        # assert that the issuer was published to and fetched from the cache
        with self.assertNumQueries(0):
            slug = response.data.get('slug')
            response = self.client.get('/v1/issuer/issuers/{}'.format(slug))
            self.assertEqual(response.status_code, 200)