def test_get_prep_value(self):
     res = CloudinaryResource(metadata=self.uploaded)
     value = "image/upload/v{version}/{id}.{format}".format(
         version=self.uploaded["version"],
         id=self.uploaded["public_id"],
         format=self.uploaded["format"])
     self.assertEqual(value, res.get_prep_value())
class TestCloudinaryResource(TestCase):
    mocked_response = http_response_mock('{"breakpoints": [50, 500, 1000]}')
    mocked_breakpoints = [50, 500, 1000]
    expected_transformation = "c_scale,w_auto:breakpoints_50_1000_20_20:json"

    crop_transformation = {'crop': 'crop', 'width': 100}
    crop_transformation_str = 'c_crop,w_100'

    @classmethod
    def setUpClass(cls):
        cloudinary.reset_config()
        cls.uploaded = uploader.upload(TEST_IMAGE,
                                       public_id=TEST_ID,
                                       tags=TEST_TAG)

    @classmethod
    def tearDownClass(cls):
        api.delete_resources_by_tag(TEST_TAG)

    def setUp(self):
        self.res = CloudinaryResource(metadata=self.uploaded)

    def test_empty_class(self):
        """An empty CloudinaryResource"""

        self.shortDescription()
        res = CloudinaryResource()
        self.assertFalse(res, "should be 'False'")
        self.assertEqual(len(res), 0, "should have zero len()")
        self.assertIsNone(res.url, "should have None url")

    def test_validate(self):
        self.assertTrue(self.res.validate())
        self.assertTrue(self.res)
        self.assertGreater(len(self.res), 0)

    def test_get_prep_value(self):
        value = "image/upload/v{version}/{id}.{format}".format(
            version=self.uploaded["version"],
            id=self.uploaded["public_id"],
            format=self.uploaded["format"])

        self.assertEqual(value, self.res.get_prep_value())

    def test_get_presigned(self):
        value = "image/upload/v{version}/{id}.{format}#{signature}".format(
            version=self.uploaded["version"],
            id=self.uploaded["public_id"],
            format=self.uploaded["format"],
            signature=self.uploaded["signature"])

        self.assertEqual(value, self.res.get_presigned())

    def test_url(self):
        self.assertEqual(self.res.url, self.uploaded["url"])

    def test_image(self):
        image = self.res.image()
        self.assertIn(' src="{url}'.format(url=self.res.url), image)
        self.assertNotIn('data-src="{url}'.format(url=self.res.url), image)
        image = self.res.image(responsive=True, width="auto", crop="scale")
        self.assertNotIn(
            ' src="{url}'.format(
                url=self.res.build_url(width="auto", crop="scale")), image)
        self.assertIn(
            'data-src="{url}'.format(
                url=self.res.build_url(width="auto", crop="scale")), image)

    @mock.patch('urllib3.request.RequestMethods.request',
                return_value=mocked_response)
    def test_fetch_breakpoints(self, mocked_request):
        """Should retrieve responsive breakpoints from cloudinary resource (mocked)"""
        actual_breakpoints = self.res._fetch_breakpoints()

        self.assertEqual(self.mocked_breakpoints, actual_breakpoints)

        self.assertIn(self.expected_transformation,
                      get_request_url(mocked_request))

    @mock.patch('urllib3.request.RequestMethods.request',
                return_value=mocked_response)
    def test_fetch_breakpoints_with_transformation(self, mocked_request):
        """Should retrieve responsive breakpoints from cloudinary resource with custom transformation (mocked)"""
        srcset = {"transformation": self.crop_transformation}
        actual_breakpoints = self.res._fetch_breakpoints(srcset)

        self.assertEqual(self.mocked_breakpoints, actual_breakpoints)

        self.assertIn(
            self.crop_transformation_str + "/" + self.expected_transformation,
            get_request_url(mocked_request))

    def test_fetch_breakpoints_real(self):
        """Should retrieve responsive breakpoints from cloudinary resource (real request)"""
        actual_breakpoints = self.res._fetch_breakpoints()

        self.assertIsInstance(actual_breakpoints, list)

        self.assertGreater(len(actual_breakpoints), 0)
Пример #3
0
	def post(self, request):
		form = ConstructorForm(request.POST, request.FILES)
		if form.is_valid():
			im = Image.open("static/img/template-{}.png".format(form.cleaned_data["sex"]))
			is_pattern = form.cleaned_data["is_pattern"]
			print(is_pattern)
			bg = form.cleaned_data["background"]
			if is_pattern:
				imP = Image.open(form.cleaned_data["file"])
				
				width, height = imP.size   # Get dimensions

				left = (width - 1000) / 2
				top = (height - 1000) / 2
				right = (width + 1000) / 2
				bottom = (height + 1000) / 2

				imP = imP.crop((left, top, right, bottom))
			else:
				imP = Image.new("RGBA", size=(1000, 1000), color=(int(bg[1:3], 16), int(bg[3:5], 16), int(bg[5:7], 16), 255))
			
			imP.paste(im, (0, 0), im)
			
			im = imP.copy()

			if not is_pattern and form.cleaned_data["file"]:
				imPR = Image.open(form.cleaned_data["file"])

				ratio = (imPR.size[0] / 250)

				r_imPR = imPR.resize((250, int(imPR.size[1] / ratio)))

				pos = (500 - r_imPR.size[0] // 2, 500 - r_imPR.size[1] // 2)
				im.paste(r_imPR, pos)

			im.save("temp/temp.png")

			resp = cloudinary.uploader.upload('temp/temp.png')
			result = CloudinaryResource(
				public_id=resp['public_id'],
				type=resp['type'],
				resource_type=resp['resource_type'],
				version=resp['version'],
				format=resp['format'],
			)

			str_result = result.get_prep_value()

			if request.FILES:
				resp2 = cloudinary.uploader.upload(File.open(request.FILES["file"], "rb"))
				result2 = CloudinaryResource(
					public_id=resp2['public_id'],
					type=resp2['type'],
					resource_type=resp2['resource_type'],
					version=resp2['version'],
					format=resp2['format'],
				)
				str_result2 = result2.get_prep_value()
			else:
				str_result2 = None


			tshirt = TShirt.objects.create(
				user=request.user,
				name=form.cleaned_data["name"],
				description=form.cleaned_data["description"],
				image=str_result,
				sex=form.cleaned_data["sex"],
				uploaded_image=str_result2,
				background=form.cleaned_data["background"],
				is_pattern=form.cleaned_data["is_pattern"],
			)
			tshirt.topic.set(form.cleaned_data["topic"])
			tshirt.tag.set(form.cleaned_data["tag"])
	


			return redirect('design_view', tshirt_id=tshirt.id)
		else:
			data = {
				"form": form,
			}
			return render(request, "core/constructor.html", context=data)
class TestCloudinaryResource(TestCase):
    mocked_response = http_response_mock('{"breakpoints": [50, 500, 1000]}')
    mocked_breakpoints = [50, 500, 1000]
    expected_transformation = "c_scale,w_auto:breakpoints_50_1000_20_20:json"

    crop_transformation = {'crop': 'crop', 'width': 100}
    crop_transformation_str = 'c_crop,w_100'

    @classmethod
    def setUpClass(cls):
        cloudinary.reset_config()
        cls.uploaded = uploader.upload(TEST_IMAGE, public_id=TEST_ID, tags=TEST_TAG)

    @classmethod
    def tearDownClass(cls):
        cleanup_test_resources_by_tag([(TEST_TAG,)])

    def setUp(self):
        self.res = CloudinaryResource(metadata=self.uploaded)

    def test_empty_class(self):
        """An empty CloudinaryResource"""

        self.shortDescription()
        res = CloudinaryResource()
        self.assertFalse(res, "should be 'False'")
        self.assertEqual(len(res), 0, "should have zero len()")
        self.assertIsNone(res.url, "should have None url")

    def test_validate(self):
        self.assertTrue(self.res.validate())
        self.assertTrue(self.res)
        self.assertGreater(len(self.res), 0)

    def test_get_prep_value(self):
        value = "image/upload/v{version}/{id}.{format}".format(
            version=self.uploaded["version"],
            id=self.uploaded["public_id"],
            format=self.uploaded["format"])

        self.assertEqual(value, self.res.get_prep_value())

    def test_get_presigned(self):
        value = "image/upload/v{version}/{id}.{format}#{signature}".format(
            version=self.uploaded["version"],
            id=self.uploaded["public_id"],
            format=self.uploaded["format"],
            signature=self.uploaded["signature"])

        self.assertEqual(value, self.res.get_presigned())

    def test_url(self):
        self.assertEqual(self.res.url, self.uploaded["url"])

    def test_image(self):
        image = self.res.image()
        self.assertIn(' src="{url}'.format(url=self.res.url), image)
        self.assertNotIn('data-src="{url}'.format(url=self.res.url), image)
        image = self.res.image(responsive=True, width="auto", crop="scale")
        self.assertNotIn(' src="{url}'.format(url=self.res.build_url(width="auto", crop="scale")), image)
        self.assertIn('data-src="{url}'.format(url=self.res.build_url(width="auto", crop="scale")), image)

    @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response)
    def test_fetch_breakpoints(self, mocked_request):
        """Should retrieve responsive breakpoints from cloudinary resource (mocked)"""
        actual_breakpoints = self.res._fetch_breakpoints()

        self.assertEqual(self.mocked_breakpoints, actual_breakpoints)

        self.assertIn(self.expected_transformation, get_request_url(mocked_request))

    @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response)
    def test_fetch_breakpoints_with_transformation(self, mocked_request):
        """Should retrieve responsive breakpoints from cloudinary resource with custom transformation (mocked)"""
        srcset = {"transformation": self.crop_transformation}
        actual_breakpoints = self.res._fetch_breakpoints(srcset)

        self.assertEqual(self.mocked_breakpoints, actual_breakpoints)

        self.assertIn(self.crop_transformation_str + "/" + self.expected_transformation,
                      get_request_url(mocked_request))

    def test_fetch_breakpoints_real(self):
        """Should retrieve responsive breakpoints from cloudinary resource (real request)"""
        actual_breakpoints = self.res._fetch_breakpoints()

        self.assertIsInstance(actual_breakpoints, list)

        self.assertGreater(len(actual_breakpoints), 0)
Пример #5
0
 def test_get_prep_value(self):
     res = CloudinaryResource(metadata=self.uploaded)
     value = "image/upload/v{version}/{id}.{format}".format(version=self.uploaded["version"],
                                                            id=self.uploaded["public_id"],
                                                            format=self.uploaded["format"])
     self.assertEqual(value, res.get_prep_value())